I'm John from the Developer Relations team at QNX. I'm a loooong time lurker of this forum and excited to make my first post.
I just wanted to let you know that we've kicked off a new program to start opening the doors to QNX like things used to be. Many of you probably used or tinkered with (the very open) QNX back in the day. You can now easily get a free non-commercial license to use the newest QNX. We've also just released some sample apps and a ready-to-go QNX 8.0 quick start target image for Raspberry Pi. So you can get QNX and the development tools for free now to learn, experiment, and build.
It's been a long time in the making, so I'm really excited to get to post about this first phase of the QNX Everywhere initiative. My team and management have open ears, so please share feedback about what more we can do to open things up, be more transparent, and get you what you need to create an awesome embedded QNX project.
Cheers!
So do you plan to offer access to QNX source code again in the future?
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...
with BB's stock performance : maybe?
In my opinion, any platform should be available for free for any non-commercial purpose. This is how people get started, and this is how the platform proliferates.
I might even suggest going a bit further: provide some limited support for non-commercial users, for example, make it super-easy to file a bug.
But otherwise, it's a win-win for both the free tier (students, hobbyists) and the corporate.
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?
* http://toastytech.com/guis/qnxdemo.html
* https://winworldpc.com/product/qnx/144mb-demo
* https://crackberry.com/heres-how-qnx-looked-1999-running-144...
x -> 0.0.0.x
x.y -> x.0.0.y
x.y.z -> x.y.0.zI was also coming back in to edit my comment and write that my x -> 0.0.0.x was technically wrong and the same for the others. If you stick to only single-byte values then what I wrote was correct but if the values span multiple bytes they fill in the missing 0s appropriately, as in:
256 -> 0.0.1.0
1.256 -> 1.0.1.0 x -> x3.x2.x1.x0
x.y -> x.y2.y1.y0
x.y.z -> x. y.z1.z0
x.y.z.w -> x. y. z. w
The "zeros" happen when the last number is smaller than 256 (or 65536, etc.), but it doesn't have to be. For example 10.258 is a valid way to write an IPv4 address, it's the same as 10.0.1.2.
10.0.0.3 -> ping 10.3
If you are talking about the short url, well ipv4 allows it and they needed to save space to fit on the floppy ;)
> A popular implementation of IP networking, originating in 4.2BSD, contains a function inet_aton() for converting IP addresses in character string representation to internal binary storage. In addition to the basic four-decimals format and 32-bit numbers, it also supported intermediate syntax forms of octet.24bits (e.g. 10.1234567; for Class A addresses) and octet.octet.16bits (e.g. 172.16.12345; for Class B addresses). It also allowed the numbers to be written in hexadecimal and octal representations, by prefixing them with 0x and 0, respectively. These features continue to be supported in some software, even though they are considered as non-standard.
(https://en.wikipedia.org/wiki/Dot-decimal_notation#IPv4_addr...)
Never use this.
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.
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
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.
Even a $12 SoC is no longer resource constrained with a stripped minimal Linux kernel. QNX missed their launch window decades ago...
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
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.
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.
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.
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.
Separately, I think making a GPS-synced weather station would be a fun project. QNX is often used when tight timing is needed for telemetry, so using it to collect weather (and other) data, including from pulsing hardware like an anemometer, and then publishing it to an online service would be a lot of fun.
If software-only is more your style, there may or may not be someone in the office next to me porting some classic games right now! =)
Maybe I will tell it all wrong, but I remember that for example it could be easy to do RPC on the same machine for the isolation. A client calls the server and the scheduler would switch context immediately to the server process upon IPC.
You already have to add things to microkernel-based systems to make them useful. You have to add even more to those based on separation kernels.
What would be QNX specific would be making sure the main app is always responsive to user input. That the network, DB, or other things don’t slow it down. That might be done by scheduling dedicated time for both input and the main loop. Non-blocking I/O so main loop can check the progress of other things. Maybe a monitor in there watching for freezes.
If any component freezes, have it restart and get new/updated state. If that works, next version is a two-board, highly-available system with QNX’s networked IPC.
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 ^^;
The existing information out there is of questionable reliability and probably out of date too...
That's convenient, as I have a lot more of those sitting around than I do Pis at the moment.
First there is so much text that wants to tell me how great this software/tooling/resources is, without telling me what exactly it is.
As I still wanted to know what it is, after reading your comment here†, I clicked on the front page https://blackberry.qnx.com/en which has a concise introduction
"Real-Time OS and Software for Embedded Systems
Launch your critical embedded systems faster with our commercial RTOS, hypervisor, development tools and services."
An RTOS for embedded system, aha! That would be valuable information on the QNX Everywhere page. (Real-Time OS / RTOS isn't mentioned once)
Then I found the resources section nearly at the bottom, which has quick start guide, where I can see what I will get when I sign up for a free license and that would be exactly what I (as someone who has no clue what to expect from QNX) would want to see at the top, after a short introduction to what it is and why I want to try it out.
Maybe this page is more intended for people who are already aware of QNX, but if you intend to "catch" new people I really would recommend you to reorder/simplify this page, by putting relevant information (like a short introduction, why I would want to try it and a quick start guide) at the top instead of a wall of marketing text.
† this comment was first under a comment from the author, which now got moved to the HN post text
Apple doesn't have to explain on their homepage what they do. QNX, in some sectors, has been a very well-known brand for a few decades, which is probably why their marketing material is stuck in that mode.
The obvious fact though, as your comment demonstrates, they're now just another nobody.
I make embedded linux device and I'm curious if QNX could make things easier, especially for long term stability.
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.
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.
Well I didn't and it was not easy to understand what it is from your website. Wikipedia came to my rescue. You may want to consider that.
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...
So thank you very much for the link.
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.
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.
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 wonder how far Redox's microkernel design is from what that comment describes.
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
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).
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 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.
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
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.
That totally killed my desire to develop for my flip phone.
https://www.visualcapitalist.com/music-industry-revenues-by-...
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.
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.)
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.
It applies to both sides of the argument, with organizations keeping things to themselves or others avoiding codebases for the inverse reason.
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.
They presumably can salve that horrible wound with all the money they get (not make or earn, just get) from their chosen modus operundi.
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.
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?
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.
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...
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 :-)
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.
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.
I think a fork could have some maintainers. I'd be more worried about people wanting to put new features in than anything else.
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.
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.
i have seen some try and fail in an effort to save $perceived_value
my experiences then would lead me to recommend it, though.
Forgot to mention: the neat part of RTEMS is it allows one to sort of turn a Unix program into a bare metal program.
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.
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.
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.
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.
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.
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.
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.
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.
Not open source. Those words have a specific definition[0], which QNX never met.
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.
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.
Open anything is just completely foreign to that company’s DNA. I would not trust them an inch.
What is QNX haha
Everything is a message, rather than being a file. Messaging works like a function call - you send a block of data to another process, wait, and get a reply back. Processes which receive messages act like servers - they have a thread or threads waiting for incoming requests, and when a request comes in, it's handled and a reply is sent back. It's a microservices architecture.
Unlike Linux, it's a fast microservices architecture. Message passing and CPU dispatching are integrated. When a process sends a message to a service process, the sender blocks. (Timeouts are available.) If the service process isn't busy, control immediately transfers to the service process without a trip through the CPU dispatcher. When the service process replies, the reverse happens, and control goes back to the original sender. With most inter-process communication systems, there's queuing delay for this kind of operation. QNX got this right. This is the core insight behind QNX.
Yes, there is message passing copying overhead. In practice it's under 10%. I've sent video through the message system. Copying is less of a problem than you might expect, because, with today's large CPU caches, the data being copied is probably warm and in cache.
All this is real-time aware. Higher priority processes get their messages through first. If you call a service, it inherits the caller's priority until it replies. This prevents priority inversion, where a high priority process calls a low priority one and gets preempted by lower priority work. This works so well that I was able to do compiles and web browsing on a single-CPU machine that was also running a robot vehicle.
There's a tool for building boot images. You put in the kernel, a standard utility process called "proc", and whatever else you need available at startup. For deeply embedded systems, the application might go in the boot image. It's all read-only and can execute from ROM if needed, which is good for applications where you really, really want startup to always work.
Files and file systems are optional. For systems with files, there are file system and disk drivers to put in the boot image. They run in user space. There's a standard startup program set that creates a Unix-type environment at boot time. This is all done in user space. The file system is accessed by message passing.
System calls look like POSIX. Most of them are implemented in a library, not the kernel. Service processes do the work. When an application calls POSIX "read", the library makes an interprocess function call to the file system or network service server. Program loading ("exec") is done in user space. The boot image can contain .so files. "Exec" is done by a .so file that loads the image. So the kernel doesn't have to worry about executable format, and program loading is done by untrusted code.
Because it uses POSIX, most command line UNIX and Linux programs will compile and run. That's QNX's big advantage over L4. L4 is a good microkernel, but it's so stripped down it's just a hypervisor. Typically, people run Linux on top of L4, so all the bloat comes back.
There is no paging at the OS level. That would kill real-time. There's a paging to disk library that can be used by programs such as compilers with big transient memory needs, but most programs don't use it. The effect is that responsiveness is very consistent. I miss using QNX desktop. There's no lag.
So that's an overview. Microkernel done right.
That'd be seL4.
Whereas, seL4 is a separation kernel. It does almost nothing but with high security. To do anything, you have to add software to it that can undermine its security or performance claims at a system level. These are also unproven additions most people know nothing about. That overall deal might be fine if one component being ultra-secure is your highest goal.
QNX is usually better than seL4 for most needs. Even security people because they’ll want useful functionality which they’d have to secure on seL4 anyway.
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)
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.
“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.”
(I prefer 32-bit because most applications don't need more than 4GB RAM, but I guess 64-bit could be useful too)
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.
https://ioactive.com/pdfs/IOActive_Remote_Car_Hacking.pdf or https://insights.sei.cmu.edu/blog/vehicle-cybersecurity-the-...
That was such a time. It's sad that it was a security panic, to me, because there was incredible promise there... All of the cars infotainment, windows, interior lighting, HVAC, all these things are just DBus services hosted on QNX? And I can just connect to my car & modify them, in some cases even over the air? QNX & DBus could have been a huge selling point, could have been such an awesome way to debundle the car from its infotainment. If only.
Really interested to see if DBus really does underpin much of QNX, or whether this was just a time & place. Seeing how monolithic versus networked QNX is in general would be fascinating; is there one or two QNX hosts & lots of devices, or so the story more distributed that that?
I've worked on vxWorks, QNX and Linux and I found the pace of development using Linux the fastest.
Even the GPL doesn't have this restriction...
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.
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.
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.
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!
Read: we take free things thankfully, but we don't live by the same standards.
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.
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.
3ms vs almost a second is a pretty big difference...
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).
What OS nowadays is the closest to that snappiness? Haiku OS? (I'm a happy M1 Macbook user, but it sometimes feel note nough.)
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 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.
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...
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...
Because if it does, that is worth it right there.
We ran QNX for ASI statistical multiplexing in TV. I would always fire up a game while waiting for logs.
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.
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.
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
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 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.
fwiw they have been working hard to support linux as a second option, and have been major contributors to Real Time Linux
sooooooo
> 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
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’m glad the company is making this investment again.
I feel bad for saying this because probably someone out there spent energy building political capital in the organisation and has stuck their neck out a bit to make this happen, but yeah, I'll have a look and a play, but no way would I invest serious energy into the QNX platform with these current terms.
Not that you're missing anything. I'm no wizard.
People who are not the audience need to read it to determine that they don’t need to read it because they’re not the target audience? That’s your solution over them integrating “QNX is an embedded Os” into their opening paragraph?
What a strange response to a rather simple hey could you be clearer request
[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...
I would have more interest on it if being open source.
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.
I'm old.
You lost me at step 1.
You can run linux on many workloads where QNX used to dominate, why bother then.
I have an old first-gen raspberry pi, would QNX work on that ?
I guess your "benevolence" is no coincidence given that real-time support was merged into the linux kernel a month ago...
