Electronics Guide

Transparency and Auditability

Safety and security reviews benefit directly from access to source. An engineer can confirm that a system call has bounded execution time, verify that an interrupt service routine does not disable interrupts longer than specified, and inspect the exact memory layout of kernel objects. Proprietary kernels often document these properties, but open source allows independent verification rather than reliance on vendor assertions.

Auditability also supports supply-chain assurance. Because the entire kernel is present in the build, an organization can reproduce binaries deterministically, scan for known vulnerabilities, and maintain the code even if the original maintainers move on. This durability is significant for products with service lifetimes measured in decades.

Cost and Ecosystem Effects

Eliminating royalties matters most in consumer and industrial products manufactured in large quantities, where even a modest per-unit license fee aggregates into substantial cost. Beyond direct savings, a large user base produces network effects: silicon vendors port their chips to popular kernels, tool authors add kernel-aware debugging, and engineers arrive already familiar with the application programming interface. These effects compound, concentrating activity around a handful of dominant platforms.

Limitations to Weigh

Open source does not eliminate every cost. Integration, configuration, certification evidence, and long-term maintenance still require engineering effort, and a freely licensed kernel shifts responsibility for these activities onto the adopting organization. Communities vary in responsiveness, and not every platform provides the certification artifacts that safety-critical domains demand. These considerations motivate the commercial support arrangements discussed later in this article.

Permissive Licenses

FreeRTOS, Zephyr, RT-Thread, and NuttX are distributed under permissive licenses. FreeRTOS adopted the MIT license when Amazon Web Services assumed stewardship in 2017, replacing its earlier modified GNU General Public License. Zephyr uses the Apache License, Version 2.0, as does RT-Thread for releases from version 3.1.0 onward, after migrating from the GNU General Public License, Version 2, in earlier releases. NuttX is likewise distributed under Apache 2.0 following its move to the Apache Software Foundation, where its license was changed from the BSD license. Permissive terms allow the kernel to be linked with closed-source application code and shipped without disclosing proprietary modifications, which suits commercial products that combine open and private components.

The Apache 2.0 license additionally includes an explicit patent grant, offering recipients defined patent rights from contributors. This provision provides clarity that the MIT and BSD licenses do not address directly, and it is one reason several foundation-hosted projects selected Apache 2.0. The convergence of RT-Thread and NuttX on Apache 2.0 from earlier GPL and BSD terms reflects a broader trend toward permissive licensing for embedded kernels.

Copyleft and Weak Copyleft

RIOT departs from this pattern. Its kernel is released under the GNU Lesser General Public License, Version 2.1, a weak-copyleft license. The Lesser GPL requires that modifications to the licensed code itself be made available under compatible terms, yet it explicitly permits an application to link against the library, including by static linking under defined conditions, without imposing copyleft obligations on the proprietary application code. This middle ground lets RIOT remain freely usable in commercial products while keeping improvements to the kernel itself open.

Stronger copyleft licenses such as the full GNU General Public License go further, requiring that derivative works as a whole be distributed under compatible terms. Engineers must therefore read the specific license accompanying any third-party module, because a project may combine a permissively licensed kernel with components carrying different obligations. Several proprietary kernels are also offered under dual-licensing arrangements, in which the same code is available under an open-source license for community use and a commercial license that removes copyleft obligations or adds indemnification. Awareness of these models helps engineers interpret the broader marketplace.

Scheduling Policies

All five kernels implement fixed-priority preemptive scheduling, in which the highest-priority ready task runs and immediately preempts lower-priority tasks. Most support optional round-robin time slicing among tasks that share a priority level, distributing processor time fairly within a band. Zephyr extends this model with additional policies, including cooperative scheduling, an earliest-deadline-first option, and metairq priorities for deferred interrupt work, giving designers finer control over mixed workloads.

The choice of priority count and tick rate affects both responsiveness and overhead. A higher tick frequency improves the resolution of time delays at the cost of greater interrupt load, so tickless idle modes that suppress unnecessary ticks during quiet periods are common across the platforms to conserve energy.

Synchronization and Communication

Each kernel provides the synchronization primitives that real-time applications require: mutexes, binary and counting semaphores, message queues, and event flags. Mutex implementations generally support priority inheritance to bound the priority inversion that arises when a high-priority task waits for a resource held by a lower-priority task. The richness of these services varies; Zephyr and RT-Thread offer broad sets including mailboxes, pipes, and memory slabs, while FreeRTOS provides a focused core supplemented by stream and message buffers.

Memory and Footprint

Footprint distinguishes the platforms sharply. FreeRTOS and RIOT target severe memory constraints, with kernels that can fit in a few kilobytes of read-only memory and a few hundred bytes of random-access memory for minimal configurations. Zephyr and RT-Thread scale from small microcontrollers upward but pull in more code as networking and subsystems are enabled. NuttX, which presents a Portable Operating System Interface compatibility layer, typically occupies more memory in exchange for a programming model familiar to developers of larger systems. All offer configuration options to compile only the features an application uses.

Symmetric Multiprocessing

As multicore microcontrollers proliferate, symmetric multiprocessing support has grown in importance. Zephyr, RT-Thread, and NuttX include symmetric multiprocessing capabilities that schedule tasks across multiple cores under a single kernel. FreeRTOS introduced symmetric multiprocessing support in its kernel as well, extending its traditionally single-core model. RIOT, oriented toward the smallest constrained nodes, focuses on single-core deployments. Multicore scheduling introduces inter-core interference and synchronization concerns that single-core analysis does not, and platform maturity in this area should be evaluated carefully.

Architecture Coverage

FreeRTOS provides official ports for a wide range of architectures, with the Arm Cortex-M family being the most common deployment target, alongside ports for Cortex-A, RISC-V, Xtensa, and various microcontroller cores. Zephyr supports Arm Cortex-M and Cortex-A, RISC-V, x86, ARC, and additional architectures, and it emphasizes a hardware abstraction layer that standardizes device access. RT-Thread covers Arm, RISC-V, MIPS, and other cores with an extensive board-support collection oriented toward the chips common in its user base.

RIOT targets low-power microcontrollers and supports Arm Cortex-M, several 8-bit and 16-bit cores in its historical lineage, and RISC-V, with an emphasis on the constrained devices typical of the Internet of Things. NuttX runs across Arm, RISC-V, Xtensa, and other architectures, and its design favors portability of its operating-system interfaces across this range.

Board Support and Device Models

Beyond the processor core, practical adoption depends on drivers for peripherals such as timers, serial interfaces, analog converters, and communication controllers. Zephyr's devicetree-based configuration describes hardware declaratively, decoupling driver code from board specifics and easing the addition of new boards. RT-Thread and NuttX maintain large driver collections, while FreeRTOS relies more heavily on silicon vendors and reference projects to supply peripheral drivers, since its kernel deliberately scopes itself to scheduling and synchronization.

Build Systems and Configuration

Zephyr employs a CMake-based build system with the Kconfig configuration framework borrowed from the Linux kernel and a west meta-tool for managing repositories, producing a highly configurable but initially complex environment. RT-Thread offers its own configuration tooling and integrates with common integrated development environments, including a package manager for add-on components. NuttX uses a Kconfig-driven configuration similar in spirit to Linux. FreeRTOS, by contrast, is frequently integrated directly into vendor-supplied development environments and is distributed as source files that drop into an existing project, lowering the barrier to a first build.

Debugging and Trace

Kernel-aware debugging, which displays task states, queue contents, and synchronization-object status, is supported across the platforms through popular debuggers and trace tools. Recording trace utilities capture context switches and interrupt events to a buffer for timeline analysis with minimal disturbance to timing, an essential capability given the probe effect that intrusive debugging introduces. The depth of integration varies, and engineers should confirm that their preferred toolchain offers kernel awareness for the chosen platform.

Connectivity and Middleware

Connectivity stacks differentiate the larger platforms. Zephyr bundles networking that includes a Bluetooth Low Energy stack, an Internet Protocol stack with both fourth and sixth version support, and constrained-device protocols. RIOT emphasizes low-power and mesh networking for the Internet of Things, including sixth-version addressing over low-power wireless. RT-Thread ships a broad middleware collection spanning file systems, graphical interfaces, and network protocols. FreeRTOS pairs with companion libraries for transport security and cloud connectivity, particularly toward Amazon Web Services, while keeping these outside the kernel proper. NuttX provides a substantial set of subsystems consistent with its operating-system-interface heritage.

Corporate Stewardship

FreeRTOS is maintained by Amazon Web Services, which acquired stewardship from the original author in 2017 and continues to develop the kernel and associated libraries. Corporate stewardship concentrates resources and provides a clear point of accountability, though it also ties the project's direction to a single organization's priorities. Commercial long-term support and additional services are available for FreeRTOS through associated offerings, giving teams a path to vendor backing when required.

Foundation Governance

Zephyr is hosted by the Linux Foundation and governed by a consortium of member companies, distributing influence across silicon vendors, tool authors, and product companies. NuttX is an Apache Software Foundation project, governed under that foundation's meritocratic model. RT-Thread is developed by a company in association with an active community and is widely deployed, particularly in its region of origin. RIOT is a community-driven project with academic roots and broad institutional participation. Foundation governance reduces dependence on any single sponsor and tends to favor vendor-neutral decision making, which appeals to organizations wary of lock-in.

Support Channels

Commercial support for these platforms is available through silicon vendors, independent consultancies, and, in several cases, the sponsoring organizations themselves. Such arrangements provide service-level agreements, certification assistance, and indemnification that pure community support cannot guarantee. For products in regulated industries, the availability of paid support and certification evidence often weighs as heavily as the technical merits of the kernel.

Resource Budget and Workload

The available memory and the nature of the workload narrow the field quickly. Severely constrained nodes favor FreeRTOS or RIOT, whose minimal footprints leave room for application code. Products that integrate networking, file systems, and graphical interfaces may benefit from the bundled middleware of Zephyr or RT-Thread, accepting a larger footprint in exchange for ready-made subsystems. Applications that demand a familiar operating-system-interface programming model may prefer NuttX.

Licensing and Compliance

License compatibility with the product's distribution model must be confirmed early. Permissive licenses simplify combining open and proprietary code, while any copyleft components require careful handling. In safety-critical and security-sensitive domains, the availability of certification artifacts, a documented development process, and commercial support may prove decisive. Engineers should also consider the longevity of the platform and the health of its community, since maintenance must continue across the product's service life.

Hardware and Tooling Fit

An existing port to the target silicon, mature peripheral drivers, and kernel-aware debugging for the chosen toolchain reduce development risk substantially. Where a platform already supports the selected board, bring-up effort falls dramatically. Conversely, adopting a kernel that requires a new architecture port introduces schedule and quality risk that should be weighed against its other advantages.