Introduction
So, you’re kicking off a new embedded project, congrats! Whether you’re wrangling sensors, spinning motors, or just trying to blink an LED and talk to the cloud at the same time, you’ve probably hit the age-old question: which Real Time Operating System (RTOS) should I use? Picking an RTOS can feel like walking into a hardware store with a vague idea of what you need—there are so many options, and they all promise to be just what you’re looking for. In this post, we’ll break down the key considerations to help you navigate the RTOS jungle and make a choice that won’t come back to bite you in the bootloader.
But wait, what is a RTOS?
An RTOS is a lightweight OS designed to run on embedded systems where timing is critical. Unlike general-purpose operating systems, an RTOS is built to respond to events predictably and quickly. At its core, it manages tasks, prioritizes them, and ensures they meet timing deadlines which are often within milliseconds or even microseconds. Common features include task scheduling (usually preemptive), inter-task communication (like queues, semaphores, pipes, or message buffers), and resource management (e.g., memory, peripherals). You’d use an RTOS when your system has to juggle multiple things at once like reading sensors, communicating over a network, and controlling outputs without missing a beat. It helps keep your code modular, responsive, and easier to scale as complexity grows. Let’s go through 5 commonly used RTOS, how they compare to each other and when would you choose one over the other!
Common RTOS in the wild
FreeRTOS
FreeRTOS is one of the most widely used open-source RTOS options in the embedded world. It’s lightweight, simple to integrate, and has strong support across a broad range of MCUs. It is managed by Amazon who fully integrated security/connectivity libraries and provides a tight integration with AWS IoT. FreeRTOS is great for smaller systems that need task management without a ton of overhead. It has a massive user base, which means plenty of community help and examples. The FreeRTOS community is also actively working on Safety Certified FreeRTOS which will be certified for use in certain safety-critical systems.
Zephyr
Zephyr is a scalable, open-source RTOS backed by the Linux Foundation. It targets everything from small embedded devices to more capable IoT nodes and supports a wide range of hardware. Zephyr includes a modern device driver model, a built-in configuration system (via Kconfig and devicetree), and a rich set of features such as networking, file systems, security, and more. Its highly configurable build system allows developers to optimize for minimal memory footprint or expand to include advanced capabilities as needed. The project also offers a broad set of modular components, such as Bluetooth stacks, USB device support, and sensor frameworks, making it a powerful platform for connected and feature-rich embedded applications. Since Zephyr specializes in abstracting hardware-specific logic from application logic using various abstraction methods mentioned above, it is great for cross platform or if you would like to quickly port your applications between different versions/boards.
ThreadX
ThreadX used to be part of Microsoft’s Azure RTOS suite but has now transitioned to an open-source model under the Eclipse Foundation, becoming Eclipse ThreadX. It is a compact, high-performance RTOS with a reputation for speed and simplicity. It features an elegant API and ultra-low context switch times. It’s often found in consumer electronics, medical devices, and IoT products. Eclipse ThreadX also offers components like a file system (FileX), networking (NetX Duo), and USB stack (USBX).
embOS
embOS is a commercial RTOS developed by SEGGER, known for its small footprint, fast context switching, and zero royalties. It’s designed for high reliability and real-time performance. embOS integrates well with SEGGER’s ecosystem, including debugging and trace tools like SystemView and Ozone. While the core kernel is compact and monolithic, it supports modular extensions through SEGGER’s middleware stack. embOS is also available in a safety-certified version (embOS-Safe) and prequalified for standards like IEC 61508, and ISO 26262.
µC/OS & CesiumRTOS
Originally developed by Micrium and widely adopted across safety-critical industries, µC/OS (including µC/OS-II and µC/OS-III) is a proven RTOS known for its deterministic behaviour, clean architecture, and extensive documentation. While Silicon Labs now owns the Micrium brand and maintains Micrium OS for their own hardware platforms, Weston Embedded Solutions is the official maintainer of µC/OS, which is open source now, for general embedded use. Weston Embedded provides ongoing updates and safety-certification packages (such as for FDA, ISO 26262, IEC 61508).
Weston Embedded also offers CesiumRTOS, a modern evolution of µC/OS-III. While µC/OS continues to be maintained for compatibility and long-term support, CesiumRTOS is a clean, enhanced implementation with new features, additional architecture support, and active development. Both options come with safety certification support and commercial licensing, making Weston Embedded a go-to resource for embedded teams building high-reliability systems.
General Differences to Consider
| RTOS | License | Footprint (min ROM) | Cloud Integration | Community Support |
| FreeRTOS | MIT (Open Source) | ~5-10 KB | AWS | Huge open-source community, very active |
| Zephyr | Apache 2.0 (Open Source) | ~2-8 KB | Optional (via modules) | Growing open-source ecosystem with Linux Foundation backing |
| ThreadX | MIT (Open Source) | ~2 KB | Azure | Moderate; small dev community post-transition |
| embOS | Commercial (SEGGER) | ~1.7 KB | None | Vendor-supported, strong tooling, small public community |
| µC/OS | Apache 2.0 (Open Source) | ~6-24 KB | None, manual integration | Small but stable |
| CesiumRTOS | Commercial (Weston Embedded) | ~6-24 KB | None, integration-friendly | Actively supported by Weston Embedded, commercial access |
More Technical Differences to Consider
| RTOS | Kernel Type/Scheduling | Modularity | Portability | Debugging/Tracing | Safety/Certification |
| FreeRTOS | Simple, preemptive/cooperative, SMP | Minimal, monolithic with optional components/libraries | Very portable, wide MCU support | Basic, enhanced via 3rd-party tools like SEGGER SystemView | In progress. Commercial SAFERTOS pre-certified |
| Zephyr | Microkernel-like, SMP support | Highly modular with Kconfig/devicetree | Modern HAL + devicetree, flexible | Built-in tools, setup can be complex | In progress, not fully mature |
| ThreadX | Fast context switching, preemptive | Tight core, modular Azure RTOS suite | Excellent portability, now under Eclipse | TraceX included, good visualization | Certifiable, used in regulated industries |
| embOS | Priority-based, preemptive, non-SMP | Monolithic, modular via SEGGER tools | Highly portable, SEGGER-supported ports | Deep integration with SEGGER SystemView/Ozone | Certifiable, used in safety-focused projects |
| µC/OS | Deterministic, preemptive with time slicing | Highly modular, legacy structure | Portable especially for Cortex-M, customizable | Advanced tools (SEGGER SystemView, uC/Probe) | Certifiable for FDA, IEC 61508, ISO 26262, etc. |
| CesiumRTOS | Enhanced deterministic kernel preemptive with extensions | Modular with improved abstraction and integration options | Extended platform support (ARM, RISC-V, etc) | Advanced tools (SEGGER SystemView, uC/Probe) | Certification-ready, with modern compliance packages |
Which RTOS Should You Choose?
Choosing the right RTOS depends on your application, hardware, and team experience. Here’s a quick cheat sheet with those RTOSes included in this blog post:
- Use FreeRTOS if you want fast startup, a huge community, and lightweight scheduling for a small MCU which is battle-tested and well-documented, especially for resource-constrained systems.
- Use Zephyr if you’re working on a complex or scalable IoT/network platform and want modern tooling, open-source flexibility, cross-platform/portability and an active development community.
- Use ThreadX if you’re targeting an IoT or consumer device, want performance and a clean, mature API.
- Use embOS if you’re already in the SEGGER ecosystem and need a small-footprint RTOS with excellent tooling, strong commercial support, and safety certification options.
- Use µC/OS if you’re building a cost-sensitive or non-critical embedded system and want a proven, open-source RTOS with minimal overhead.
- Use CesiumRTOS if you’re developing a safety-critical product and need certification artifacts, ongoing support, and a modernized, production-ready RTOS.
Remember, these are general recommendations, not strict rules. There are many excellent RTOS options out there, and the best choice always depends on your specific project needs, constraints and ecosystem. Use these recommendations as a starting point, but be sure to evaluate each option carefully based on your needs.
Conclusion
There’s no one size-fits-all answer, but understanding your project’s requirements and the trade-offs of each RTOS will help you make a confident choice. And remember, whichever RTOS you pick, the key is how you use it. Good architecture, solid debugging practices, and clear task design will get you further than any kernel flag or preemption tweak. If you have questions about selecting an RTOS or designing and implementing your RTOS project, Dojo Five can help you with all aspects of your embedded project.
Book a call with us to get the conversation started. Or, check out our CI build platform and increase your productivity.
We look forward to hearing from you! -D5
References
- FreeRTOS
- Zephyr
- ThreadX
- embOS
- µC/OS/CesiumRTOS
- – https://weston-embedded.com/products/cesium
- – https://weston-embedded.com/micrium-software
- – https://github.com/weston-embedded
- – https://www.mouser.com/datasheet/2/266/ucos-iii_datasheet-2239.pdf?srsltid=AfmBOopsszmOyg03p12L7X-CrnFCMVYvEDZ1XxN-79tjKXcHuza__A5X
- – https://www.weston-embedded.com/cesium-kernels
