If only you could believe them.

QNX has been "opened" twice before. Each time, there was a rug pull, and it went closed again.

Before the first rug pull, open source groups routinely added QNX to their target list. There was a Firefox for QNX. Eclipse had QNX as a target. GCC and most of the Gnu command line tools could be built for QNX. There was a desktop environment, Photon. I used that as a primary desktop for three years when working on a DARPA Grand Challenge vehicle.

All of that went away after the Harman acquisition of QNX in 2004.

Then, in 2007, QNX went open source. You could even look at the microkernel. It wasn't openly licensed, but you could look inside and build it.

In 2010, RIM acquired QNX, and, with no warning, closed the source. All open source development related to QNX ceased, and QNX lost all credibility in the community. So QNX shot itself in the foot. Twice.

Note the contractual terms.[1] "TERMINATION. This Agreement and licenses granted hereunder may be terminated by either Party upon written notice to the other Party". QNX can pull the plug at any time. Since they've done so twice in the past, there's a good chance that will happen again.

Now, if QNX is serious about this, the way to go is to use the licensing model Epic uses for Unreal Engine. Unreal Engine is behind most AAA game titles. The basic terms are that you can download the source and use it for anything you want, and there's no charge until you get the first $1 million in revenue from your product. Then Epic takes a 5% royalty.[2] This has been extremely successful for Epic. There's not much of a piracy problem, because if your game gets enough revenue to matter, it has enough visibility that their licensing people will notice. Meanwhile, there's a large pool of people using Unreal Engine.

That's the way to do it if you want more adoption of QNX. Take the Epic term sheet to your lawyers and management. And have them take a look at Unreal Engine's revenue growth vs. QNX.

As I once told a QNX sales rep, your problem isn't that you're being pirated. It's that you're being ignored.

[1] http://www.qnx.com/download/feature.html?programid=51624

[2] https://cdn2.unrealengine.com/UnrealEngine/faq/UnrealEngineE...

I worked for a startup in Germany that was acquired by RIM/Blackberry in 2011. The company tried to get all the employees to sign new contracts for their existing roles and pay. The new contracts put severe IP limitations on everyone. All open source was forbidden. Many of us were very active in open source at the time. (I had worked for the Eclipse Foundation). A friend who wrote fiction was told he’d need written permission for each story he wanted to post or publish. They insisted that German engineers sign contracts where the binding language was English even though it was provided with a German translation. Many of us just left instead. My favorite line from the transition team sent from Canada was about how lucky we were going to be that they’d let us keep our awesome office in Munich because everyone at RIM worked in dark concrete dungeons. Yeah, how lucky we were that we could keep what we had.

Open anything is just completely foreign to that company’s DNA. I would not trust them an inch.

Ubitexx?

> Now, if QNX is serious about this, the way to go is to use the licensing model Epic uses for Unreal Engine. Unreal Engine is behind most AAA game titles. The basic terms are that you can download the source and use it for anything you want, and there's no charge until you get the first $1 million in revenue from your product. Then Epic takes a 5% royalty.[2] This has been extremely successful for Epic. There's not much of a piracy problem, because if your game gets enough revenue to matter, it has enough visibility that their licensing people will notice. Meanwhile, there's a large pool of people using Unreal Engine.

One option: Dual-license as GPLv3 (the 3 is important!) or commercial license. Hobbyists and FOSS projects will be quite happy to use a GPLv3 OS. The big commercial users - traditionally cars and other embedded uses - will not want to be legally obligated to give users the ability to install custom firmware (which GPLv3 basically requires), so they'll still pay for it. Everyone wins.

(IANAL, this is not legal advice, interpret licenses yourself.)

> The big commercial users - traditionally cars and other embedded uses - will not want to be legally obligated to give users the ability to install custom firmware (which GPLv3 basically requires), so they'll still pay for it. Everyone wins.

Yes. And it is even more than that.

Blackberry could have a general QNX verison under AGPLv3 and keep the "safety certified" version proprietary and they would not loose a single customer.

What the automotive world, robotic world and others are paying for is not standalone QNX... it is the safety-critical certified version of QNX.

It is easy to understand: Making an RTOS is easy. Making an RTOS (and a compiler) ASIL-D ISO-26262 certified is a freaking nightmare. And this is why companies are paying for QNX.

Opening the QNX source code under GPL would increase significantly the number of software ported on QNX and consequently the adoption of QNX.

Unfortunately, Blackberry is way too stupid to do it: It is not in their culture. That is very unlikely to happen.

> One option: Dual-license as GPLv3 (the 3 is important!) or commercial license. Hobbyists and FOSS projects will be quite happy to use a GPLv3 OS. The big commercial users - traditionally cars and other embedded uses - will not want to be legally obligated to give users the ability to install custom firmware (which GPLv3 basically requires), so they'll still pay for it. Everyone wins.

GPLv3's protection against locked systems isn't as strong as people often think it is.

In the case of cars at some point the makers are going to realize that instead of including firmware with all the features the car can support they can switch to shipping the car with a more basic firmware that just has built in support for basic car features and has an app store.

They can then put all the other features in apps that you have to buy (or subscribe to).

If that basic firmware is locked down so it can't be replaced by the user then they do indeed after avoid using GPLv3 for any code in that firmware.

The GPLv3 provisions about locking thing down do not apply to apps downloaded from an app store. They designed those previsions to stop what Tivo was doing, which was ship with a locked down operating system, and they wrote fairly narrow terms that don't cover much outside that case.

In particular, they apply when you convey object code of a GPLv3 work in, with, or specifically for use in a "User Product" and that conveyance is part of a transaction "in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term".

I.e., sell (or rent or lease etc) hardware that includes GPLv3 code and you have to provide a way to replace that code with modified versions. Sell (or rent etc) GPLv3 programs separately from hardware and then GPLv3 is neutral on locking it down.

Even better, GPLv1+TiVO clause AND commercial (i.e. you don't choose, but both terms simultaneously apply).

Even more critically, dual-license commercial and AGPLv3 to avoid the AWS loophole (hosted services or source modifications without licensing it commercial.)

AGPLv3 is perfect for kernel and userspace tools because, while it doesn't guarantee licensing revenues, as soon as they do anything to modify it they have to release those changes to ANY users of the system, whether downstream distributors or simply users of the network services they provide. Since they have to provide any IP/patents they used to do it under copyleft terms, QNX would get publicly visible benefits, albeit with changes that might not be useful under the commercial license without negotiating a CLA with the modifying party, but under the commercial license you could negotiate terms/a discount to trade their new code for a reduction in their cost of licensing. It's a win/win from either an open source PR or a behind the scenes commercial negotiation point. Obviously your lawyers, bean counters, and C-suite have to get onboard, but if you are serious about growing QNX's marketshare now that Linux is gaining real-time kernel support in mainline, you had better point out to your bosses they need to make the decision quick and stick to it, or there won't be a next time.

Edit: Adjustments made to clarify my position and suggestion.

> AGPLv3 is perfect for kernel and userspace tools because, while it doesn't guarantee licensing revenues, as soon as they do anything to modify it they have to release those changes to ANY users of the system, whether downstream distributors or simply users of the network services they provide.

This is actually fairly ambiguous in the text. It says "if you modify the Program, your modified version must prominently offer all users interacting with it remotely through a computer network (if your version supports such interaction) an opportunity to receive the Corresponding Source of your version". This is fairly straightforward when applied to a database—if you modify an AGPL database and offer it as a hosted version then your users are obviously interacting with it over the network—but much less straightforward when talking about an AGPL program that doesn't intentionally build in network connectivity.

The GPL FAQ addresses this provision [0] and it seems to support a more conservative reading. My understanding from the FAQ is that a Program that is not "expressly designed to accept user requests and send responses over a network" derives no benefit from being AGPL vs GPL, even if a web app interacts with that AGPL code over IPC or similar.

[0] https://www.gnu.org/licenses/gpl-faq.html#AGPLv3InteractingR...

Yep, I think the agplv3 behaves like the gplv3 for programs that are not network services.

With the twist that if your non networked, agplv3 program happens to contain code that's interesting to build a network service, this code can only be used under the agplv3 :-)

> this code can only be used under the agplv3 :-)

This code can only be used to make a derived work under the AGPLv3. What constitutes a derived work is still... complicated.

I wouldn't risk this in a production setting for a real business just out of caution, but my reading of the license would suggest that you'd be perfectly fine to wrap AGPLv3 code in a web service and then have your own code interact with that web service. Release the wrapper service as AGPL, but then the rest can be proprietary.

The main protection that AGPL gives isn't legal, it's that you scare most legal departments away just because it's such a weird license with no established precedent.

> I wouldn't risk this

This seems like a technical workaround for a legal requirement. Indeed, that seems risky xD

Working as intended. If they don't want to share, then they can't benefit.

It's not so much that as there is the net-negative side effect of having people redo the same work over and over again at their day job or whatever. It horrifies me when I think about the number of hours of people's lives wasted on things like that.

It applies to both sides of the argument, with organizations keeping things to themselves or others avoiding codebases for the inverse reason.

> It's not so much that as there is the net-negative side effect of having people redo the same work over and over again at their day job or whatever. It horrifies me when I think about the number of hours of people's lives wasted on things like that.

Given that this issue applies to all proprietary/non-opensource software, which is the overwhelming majority of software out there, you can hardly blame GPL3 for this fact of life.

I would argue that in many ways (that vary from project to project) the duplicated efforts are a good thing overall. Now, instead of having one single group or person working on a particular topic, there are many and the knowledge, learning, experience, and expertise that comes from that isn't locked up with only a select few. That can be applied in more areas, used for more things, or carried into other endeavors. It also hedges against all that expertise being lost if the few experts of the original project abandon it for whatever reason.

I don't see all the efforts that go into *BSD, Windows, macOS, etc... as being wasted just because Linux is available, nor would I consider the effort to try something completely new in os/kernel design that starts from a clean slate a waste, even if it doesn't end up becoming wildly popular. Not everyone who has the capacity to work on a duplicate effort would be able to contribute to the original, and the original will never be able to perfectly meet the goals/needs of everyone.

But who cares if someone chooses to redo work they didn't have to? I don't care about that at all. Self inflicted wound.

They presumably can salve that horrible wound with all the money they get (not make or earn, just get) from their chosen modus operundi.

Absolutely. LLVM exists because GCC is GPL; that's a feature not a bug.

LLVM exists because its original developers wanted to do research, not because of GPL and at the time there wasn't even a C compiler for it, not to mention that GCC wasn't designed at all to do what LLVM did.

The license angle with Apple did happen because of GCC's switch to GPLv3 but that came years later - and GCC still wasn't (and AFAIK still isn't) designed to be used like LLVM or (later) Clang, like using it as a backend for IDEs, analyzers, language servers, etc. The two projects aren't interchangeable with only the license being the thing that differentiates them.

They could have very well used lots or reusable parts of GCC. It was possible, and were many projects trying to change GCC.

gcc was specifically designed to not have many reusable parts to avoid people ripping them out. modularity only happened after LLVM and clang specifically started eating its lunch.

> LLVM and clang specifically started eating its lunch

I don't know how you can eat GCC's lunch. I feel like in this analogy GCC eats from a communal trough and is very happy to share. A company that sells licenses can lose customers, the GNU project just wants the world to benefit. GCC is still ubiquitous and has plenty of developers and mindshare, what more could they want?

Basically most of the embedded folks that used GCC forks are now on clang, and if in the old days they were breaching GPL, nowadays they are fully compilant, so not upstreaming is not even a legal issue any longer.

Fair enough. I guess you're talking about microcontrollers rather than lightweight CPUs, at least in my experience it's still standard to use GCC on the sort of dinky ARM-based devices my company produces.

I'll note that GPL never says anything about upstreaming. It can certainly make life easier if you want to keep your patches up to date and hand off maintenance responsibility, but it suffices to make a written offer of source code under the same license (on a conventional medium) to your customers to comply with any GPL version. You're never obliged to upstream or even publish your code.

Sure, but they didn't even do that most of the time, with MIT that isn't even part of the conversation.

Most certainly not. The modularity was not great, but BIG chunks of code could be copied. I did that myself.

I don't even understand how you can point to LLVM as an example of this failing. GCC is still alive and well, and perfectly suited for the task it was always intended to fill. People that wanted a commercial C compiler always had the option to purchase one at-cost, GCC was intended as an alternative to that process, not the alternative. It may be hard to remember, but less than 50 years ago squabbles over compiler licensing was what most developers had to deal with.

Respectively, LLVM fills it's own gap nicely. It has the classical BSD-like issue where hundreds of unique and disperate forks exist with no roadmap to bring them together, but that's also technically a "feature" of each license and not a bug. If GCC developers felt their job was obsoleted by Lattner, there wouldn't be a reason to update and maintain it. The end result has been healthy competition, accountability for either team, and better optimizations for everyone using either compiler.

Also after LLVM came to be, GCC gained on its official collection Go, D, and Modula-2 frontends.

And, hopefully, Rust soon as well[1][2][3].

[1] https://rust-gcc.github.io/

[2] https://github.com/Rust-GCC/gccrs

[3] https://blog.rust-lang.org/2024/11/07/gccrs-an-alternative-c...

I think wheel-reinvention is the perfect punishment for people that want to be stingy with their wheel development. Copyleft infringement deserves no more empathy than copyright infringement.

Shitty dx is baked into RIM/Blackberry's institutional DNA.

I had a long conversation with their engineering people way back before BB10 came out. At the time you had to apply to get access to the full blackberry SDK, and IIRC you also had to sign an NDA. Meanwhile Android and iOS were in full swing and wouldn't you know it, the platforms that had better developer experience, that prioritized making it easy to write apps, were successful.

Blackberry is just institutionally incapable of handling this sort of relationship with the community. It's that legacy telco "us vs them" mindset at the top of the org, and it filters down whether implicitly or explicitly.

It was worse than an NDA! You also had to start your application with a trip to a notary to get your ID confirmed.

And if their signing servers were down…You couldn’t load had just compiled onto your own dev / test device.

I loved using my blackberry but I hated developing against it. Bb10 was its own little adventure but had similar draconian dx

One of the dirty secrets of the mobile industry, particularly before Apple showed up and spoiled all the fun, was how many execs and chunks of the ethos were airlifted out of Ma Bell. The kind of moat-building we're seeing take over the internet over the last couple decades is something that mobile carriers already had in heaps.

It was also common for carriers to extort very high fees from anyone selling apps on their platforms. People bitch and moan about Apple taking 30% (which is more like 15% now) but I saw mobile app execs complaining about only grossing 30% after the carrier fees, and so you could only either make blockbusters and pay for R&D on volume, or set your VC money on fire to fatten up the carriers and get nothing, except more powerful carriers, for your efforts.

I'm not at all surprised to hear that RIM was only slightly less evil.

I remember getting some LG phone in maybe 2007 and being excited because I read you could write 3rd party apps and games for it. Then I tried reading the BREW developer docs and trying the emulator, which were both abysmal. Then I read that just to try an app on my phone I would need to pay hundreds of dollars (IIRC it was $400) to get it signed.

That totally killed my desire to develop for my flip phone.

It's crazy to think that that's an ecosystem where paying a dollar or more for a ringtone had been normalized.

If you look up the music industy revenue source breakdowns by year, there was a time when ringtone revenue represented 10%.

https://www.visualcapitalist.com/music-industry-revenues-by-...

Was this North America specific. I remember using sdk/dev tools for Symbian. I don't remember timelines, so maybe they changed after iPhone release.

If I recall correctly the Symbian SDK was freely available more or less from the Psion start. Not sure about it's different "editions" though.

> Bb10 was its own little adventure but had similar draconian dx

I did some development for it but the bureaucracy killed my will to do more.

It was a great phone OS though. The real time nature makes even modest hardware responsive.

The BB10-powered Passport was my favorite device

> The BB10-powered Passport was my favorite device

I loved mine.

My favourite device was my Nokia E90 Communicator. Hardware-formfactor-wise that's the best smartphone I ever owned.

Closed, it's a one-hand T9-driven smart candybar phone. Open, it has a usable QWERTY keyboard, a letterbox screen that can display a slice of an A4 or Legal PDF at readable size. I never watched films on it, but you could do in principle.

I still want one. Can’t find any.

I still have mine but it's useless because it isn't receiving updates and can't run third party OSes due to the locked down boot chain.

Still runs the base BB 10 apps. My Q-10 still works as a phone. And can read e-mail.

Even worst! When everything was signed, you would get no support at all! Worst experience ever!

From the people I know who worked there, same crap in internal culture, too.

Back before 2004, QNX could have still been relevant as there was still a lot of OS experimentation from the user/developer themsevels. They could have attracted enough people to carve a niche even in the desktop space at that time.

After beos failed, I played/developed with QNX until they pulled the rug. I was on it full time on my main dev machine. I loved it.

When they closed it I got severely burned to the point that I will not touch a any closed development platform. I see from the license they didn't change a bit.

Not that it matters anymore.. they're largely irrelevant today except for whatever existing markets they already have. It would be fooling to choose QNX today: we now have good alternatives, and all of them with open licenses.

I remember being really excited about QNX for a few months after BeOS closed up. It had a cool desktop environment and was mostly posix so it was more or less familiar coming from Be or Linux.

Also I wonder how many applications really need more real time responsiveness than you can get out of Linux. We even have

https://arstechnica.com/gadgets/2024/09/real-time-linux-is-o...

If I use Linux I know I won't have to have a discussion about licensing, I know I won't get rug pulled, etc.

Also the ban on commercial use is heinous. I am going through this with Arangodb right now. I love the product, but I have no budget for a cloud instance they manage and I have no budget to talk with their sales people about a commercial license. I have several systems that use it (including one that's about 80% of a way to a "too big for free" database) and I don't know if their fate will be (a) open sourcing, (b) a product or (c) a system that makes money for me directly but for me the short path is to switch to postgres, not talk to people whose business model doesn't necessarily allow my business model.

Real time is about worst case time, not average.

The classic test for a real time OS is simple. You write a program that waits from an interrupt from an input pin. When the input is raised, there's an interrupt. That activates a user process. The user process turns on an output pin.

You hook this up to a signal generator and a scope. Feed in a square wave. See the delay between input and output. If there are outliers, delays much larger than the normal delay, the system is doing real time properly at all.

If it passes that test, run some other program at a lower priority than the one that's monitoring the input pin. The results should not change. The other program should reliably be preempted.

QNX could pass that test, at least when I last used it.

Note that this requirement conflicts with many modern CPU and OS features, such as sleep modes, power-saving under light load, and paging. Classically, you didn't care, because the control CPU used far less power than whatever large piece of equipment it was controlling. But for things that run on batteries, it's a problem.

Something that's given trouble: "system management mode". Some industrial computers used code running in system management mode to help out with some peripherals, such as making flash memory look like a hard drive. This time-stealing shows up in the interrupt latency test. QNX techs used to quietly have a blacklist of embedded computers to avoid.

> If there are outliers, delays much larger than the normal delay, the system is doing real time properly at all.

Just to clarify for anyone reading, I think you meant:

> If there are outliers, delays much larger than the normal delay, the system is not doing real time properly at all.

That has to be the correct reading.

rt linux is not appropriate for many hard realtime requirements

i have seen some try and fail in an effort to save $perceived_value

RT Linux is not the only alternative. There are now plenty of options for achieving hard real-time performance without relying on proprietary RTOS solutions:

  Dedicated Real-Time Cores: Many SoCs include dedicated cores specifically for hard real-time tasks.
  Microcontroller Companions: Pairing a microcontroller running a lightweight RTOS with a larger, general-purpose processor as a supervisor (You can use normal Linux).
  FPGAs: Custom FPGA implementations can deliver deterministic timing where ultra-low latency or specialized processing is needed.

And ofc, RT Linux, that in my experience is suitable for over 80% of hard real-time applications (an estimation, based on experience as a former user—your mileage may vary).

Out of curiosity, to what extent can modern x86 / Arm systems support hard-realtime guarantees?

I'm wondering about things that could cause unexpected delays, like PCIe bus contention / error correction, high interrupt traffic, etc.

(I don't know much about this topic, so apologies if my question is ill-conceived.)

If by "modern" you mean a desktop/server CPU, the problem is the complexity that exists because of optimization for average throughput. Do you really know how long you will wait, worst-case, if three different cores flush the same cache line back to DRAM? Or maybe some niche hardware you use has some funky behaviour that stalls some hardware bus, or waits in the kernel for a millisecond, twice a month or whatever.

On the other hand, on FPGAs, deterministic timing is so very simple. Your output will not be a single clock cycle late even if something else goes wrong in logic running on the same FPGA (except through a connection that you control).

If you really want to know, OSADL has a QA Farm that monitors worst-case interrupt and scheduling latency for various CPUs and Linux versions.

Is there a good libre real-time OS you would recommend over it?

RTEMS is one and there is also eCOS. RTEMS has flown in space a few times so it is proven.

Forgot to mention: the neat part of RTEMS is it allows one to sort of turn a Unix program into a bare metal program.

Why do RTEMS and eCOS trump, say, Linux? Linux on a RPi has also famously flown (really!) in space.

It's all very well asserting something but a bit more chat would be nice.

I'm not sure what "turn a Unix program into a bare metal program." means.

Say all your program does is read some sensors via gpio, save those readings in ram, do a bit of math on that state, then set some other gpio pins, and that's all the entire system does. when it turns on, it should jump right into doing that and nothing else.

It may be easier to write that on a full sized Linux system, but come time to deploy it, all that Linux code that isn't being used is a liability for bugs and unexpected behavior to crop up. One approach is to slim down Linux to avoid that (eg removing systemd, esp for systems that don't have enough ram to run it), but another approach would be to just use something less complicated than Linux. It would suck to get to space only to find that something had messed up permissions on the gpio pins again so your satellite didn't deploy and now you've wasted a launch. If there's no permissions system to mess up, that can't go wrong.

As far as bare metal, I presume it means to port a Unix program which has all sorts of assumptions about running on a Unix operating system, to an OS that's not one, with simplified models for a lot of things, and for the system to reliably run that program on boot and not do anything unecessary. Like run cups.

For some tasks you don't need even need an OS and that competes with QNX. For instance I do hobby experiments with persistence of vision displays on AVR-8 and assembly language on the bare metal is so simple but it is simple hardware and simple software, bigger jobs need something more.

As it has been already said, with RTEMS and other similar real-time operating systems it is easy to predict the worst case time for the handling of any event. This is absolutely necessary when controlling many kinds of hardware devices.

This is completely impossible with standard Linux. Real-time Linux might offer some guarantees, but I am pretty sure that they are rather soft.

Linux is already too big to be easy to understand and audit in order to be certain that you really know which will be the worst case.

With a simple OS like RTEMS, a competent programmer can become an expert in its internals in a month or so, and then it is easy to understand what exactly will happen in any circumstance.

I have used in the past some commercial real-time operating systems, like pSOS and VxWorks, but the free RTEMS has been much better than those, especially because being open-source it allows a much deeper customization than any proprietary solution.

I believe seL4 is formally verified.

Verified worst case execution time analysis. So instead of just hanging on it until it achieves the desired responsiveness (like QNX and rt Linux) Sel4 can actually back up its claim.

In that case, you’re just hanging on the specs, prover, compiler, and other dependencies. Things most developers can’t even begin to verify. That also assumes the hardware works which isn’t safe if talking about cosmic rays.

Empirical testing of “verified” software often found errors, too. High-assurance, security certification used to require formal methods, thorough testing of code, review of anrtifacts, and pen testing by independent team. We should do that today.

In this case, you’d do white box and black box testing of the WCETS of seL4.

chibios is great, but I haven't followed their culture or licensing in a few years now.

my experiences then would lead me to recommend it, though.

ChibiOS doesn't really compete in the same space as QNX. It's a single address space executive that's more like FreeRTOS than QNX.

Agree but I have seen more people wrongly think they need hard real time than people incorrectly picking their kernel.

I don’t doubt this but it’s worth noting that I believe spacex uses Linux as their RTOS.

SpaceX can afford that by their _very_ resilient design and accepting, even anticipating failure.

If your design is resilient to missing deadlines, you don't need a RTOS and the question becomes moot.

talk nerdy to me, which ones ?

For everyone else, your QNX comment from 2015: https://news.ycombinator.com/item?id=9872640

As someone who knows only that QNX is a RTOS and that "real time" is good in some vague hand-wavy way, I found this 2015 comment a very succinct, concrete and illuminating description of one aspect of QNX's architecture that makes it properly real-time.

So thank you very much for the link.

"Real time" is only good if you need guaranteed responsiveness within certain time limits. It can actually be suboptimal and slow you down if you don't need it and want to optimize other things like throughput.

Though in practice, the act of designing your code for realtime tends to produce better performance than the status quo of doing nothing. Most uses of this warning seem intended to promote the latter rather than to get people thinking about their actual requirements.

Who needs throughput? Server software, but Linux is already dominant there and everyone's happy. For everything else, including desktop and mobile operating systems realtime sounds like a good idea.

That's waaaay too broad a grouping. You're thinking of PC's, basically, in one form or another (or their modern replacement, mobile devices).

Industrial automation and hard real-time embedded devices like those that control surfaces in Fly-By-Wire systems are out there and with those it's not a matter of "throughput" but a matter of timeliness.

I did a major project with QNX about a decade ago where the maximum allowed latency between any device on the (fiber-optic) network being asked a question by the master controller and the reply - then the processing of the reply - was less than 1 millisecond, full stop.

Come in late and most of the time the sky doesn't fall in. But on the occasions that it does, you potentially have a 4 meter wide ribbon of red-hot steel flying out of the stands at 50mph. Or you blow one of the transistors that controls the 10-20 megawatt DC motors in each stand. (These "transistors" were boxes about 7' tall, filled with oil, and cost northwards of $200k).

Sometimes it just doesn't pay to be late.

What a terrifying and cool project!

Can you say what kind of shop / machine it was for?

It was a hot-strip mill; this video shows the general gist of it: <https://www.youtube.com/watch?v=13dUL9OQFvw&t=15s> (tho the ones I worked with were all made by GE).

Absolutely deterministic latency isn't a requirement for the desktop like it is for industrial control.

If 99% of the time performance is faster, and the remaining 1% of the time isn't that bad, most people will take the trade of higher average performance. If it's running the antilock braking in your car, that's pretty bad.

> Who needs throughput? Server software, but Linux is already dominant there and everyone's happy. For everything else, including desktop and mobile operating systems realtime sounds like a good idea.

No, not at all. The actual question is who needs realtime.

Desktop is a typical place where you absolutely don't need realtime. You just want latency to be under the user perception threshold but that's easily achievable with a standard kernel. Plus the consequence of failing is basically nil. Why bother with the complexity introduced by a RT kernel?

The latency in modern desktop is not a consequence of unpredictable scheduling. It's just poorly optimised applications. A RT kernel is not a magical solution to that.

> Desktop is a typical place where you absolutely don't need realtime.

On a desktop, you want at least soft real-time when playing any sort of multimedia (audio, video, or interactive applications like video games). Otherwise, you get things like glitched audio or dropped frames.

Yes, I agree especially for audio which is a typical exemple of a latency sensitive application (video games are generally purposefully design to be as latency insensitive as possible and will drop frames with no impact on actual gameplay). But a performent application and proper scheduler priorities will bring you there without a RT kernel.

> For everything else, including desktop and mobile operating systems realtime sounds like a good idea.

Why on earth would you need real time on desktop? Every time the topic is discussed on internet bunch of confused people chime in with this sentiment that doesn't make much sense. "RTOS" is not some magic that somehow makes everything on your desktop fast. All it would do in reality is make everything slower for 99% of your interaction but guarantee that "slowness" is uniform and you don't have any weird latency spikes in other 1%. Note that for cases that are not "nuclear reactor control system that requires Very Certified OS with audited and provable reaction times" RTLinux is already available, but distros are not inclined to leverage it on desktop for reason described above.

I've read many opinions of those who used QNX on desktop in the past, that it felt much more "snappy" compared to other systems.

Desktop definitely has real time tasks. Any animation is real time task. When I'm listening to music, it's real time task. macOS sound interrupts for a short time, when something hardware-related happens, so it's not pleasant experience. You might argue that user can tolerate those interruptions, but for me those are just bugs.

Indeed. There are people who have a fair point that desktops for users (as opposed to servers) should have a focus on being responsive and useful. Like how writing on a piece of paper produces meaningful markings in real time, user interfaces should be able to perform tasks with analogous interactivity. See comments about BeOS elsewhere in this thread. I don't know about the extreme, but the overall sentiment is valuable and a far cry from the current state of the desktop experience.

When recording live audio performances, some guarantees that the thread that records the signal will always get some attention for the scheduler, would be nice. Otherwise the recording program will miss on the signal, and the recording will have cracks.

We sidestep this problem because our CPUs are insanely fast for this task, so as long as you don't game, compile and record audio at the same time, you should be fine. But we don't have any guarantees.

Desktop use at its lowest latency is typically 17ms and up to 33ms when using a 60Hz screen with one frame in the buffer and whether you have to wait for the one after that. But most operating systems and games default to more than one buffered frame. Still, even that lowest case scenario is a pretty big budget of time. The microsecond precision of a RTOS is not necessary then. If you want to increase responsiveness or reduce latency for interactive use of desktops or phones there are different avenues to approach to shave off milliseconds at a time.

Thank you for adding that link. What I find particularly remarkable is that the author of that comment is John Nagle himself (of Nagle’s Algorithm fame https://en.m.wikipedia.org/wiki/Nagle%27s_algorithm).

> Somebody really should write a microkernel like this in Rust.

I wonder how far Redox's microkernel design is from what that comment describes.

Redox's IPC is a fair bit weaker of a design than that of QNX or my seL4-derived kernel. It works sort of like that of QNX in that it has direct copying of messages between address spaces and RPC-like semantics with direct context switch from sender to receiver and back, but it is more limited and implemented in a slower way. Also, there seems to be no consideration for real-time performance at all.

Outside the core IPC model, the namespace model is also more limited than that of QNX; QNX allows multiple servers of a given type mounted anywhere within a namespace, whereas Redox's scheme-based namespace model only allows a single server of a given type per namespace, mounted on a fixed top-level prefix.

I think elaborate IPC designs are too much trouble, and I favor seL4's "context switch with benefits" approach of delegating larger messages to shared memory. It avoids performance and security hiccups with copying or kernel-mediated shared memory, like in EROS. To be fair, I'm less focused on efficiency and more on simplicity/robustness of the kernel, similar to seL4. Could you elaborate on your thoughts in the IPC space?

A friend of mine is working on this OS:

https://gitlab.com/uxrt

I see this was submitted to HN a couple times over the last few years and has not received any comments. Can you describe the goals and status of this project? Does it fit into any larger ecosystem? Is it a research project or intended for eventual mainstream adoption?

I'll start by saying that micro-kernel OS development is a bit beyond my skill set but I can tell you that the goal is more or less to make an open source QNX with features from Plan 9 that is suitable for desktop use and higher level embedded platforms.

I'm not sure what you mean by larger ecosystem but a compatibility layer with Linux binaries is on the feature list. You can read the extremely detailed architecture notes document here[0]

It is absolutely intended for mainstream adoption and the project has recently received interest and funding from a very large OEM. I don't want to say who it is because I am not certain if they want it publicized yet. It's probably okay for me to say but I'm erring on the side of caution.

If you or anyone you know is interested in contributing to the project let me know or reach out to Andrew Warkentin on gitlab.[1]

[0] https://gitlab.com/uxrt/uxrt-toplevel/-/blob/master/architec... [1] https://gitlab.com/andreww591

Basically I'm trying to write a better Linux than Linux and a better QNX than QNX, at least for certain use cases that is. At least initially, my primary focus is on workstation/enthusiast desktops and higher-end embedded systems (some types of servers, especially ones where high security is important, are also a focus as well but maybe not quite as much for now). Pure consumer desktops aren't really much of a priority; the goal is to make something that's approachable but definitely not dumbed down. Almost every day I see people complaining about mainstream OSes and I think there's an opportunity for an OS that's cleaner and more integrated than Linux and has various advanced features not found in Linux, but still tries to maintain a high degree of compatibility with it. I'm not really trying to clone QNX or Linux 1:1, but I am trying to maintain similar enough semantics to allow easy implementation of compatibility layers for both systems.

At the moment I have a working microkernel and an incomplete process server with a partially-implemented VFS but no support for running regular user processes. Currently I am working on some of the first special filesystems built into the process server (specifically an early log/console device at the moment).

The kernel is a hard fork of seL4 (the biggest addition at the moment is a preliminary implementation of QNX-style arbitrary-length arbitrary-address message copying); I've forked it because seL4 is focused on lower-end static embedded systems, and full verification of just the kernel isn't really particularly useful for a dynamic OS when all of the servers are unverified. The process server is written in Rust, and it's likely most of the other low-level servers will be as well, although I'm not really writing a "Rust OS" as such. Many of the basic utilities will most likely be BSD-derived, and some of the higher-level desktop-related stuff may be written in various other languages (haven't completely decided there).

Interesting, but sounds like much more than a lifetime achievement. As far as I understand, it is written in Rust; this raises the question of whether there are significant differences to Redox OS, which seems to share most of the goals. But sel4 on the other hand is written in C; are you going to migrate sel4 to Rust?

Like I said, it's not meant to be a "Rust OS" and will incorporate a lot of C code still (and various other languages as well). I doubt that the kernel will ever get completely rewritten in Rust, although eventually some Rust code might get added (once I break up the giant kernel lock I am thinking I'll use the same locking library I'm using in the process server, so that would add some Rust code to the kernel). I don't see a lot of point to rewriting the kernel since it's probably not going to see lots of new code being added all the time and is generally pretty limited as to what it includes (I'm not quite as reluctant to add stuff to the kernel as the seL4 developers are, but I still am going to try avoiding it unless there's no other good way to do something).

Redox has several of what I consider to be questionable design/implementation decisions. I explained a couple of them in a previous comment (the limited filesystem namespace and IPC models and the lack of real-time support). Some other things include the weak implementation of locking (it uses pure spinlocks instead of something like the adaptive queue-based locking that I'm using in the process server), a rather limited heap allocator that doesn't support growing/shrinking the heap or custom object sizes for slabs (the heap allocator I'm using is a derivative of the same one that Redox uses but it's been heavily enhanced with support for shrinking/growing the heap and custom slab sizes), and the rather boilerplatey implementation of some of the libraries (for example fork() is implemented as a library function that copies process context through a filesystem-based API, but rather than having object-oriented wrappers on top of the filesystem for the various state objects that it's manipulating, the fork() implementation directly invokes open(), read(), and write() a lot).

That's interesting, thanks for the explanations. Which of the many OS text books do you think covers the topics you are confronted with in this projectk best (especially how to implement an efficient microkernel and integrated ipc)?

>QNX went open source.

Not open source. Those words have a specific definition[0], which QNX never met.

0. https://opensource.org/osd

Things don't become true just from being written down on the Internet. Open source means that the source code is open for the public to see, and that's it.

This misunderstanding continues to crop up on Hacker News. [0]

> Things don't become true just from being written down on the Internet

That's not what they were saying.

People who care about open source software use the OSI's definition. You can't reason about the open source movement if you use a fundamentally nonstandard understanding of the term, such as the one you are proposing. You wouldn't be able to make sense of a blog post like this, for instance. [1][2]

> Open source means that the source code is open for the public to see, and that's it.

The open source movement disagrees. Are we expected to accept your definition just because it's written down on the Internet?

[0] https://news.ycombinator.com/item?id=31203209

[1] https://drewdevault.com/2024/07/16/2024-07-16-So-you-want-to...

[2] https://news.ycombinator.com/item?id=40993787

Even getting the licensing right isn't sufficient. They could license it as MIT today, close source it again tomorrow, and within a few releases no one would be using the MIT version.

Unless someone is interested in maintaining a full fork. It's the same reason Google can do whatever they want with Chromium even though it's technically open source. No one else has the resources/will to maintain it so there's no credible threat of a fork.

That's not a great example. Maintaining a full fork of QNX would not be terribly complex compared to maintaining a full fork of Chromium. The latter targets standards which are moving and evolving. Nobody cares which version of POSIX QNX is compatible with. (Also, Chromium is much bigger)

I think a fork could have some maintainers. I'd be more worried about people wanting to put new features in than anything else.

Between Microsoft on one hand and all the other browser companies (Opera, Brave etc) on the other, I wouldn't be so sure.

Following Google's lead is massively cheaper than having a custom fork or engine, but it's not impossible. If Google does something wild and unpalatable to all these companies, I wouldn't be surprised if we see a Linux Foundation version of Chromium, with custom skins on top.

That could even get Mozilla to jump on the bandwagon, especially if they lose 9x percent of their revenue due to Google's antitrust remedies, which is not that unlikely.

So it's not just me. I asked for a license to do pkgsrc package building on QNX, got rejected, and couldn't even get a human to respond to my messages with anything that didn't resemble a copied-and-pasted form response.

They gave the impression at the time that they really couldn't be bothered with open source. This just happened to be not long after 2010.

> As I once told a QNX sales rep, your problem isn't that you're being pirated. It's that you're being ignored.

Microsoft realized that a long time ago. That's why you could always get Windows for free if you knew where to look.

QNX will lose even more since linux merged the RT patches. There is almost no reason to use QNX on an embedded system where linux is also available.

It is sad. With GNU it could have been something interesting.

Unreal engine has certainly had its licensing issues.

https://www.theverge.com/2023/10/5/23905082/epic-unreal-engi...

For QNX 8.0, here’s a saved-you-five-minutes direct link to the developer terms associated with noncommercial use:

https://support7.qnx.com/download/download/51624/BB_QNX_Deve...

(I am not your lawyer, this is not legal advice. This is not a comprehensive review, assessment, or summary of possible interpretations of that license. Seek professional counsel from a lawyer before acting on anything stated below.)

These terms open with a ‘user did not have an opportunity to review and agree before binding themselves, their business, and/or their institution’ clause that may well wholly invalidate the entire document in the US, so please review these with your lawyer before use, so that your usage is not put at risk due to legalese overreach.

Academics, only students and faculty of your institution qualify, and your usage under this license will be viewed by your legal team as you signing a binding agreement on behalf of your employer; make sure you’re not exposed to liability through open source contributors or at risk of being fired for misrepresenting yourself as a signing authority for your institution.

Cloud users, your license is restricted to AWS per their terms; use on GCP, Heroku, or any other server instance not under your personal contractual control may result in owing licensing fees.

Only OSI definitions of “Open Source” are permissible here; this disqualifies anyone licensing software under a restrictive non-commercial license from making use of the QNX non-commercial license, as per OSI, all such restrictions are not “open source”.

Social apps are excluded by the “high risk” clause, which prohibits any use under these terms to develop applications that could harm society. Take care not to create viral applications that violate this clause.

They collect and retain all serial numbers identifiable on all hardware you use in association with this product.

Your noncommercial license may be severed unconditionally at any time without recourse, regardless of whether you have faithfully complied with the terms; at which time you may be compelled under contract to provide an undefined ‘certification’ of indeterminate cost that you deleted all QNX code provided to you.

Stay safe, folks.

Since when are social apps high risk? The high risk clause is clearly targeted at applications that have safety requirements (IEC 61508, ISO 26262 etc.). A crashing Twitter client won't injure or kill anyone.

This is their definition of “High Risk Application”:

any product, device, component, or system which if it fails or is interrupted, may result in loss of life, or other serious or catastrophic personal injury and/or substantial financial or commercial or societal loss.

So its not just safety-critical applications, it also includes "societal loss". What does that mean I have no idea. Does losing Twitter client leads to "societal loss"? You can argue both ways

Only a court of law can determine what that means with certainty, as written anyways. They might even determine that it’s invalid! At which point they’ll just sever the agreement anyways, and until nullified or upheld it serves as a form of uncertainty gatekeeping.

I cannot possibly imagine what motivated them to put in a “no edgy apps” clause and then post it on a bleeding edge site like HN. A job’s a job, I suppose.

Why would I use QNX for any project when RTOS Linux is mature? Why would I care? So you can rug-pull license changes?

Should I use it because it's cute? It's academically interesting? Sure, I've used QNX in the past for those reasons. The next time I pick a soc for a project, and its associated bsp, I'm not going to look for QNX. I'm either going to use whatever freertos distro they include or install the android build tools so i can push an apk to its wackity ass android fork.

I suppose if i was doing automotive or medical, the story would be different. But I know the space well enough to know that you have many competitors all nipping at your heels, and with the linux rtos changes, it's not going to get better.

This is not 2010. There are options. While QNX has languished behind obscure and annoying licensing requirements, literally dozens of companies have been developing alternatives. Some of them are quite big, and in some cases, have gone to space.

At this point, if you want QNX to be taken seriously, you're going to have to do better than "start opening the doors to QNX like things used to be".

I'll take it one step further - if it's not completely open source for commercial use, I have no interest in using it. I could be enticed to put up with an Epic-style license if the associated tooling and bsp support was worth my time. I have zero interest in paying a license to get started. Again - not 2010.

Your product has been commoditized and now it's a curiosity. The only way it gets enough active development and adoption is if its a community effort.

Name/reputation still means a lot to some people, as does not learning yet another OS. Not everyone cares if something is FOSS or not. Different people have different leaning when it comes to this stuff, and that shouldn't be surprising.

> Name/reputation still means a lot to some people, as does not learning yet another OS

Great, people on QNX can keep using it. A stagnating user base doesn't make for a good business.

> Not everyone cares if something is FOSS or not.

No, but I would rather not enter into onerous licensing terms if better ones exist

I don't know QNX, never heard of them.

But the name and reputation of Blackberry are not things I would consider ... stellar or relevant...

You would use it if you wanted to get a job doing RTOS dev and wanted to show you had some skin in the game.

Maybe you would have used QNX as an engineer flex in 2012, but as an embedded firmware dev myself, I'd laugh if someone suggested we use QNX for anything. Besides the licensing issues... just why? It confers no imaginable benefit versus any one of dozens of alternatives. It's like if someone suggested I run Haiku on my work laptop.

ISO 26262 ASIL D safety certification, mature tooling and ecosystem, easy to hire experienced devs, “it worked for the last 5 projects”, etc.

There's a few vendors that sell FreeRTOS forks that have that cert. SAFERTOS is a very common one

> mature tooling and ecosystem

Amazon has been working on freertos for a long time

> easy to hire experienced devs

tbh if you've used one rtos, you've used them all. the learning curve is in the concepts, not the api. any good vendor will have engineering support that helps you where appropriate

> “it worked for the last 5 projects”

inertia only takes you so far

lmao "skin in the game". what a useless cliche.

that's such a lame excuse, and if for some stupid reason, i chose the rtos first, i would simply choose one of the many competitors that have positive mindshare and increasing install base. freertos, rt linux, hell even vxworks.

the simple fact is that rtos are more commodity than ever. if im going to start a project, im going to do it based on the requirements, find a soc and bsp that has excellent support for those requirements, and then follow up writing a task for whatever rtos it uses.

for example, im not using freertos because its "cute" and has a neat little floppy disk demo. im currently using amazon's freertos beceause that's what the espxx family supports. im using the esp32 because it has the power profile i need for my sensor project.

in today's market, it's absolutely asinine to choose the rtos first. i honestly have no idea what qnx is a first class citizen on anymore. I actually feel bad for anyone who's spent their whole career in QNX-land - that train might be coming to a stop and there's probably a lot of people who would rather not retrain.

actually, there's a nugget of wisdom in there for the qnx team: i should be able to buy a $20 board that runs qnx, and fits into the power, performance, and hardware profile of something like the esp32. integrate it heavily with platform.io. let me use qnx without having to specifically go and seek it out and hack on it a bunch.

any commercial rtos shop where QNX may be appropriate is either using 1. some wacky expensive proprietary rtos that you've never heard of, 2. freertos or 3. real-time linux depending on what they need. asking what makes QNX a compelling rtos when freertos exists, is widely supported and used, and has an MIT license is a very valid question.

further, no one in embedded actually cares what RTOS you used. they are all similar enough that you won't get stuck if it's a brand new RTOS

QNX is heavily used in industries where functional safety or particular high assurance models are required.

Sure FreeRTOS has a SafeRTOS mode, but its not sufficiently functional for a modern ADAS stack or complex robotics systems. QNX is used in all major automotive companies around the world for a reason, and a crucial part of NVIDIA's DriveOS stack.

QNX is in a space with few competitors. FreeRTOS or ThreadX are designed to provide microcontrollers with scheduling and memory management functionality. They don't depend on fancy things like MMUs or provide frameworks for networking or file systems out for the box. The flipside is that you can compile them down to maybe 30kB of machine code.

QNX is designed for more powerful and featureful hardware to drive a software stack with true process isolation and generally provide the bells and whistles of general purpose OS on top of a hard realtime core. It can run complex GUIs without sacrificing its real time capabilities. Not many competitors live in that particular space.

> and a crucial part of NVIDIA's DriveOS stack

fwiw they have been working hard to support linux as a second option, and have been major contributors to Real Time Linux

sooooooo

Are there any automakers out there that use real-time Linux for anything at or above ASIL-B?

I know there are a few hypervisor vendors that do heartbeats for C and D. You can use whatever solution you like as long as there's a fallback task.

> no one in embedded actually cares what RTOS you used. they are all similar enough that you won't get stuck if it's a brand new RTOS

Out of curiosity (as an outsider), how does the availability of device drivers factor in?

I assume they still need to be ported to each combination of OS and device.

I don't think that "skin in the game" means what you think it means.

I meant it as a job-seeker proving they spent time doing a sample project on a real OS, such as QNX, instead of studying leet-code trivia and thinking they're ready for a job. As an interviewer, I would always choose the one who has skin in the game.

QNX and BeOS were the only operating systems I tried in the early '00s that could make old single-core mid-90s Pentiums feel excellent and snappy to use. Far, far better than any Windows version, or Linux.

I assume it's mostly scheduler stuff and much better multimedia stacks, in both cases. I always hoped the operating systems of the future would feel more like that. Closest we've got is probably iOS and it cheats by killing processes all the time. The future is lame.

BeOS was “pervasively” multithreaded, which in non marketing speak means the kernel did not have a giant lock (since it was designed as a many core system from day #1). Its contemporary OS’s at the time had a giant single lock. BeOS also had 750ms preemption interval (or was it 3ms, I dont remember) while Linux and Windows had 20ms, then later 10ms, so this is what you fealt. A couple of decades later and most OS’s matched the finer locking granuality in kernel space, minus the premption interval (argument being throughput vs latency, since scripted OS benchmarks measure overall throughput, not GUI responsiveness). A perfect example is media buffers that benefit from smaller buffer sizes, at the cost of less throughput. Musicians notice better responsiveness in BeOS, hence the monicker “Media OS”.

Also, in GUI space, the BeOS/Haiku app server still offers a more distributed workload compared to other desktop environments. Every windows is assigned its own thread, the app gets its own thread, and the app and application server have 1 thread per app and window to ensure they are not blocked waiting for slow app message parsing. So minimum BeOS app with graphical “Hello World” window is 4 threads. So even if the app is busy, the rest of the system still feels responsive.

All this comes at a throughput cost, as well as an app development complexity cost, especially for ported apps. Haiku needs to marshall Qt/Gtk/toolkit messages from many windows into a single message queue to prevent multithreaded bugs from popping up (since in their original environment, all app message loopers were not multithreaded). This marshalling needs additional lock/unlock calls in Haiku even when not needed (messages to same window).

Haiku native apps, on the other hand, are smooth as ice. See this screenshot of Medo video editor where all windows are working in their own threads (https://raw.githubusercontent.com/smallstepforman/Medo/refs/...). On modern systems, this app is smooth as ice, which for a video editor is heresy. Disclaimer: I wrote the linked Haiku app.

> BeOS also had 750ms preemption interval (or was it 3ms, I dont remember)

3ms vs almost a second is a pretty big difference...

I non-ironically dream for the day that a modern computer is as snappy booting as my old Commodore 128, as fast to reset, and as responsive to all keystrokes.

devuan on vbox boots ~2x slower than CCS64 under emulation. If you're talking about "to a desktop" or something, i don't do that, i just boot to a shell on devuan and COMMODORE 64 BASIC V2 on the CCS64

Just install FreeDOS on it :)

Although they’re cheating, I give them props for trying. I abandoned Android when even Samsung didn’t make an honest effort to make their phones responsive. It’s nice that Apple consistently values responsiveness because then Google, Samsung and Microsoft have some incentive to address their bloated products.

As someone also have used BeOS and OS/2 Warp, I miss the snappiness of old systems. (I never got my hands on QNX)

What OS nowadays is the closest to that snappiness? Haiku OS? (I'm a happy M1 Macbook user, but it sometimes feel note nough.)

I worked with QNX on a floppy and it was the first time, after years of Windows, Mac and DOS in the 90's, that something felt so magical.

Every OS has a delay between mouse click and impact on the UI. Only QNX has ever felt sub 30ms in response time.

>What OS nowadays is the closest to that snappiness? Haiku OS?

Probably Haiku running native Haiku apps.

FreeDOS, KolibriOS, maybe ReactOS.

I never ran QNX, but my experience with BeOS were similar to yours in that a Pentium 90 felt great!

Another data point:

SGI IRIX has an unusually good scheduler. I ran a 30Mhz machine for a while and it's desktop was pretty snappy.

One day, I compiled AMP and fed it a list of .mp3 files, most being 192kbps. The program could decode 256kbps without skipping, just FYI.

Those files were on an NFS share.

When I ran the gr_osview program, CPU was 95 percent utilized, and still the file manager was responsive and that music did not skip.

Frankly, just decoding higher bitrate > 192kbps mp3 files at 30Mhz was impressive.

Doing it with a full X Window system desktop, while playing he files off an NFS share, while remaining responsive speaks to a lean and mean network stack and scheduler that performed even on low spec hardware.

Was IRIX 5.3 FYI. Indigo Elan

A friend and I enjoyed operating systems and ran Be on an old Pentium 90, and like the parent comment says, it was snappy!

Linux also has a part in this:

After a water event, that Pentium 90 was no longer reliable. Used non parity RAM and Windows NT would go slowly senile eventually blue screening over and over.

For funzies, we put Red Hat 5.2 on that box and it ran fine! The syllog had a bunch of entries every second too. Open X console, and just watch them go by...

That box served up the company web page for a coupla weeks just for fun too.

Good times.

I feel sad that people don't remember OS/2 anymore. It was also able to run multiple dos windows, have video running in the background etc, and that was in the late 90's.

There is still ArcaOS[1] that can run OS/2 applications.

[1] https://www.arcanoae.com/arcaos/

I had OS/2 Warp 4 and it was one of the best pieces of software I ever had: from the box design to contents, included software and its quality; and even voice recognition.

iOS has very strict process/resource management because it wants to preserve both available RAM (for responsiveness) and your battery life. I wouldn't call it cheating (even in jest); it's a very deliberately and carefully designed feature of the OS.

Sure, and that's fair, but to me the "cheating" is more about how it is limited to only certain types of computing. On a Mac, or indeed any non-Apple OS since Windows 3.1, you've been able to for instance, start a long-running, resource-intensive process like encoding a video, minimize that window, and open say, Minesweeper or read a text file for an hour, all knowing that the OS wouldn't dare interfere with your background task. In iOS you can be assured that the moment you background an app, iOS can and will send something to kill it at any minute, and there's not even a way to explicitly allow a certain app to be immune from being killed, even on a one-time basis.

All of this is totally by design (and thinking only of phone handsets I'm sure some people would defend this), but it is maybe the #1 thing that prevents this otherwise capable hardware from being used for more things. (Not to mention how much it hamstrings iPad OS).

This was most certainly not the case when using CD burners in windows 9x. I remember my friend being afraid of even moving the mouse while burning a CD.

Yes, but that was actual contention for resources resulting in the CD-R drive's buffer not being filled in time to keep the write operation going.

That's quite different from the operating system choosing to shoot the CD writing software in the head because you looked away from it for a moment.

most people just want a phone, to check email, watch a youtube video, check tiktak, etc. they don't want to do serious computing on their phone. I'm in that crowd. I have more computers than you can throw a stick at, I don't need that out of my phone.

And yet I can't get more than a full days use out of it if I use the phone to read news during my commute etc.

To add some details - the source code for QNX was available from 2007 until the takeover by RIM/Blackberry in 2010.

So do you plan to offer access to QNX source code again in the future?

https://www.qnx.com/news/pr_2471_1.html

Don't hold me to timelines, but we're definitely headed in the direction of being more open and transparent. We're hearing that this is important to our customers and the community alike. Stay tuned!

The stock is almost dead. Please just opensource it instead of taking all that to the grave with you. Just do it.

I just looked. BB peaked around US$140 and is now around US$2. Financials are so bad it's amazing the doors are still open.[1]

QNX is a great technology, but nobody who acquired it knew what to do with it.

[1] https://www.bing.com/entitydetails?q=BB+stock&wt=FinanceGene...

Looking at those numbers, you have to be thinking about what happens to QNX if (when?) RIM/Blackberry goes bust. You need license terms that survive bankruptcy. "We can terminate at any time" does not work in this situation.

So from what I gather, this is the third time you want to be open and transparent with your sources?

But then it will be clear that almost nothing was done in that time…

You are not John "patent troll" Chen right? Your ceo suck

he retired last year, but it's amusing to think of some exec-level ceo going onto forums to peddle merch.

with BB's stock performance : maybe?

My previous company, which made high-availability (Active/Standby) routers for mobile networks, used QNX as the OS. I remain impressed by its capabilities.

My memory is rusty, but we ran QNX on the control-plane processors, and it natively allowed launching processes on remote processors over the internal network of the router. That is: their low-level IPC was IP-capable. QNX's IPC was essential for our HA failover functionality.

Also, device drivers as user-space processes that you could restart on crash was great (we were developing our network drivers, so this would occasionally happen). Also, better respect for devices actually showing up in the /dev/ tree, unlike Linux where network devices are a notable exception.

One funny story, I once spent days debugging an issue which turned out to be due to me accidentally marking const the return values of some IPC, which caused my process to crash in between QNX's IPC function and mine! Whatever level of debugger (C/userspace) I was using at the time could not catch the error ^^;

I also worked on routes for mobile networks. Everything ran Linux, especially the control plane. Line cards were also linux, but the only task they had to do is to program the ASICS as the control plane told them to do. None of those features are relevant, you could do the IPC over HTTP or whatever you wanted.

> it natively allowed launching processes on remote processors over the internal network of the router

This was already possible in CP/NET (https://en.wikipedia.org/wiki/MP/M#CP/NET) or CP/J with JUNET [https://pl.wikipedia.org/wiki/JUNET_(CP/J)].

@JohnAtQNX can you remove the "everybody needs an account" restriction from your website downloads, and also remove the license mechanism from qcc? That would go a long way towards encouraging hobbyists to try it out.

Your money comes from high-volume licensing deals, where you presumably get a per-unit license fee. That revenue stream is jeopardized by pissing off the CI/CD teams that have to support QNX product lines.

Hiya! We've discussed how to make that work. It's good to hear the same thing from an outside voice. I'll bring it back to the table to inch it along. Thanks!

I will echo this. Back around 2000 I recall getting a QNX live CD with a magazine. That was the ultimate in low friction, I didn't even know QNX was a thing but a copy of it landed in my lap so I gave it a shot.

At the time it didn't support my sound card or modem so it was dead in the water for me but it was an interesting experience that earned the platform a near mythical spot in my mind for decades following.

Keep friction low if you want people to try your thing.

This is in the same category as VPN vendors that require a login to download their VPN client.

When you're a consultant or a random sysops person in a huge enterprise, that's infuriating. There is zero benefit to the vendor doing this, nobody can ever benefit from "pirating" a free component that can't be used without another paid component.

I've permanently blacklisted vendors for pulling this kind of thing.

Most recently Crowdstrike: I was up all weekend doing emergency server rollbacks and they had the nerve to publish critical information behind a login!

Tip: If your company ever uses the word "you" in any communication of any kind, then that company has made a serious error of understanding. There is no "you" at an enterprise customer! There's teams of many people each, and not all of them are even aware of who has an account and for what.

Or at the very least, allow people to log in using other services, like Google, et al, that plenty of other sites are using.

I'm loathe to keep adding new logins every time something new comes about. Same with news feeds, where nearly half of all news sites want you to log in, even if it is "free." At least in that case, it's easy to just go elsewhere for the same story.

Exactly. I'm more likely to go somewhere else with less friction.

I still remember being blown away by the single-floppy QNX demo that included a web browser. It was so fast.

I wish you guys the best. I can only imagine what a gordian knot it must be getting all the legal ducks in a row to actually open things up. Like others have mentioned, after two rug pulls, we're all wary, but there's so much to enjoy about QNX, I hope you manage to get traction with this.

That QNX demo floppy was _magical_ back in the late 90's, revealing just how fast things _could_ feel on a 486 DX2 or DX4 CPU compared to the same use on Linux/Windows at the time.

I've always had a somewhat positive view of QNX since then, but intermediate ownership and open/commercial status changes always kept me away from it. Sadly, this "opening" is familiar enough, and previous experience lead me to believe unless it gets a truly open GPL license and a large enough FOSS community to maintain a fork, this'll just get rug pulled again...

Kudos on your bold undertaking! I've been a side-lined QNX admirer for some time, though not a potential user in most cases. A good next step would be a series of blog posts where the author takes on common types of enthusiast projects and unpacks how QNX's strengths can be applied in those scenarios.

I’d love to see this. I’m curious about QNX but at a loss as to how it could benefit me as someone who tinkers with robotics at home.

I also work for a non-profit org which does coastal margin research. We have several people working on custom hardware. Could this benefit us?

Start with https://gitlab.com/elahav/qnx-rpi-book/-/blob/master/pdf/qnx... as an intro to tinkering at home.

We (Rizin) would love to improve QNX support of our FOSS reverse engineering and debugging framework. We already support[1][2][3][4] it, but can't reliably test. Would be awesome to have the QEMU image out of the box, just like Windows provides ready to use limited VMs for testing[5].

[1] https://github.com/rizinorg/rizin/tree/dev/librz/bin/format/...

[2] https://github.com/rizinorg/rizin/blob/dev/librz/bin/p/bin_q...

[3] https://github.com/rizinorg/rizin/blob/dev/librz/debug/p/deb...

[4] https://github.com/rizinorg/rizin/tree/dev/subprojects/rzqnx

[5] https://developer.microsoft.com/en-us/windows/downloads/virt...

You should be able to use the free QNXE Everywhere license to spin up a QEMU VM with a few clicks in the IDE. I appreciate it would be easier of it was a single-click download like the Windows image though. I'll take that feedback.

If I can help enable your QNX support in any other way, feel free to DM or message: qnxcommunityengagement at qnx dot com.

I’ve had a lot of experience in developing on QNX over the years, and with each successive year, the call to migrate to Linux got stronger. The day to day developer experience is great, you can very easily setup a CMake toolchain and bypass the need for QNX’s Momentics, which if you’re just developing for QNX is something you will want to do. But, in my experience the driver support simply isn’t there, and that became painful. A fair few major board manufacturers treat QNX integration as a complete afterthought, and at a point you start to feel that this is directly related to RIM’s decision to shutdown source access to QNX. I’ve since left that company, but I imagine there is still a call to use Linux.

I use CMake for QNX all the time. It just works, out of the box.

For anyone who (like me) was confused at what this is, it's a Unix like OS for embedded systems.

https://en.m.wikipedia.org/wiki/QNX

They are the brains of a ton of cars on the market, like all Ford cars. Used for complex calculations like automatic transmissions.

I think we're at something like 235 millions cars on the road today with QNX inside. The volume blows my mind. We're also hiding inside lots of healthcare products, industrial control systems, etc.

There's lots of interesting key differences between something based on Linux, for example, and QNX. Worth digging into if you're interested in these things. My colleague wrote a short ebook and the intro has a good summary: https://gitlab.com/elahav/qnx-rpi-book/-/tree/master/pdf

There is however also TRON:

https://ethw.org/Milestones:TRON_Real-time_Operating_System_...

which was demoed running on an 80186 with _multiple_ windows running videos w/o dropping a frame.

Described as "The most installed operating system in the world":

https://www.linuxinsider.com/story/the-most-popular-operatin...

Unfortunately, the U.S. State Department viewed the Japanese plan to place it on all computers in their educational system as anti-competitive.

Really wish it was available for the Raspberry Pi.

There is a micro kernel version that runs on RP2040 would that work for you?

Unfortunately, I want a desktop environment, so probably not.

> My colleague wrote a short ebook and the intro has a good summary

Can you recommend books or papers on how the kernel works, and what makes it better than e.g. L4/sel4 or Mach?

> They are the brains of a ton of cars on the market, like all Ford cars. Used for complex calculations like automatic transmissions.

I would seriously doubt that QNX or anything like it resembling a "real OS" is running on the automatic transmission. If the transmission controller is running any OS at all it's likely a microcontroller running a much more specialized RTOS.

QNX is very common in automotive applications, but in things like digital instrument clusters and ADAS where the software is complex enough to benefit from a full networkable OS with support for a lot of different high speed buses but the use case still needs real-time guarantees and/or microkernel stability. I've specifically seen QNX's hypervisor marketed for digital clusters where the critical data display and interaction with the ECU could happen within a fully certified QNX environment that would be designed to be as stable and reliable as possible while allowing infotainment applications to run in a VM instance of Android, Linux, or even more QNX where software reliability was less critical. If it crashes, the important instruments are still working.

Ford's "Sync 3" and "Sync 4/4A" infotainment systems run on QNX as well, though being just infotainment they didn't really care about the realtime aspect (though I'm sure stability was a big thing compared to their Windows CE based predecessors). They've moved to Android for their latest revision.

> Ford's "Sync 3" and "Sync 4/4A" infotainment systems run on QNX as well, though being just infotainment they didn't really care about the realtime aspect (though I'm sure stability was a big thing compared to their Windows CE based predecessors).

I've got a Sync 2 car, and I can't say I've noticed instability. The UI toolkit is slow, but the story on that is someone's cousin did something some Macromedia stuff that barely worked and they shipped that. I've got some issues with GPS offset, but that's pretty stable. I had worse stability with the Chrysler UConnect in my 2017 Pacifica, and that was reportedly based on QNX; it would sometimes crash and restart, or the screen would not come on at all unless you knew the magic buttons to hold to force reboot.

FWIW I have a 2015 that shipped with a late version of MyFordTouch and I upgraded in 2021 to Sync 3 hardware from a 2016 model.

Whatever version of MFT my car shipped with was pretty bad, hitting the category button in the satellite radio controls was about a 1/5 chance of a crash. It also wasn't great at handling my USB drive full of MP3s. A few months later an update came out that was actually never officially released for my car, but if you put the right files on the USB drive it installed just fine. After that update those crashes were gone. All that was left, and it happened until I upgraded the system, was maybe once every 2-3 months the Bluetooth stack crashed and took the entire media UI with it, I'd have to use the physical Source button to switch to AM/FM and then switch back to regain control though whatever was playing would keep working.

I upgraded to Sync 3 and haven't crashed it since. Sometimes it gets in a fight with my wireless android auto adapter, but it's never had an issue in wired mode which is all it officially supports so I'm not going to fault it there.

QNX was the OS behind the ICON computer that was used in schools across Ontario in the mid-80’s. At the time, I thought they were pretty cool.

https://en.wikipedia.org/wiki/ICON_(microcomputer)

I think my (American) HS had two of these just a few years later, but I didn't remember any QNX connection!

Your school might have had a PET or something, the ICONs were Canadian machines.. software had to be obtained from the government.

These machines didn't work at all without a server to network boot from, aka the LEXICON machine, so it's not likely some teacher squirreled all that across the border.

They were not commercially available.

I’d be very surprised! I thought it was very much an Ontario ministry of education thing.

Wow, I didn't know this! Thanks for sharing!

Discussed on HN at least once before: https://news.ycombinator.com/item?id=41163875

Wow. 80186. That's something you don't see every day.

Subaru runs WinCE, or still did ten years ago anyways. Hopefully they cutover to something else someday!

Does this mean it's good or bad? These companies aren't exactly the beacons of innovation.

I don't have great expectations for this, we've been rug pulled before.

https://www.osnews.com/story/23565/qnx6-is-closed-source-onc...

They then killed the self-hosted QNX entirely, no downloadable .ISOs after 6.5. No working toolchain, so porting software became difficult, pkgsrc abandoned.

They are completely noncommittal, nothing short of actually open-sourcing it, MIT/BSD, would convince me otherwise.

QNX is squeezed from above by Linux, especially as real time patches have finally been fully accepted. And from below by FreeRTOS and Zephyr. Current attempt to open source is a desperate move by QNX as their market share is disappearing. Why would anyone in their right mind step on the same landmine, called QNX, which already pulled a rug from under the developers feet once? Absolutely no trust in QNX ecosystem. Save yourself pain and aggregation. Don’t use QNX.

There are not any real time patches for Linux: there's only the low-latency kernel. Low-latency and realtime are different things. A lot of the time the two can appear superficially similar, until they don't and your airplane falls out of they sky.

The realtime executives are not operating systems. Executives and operating systems are two different things.

QNX is a realtime operating system. It addresses the niche of a realtime operating system that isn't being met by anything else out there, and has been doing so for 40 years, even if free versions for hobbyists haven't been available for many of those years. It's not about market share since that's always been there. It's about mindshare and given the comments here, that's obviously missing.

A major upgraded was landed recently: https://www.infoq.com/news/2024/10/linux-6-12-real-time/

A preemptable kernel does not make Linux a realtime OS. A low-latency kernel does not make Linux a realtime OS. There are great things in their niches but when you need a realtime OS, Linux is still not going to be fit for purpose.

> Current attempt to open source is a desperate move by QNX as their market share is disappearing

Are you sure they want to open source it? Is this just an assumption, or can you provide a reference?

I actually tried to find out whether the source code of the kernel etc. is included in the free version they provide, but they require to install a license manager on my machine, so I stopped; and it doesn't look as if it was open-source when there is a license manager (would be very easy to get around).

Please consider bringing back some legacy software.

When I was learning computers, we learned on QNX (poor kids younger than I started on Windows!) and there were some very interesting software packages that I think don't exist anymore.

For example, QPaint. What made it interesting, is that you could save your image in a few image formats, or as a C header for inclusion in a C program. It could also import/export Logo generated images.

There was also a software voice module. I assume it had different voices because when it was demoed to us, it was a robot guy voice, but later there was an educational graphical interface that looked like a girl's face, and it of course had a female voice when it spoke. It would be strange to have two things do exactly the same thing, so I suspect they were the same software for speech.

I think it was simply invoked with 'speak'. We used to prank other students by speak -something- /dev/tty.... where the tty pointed to other people's nodes on the server network. Fun times!

15 years too late (since you last snatched QNX away from us), and with a license that you can revoke at any time. What are you blackberry folk smoking?

I guess your "benevolence" is no coincidence given that real-time support was merged into the linux kernel a month ago...

In case you are wondering: QNX is a commercial Unix-like real-time operating system owned by BlackBerry, aimed primarily at the embedded systems market.

From https://www.sealevel.com/2023/01/02/what-is-qnx

The "unix-like" characterisation seems it might be be from the Wikipedia QNX article and repeated by a lot of web content. But it doesn't seem really accurate to me and it's not used by their own web site or documentation. It seems quite opposite to Unix in a lot of ways even though it has some API compatibility.

Perhaps Wikipedia by way of the old QNX FAQ? https://web.archive.org/web/20080424102623/https://www.bitct...

“In the early 80's they began work on a small message passing kernel based OS that had some user interface similarities to UNIX.”

“They called their product QUNIX, reportedly because it was a "Quick UNIX". They named their company Quantum Software Systems Limited. The QUNIX name lasted a year or two until they received notice from AT&T; that a change would be appropriate. Always ready for a challenge, they changed the spelling to QNX® without changing the pronunciation.”

It's got a POSIX API layer, but it's about as "unix-like" as Haiku.

How does it seem like the opposite? It's POSIX.

Check out eg this paper about the OS: https://cseweb.ucsd.edu/~voelker/cse221/papers/qnx-paper92.p...

Yes it has some source-level Unix compatible app-facing interfaces, but we don't call the Steam OS/Deck a Windows-like either. (eg Windows NT was also POSIX certified)

I'd definitely call the Steam Deck unix-like, although GNU/Linux is less POSIX-conformant than QNX is.

Source-level and command-level compatibility is what makes something "unix-like". Paying a hefty annual license fee to the Open Group is what makes your OS "Unix". I don't believe there is any benefit to BlackBerry paying such a fee so they can slap their logo on their web site since the US DoD is not a target market for them.

Nevertheless, arguing that something is not "unix-like" just because it's very much like Unix is, well, odd.

You should update the Wikipedia article in that case.

Typical marketing euphemism: "Built-in Support for Open-Source Components"

Read: we take free things thankfully, but we don't live by the same standards.

With linux options in embedded space aplenty, who would want to move to a propriety os? QNX's big brother Vxworks has already been pushed out of most consumer embedded devices and is now limited to space probes and critical medical equipment. I just don't see a future for QNX anywhere.

Dealing with Linux can be a PITA. Once you get a base system up you still need to roll a bunch of our own stuff. Do you use System unit or systemd, etc. The driver api's are pretty unstable.

I make embedded linux device and I'm curious if QNX could make things easier, especially for long term stability.

Not everything has to be linux. It's good to have options for avoiding monoculturalization.

It's not a real option (to Linux) though at it is still governed by a non-free license.

not everyone cares about that. They want something they know and something that works for them, not everything has to be FOSS

For real-time systems, QNX should be compared to FreeRTOS, CMSIS/RTX, VxWorks, or, if you after the new cool stuff, Zephyr, perhaps, but not Linux.

> but not Linux.

I disagree. Linux merged the real time stuff (https://news.ycombinator.com/item?id=41594862) not so long ago so it's now a real-time capable kernel, and hence it should be held comparable to other real time kernels.

Good luck certifying an automotive or an industrial system that can lead to loss of life or severe disruption if it malfunctions. As far as I am aware, QNX, VxWorks, and CMSIS have all been used in systems that passed certifications. As IoT &co. get applied more broadly in our society, they are put in more places where they are expected to function flawlessly. I would rather want my power grid or water utility operator to use CMSIS, for example, than rt-linux.

The only serious user of rt-linux which uses it to build a hard-RT system that I know is SpaceX. Look up the Reddit AMA post from them on how rt-linux is used. They are staying on a specific kernel version, had to do kernel patches (other than applying rt-linux), they use a very specific model of an old Xeon for low latency interrupts, incorrect programming of one process can disrupt the RT behaviour of another process, and most importantly, they have a secondary board, a truly real time one (PowerPC based, IIRC) to communicate with the real hardware.

One interesting morsel in all of what you described is that for all of the hoop-jumping SpaceX does to bolster rt-Linux, it is -still- easier/faster/ better by some business metric for them than the alternative.

If the redundant hardware and some ground rules they have in place have made the onboarding of developers better and faster, than perhaps it should be recognized that they seem to be prioritizing the DX - especially since plenty of applications in RT will also use redundant hardware and confine their hardware selection similarly to prioritize the performance targets of their application, SpaceX just added developers to the feature matrix.

There's BSD too (e.g. Playstation, Apple Airport, Some POS devices and printers)

> Develop open-source software (OSS) that is interoperable with QNX software, provided you make the resulting OSS publicly available at no charge.

Even the GPL doesn't have this restriction...

@JohnAtQNX the way to put the rug-pulling concerns to bed is to license all the source code under the ISC License, BSD 2-clause License, or MIT License.

This would certainly have an impact once that was done. Of course I cannot speak to what that would do to your software business...

I hear it loud and clear. We're certainly in the early days of this initiative, but as things progress I'll make sure to bring up source code licensing as a community concern.

Things aren't going to progress if you are asking people to risk you rugging them a third time. They have alternative operating systems to invest their time in that are safer.

This is very interesting and I'm happy to see this. It's probably not relevant but i'm remembering reaching out 20+ years ago for a license to use in a Darpa GC team and getting a quote for 16K which made it unavailable for our make shift team but I have a tremendous amount of respect for the company and their work to build QNX. I will probably be looking into this for something in the future.

Thanks, John. QNX has always been one of my favourite OSs (I still have my Blackberry Q10) since I learned C on it in the mid 1980’s. A full-featured multi-tasking OS running from a 360K floppy on a PC/XT is not something easily forgotten.

I’m glad the company is making this investment again.

For attracting more developers can you compile a comarison table with the benefits of QNX versus competitors?

The existing information out there is of questionable reliability and probably out of date too...

This is a good blog post idea. I'll get it on our backlog.

We need to start treating “non-commercial” as the ambivalent term that it is.

Eg: All “non-profit” and “personal” use likely isn’t necessarily “non-commercial”, but those two can be easily identified based on who it is that makes use of the software.

So what is the definition of “non-commercial”? Nothing in itself. Eg. Creative Commons elaborates a lot on what it means in that context: https://wiki.creativecommons.org/wiki/NonCommercial_interpre...

20 years too late but ok.

And about a month after the RT Linux patches were put in the kernel master.

Agreed, a walled garden is still a walled garden...

Even a $12 SoC is no longer resource constrained with a stripped minimal Linux kernel. QNX missed their launch window decades ago...

The just bought a cow and wanted to milk to death. RIM is just a slow company to react.

I worked with it in the early 2000's when it was free; though the work was for QNX itself so they would have provided a license for the duration of development regardless. I am curious how it has evolved since then.

I think people are looking at this announcement the wrong way. If you are a hobbyist who is happy with a free OS you currently use, asking yourself "what's in it for me?" then the answer is: probably nothing. But if you are interested in QNX, want to see what it can do, maybe try a project or learn how to write drivers for a microkernel-based OS, you now have a free option.

I was excited to see "free", and even more excited to read "like things used to be", but after reading more closely I see it's merely free-as-in-gratis, as opposed to the more interesting definitions.

I don't want to create an account just to know if it'll work on a pi zero w, will it?

https://blackberry.qnx.com/en/developers/board-support-packa... - no need to create an account, BSPs listed here and you can filter by several fields.

As I was scrolling down, I saw all the TI Jacinto and Sitara dev boards, and I wondered if there might be one for the Beaglebone. And indeed, scroll a bit further!

That's convenient, as I have a lot more of those sitting around than I do Pis at the moment.

Right now, in the Pi family, only the Pi 4 on the BCM2711.

TIL the Blackberry brand still exists in this space. Similar to Nokia I suppose, the consumer side no longer exists but the enterprise side is still going.

I found this a while back. Unsure if it's related https://github.com/vocho/openqnx

(I prefer 32-bit because most applications don't need more than 4GB RAM, but I guess 64-bit could be useful too)

GPL it or we pretend nothing has changed at all. No more indian-giving, put up or buy an ad!

Reminds me of this guy:

https://membarrier.wordpress.com/2017/04/12/qnx-7-desktop/

The same guy wrote the QNX Raspberry Pi book https://gitlab.com/elahav/qnx-rpi-book/