On behalf of the Zephyr Project, I am thrilled to announce the general availability of Zephyr 4.4—the first release under the project’s new bi-yearly release cadence. Moving to two major releases per year gives the community more time to mature each release and makes it easier for downstream projects to plan upgrades (one release in April, one in October, like Ubuntu!). This cycle brought contributions from over 930 individuals, delivering a release packed with significant networking improvements, support for a new processor architecture and much more.
As usual, I also recorded a demo video to accompany this article and show some of these features in action. Enjoy!
Throughout the article, clicking the ▶️ symbol will take you to the relevant section of the video.
▶️ Zephyr SDK 1.0 and C17
Zephyr 4.4 is the first release to ship with Zephyr SDK 1.0 (1.0.1, to be precise!). The Zephyr SDK is a complete, standalone toolchain package that includes everything needed to build, flash, and debug Zephyr applications across all supported architectures and for all major operating systems (Windows, Linux, macOS). One of the most notable changes is the new experimental Clang/LLVM support, as well as the fact that it ships with pre-bundled versions of OpenOCD and QEMU for all operating systems.
This release also modernizes Zephyr’s C baseline by moving to C17 (ISO/IEC 9899:2018) as the minimum required standard. While C17 was primarily a maintenance update, the transition allows the project to fully embrace modern C11 features, such as static assertions, _Generic (type-generic macros), and more. Of course, the new SDK fully supports C17 but in case you’re tied to an older toolchain you can always force e.g. CONFIG_STD_C99 as needed.
▶️ OpenRISC Architecture Support
Zephyr 4.4 adds support for OpenRISC (32-bit only for now), an open-source processor architecture popular in FPGA-based designs, academic research, and custom silicon applications. OpenRISC joins ARM, RISC-V, x86, Xtensa, ARC, MIPS, SPARC, and others in Zephyr’s already broad list of supported processor architectures.
If you’re working on open hardware or FPGA-based designs and have been looking for an RTOS to run on your OpenRISC cores, Zephyr is now an option worth considering.
Secure, Direct Connectivity: Wi-Fi Direct and WireGuard VPN
Two notable networking features land in Zephyr 4.4: Wi-Fi Direct support in the Wi-Fi management stack, and native WireGuard support.
▶️ Wi-Fi Direct (P2P)
The Wi-Fi management stack now supports Wi-Fi Direct (P2P), allowing devices to discover and connect to each other directly—without a traditional access point. Think device provisioning in the field, peer-to-peer data synchronization, or direct sensor-to-gateway communication in environments where infrastructure Wi-Fi is unavailable or impractical. Wi-Fi Direct supports multiple security modes, including WPA2-PSK and WPA3-SAE.
▶️ WireGuard VPN
The networking stack also gains support for WireGuard VPN, enabling secure, low-overhead tunneling directly on your Zephyr devices. WireGuard is known for its simplicity, speed, and strong cryptography, making it an ideal fit for resource-constrained embedded devices that need secure remote management or encrypted data transport.
Check out the sample application that’s available to get a sense of the (very few!) configuration options you need to enable WireGuard in your application.
▶️ USB Host Expansion: Cameras and More
Experimental USB host support has been significantly expanded in Zephyr 4.4 with a new host-class driver framework and support for UVC (USB Video Class) cameras on Zephyr devices acting as USB hosts.
This opens the door to embedded vision scenarios that pair really well with the networking additions above. Once it becomes possible to connect virtually any webcam to a Zephyr-based device, it is easy to imagine building systems that capture a video feed and then expose or tunnel it over a direct peer-to-peer connection or a VPN link.
Interestingly, this release also adds a number of new video camera sensor drivers, including for the Himax HM0360, OmniVision OV5642 and OV7675, and the Sony IMX219 (the sensor at the heart of the Raspberry Pi Camera Module 2).
▶️ Pressure-Based CPU Frequency Scaling
Building on the CPU frequency scaling subsystem introduced in Zephyr 4.3, this release adds a new pressure-based policy that automatically adjusts CPU frequency according to scheduler load. The policy monitors “system pressure” by observing the number of threads currently in the ready queue and their relative priorities. When the queue lengthens or higher-priority tasks are waiting, the system ramps up the clock for responsiveness; when the load subsides, it scales back to save power.
For battery-powered devices that occasionally need bursts of performance—think handling sensor data, processing network packets, or running ML inference—this kind of intelligent frequency scaling can help extend battery life without sacrificing real-time responsiveness. This is just one example of a scaling policy built into Zephyr, and it is straightforward to implement your own if you want to account for additional factors (system temperature anyone?).
▶️ ARM Cortex-M Context Switching Performance
A new context switch implementation for ARM Cortex-M, enabled via CONFIG_USE_SWITCH, delivers significant performance improvements.
When running the standard thread_metric benchmark, an average 8% speed improvement is observed. Given that ARM Cortex-M is Zephyr’s most popular architecture family, this change provides a meaningful boost to a large number of applications!
▶️ New Driver Classes
Zephyr 4.4 introduces several new driver APIs, expanding the types of hardware that it can natively support:
- One-Time Programmable (OTP) Memory – A new API for provisioning and reading permanent device data such as calibration values, secure keys, and device identifiers. Drivers are available for NXP OCOTP, STM32 BSEC, Sifli eFuse, and more. OTP devices can also be accessed through the NVMEM subsystem.
- Biometrics – A new API for integrating biometric sensors such as fingerprint scanners or facial recognition systems. This enables new product categories ranging from biometric access control to secure authentication on embedded devices. Initial drivers support the ADH-Tech GT5x and Zhiantec ZFM-x0 fingerprint sensors.
- Wake-up Controller (WUC) – A new API for managing wake-up sources that can bring the system out of low-power states, providing finer-grained control over power management behavior.
▶️ Zbus Proxy Agents: Multi-Core Messaging
Zephyr’s zbus publish-subscribe message bus now supports proxy agents that can forward channel traffic across CPU and domain boundaries over IPC. This makes it possible to use zbus’ high-level messaging API in potentially complex multi-core scenarios without having to use low-level, sometimes error-prone IPC APIs.
The setup is straightforward: define a proxy agent, create shadow channels, and let zbus handle the forwarding:
ZBUS_PROXY_AGENT_DEFINE(proxy_agent, ZBUS_PROXY_AGENT_BACKEND_IPC, IPC_DEV_NODE); ZBUS_CHAN_DEFINE(sensor_data, struct sensor_msg, NULL, NULL, ZBUS_OBSERVERS_EMPTY, ZBUS_MSG_INIT(0)); ZBUS_PROXY_ADD_CHAN(proxy_agent, sensor_data);
A new sample application demonstrates the full setup.
Developer Experience Improvements
As always, several quality-of-life improvements made it into this release. In no particular order:
▶️ Build Dashboard
A new dashboard build target consolidates a wealth of build information into a single interactive HTML report. RAM and ROM footprint (as drill-down tables and sunburst charts), Kconfig symbol values and their sources (from traceconfig, introduced in Zephyr 4.3), initialization levels, and a navigable Devicetree view with property values and binding details—all in one place.
west build -p -b <board> samples/hello_world -t dashboard
The generated report opens up automatically in your browser 🙂 If you’ve been running ram_report, rom_report, traceconfig, and similar tools separately, this will undeniably save you time.
Heap Hardening
A new tiered heap hardening system (enabled and configured through CONFIG_SYS_HEAP_HARDENING) adds runtime corruption detection to sys_heap_alloc and sys_heap_free.
In many ways, heap corruption can get even nastier than your classical stack overflow. A buffer overflow that writes past the end of an allocation silently clobbers the size metadata of the next chunk; a double-free leaves the free list in an inconsistent state; a stale pointer writes into memory that’s already been returned to the heap; etc. In all of these cases, the allocator operates on corrupted data, and the failure surfaces somewhere completely unrelated, often much later.
The four levels of hardening go all the way from “basic” double-free and overflow detection (with a negligible runtime cost) to complete validation of the heap structure after every allocation and free operation (which you would likely only use when debugging due to the massive overhead!).
▶️ Scope-Based Cleanup Helpers (RAII/defer for C)
One of the most common sources of bugs in embedded C code is forgetting to release a resource—unlocking a mutex, freeing memory, closing a file handle—especially in code paths with early returns. Zephyr 4.4 introduces scope-based cleanup helpers that bring RAII/defer-style automatic cleanup to C.
For example, here’s how you can use a scoped guard to automatically lock and unlock a mutex:
static K_MUTEX_DEFINE(lock); void critical_section(void) { scope_guard(k_mutex)(&lock); // Lock is held here // Perform critical operations // Lock is automatically released when scope exits, // even on early return! }
The API also supports scoped variables (auto-init and cleanup), scoped defers (for arbitrary cleanup functions), and works with all code paths including early returns, breaks, and gotos. Enable it with CONFIG_SCOPE_CLEANUP_HELPERS.
▶️ Ztest Benchmarking Framework
Writing performance benchmarks for embedded code has traditionally been ad-hoc and inconsistent. Zephyr 4.4 adds a new ztest benchmarking framework that provides a standardized way to create cycle-accurate benchmarks with automated data collection, overhead compensation, and statistical reporting (mean, standard deviation, min/max). Use the familiar ZTEST_BENCHMARK() macro, and get publication-quality performance data out of the box.
▶️ QEMU Display Driver
LVGL demo app running on qemu_x86 on macOS
And more!
Catch up on the full release notes and don’t forget the migration guide that documents the steps you need to take to update your Zephyr 4.3-based code.
Enjoy this new release, come and say hi on Discord if you have questions, feedback, or would like to get involved. Finally, check out the Zephyr YouTube channel and Zephyr Podcast to not miss future news!