Zephyr Lands on Variscite SoMs
Variscite, a trusted and long-standing System-on-Module supplier, has announced official support for the Zephyr RTOS on its System-on-Modules based on the NXP i.MX8 and i.MX9. This development marks more than just another software feature—it signals a shift in the way embedded systems are architected and deployed on heterogeneous SoCs.
With Zephyr now available on the real-time cores of Variscite’s powerful platforms, developers can harness a modern, scalable RTOS alongside Linux, all within a unified and maintainable software stack.
What is Zephyr, and Why Does It Matter?
Zephyr is a modern, open-source real-time operating system developed under the Linux Foundation. Backed by major semiconductor vendors and embedded leaders, it offers a comprehensive and modular environment for microcontroller-class devices.
Unlike legacy RTOS solutions, Zephyr emphasizes portability, security, and maintainability. It brings many of the software development principles traditionally found in the Linux ecosystem—structured APIs, device tree configuration, board abstraction layers, and continuous integration—to the realm of microcontrollers.
It is not just an RTOS kernel. Zephyr comes bundled with drivers, protocol stacks, and middleware, all built into a coherent system with long-term support and a clear governance model.
Zephyr vs. FreeRTOS: Not Just a Matter of Size
FreeRTOS has earned its place as a lightweight, efficient RTOS suitable for resource-constrained MCUs. But Zephyr addresses a different class of problems—especially when real-time cores are paired with Linux-capable processors on the same SoC.
Here are some of the key differences:
POSIX Compatibility
Zephyr offers a subset of POSIX APIs, allowing easier porting of existing code and fostering consistency with Linux-based development. FreeRTOS lacks POSIX support, making portability a challenge.
Driver Infrastructure
In Zephyr, drivers follow a standardized model similar to Linux: devices are initialized and accessed through consistent interfaces (init, open, read, write, ioctl). In FreeRTOS, there is no such model. If you want drivers, you write them yourself—or depend on vendor SDKs that often lack standardization or long-term support.
Middleware and Stacks
Zephyr includes built-in support for networking (TCP/IP), USB, Bluetooth, file systems, and more. These features are integrated and ready to use. In FreeRTOS, the same capabilities exist but are typically provided as optional plugins that require manual integration via callbacks. This approach keeps FreeRTOS lean but puts more responsibility on the developer.
Footprint and Use Case
FreeRTOS shines in ultra-low-power or ultra-low-footprint designs. But for hybrid SoCs like the i.MX8 or i.MX9, Zephyr strikes a better balance between performance, integration, and maintainability.
Unlocking the Power of Asymmetric Multi-Core SoCs
Variscite’s i.MX8 and i.MX9 platforms combine Cortex-A application cores with real-time Cortex-M cores. Historically, these Cortex-M cores have often gone unused—or were programmed with proprietary SDKs disconnected from the Linux build system.
Zephyr changes that.
It allows the Cortex-M core to serve as a true real-time companion to Linux. Tasks such as sensor fusion, motor control, low-latency data acquisition and timestamping, or security-critical functions can now be isolated on the M-core, running under Zephyr. Meanwhile, Linux continues to manage UI, networking, AI inference, and application logic on the A-core.
This clean partitioning opens the door to robust, deterministic designs that fully exploit the asymmetric architecture of modern SoCs.
Communication between the two worlds is facilitated via mechanisms like RPMsg and shared memory, supported natively in both Zephyr and Linux. This promotes a clean and maintainable design pattern—one that avoids spaghetti IPC solutions or tightly-coupled monolithic codebases.
Yocto Integration: A Unified Build Environment
For teams building production systems, integration into the Yocto Project is not optional—it’s essential. Zephyr addresses this with first-class support via the meta-zephyr layer.
This makes it possible to:
Build the Zephyr firmware alongside Linux in the same Yocto project
Package both firmwares in a single image for flashing or OTA distribution
Share configuration elements like devicetree sources and board metadata
In contrast, FreeRTOS typically lives outside the Yocto build process. It’s often compiled separately using vendor tools, and then stitched into the Linux image as a binary blob. This makes automation, testing, and version control more difficult—especially for teams managing field upgrades and long product lifecycles.
With Zephyr, you gain consistency, traceability, and reproducibility across the entire stack—from bare-metal to Linux userspace.
Toward Convergence: One Platform, Two Worlds
The traditional boundary between real-time and application software is fading. With Zephyr on the real-time core and Linux on the application core, embedded systems can now be architected as a cohesive, layered platform—rather than two disjointed environments.
One of the most powerful enablers of this convergence is shared tooling and configuration, especially the use of device tree. Originally a core part of Linux kernel board support, the device tree model is now central to Zephyr as well. This means:
Peripheral configuration, memory maps, and pin assignments are described using the same paradigm in both Linux and Zephyr.
Developers can reuse or align board definitions across cores and subsystems, reducing duplication and integration errors.
Maintenance is simplified—hardware changes need only be updated once, and then reflected cleanly in both the Linux and Zephyr contexts.
In addition to device tree, convergence also manifests through:
Unified logging and monitoring
Coordinated OTA updates
Shared development environments and CI/CD pipelines
This tighter alignment leads to cleaner separation of concerns: Zephyr can focus on low-latency, deterministic tasks while Linux handles rich applications, connectivity, and user interaction. And because both systems speak the same “language” in terms of hardware description and system integration, teams can work faster—with fewer surprises at integration time.
Variscite’s support for Zephyr reflects this trend. Developers now have access to a software stack that spans both real-time and rich application domains, while speaking the same architectural language.
Key Takeaways
At Embedded Expertise, we have quite a bit of experience with asymmetric multi-cores, including those carried by Variscite’s SoMs. We’ve seen firsthand how powerful these platforms can be when paired with the right software architecture.
We also have substantial experience with FreeRTOS in this context, and it remains a robust, efficient, and widely-used RTOS—especially for low-power or tightly constrained systems. But the Linux-style convergence offered by Zephyr brings something more: a unified development model, consistent configuration via device tree, and seamless integration with modern build systems like Yocto.
Zephyr is not a replacement for FreeRTOS in all cases. But for hybrid SoMs like the i.MX8 and i.MX9, it offers a future-ready alternative that better supports scalability, maintainability, and system-level integration.
With POSIX APIs, integrated drivers, built-in middleware, and Yocto compatibility, Zephyr enables cleaner designs and faster development cycles. When combined with Linux on asymmetric SoCs, it becomes the foundation for powerful, scalable, and maintainable platforms.
If you’re designing with Variscite’s i.MX8 or i.MX9 modules, it’s time to explore what Zephyr can bring to your system. This isn’t just another RTOS—it’s a strategic upgrade for embedded development.
