I need to choose a real-time operating system (RTOS) for a new IoT device. What are my best options?

For a new IoT device, I’d narrow the field to Zephyr, FreeRTOS, Eclipse ThreadX, and Apache NuttX. The best choice depends less on raw RTOS performance than on your MCU, connectivity stack, security/update requirements, certification needs, and team expertise.

My shortlist

1. Zephyr Project — my default choice for a new IoT product

I'd start here unless you have a strong reason not to.

Zephyr is designed specifically for resource-constrained connected devices and supports a very large range of architectures and boards. The project currently advertises 1,000+ supported boards, while its documentation emphasizes networking, device drivers, power management, filesystems, and other modular subsystems.

It also uses a permissive Apache 2.0 license, making it attractive for commercial products.

Choose Zephyr if:

• You're starting a product from scratch.
• You want to avoid being locked into one silicon vendor.
• The device needs Bluetooth, Wi-Fi, Thread, Matter, networking, OTA, etc.
• You expect the product to evolve over many years.
• You want a substantial open-source ecosystem.

Potential downside: Zephyr has considerably more concepts and configuration machinery than bare-bones FreeRTOS. Your team needs to be comfortable with its build/configuration ecosystem.

2. FreeRTOS — safest conventional MCU choice

FreeRTOS remains an excellent choice when the device is relatively constrained and you primarily need a reliable scheduler/kernel plus selected connectivity components.

It supports 40+ architectures, is MIT-licensed, and has LTS releases. Its ecosystem also includes connectivity, security and OTA libraries.

Importantly, you don't have to use AWS: FreeRTOS is cloud-neutral and can connect to other cloud services.

Choose FreeRTOS if:

• Your MCU has tight RAM/flash constraints.
• Your developers already know FreeRTOS.
• Your silicon vendor has an excellent FreeRTOS SDK.
• You want a relatively straightforward RTOS kernel.
• You're using AWS IoT and want the shortest path to AWS's ecosystem.

I'd particularly favor it for a simple sensor, actuator, wearable, gateway peripheral, or battery-powered MCU device.

3. Eclipse ThreadX — strong for industrial/commercial requirements

ThreadX is worth serious consideration when reliability, established middleware, and functional-safety certification matter. Eclipse describes ThreadX as vendor-neutral, open source, permissively licensed, and safety certified.

It's particularly interesting if your product has requirements that go beyond "make an IoT gadget work"—for example industrial equipment or products with demanding lifecycle/certification requirements.

Choose ThreadX if:

• You're building industrial/embedded equipment.
• Certification is important.
• You want mature middleware around the RTOS.
• Your MCU vendor already provides strong ThreadX integration.
• Your organization has existing ThreadX expertise.

4. Apache NuttX — excellent if POSIX matters

NuttX takes a notably Unix/POSIX-oriented approach while remaining suitable for small microcontrollers. Its documentation describes it as scalable from 8-bit through 64-bit MCU environments, with POSIX and ANSI standards as major design influences.

Choose NuttX if:

• You want POSIX-like APIs.
• You expect software portability from a Linux/Unix environment.
• Your application is relatively OS-like.
• You need a small footprint but don't want a purely traditional MCU RTOS model.

What I'd choose by product type

• Battery-powered BLE/Thread/Matter sensor: Zephyr
• Simple MCU + Wi-Fi/BLE + cloud: FreeRTOS or Zephyr
• AWS-centric IoT product: FreeRTOS
• Industrial controller: ThreadX or Zephyr
• Safety-critical/regulated product: ThreadX, or Zephyr if its certification story fits your requirements
• POSIX-oriented embedded application: NuttX
• Highly resource-constrained MCU: FreeRTOS
• New product with uncertain future hardware: Zephyr
• Existing team with deep FreeRTOS experience: probably FreeRTOS unless another requirement argues strongly otherwise

The decision I'd make

If I were starting a greenfield connected IoT device in 2026, my initial evaluation would be:

1. Zephyr → 2. FreeRTOS → 3. ThreadX → 4. NuttX

But I wouldn't make the final decision until testing the RTOS on the actual MCU and radio module. Driver quality, power consumption, boot time, OTA mechanism, memory footprint, and vendor support can matter much more than benchmark numbers.

If you tell me your MCU/SoC (e.g. ESP32, STM32, nRF52/nRF54, RP2040, i.MX, RISC-V), connectivity (BLE/Wi-Fi/Thread/LTE), RAM/flash, battery constraints, and whether you need Matter or OTA, I can narrow this down to a specific recommendation and architecture.

Choosing the right Real-Time Operating System (RTOS) for an IoT device depends heavily on your hardware constraints, connectivity needs, and licensing preferences.

The top RTOS options for modern IoT development stand out for distinct use cases:

• FreeRTOS
  • Best for: Lightweight, resource-constrained microcontrollers.
  • Pros: Widely deployed, highly reliable, extremely small memory footprint, and backed by Amazon Web Services (AWS) with robust commercial support (AWS IoT libraries). It uses a permissive open-source MIT license.
  • Cons: Minimalist by design. You often have to integrate your own networking stacks, security, and middleware for complex connected devices.
• Zephyr RTOS
  • Best for: Modern, highly connected IoT devices utilizing Bluetooth LE, Thread, or Matter.
  • Pros: Backed by the Linux Foundation under an Apache 2.0 license. Offers a modular, highly scalable architecture with native, built-in networking stacks, security features, and file systems.
  • Cons: Steeper learning curve than FreeRTOS due to its comprehensive configuration system (Devicetree and Kconfig).
• Azure RTOS (Eclipse ThreadX)
  • Best for: Commercial products requiring pre-certified safety and industrial standards.
  • Pros: Highly optimized, rapid context-switching, and comes with a deep suite of tightly integrated middleware (USB, file systems, networking). Now part of the Eclipse Foundation, making it fully open-source.
  • Cons: Transitioning ecosystems can feel complex compared to the grassroots community of Zephyr or FreeRTOS.
• Embedded Linux (with PREEMPT_RT)
  • Best for: High-performance gateway devices or smart displays with hefty processors (Cortex-A or similar).
  • Pros: Full POSIX compliance, massive driver availability, and easy integration with heavy application software, databases, or web servers.
  • Cons: Requires significantly more RAM and flash storage; not suitable for tiny, battery-powered microcontrollers.

Developer Perspectives

“FreeRTOS is a strong choice for simple applications where minimal overhead and familiarity matter most. Its lightweight footprint and large install base make it dependable.”

To help narrow down the ideal choice, tell me:

• What microcontroller or hardware architecture (e.g., ARM Cortex-M, ESP32, RISC-V) are you using?
• What kind of connectivity do you need (Wi-Fi, BLE, Cellular, Thread)?
• Are there any power or memory constraints (e.g., battery-powered vs. wall power)?

Choosing the right real-time operating system (RTOS) for an IoT device depends heavily on your hardware constraints (RAM/Flash), connectivity needs (Wi-Fi, BLE, Cellular), safety certifications, and licensing preferences.

The top options for IoT development stand out for distinct use cases:

• FreeRTOS
  • Best for: Lightweight microcontroller-based IoT devices and AWS-connected products.
  • Why choose it: It is the undisputed lightweight king of microcontrollers (MCUs). It has a tiny memory footprint, massive community support, exceptional chip vendor backing, and deep integration with Amazon Web Services (AWS) via FreeRTOS libraries. If you need safety certification, SafeRTOS offers a pre-certified derivative.
• Zephyr Project
  • Best for: Modern, highly connected, and modular IoT devices using ARM, RISC-V, or x86.
  • Why choose it: Backed by the Linux Foundation, Zephyr RTOS features a powerful build system, robust native security features, and a rich built-in stack for connectivity like Bluetooth Low Energy (BLE) and Wi-Fi. It is heavily adopted by silicon heavyweights like Nordic and NXP, making it ideal if you want a standardized, highly modular open-source ecosystem.
• Eclipse ThreadX (formerly Microsoft Azure RTOS)
  • Best for: Commercial products requiring pre-certified safety components and tight enterprise cloud integration.
  • Why choose it: Now open-source under the Eclipse Foundation, Eclipse ThreadX offers ultra-fast context switching and a tiny footprint. It includes fully integrated middleware (USB, file systems, network stacks) that come with industrial and medical safety pre-certifications out of the box, saving immense time and testing capital.
• Apache Mynewt
  • Best for: Ultra-low-power connected devices heavily reliant on BLE and secure Over-The-Air (OTA) updates.
  • Why choose it: Apache Mynewt was built from scratch for IoT. Its standout feature is "Newt," a robust image manager and bootloader designed to safely handle multi-image firmware swapping over constrained wireless links.
• NuttX (Apache NuttX)
  • Best for: Complex IoT edge devices transitioning from bare-metal to POSIX compliance.
  • Why choose it: Apache NuttX emulates a mini-Linux environment while keeping a strict RTOS deterministic footprint. It’s a great fit if you want to port standard POSIX/Unix C-applications to a resource-constrained microcontroller.

Community Insights

Developers weighing these frameworks often highlight the ecosystem and tooling trade-offs:

To help narrow down the ideal choice, tell me:

• What microcontroller or processor architecture (e.g., STM32, ESP32, Nordic nRF52/53, RISC-V) are you targeting?
• Does your device require safety certifications (like medical IEC 62304 or automotive ISO 26262)?

For a new IoT device, I’d narrow the field to Zephyr, FreeRTOS, and Eclipse ThreadX first. The right choice depends heavily on your MCU, connectivity, memory budget, safety requirements, and whether you want a broad OS or a minimal kernel.

My shortlist

1. Zephyr — my default choice for a new IoT product

I'd put Zephyr at the top of the list if you're starting a product today and don't have a strong reason to choose something else.

It is specifically designed for resource-constrained connected devices, supports a very broad range of architectures, and includes networking, device drivers, filesystems, power management, security facilities, and other functionality as integrated subsystems.

Its hardware coverage is particularly attractive: current documentation lists architectures including ARM, RISC-V, x86, Xtensa, ARC, MIPS, SPARC and others, with extensive board support.

Choose Zephyr when:

• You're building a connected sensor, wearable, appliance, tracker, or industrial IoT device.
• You expect the product to evolve across different MCUs.
• You need Bluetooth LE, Thread, Wi-Fi, IPv6, CoAP, MQTT, etc.
• You value an open-source, vendor-neutral ecosystem.
• You want integrated device-tree/Kconfig-based configuration.
• You anticipate needing more OS functionality as the product grows.

Zephyr 4.4, released in April 2026, also moved to a twice-yearly major-release cadence, which is useful for product planning.

2. FreeRTOS — the safe, simple MCU choice

FreeRTOS is probably the best choice when your priority is a small, familiar RTOS kernel with a huge MCU ecosystem.

It supports 40+ processor architectures and has a small footprint, while its ecosystem includes networking, SMP, IPv6, and IoT/cloud integrations. The kernel is MIT-licensed.

Choose FreeRTOS when:

• You're using a conventional Cortex-M/RISC-V MCU.
• RAM/flash are very constrained.
• Your team already knows FreeRTOS.
• Your chip vendor has excellent FreeRTOS support.
• You want maximum freedom to build your own firmware architecture around a relatively minimal kernel.
• Getting a prototype running quickly matters more than having an integrated OS platform.

The major philosophical difference is that FreeRTOS is more "RTOS kernel + libraries", whereas Zephyr feels more like a complete embedded OS.

3. Eclipse ThreadX — worth considering for established commercial products

Eclipse ThreadX is a strong option if you're building an industrial/commercial product where a mature embedded ecosystem and predictable engineering environment are important.

I'd particularly investigate it if your MCU vendor already has excellent ThreadX integration or your organization has existing ThreadX expertise.

4. NuttX — if you want POSIX/Linux-like development

NuttX becomes interesting when you want substantially more OS functionality and a POSIX-oriented programming model than you typically get with a minimal MCU RTOS.

It's a particularly good candidate for relatively capable MCUs/MPUs where you're doing more complex networking, storage, peripherals, or applications.

What I'd pick

A rough decision tree:

• Small battery-powered sensor → FreeRTOS or Zephyr
• New connected consumer IoT product → Zephyr
• Bluetooth LE/Thread/Matter-heavy product → Zephyr
• Very constrained MCU → FreeRTOS
• Industrial product with an established RTOS/vendor ecosystem → ThreadX
• Complex MCU application wanting POSIX APIs → NuttX
• Linux-class processor/gateway → Embedded Linux rather than an MCU RTOS

One important point: don't choose the RTOS before choosing the MCU/SoC and wireless stack. Hardware support can overwhelm almost every other consideration. For example, if your chosen SoC has first-class Zephyr support but only mediocre support for another RTOS, Zephyr may be the obvious choice.

If you give me your MCU/SoC, RAM/flash, wireless technology (BLE/Wi-Fi/Thread/LoRa/etc.), battery-powered vs. mains, and whether you need Matter or OTA updates, I can narrow this down to 2–3 concrete choices and compare their architecture, licensing, memory footprint, tooling, security, and long-term maintenance.

4. NuttX — if you want POSIX/Linux-like development

NuttX becomes interesting when you want substantially more OS functionality and a POSIX-oriented programming model than you typically get with a minimal MCU RTOS.

It's a particularly good candidate for relatively capable MCUs/MPUs where you're doing more complex networking, storage, peripherals, or applications.

What I'd pick

A rough decision tree:

For a new IoT device, I’d put Zephyr, FreeRTOS, and Eclipse ThreadX at the top of the shortlist. The “best” choice depends heavily on your MCU, RAM/flash budget, connectivity, safety requirements, and how much OS functionality you want out of the box.

1. Zephyr — my default choice for a new IoT product

I'd choose Zephyr first if you're starting a product from scratch and expect it to evolve over several years.

It's designed specifically for resource-constrained embedded and IoT systems, with networking, device drivers, power management, filesystems, security-related facilities, and multiple hardware architectures integrated into one ecosystem. Its kernel supports ARM, RISC-V, x86, Xtensa and several other architectures.

Hardware breadth is a major advantage: the project currently advertises 1,000+ supported boards, and its documentation provides an extensive board/shield catalog.

It is also Apache 2.0 licensed, although individual imported components can have different licenses.

Choose Zephyr if: you're building a connected product, want portability between MCU vendors, need substantial networking/security functionality, or don't want your application architecture tied to one silicon vendor.

---

2. FreeRTOS — safest conventional choice

FreeRTOS is still an excellent choice, particularly when your device is fundamentally an MCU application with a relatively small number of tasks.

It supports 40+ processor architectures, has a small footprint, and includes networking and IoT-oriented libraries. The kernel is MIT licensed, and AWS maintains LTS libraries with two years of security/critical-fix coverage.

The ecosystem is enormous, which can substantially reduce development risk: MCU vendors frequently provide FreeRTOS examples, BSPs, middleware integrations, and debugging support.

The distinction I'd make is:

FreeRTOS is fantastic when you want an RTOS kernel and selectively assemble the rest of the system. Zephyr is more attractive when you want an integrated embedded OS platform.

Choose FreeRTOS if: your MCU vendor has excellent FreeRTOS support, you have tight memory constraints, your team already knows it, or you're building an AWS-oriented IoT product.

---

3. Eclipse ThreadX — particularly interesting for industrial products

Formerly associated with Azure RTOS, ThreadX is now an Eclipse Foundation project.

It goes beyond the kernel: the suite includes NetX Duo networking, FileX, USBX, GUIX, LevelX, and TraceX. Eclipse describes it as an open-source, safety-certified RTOS under a permissive license.

That's compelling if your product needs a fairly complete embedded software stack rather than just scheduling and synchronization primitives.

Choose ThreadX if: you're building industrial/medical/automotive-adjacent equipment, need safety certification, or value a cohesive embedded software suite.

---

4. Apache NuttX — worth considering for POSIX-oriented teams

NuttX is an interesting alternative if your developers are comfortable with Unix/POSIX concepts. It implements a substantial portion of POSIX functionality, including POSIX threads.

I'd consider it particularly for more capable MCUs where you're approaching the boundary between a traditional RTOS-based firmware architecture and a small embedded operating system.

---

My practical decision tree

If I were selecting today:

• New general-purpose IoT product → Zephyr
• Small MCU + simple deterministic firmware → FreeRTOS
• AWS ecosystem + FreeRTOS expertise → FreeRTOS
• Safety/industrial requirements → Eclipse ThreadX or a safety-certified Zephyr/FreeRTOS offering
• POSIX/Linux-like application architecture → NuttX
• Single-vendor MCU with excellent proprietary SDK → seriously consider the vendor's RTOS/BSP

One important caveat: RTOS selection should come after selecting the MCU—or at least simultaneously with it. A theoretically superior RTOS is a poor choice if your chosen wireless SoC has immature drivers, poor power-management support, or an awkward SDK integration for that RTOS.

If you give me your MCU/SoC (or candidates), RAM/flash, wireless technology (Wi-Fi/BLE/Thread/LoRaWAN/etc.), power target, and whether you need OTA updates/security certification, I can narrow this to 2–3 concrete choices and compare them on memory footprint, networking, tooling, licensing, security, and long-term maintainability.

Your best options for a new IoT device are FreeRTOS, Zephyr RTOS , and ThreadX (now part of Eclipse), as they offer the optimal balance of resource efficiency, active community support, and native connectivity stacks.

Top RTOS Options Compared

Choosing the Right Fit for Your Device

• FreeRTOS : Go with this if you are building a simple or highly constrained sensor node, want an immediate selection of vendor-supplied hardware abstraction layers (HAL), or need straightforward integration with cloud ecosystems like AWS IoT.
• Zephyr RTOS : Choose this if your device relies heavily on complex multi-protocol wireless stacks (such as Bluetooth Low Energy, Thread, or Matter) where security and network connectivity must be embedded directly into the core kernel.
• ThreadX : Ideal if you require ultra-fast, deterministic performance with a tiny memory footprint alongside deep commercial backing and safety-critical certifications.

“FreeRTOS is a strong choice for simple applications where minimal overhead and familiarity matter most. Its lightweight footprint and large install base make it dependable, but developers often find themselves assembling additional components, connectivity...”

“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.”

If you want to narrow this down, let me know:

• What is the target microcontroller or SoC architecture (e.g., ARM Cortex-M, RISC-V, ESP32)?
• Does your device require complex wireless stacks like Wi-Fi, BLE, or Matter?
• Are you bound by any safety or security certification mandates (e.g., IEC 61508, PSA Certified)?

For a new IoT device, I’d shortlist Zephyr, FreeRTOS, and Eclipse ThreadX. The right choice depends heavily on your MCU, connectivity, memory budget, safety requirements, and how much OS functionality you want versus a minimal kernel.

My default recommendation: Zephyr

For a new connected IoT product in 2026, I'd start with Zephyr unless there's a strong reason not to.

Zephyr is specifically designed for resource-constrained embedded and IoT devices, supports a very broad range of architectures—including ARM, RISC-V, x86, Xtensa and others—and provides networking, filesystems, device drivers, power management, security-related facilities and OTA/device-management infrastructure.

It also has a particularly attractive licensing model for commercial products: the project is primarily Apache 2.0, while some imported components have their own licenses that you'll want to audit for your particular firmware configuration.

Choose Zephyr if:

• You're building a connected product rather than just an MCU application.
• You expect the product family to use multiple MCUs or potentially migrate architectures.
• You need Bluetooth, Wi-Fi, Thread, Matter, TCP/IP, USB, filesystem, OTA, etc.
• You value an open, vendor-neutral ecosystem.
• You want a path toward a larger embedded platform rather than just a scheduler.

When I'd choose FreeRTOS instead

FreeRTOS is probably the better choice if simplicity and minimal footprint are your top priorities.

Its kernel is MIT-licensed, has support across 40+ architectures, and has extensive semiconductor/vendor ecosystem support. AWS also provides LTS releases; current LTS libraries receive security updates and critical bug fixes for two years.

I'd lean FreeRTOS when:

• You're using a relatively small Cortex-M MCU.
• Your application is mostly sensors → processing → communications.
• Your chip vendor provides an excellent FreeRTOS BSP/examples.
• You want the smallest conceptual jump for an embedded team.
• You don't need Zephyr's broader integrated OS ecosystem.

A useful distinction is "kernel" versus "operating-system platform." FreeRTOS can give you an excellent RTOS kernel and a collection of libraries, whereas Zephyr tends to give you more of the integrated embedded platform out of the box.

When ThreadX makes sense

Eclipse ThreadX is worth serious consideration for industrial/commercial products, especially when mature embedded middleware and safety considerations matter.

The Eclipse project now provides ThreadX as an open-source, vendor-neutral RTOS, along with NetX Duo, FileX, GUIX, USBX, LevelX and TraceX as part of the broader suite.

I'd investigate ThreadX particularly if:

• Your team already has ThreadX/Azure RTOS expertise.
• Your MCU vendor has strong ThreadX integration.
• You need its integrated networking/filesystem/USB stack.
• Functional-safety requirements influence the architecture.

A practical decision tree

Tiny battery-powered sensor → FreeRTOS or Zephyr
BLE/Thread/Matter connected device → Zephyr
Wi-Fi IoT product → Zephyr or FreeRTOS, depending heavily on the silicon vendor's SDK
Industrial controller → ThreadX or Zephyr
Safety-critical product → evaluate certified variants/processes first, rather than choosing solely on technical features
Multiple MCU vendors / long product family → Zephyr
Fastest development on a specific vendor MCU → whichever RTOS has the best-supported BSP/SDK for that chip

One important caveat: the MCU should be part of the decision, not an afterthought. A theoretically superior RTOS can be the wrong choice if your chosen SoC has immature drivers, radio integration, bootloader support, or power-management support for it.

If you tell me your MCU/SoC (e.g. nRF52840, ESP32, STM32, RP2040, NXP, TI), RAM/flash budget, wireless protocol, battery vs. mains power, and whether you need Matter/OTA, I can narrow this to a specific recommendation and architecture.

Choosing a real-time operating system (RTOS) for an IoT device depends heavily on your hardware constraints, connectivity needs, and whether you prefer a minimalist kernel or a fully integrated "batteries-included" stack.

The top options dominating the IoT landscape offer distinct advantages:

1. FreeRTOS (AWS)

• Best for: Resource-constrained microcontrollers (MCUs) and quick time-to-market.
• License: Open-source (MIT)
• Key Characteristics: It has a tiny memory footprint (down to a few KB) and supports a massive array of microcontroller architectures. Because it is backed by AWS, it features robust, native libraries for connecting smoothly to cloud services, MQTT, and over-the-air (OTA) updates.
• The Trade-off: It is strictly a kernel and basic libraries. You often have to source or write your own drivers, security implementation, and complex networking stacks.

2. Zephyr Project (Linux Foundation)

• Best for: Modern, highly connected IoT devices utilizing Bluetooth Low Energy (LE), Thread, or Matter.
• License: Open-source (Apache 2.0)
• Key Characteristics: Backed by heavy hitters like Intel, Nordic, and Google, Zephyr is modular, scalable, and features a device-tree configuration model borrowed from Linux. It comes with pre-integrated networking, robust security/isolation features, and a vast collection of built-in drivers.
• The Trade-off: It has a steeper learning curve and a slightly larger memory footprint than vanilla FreeRTOS.

3. ThreadX (Microsoft Azure RTOS)

• Best for: Commercial-grade, high-performance, or safety-certified IoT modules.
• License: Open-source / Permissive commercial terms (historically commercial, transitioned under Microsoft)
• Key Characteristics: Extremely deterministic, ultra-small footprint (picokernel architecture), and rich pre-certified middleware options. Ideal if you are deeply tied into the Azure IoT ecosystem or need strict safety readiness.

4. RT-Thread

• Best for: Resource-rich IoT devices wanting an object-oriented, modular C approach.
• License: Open-source (Apache 2.0)
• Key Characteristics: Highly scalable (ranging from a tiny Nano kernel up to a fully-loaded IoT OS with an online package management tool). It feels structured and intuitive if you want a rich component ecosystem out of the box.

Community Perspectives

FreeRTOS vs Zephyr

“FreeRTOS is a strong choice for simple applications where minimal overhead and familiarity matter most. Its lightweight footprint and large install base make it dependable, but developers often find themselves assembling additional components, connectivity...”

“Zephyr RTOS enters this landscape with a different proposition. As an open-source RTOS backed by the Linux Foundation, it emphasizes modularity, scalability, and built-in support for modern connectivity standards. Instead of treating networking and security...”

To help narrow down the best fit, could you tell me:

• What microcontroller or chip family (e.g., STM32, ESP32, Nordic nRF52/nRF53) are you targeting?
• What kind of connectivity protocols do you need (Wi-Fi, BLE, Cellular, Thread/Matter)?

When choosing a real-time operating system (RTOS) for a new IoT device, the best option depends heavily on your hardware constraints, connectivity requirements, and long-term maintenance strategy.

The embedded landscape is dominated by three main contenders, each representing a different design philosophy.

Top RTOS Options for IoT

• FreeRTOS
  • Best for: Resource-constrained microcontrollers, fast prototyping, and minimal overhead.
  • Profile: A lightweight, battle-tested kernel with a tiny memory footprint (around 5 KB to 10 KB). It gives you complete architectural control, but leaves networking, security, and peripheral drivers up to you or vendor SDKs.
  • License: MIT (commercial-grade safety certified variant is available as SafeRTOS).
• Zephyr RTOS
  • Best for: Complex, connected IoT devices needing built-in stacks (Bluetooth, Wi-Fi, Matter, Thread) and hardware portability.
  • Profile: A "batteries-included," modular operating system framework backed by the Linux Foundation. It uses a Linux-style Devicetree and Kconfig configuration system, making it easy to swap microcontrollers or scale up functionality without rewriting application logic.
  • License: Apache 2.0
• Eclipse ThreadX (formerly Azure RTOS)
  • Best for: Mission-critical, high-reliability, or regulated sectors (medical, automotive, aerospace).
  • Profile: Known for extreme speed, ultra-low latency, and fully deterministic behavior. It comes with a rich, pre-integrated middleware ecosystem (NetX for networking, FileX for storage) and readily available safety compliance artifacts.
  • License: Permissive open-source via the Eclipse Foundation

Community Perspectives

FreeRTOS Simplicity

FreeRTOS is great for small dedicated projects. It gives you the core functionality and you build the rest.

Zephyr Portability

Zephyr is great if you either, think you might change processors in the future... or you want higher level APIs for common services so you don't have to rewrite if you do switch processors.

If you share a few details about your project, I can help narrow down the choice:

• What is your target hardware (e.g., specific microcontroller family or memory limits)?
• What kind of connectivity do you need (Wi-Fi, Bluetooth LE, Cellular, or local mesh)?
• Do you have any regulatory or safety certification requirements?

For a new IoT device, I’d put Zephyr and FreeRTOS at the top of the shortlist, with Eclipse ThreadX as a strong alternative—especially if safety certification or a more integrated embedded stack matters.

1. Zephyr — my default choice for a new IoT design

Zephyr has become particularly compelling for connected devices. It supports many architectures—including ARM, RISC-V, x86 and others—and the project currently advertises 1,000+ supported boards. Its scope goes well beyond scheduling into networking, filesystems, device drivers, power management and connectivity.

Choose it if: you're starting a new product, expect the hardware to evolve, need Bluetooth/Wi-Fi/Thread/Matter/networking, or want to avoid locking yourself tightly to one MCU vendor.

Especially attractive: products using Nordic, NXP, ST, Silicon Labs, TI and other heterogeneous MCU platforms.

2. FreeRTOS — the safest conventional choice

FreeRTOS remains an excellent choice when you want a small, familiar RTOS with a huge MCU ecosystem. It supports 40+ processor architectures and currently includes features such as SMP, IPv6-capable TCP networking and cloud-service integration.

Choose it if: your device is relatively straightforward, your MCU vendor already has excellent FreeRTOS integration, or your team already knows FreeRTOS.

A useful distinction is that FreeRTOS is intentionally relatively focused, whereas Zephyr gives you considerably more of an integrated embedded OS platform.

3. Eclipse ThreadX — excellent for industrial products

ThreadX is now an Eclipse Foundation project and combines the RTOS with components such as NetX Duo networking, FileX filesystem, USBX and GUIX. Eclipse describes it as open source, permissively licensed and safety certified.

Choose it if: you're building industrial equipment, need a mature integrated stack, or certification/support requirements are more important than having the largest open-source IoT ecosystem.

How I'd decide

Pick Zephyr if:

• This is a greenfield product.
• Connectivity is central to the product.
• You want hardware portability.
• You expect the software to live for 5–10+ years.
• You want an integrated open-source ecosystem.

Pick FreeRTOS if:

• You have a small MCU and tight resource constraints.
• Your silicon vendor has excellent FreeRTOS support.
• Your firmware architecture is relatively simple.
• Your team already has FreeRTOS expertise.

Pick ThreadX if:

• You're building an industrial/embedded product.
• Certification is important.
• You value a mature integrated middleware stack and commercial-grade ecosystem.

One important caveat: don't choose based primarily on scheduler benchmarks. For an IoT product, MCU/SoC support, wireless stack quality, OTA updates, security architecture, power management, tooling, long-term maintenance, licensing, and your team's expertise will generally matter much more.

My shortlist

If I were starting a typical connected MCU product today, I'd prototype Zephyr vs. FreeRTOS first. If the product has significant industrial/safety requirements, I'd add ThreadX to that evaluation.

If you tell me your MCU/SoC (e.g. STM32, ESP32, nRF52/nRF54, RP2350, i.MX, RISC-V), RAM/flash budget, wireless technology, and whether you need functional safety, I can narrow this to 1–2 choices and explain why.