Request a firmware review
Menu

Zephyr, FreeRTOS or bare metal: choosing for a new product

Reader question: Should our first production firmware run on Zephyr, FreeRTOS or bare metal, given our chip, radio stack, update path and team?

Micrograph-style illustration of a forked lichen stalk dividing into three branches, with one of the three branches tinted amber.

Pick the option your chip vendor’s SDK and radio stack are built on, unless your update path or your support period rules it out. For a connected, battery-powered product that needs Bluetooth LE and signed over-the-air updates, Zephyr is often the shortest path: it ships a complete Bluetooth LE stack and works directly with the MCUboot bootloader.

FreeRTOS fits when the vendor SDK is built around it, as Espressif’s ESP-IDF is. Bare metal fits a single-purpose device with no radio stack to host and no field updates.

Most Zephyr vs FreeRTOS comparisons rank kernels feature by feature; this one decides by product. It asks four questions a small team can answer in a day: what the chip vendor already ships, how the device will update itself, how long it must receive security fixes, and who will maintain the code. Every date below comes from the projects’ own documentation, as of November 2026.

Fumbar is a Denver firmware company that writes embedded firmware for hardware startups and the over-the-air update path that keeps it improving after devices ship. A Fumbar firmware review writes down the answers to these questions before any code is chosen.

What each option actually includes

Bare metal means your code runs directly on the chip with no scheduler. FreeRTOS is a small kernel plus a set of libraries you assemble, and Zephyr is a kernel plus drivers, networking, storage, a Bluetooth stack and a build system in one source tree. Comparing them only makes sense once you count what each brings with it.

Bare metal

A bare-metal program is a main loop plus interrupt handlers, usually written against the chip vendor’s hardware abstraction layer (HAL), the vendor library that wraps registers in function calls. There is no task scheduler, so you decide in code what runs when. Everything beyond the HAL is yours: timing, power states, storage, the update agent and any radio integration.

FreeRTOS

The FreeRTOS kernel provides tasks, queues, semaphores and software timers, and it is distributed under the MIT License.

The FreeRTOS 202604 LTS release adds a fixed set of libraries around kernel 11.3.0: FreeRTOS-Plus-TCP, coreMQTT, coreHTTP, corePKCS11, coreJSON, coreSNTP, a cellular interface, a backoff algorithm, SigV4, and AWS IoT libraries for Device Shadow, Device Defender, Jobs, Fleet Provisioning and MQTT File Streams. That list has no Bluetooth stack, no bootloader and no file system, so those come from somewhere else, usually the chip vendor’s SDK.

Zephyr

Zephyr is licensed as a whole under Apache 2.0, and its kernel provides a multi-threaded execution environment. The tree also includes a network stack with an MQTT client, a settings subsystem for persistent per-device configuration, and, in the project’s words, “a complete Bluetooth Low Energy stack from application to radio hardware” (Zephyr Bluetooth documentation). Hardware is described in devicetree, a hierarchical data structure for describing hardware, and features are switched on with Kconfig, the same configuration system the Linux kernel uses.

What comes in the box

Building block Bare metal FreeRTOS (202604 LTS) Zephyr
Scheduler None; you write the main loop Kernel with tasks, queues and timers Kernel with threads and synchronization
Bluetooth LE stack From the chip vendor From the chip vendor Included, host and controller
IP networking and MQTT From the vendor or you FreeRTOS-Plus-TCP, coreMQTT Included network stack and MQTT client
Bootloader and image update You write or port one Not in the LTS list Works directly with MCUboot
Hardware description Vendor HAL and your headers Vendor HAL and your headers Devicetree and Kconfig
Published support window None beyond the vendor HAL Two years per LTS release About five years per LTS release
License Vendor HAL terms MIT Apache 2.0, with listed exceptions

The table explains most arguments about size and complexity. A Zephyr build with its Bluetooth stack, MCUboot and settings storage is not comparable to a bare FreeRTOS kernel, because the FreeRTOS product still needs those pieces from somewhere. Compare product to product: the same radio, update path and storage on both sides.

Question 1: what does your chip vendor’s SDK already run?

Start from the vendor SDK, because on many chips it has already chosen the kernel, the radio stack and the bootloader for you. Going against that choice means porting the radio stack or the SDK yourself; going along with it creates a support dependency on the vendor that you should write down.

When the SDK is built on FreeRTOS

Espressif’s ESP-IDF is the clearest example. Its FreeRTOS overview says FreeRTOS “is integrated into ESP-IDF as a component” and that “all ESP-IDF applications and many ESP-IDF components are written based on FreeRTOS”. Applications define app_main and must never call vTaskStartScheduler(), because ESP-IDF starts FreeRTOS itself.

The version matters too. The ESP-IDF v6.1.1 documentation says ESP-IDF FreeRTOS “is a FreeRTOS implementation based on Vanilla FreeRTOS v10.5.1” with “significant modifications to support SMP”, meaning symmetric multiprocessing across two cores.

The FreeRTOS LTS clock, which tracks kernel 11.3.0, is therefore not the clock that patches your product. The SDK’s clock is.

Espressif publishes that clock. Its support period policy says each major and minor ESP-IDF release “is supported for 30 months after the initial stable release date”. That splits into a 12-month service period and an 18-month maintenance period with only high-severity bug fixes and security fixes.

The radio stack comes from the same SDK: ESP-IDF offers two Bluetooth hosts, ESP-Bluedroid and ESP-NimBLE, and its Bluetooth LE overview notes that NimBLE needs less heap and flash and supports only Bluetooth LE.

When the SDK is built on Zephyr

Nordic Semiconductor’s nRF Connect SDK goes the other way. Its manifest file on GitHub (west.yml in sdk-nrf) imports Nordic’s own fork of Zephyr, named sdk-zephyr, and its own fork of MCUboot, named sdk-mcuboot. On those chips the vendor SDK is a Zephyr distribution, so the practical choice is Zephyr, and your security fixes arrive through the vendor’s SDK releases as well as upstream Zephyr’s.

Upstream Zephyr also carries Bluetooth qualification work you can reuse. Its qualification page says the project “provides a pre-qualified Bluetooth host stack” that “can be included in a product qualification design”, and lists qualified designs for Zephyr v4.4 (Q385945) and v4.5 (Q399832). Your product still goes through its own Bluetooth qualification; the listing shortens the work rather than replacing it.

Decision rules for question 1

  1. If the vendor SDK starts a kernel for you and its radio stack runs only there, use that kernel unless question 2 or 3 rules it out.
  2. If upstream Zephyr supports both your chip and your radio, you have a real choice, and questions 2 to 4 decide it.
  3. If the radio is a separate module that runs its own stack and is driven over a serial link, the kernel choice is freer.
  4. Write down the SDK name, its version, the kernel it brings and the date its support ends. That line becomes part of your support plan.

Chip choice itself is a separate decision, covered in how to choose a microcontroller for a connected product. If you are still deciding whether the product needs a Linux processor at all, read microcontroller or embedded Linux first, because that decision comes before this one.

Example (fictional). A two-founder team is building a Wi-Fi plant-light controller on an ESP32-family chip. They never chose FreeRTOS; ESP-IDF chose it for them, along with the bootloader and the Bluetooth host they use for setup.

Their real decision is which ESP-IDF release to start on. Suppose they start on a release that came out three months ago: by the 30-month policy above, they have about 27 months of fixes on it before they must move to a newer release.

Question 2: how will the device update itself in the field?

Choose the option whose update path you can use as it is: a bootloader that checks signatures, room for two images and a way to roll back a bad image. Zephyr gets this from MCUboot, ESP-IDF builds its own into the SDK, and on plain FreeRTOS or bare metal you assemble or write it yourself.

What an update path needs

Every field-updatable microcontroller product needs the same four parts:

  1. A bootloader that verifies the new image’s signature before running it.
  2. A second image slot in flash, so the running image survives while the new one downloads.
  3. A test run of the new image, which is kept only after it confirms itself.
  4. A transport that moves the image to the device: Bluetooth LE, Wi-Fi, cellular or a wired port.

In many microcontroller designs the bootloader is the one part that is not replaced in the field. It has to be right on the first production unit, which is why bootloader support weighs heavily in the choice.

Zephyr and MCUboot

Zephyr’s device firmware upgrade documentation says Zephyr “is directly compatible with the open source, cross-RTOS MCUboot boot loader”. You define the flash partitions, enable CONFIG_BOOTLOADER_MCUBOOT, and sysbuild builds MCUboot and your application together.

Zephyr’s over-the-air update page lists update options, most of which hand a signed image to MCUboot: an SMP server for updates over Bluetooth LE or UDP using MCUmgr, a plain HTTP download library, Eclipse hawkBit, UpdateHub, LwM2M, and integrations from Golioth, Mender and Memfault.

MCUboot’s design document explains the rollback. With a test swap, “if the device crashes immediately upon booting a new (bad) image, MCUboot will revert to the old (working) image at the next device reset”. Your firmware makes the swap permanent “only after performing a self-test routine”.

In Zephyr that confirm step is one call, boot_write_img_confirmed(), in the MCUboot image control API, so the logic you write is the self-test, not the mechanism.

FreeRTOS: bring your own bootloader

The FreeRTOS LTS release does not include a bootloader. Its README notes that the AWS IoT OTA library “is not included in the FreeRTOS LTS releases since 202212-LTS”. Instead, AWS IoT MQTT File Streams and AWS IoT Jobs serve as building blocks for what FreeRTOS calls Modular Over the Air Updates.

Those libraries move the image. Verifying, storing, swapping and rolling back are still up to you or your vendor.

MCUboot can still be the bootloader. Its overview says MCUboot “is not dependent on any specific operating system and hardware and relies on hardware porting layers from the operating system it works with”. The listed ports are Zephyr, Apache Mynewt, Apache NuttX, RIOT (as a boot target only), Mbed OS, Espressif and Cypress/Infineon.

FreeRTOS is not on that list, so on plain FreeRTOS you either use a vendor port, use the vendor’s own bootloader, or maintain a port yourself.

Vendor SDKs built on FreeRTOS often fill the gap. ESP-IDF’s OTA documentation requires “at least two OTA app slot partitions (i.e., ota_0 and ota_1)” plus an OTA data partition.

With app rollback enabled, a new image that resets before calling esp_ota_mark_app_valid_cancel_rollback() is rolled back to the previous one. That is the same test-then-confirm pattern as MCUboot, delivered by the SDK instead of the kernel.

Bare metal: you write the update agent

On bare metal, nothing arrives with the HAL. You write the code that receives the image, writes it to the second slot, hands it to a bootloader and confirms it after a self-test. You can port MCUboot instead of writing a bootloader, which is usually the better trade, but the port and its tests become your code to maintain.

Flash is the same arithmetic on every option

Two image slots cost the same flash whichever kernel you pick. The flash budget calculator does the arithmetic for your part, and A/B or single-slot updates explains the MCUboot layouts and what each one survives during a power cut.

Example (fictional). Loamwick’s LW-1 probe has a Bluetooth LE microcontroller with 1 MB of internal flash. MCUboot takes 48 KB, settings 32 KB and logs 48 KB, which leaves two image slots of 448 KB each.

The 412 KB application fills 92.8% of its slot, and the flash budget calculator shows that 25% growth would leave the image 71 KB short. The team plans to move the second slot to external flash on the Rev E board.

None of those numbers would change much with a different kernel; the slot layout, not the kernel, decides whether the product can still update itself next year.

Question 3: how long must the product receive security fixes?

Write down the date your security support must end, then choose the release whose support covers the start of that window and plan migrations for the rest. A Zephyr LTS release can cover most of a five-year window, a FreeRTOS LTS release covers two years, and on bare metal the window is entirely yours.

The published support windows, as of November 2026

Release Released Support ends What the project says
Zephyr 3.7.0 (LTS3) 2024-07-26 2029-07-27 Current long-term support release
Zephyr 4.4.0 2026-04-14 2027-04-12 Stable release
Zephyr 4.5.0 2026-10-28 2027-10-28 Latest stable release
Zephyr 4.6 (LTS4) Planned April 2027 Not yet published Next LTS, planned
FreeRTOS 202406 LTS 2024-06-27 2026-06-30 (ended) Two-year LTS
FreeRTOS 202604 LTS 2026-04-29 2028-04-30 Two-year LTS, kernel 11.3.0

The Zephyr rows come from the Zephyr releases page. Zephyr now ships major releases “on a six-month cadence, targeting April and October”, and stable releases are “supported for the duration of 2 release cycles (roughly 1 year)”. The FreeRTOS rows come from the FreeRTOS-LTS repository and its release list. Its README says LTS libraries “come with security updates and critical bug fixes” for two years.

Zephyr 3.7 LTS3 Zephyr 4.4 Zephyr 4.5 Zephyr 4.6 LTS4 FreeRTOS 202406 FreeRTOS 202604 Example product security only planned, about 5 years 5-year support period Nov 2026 2024202520262027202820292030203120322033 Bug and security fixes Security and stability only Planned Fictional product's promise
Figure 1. Published support windows for current Zephyr and FreeRTOS releases against a fictional product that ships in mid-2027 with a five-year support period. Zephyr 4.6 LTS is planned, not released; its bar assumes the project's stated LTS term of about five years. Sources: Zephyr Project releases page and release process, FreeRTOS-LTS repository, checked November 22, 2026.

How Zephyr LTS phases work

Zephyr’s release process says LTS releases “are published every 2.5 to 3 years” and maintained “for approximately 5 years after they were released”. Support runs in phases: “Phase 1 (first 2 years): General bug fixes and security fixes, including platform and driver fixes”, then “Phase 2 (following 3+ years): Security and OS stability fixes only”. By that definition, Zephyr 3.7 passed the end of its two-year Phase 1 in July 2026, so a product starting on it today gets security and stability fixes, not general bug fixes.

Two more lines from the releases page shape the plan. Each security fix is backported to the currently supported LTS release and to the most recent two releases, and the next LTS is planned as Zephyr 4.6 in April 2027. A team starting now has three reasonable paths:

  • Start on 3.7 and accept security-only fixes.
  • Start on 4.5 and move to 4.6 when it ships.
  • Build on 4.5 now, with the move to 4.6 written into the schedule before production.

How FreeRTOS LTS windows work

FreeRTOS LTS releases are dated (202406, 202604), and each gets two years. The 202406 release ended on June 30, 2026, two months after 202604 appeared on April 29, 2026. Teams that wanted to stay on supported libraries had that short overlap to migrate.

The 202604 README also flags breaking changes: coreMQTT, coreSNTP and AWS IoT Jobs “have had major version updates”, each with a migration guide.

AWS also offers a FreeRTOS Extended Maintenance Plan that, per the same README, provides “security patches and critical bug fixes on your chosen FreeRTOS LTS version for up to an additional 10 years”. Read its terms before counting on it. If your kernel arrives inside a vendor SDK, as it does in ESP-IDF, the vendor’s support period is the one that applies to your product.

How vulnerabilities reach you

Zephyr’s vulnerability reporting policy sets an embargo “of at most 90 days”. It is meant to allow “30 days within the Zephyr project to fix the issues, and 60 days for external parties building products using Zephyr to be able to apply and distribute these fixes”.

Product makers can ask to join the project’s vulnerability-alerts list through its Vulnerability Registry, and requests are vetted.

The vulnerabilities page lists CVEs by year; one 2026 entry describes Bluetooth GATT notify and indicate calls that checked the wrong attribute’s permissions. Fixes like that only help if you can ship them.

FreeRTOS routes reports to AWS Security. Its kernel security policy asks reporters to use the AWS vulnerability reporting page and points to a published kernel threat model that describes what the kernel does and does not protect.

Why the window matters for regulation

If you sell in the EU, the Cyber Resilience Act, Regulation (EU) 2024/2847, says the support period “shall be at least five years” unless the product is expected to be in use for less time (Article 13(8)).

The same article lets manufacturers take into account “the support periods of integrated components that provide core functions and are sourced from third parties”, which is exactly what an RTOS and a vendor SDK are.

The Regulation applies from December 11, 2027, and its Article 14 reporting obligations have applied since September 11, 2026. This is a summary, not legal advice.

Example (fictional). For example, suppose Loamwick plans to sell the LW-1 from mid-2027 and promise five years of security fixes, to mid-2032. On Zephyr, the team builds on 4.5 and moves to 4.6 when it is released. That one LTS can cover most of the window if it follows the project’s stated five-year term.

On a FreeRTOS LTS, the same promise would span the 202604 release and at least two later ones, assuming the two-year pattern continues, or AWS’s Extended Maintenance Plan. Either way, the release report for each maintenance release records which RTOS release it is built on and when that release’s support ends.

Tracking those dates release after release is the core of sustaining releases: scheduled maintenance builds, dependency and CVE review, and a written plan for the next RTOS migration.

Question 4: who will maintain the code in two years?

Choose what the people who will own the firmware after launch can read, build and upgrade without you. A hire who knows FreeRTOS and a vendor HAL is productive sooner on that stack, while Zephyr asks for devicetree and Kconfig fluency but offers upstream documentation and migration guides.

What each option asks of a maintainer

  • Zephyr. The learning curve is real: devicetree for hardware, Kconfig for features, west (Zephyr’s meta-tool) for fetching the code, and sysbuild when MCUboot is involved. In return, the structure is documented upstream, and each major release ships a migration guide that, per the releases page, documents “the actions required when moving an application from one major release to the next”.
  • FreeRTOS. The kernel API is small. The structure around it (drivers, storage, update logic, radio integration) is your code or the vendor’s, so the documentation for it is also yours to write.
  • Bare metal. The code is often the smallest of the three and the easiest to read in one sitting. The risk is that the timing assumptions live in one person’s head, and nothing in the tree tells a new engineer which loop iteration owns which deadline.

Upgrades are a recurring job, not a one-off

Whichever option you pick, someone must move the product to newer releases.

On Zephyr that means a major-release migration every six months if you track stable releases, or one LTS migration every 2.5 to 3 years if you stay on LTS. On FreeRTOS LTS it means a migration roughly every two years, and inside a vendor SDK it means following the SDK’s own schedule. On bare metal it means pulling vendor HAL fixes into code that may have drifted from the vendor’s examples.

Ask four questions about the team before you score anything:

  1. Who owns the firmware the week after launch, by name or by role?
  2. Has that person built and upgraded a product on this option before?
  3. Can the build run in CI from a clean checkout, without anyone’s laptop?
  4. Is there a written description of tasks or threads, interrupts, power states and the flash map?

If the honest answer to the first question is “a hire we have not made yet”, choose the option with the most documentation outside your own repository. That usually favors whichever stack the vendor SDK is built on, and Zephyr where the chip is supported upstream. Fumbar’s firmware development work follows the same rule: the client receives the source, the build instructions and an architecture document, so the next engineer is not starting from the code alone.

Memory, power and timing: how to read the benchmarks

Footprint and performance comparisons only mean something at equal scope: the same drivers, the same C library, the same logging and the same radio stack on both sides. Measure your own build on your own chip before memory or speed decides anything.

Footprint

A Zephyr Project blog post from May 2026, Zephyr Insights: Code Footprint, built the blinky sample for a Raspberry Pi Pico 2. The linked static libraries added up to 1,829 kB on disk, but the final zephyr.bin was 20 kB. The linker only pulls in object files that resolve a symbol the program uses, and the binary drops the debug data the ELF file carries.

Zephyr’s optimization tools include rom_report and ram_report build targets that list every object’s ROM and RAM use, so you can see where the bytes go.

Zephyr’s kernel documentation says its configurable kernel suits systems with as little as 2 KB of memory. The FreeRTOS kernel is also small, and its size depends on configuration in FreeRTOSConfig.h.

Inside ESP-IDF that file is private and the kernel is configured through menuconfig instead, which is a reminder that the SDK, not the kernel, sets many of the numbers. Bare metal has the smallest baseline, but the code you add for networking and updates counts as much as anyone else’s.

In a connected product the large items are usually the radio stack, the crypto library and the second image slot. On the fictional LW-1, the second slot alone is 448 KB of a 1 MB part. For comparison, the whole Zephyr blinky image above is 20 kB, so the kernel choice rarely decides whether a connected product fits.

Power

All three options can put the chip into its deepest sleep state; what differs is how much code you write to get there. On an RTOS, a stray periodic timer or a polling driver can keep the chip awake; on bare metal, you write the sleep entry yourself. Either way, measure sleep current on the real board with the radio stack running.

Timing

Bare metal gives the most direct control of interrupt timing, because nothing else is scheduled. An RTOS adds a scheduler, which costs some cycles and gains you priorities, so a slow radio task need not block a time-critical control loop. If your product has a hard deadline, for example a motor control loop, write the deadline down in microseconds and measure it on each option with an oscilloscope or a logic analyzer.

A fair benchmark procedure

  1. Pick the same evaluation board and the same compiler for every option.
  2. Build the same feature set: the radio stack, the update client, settings storage and logging at production levels.
  3. Record flash and RAM from the map file or the build reports.
  4. Record sleep current with the radio advertising or connected at your real interval.
  5. Record the one deadline that matters most, measured on a pin.
  6. Keep the build files so the numbers can be reproduced after the next release.

When bare metal is the right answer

Bare metal is right when the device does one job, has no radio stack to host and either never updates in the field or updates over a simple wired path. It stops being cheap when a second concurrent activity, a network stack or over-the-air updates arrive.

Signs bare metal fits

  • One main job with a fixed timing loop, such as reading a sensor and driving an output.
  • No Bluetooth, Thread or IP stack on the main chip, or a radio module that handles its own stack.
  • A very small part, with RAM measured in a few kilobytes.
  • Updates only at the factory or over a wired service port.
  • A behavior simple enough to describe as one state machine on one page.

What arrives with networking and updates

Each of these is code you would otherwise inherit:

  • An event loop or scheduler that lets a slow radio exchange run without missing a sensor deadline.
  • A bootloader, or a maintained port of MCUboot, plus the code that writes and confirms the new image.
  • Integration with the vendor’s radio stack on the vendor’s terms, including its threading assumptions.
  • Persistent storage for settings and logs that survives a power cut mid-write.
  • A way to receive and ship security fixes for every component above.

Together they are a large part of what an RTOS distribution provides. If your roadmap shows any of them within a year, starting on an RTOS is usually cheaper than migrating a shipped bare-metal product.

Keep the door open

If you do start on bare metal, structure the code so it can move. Put explicit state machines behind an event queue, keep register access behind a thin driver layer, and keep the flash map with room for a second image. Code shaped like that can later run as one task on an RTOS without a rewrite.

Example (fictional). A startup builds a wired leak sensor for commercial water heaters. It reads a conductivity probe once per second, closes a relay when it sees water and reports a fault over a two-wire alarm line.

There is no radio and no field update; firmware is programmed once at the factory. Bare metal fits: one state machine, one timer interrupt, and nothing an RTOS would add that the product needs.

Licenses and notices you ship with the binary

Both are permissive licenses: the FreeRTOS kernel uses the MIT License and Zephyr uses Apache 2.0, and neither requires you to publish your application source code. Both still ask for notices, and the vendor SDK around them often carries terms of its own.

MIT (FreeRTOS kernel)

The MIT License requires the copyright notice and permission notice to “be included in all copies or substantial portions of the Software.” For firmware, that usually means a notices file shipped with the product documentation or shown in an app.

Apache 2.0 (Zephyr and MCUboot)

The Apache License 2.0 asks you to give recipients a copy of the license, to mark files you modified, and to retain attribution notices, including any NOTICE file. It also includes an express patent license from each contributor (section 3), which the MIT License does not mention.

Zephyr’s licensing page adds that Zephyr “as a whole is licensed under the Apache 2.0 License” but imports “a small number of packages, scripts and other files that are covered by other licenses”, declared in a REUSE.toml file at the root of the repository.

The vendor SDK

The HAL, the radio stack and any precompiled libraries from your chip vendor have their own license files.

Read them for three things: whether use is limited to the vendor’s own chips, whether redistribution of source is allowed, and what notices must ship. Record each license in your software bill of materials as you add the component. This section is a summary of the license texts, not legal advice.

A one-day decision procedure

You can make this decision in one working day with an evaluation board, the vendor SDK and the four questions above. The output is a one-page decision record, not a slide deck.

The steps

  1. Morning, first hour. Write down the chip or shortlist, the radio, the vendor SDK and its version. Note which kernel the SDK starts, which bootloader it ships and when its support ends.
  2. Morning, second hour. Draw the flash map with two image slots and run the flash budget calculator. If two slots do not fit, fix that first; no kernel choice will rescue it.
  3. Late morning. Write the support end date your product will promise. Put each candidate release on the same timeline, as in Figure 1, and count the migrations.
  4. Early afternoon. Build the vendor’s radio sample and the matching update sample on the evaluation board for each candidate you are still considering. Record flash, RAM and sleep current.
  5. Mid-afternoon. Name the maintainer and list what they have shipped before.
  6. Late afternoon. Score the options with weights that reflect your product, using the RTOS selection worksheet.
  7. End of day. Write the decision record: the option, the exact release, its support end date, the next planned migration, and the two or three facts that would make you revisit the choice.
SignalPoints to ZephyrPoints to FreeRTOSPoints to bare metal
Vendor SDKThe SDK is a Zephyr distribution, or upstream Zephyr supports the chipThe SDK starts FreeRTOS for youThe SDK is a HAL with no kernel
Radio stackBluetooth LE or IP needed on the main chipThe vendor's radio stack runs on FreeRTOSNo radio, or a module that runs its own stack
Update pathMCUboot with signed images and test swapsThe vendor's bootloader with rollbackFactory or wired updates only
Support windowAn LTS covers most of the promised periodThe SDK's window, with planned migrationsShort product life, few external components
MaintainersWilling to learn devicetree and KconfigAlready know FreeRTOS and the vendor SDKOne small codebase with documented state machines
MemoryRoom left after the second image slotTight RAM with the vendor's stack already in placeA few kilobytes of RAM
Figure 2. Signals from the four questions that point toward each option. Editorial summary based on the Zephyr, FreeRTOS, MCUboot and Espressif documentation cited in this article, checked November 2026.

Choosing the weights

The worksheet multiplies each score (1 to 5) by a weight (1 to 5) that you set. The weights are where your product shows up. A battery-powered Bluetooth product that must update in the field should weight the update path and the radio stack heavily; a wired single-purpose controller might weight memory and team experience highest.

Example (fictional). Loamwick scored the LW-1 with the RTOS selection worksheet.

The weights were: update support 5; fit with the chip and vendor SDK 4; a maintained Bluetooth LE stack 4; long-term support and security fixes 4; team experience 3; memory left for the application 3; licensing 2. Zephyr scored 5 on update support, the Bluetooth stack and long-term support, and 3 on team experience and memory.

The totals were Zephyr 113, FreeRTOS 93 and bare metal 75 of 125. The decision record names the Zephyr release, the MCUboot layout with two 448 KB slots and the date of the next planned migration.

The example project follows the probe from first boards to a staged rollout.

If two options land within a few points, revisit the weight you set least confidently, often team experience, with the person who will own the code.

What to do next

Make the decision on paper before anyone writes product code. A one-page record with the release, its support end date and the next migration is worth more than any benchmark, because it is what the next engineer will read.

  • Write down the vendor SDK, its version and the kernel and bootloader it brings.
  • Check that two image slots fit, with growth, in the flash budget calculator.
  • Put your promised support period on a timeline next to the release dates above, as of November 2026, and count the migrations.
  • Build the radio and update samples on an evaluation board and record flash, RAM and sleep current.
  • Score the options with the RTOS selection worksheet and keep the scores with the decision record.
  • Plan who will carry each future migration, and when.

If you want a second reader for the record, a firmware review covers the schematics, any existing code, the flash layout and the update plan, and ends with a written plan that lists the risks and the order of work.

Facing this decision on a real device?

If this article describes a choice in front of you, a firmware review puts it in writing for your board, your code and your update plan.

Request a firmware review

Or email sales@fumbar.com, or call (720) 675-4202.