Rust OSDev roundup spotlights Linux kernel, embedded async progress

Rust's systems story is getting tangible

Rust’s most interesting work is happening where the abstraction meets hardware, and this roundup makes that plain. The issue is curated from automated collection and categorization, but it is manually proofread, which gives it the feel of a scout’s notebook rather than a machine dump. That matters here, because the projects it gathers are not all trying to solve the same problem. They show Rust moving at once through kernel work, embedded timing, homebrew consoles, and entry-level hardware.

The kernel conversation is no longer theoretical

The opening signal is a live Rust for Linux recording with Alice Ryhl and Greg Kroah-Hartman, captured from Rust Week in Utrecht. Ryhl is described as a Google software engineer working on Android and Rust for Linux, and also a core maintainer of Tokio, while Kroah-Hartman is a Linux Foundation Fellow and stable kernel maintainer. Put those names in the same room and the message is immediate: Rust-in-the-kernel is being discussed in public as day-to-day engineering, not as a lab experiment.

That lines up with the broader direction of the Rust Project Goals pages, which say Rust is now an integral part of the Linux kernel. The same material frames Rust for Linux as experimental support that also helps unblock embedded and other low-level systems work. For anyone tracking the language from the outside, that is the real shift: the kernel is not borrowing Rust as a curiosity, it is helping define where the ecosystem is headed.

Embedded async is getting sharper, not just bigger

If the kernel conversation is the headline, the embedded timer work is the part you can actually take apart on a weekend. Finding the Time Part 2 focuses on async timers for Armv8-R, using the Arm Generic Timer and Embassy’s time-driver model. That combination points to a very specific systems problem: how to make async scheduling behave cleanly on constrained hardware without fighting interrupts or wasting cycles.

The appeal here is practical. This is the kind of project that teaches how embedded Rust thinks about time, wakeups, and cooperative execution, not just how to flash an LED. It is also a good reminder that the most interesting embedded work in Rust is no longer only about portability or safety in the abstract; it is about making modern async patterns fit into environments that were built long before async was fashionable.

The homebrew lane is where Rust starts to look playful again

Two of the roundup’s projects are especially good weekend rabbit holes if you want something hands-on. Building an AsyncIO executor for the 3DS turns a handheld console into a cooperative multitasking playground, which is a charmingly direct way to test how far Rust can go outside its usual targets. Rust x GBA: Setup and Pixels takes a different route, walking through a nightly Rust project for Game Boy Advance ROM development with arm-none-eabi tooling and actual pixel output.

Together, those projects show how homebrew has become one of Rust’s liveliest proving grounds. The 3DS work speaks to scheduler design and executor behavior, while the GBA piece is the kind of low-level, visible-feedback build that makes systems work feel immediate. If kernel work is Rust at its most serious, retro-console development is Rust at its most physically satisfying: compile, load, see pixels, iterate.

uFerris lowers the bar instead of raising it

The roundup also highlights uFerris, and that inclusion says a lot about where embedded Rust is maturing. On GitHub, uFerris is described as a versatile Rust embedded learner board targeted toward beginners, and crates.io lists `uferris-bsp` as a board support package for the uFerris Learner Board. That pairing is important, because it means the project is not just a piece of hardware, it comes with the software scaffolding a newcomer needs to get moving.

Third-party coverage describes it as a modular platform centered on Seeed XIAO controllers, with a reported $24.99 price point. That kind of positioning makes it feel less like an aspirational dev board and more like a practical on-ramp. In a field that can still intimidate first-time bare-metal tinkerers, uFerris is a sign that embedded Rust is trying to meet people where they are.

Rust 1.96.0 is the quiet connective tissue

The roundup also ties all of this back to the language itself with Rust 1.96.0. The release was officially announced on May 28, 2026, and the pre-release testing post said the release was scheduled for that date as well. For systems work, that is not a side note. Kernel code, embedded timers, executors, and board support crates all sit on the same compiler and Cargo foundation, so release-cycle improvements ripple through every one of these projects.

That is part of why a roundup like this is more than a pile of links. When the language release train moves, the kernel conversation, the async timer experiments, and the hobby hardware projects all feel it together. Rust’s ecosystem does not split cleanly into “serious” and “fun” tracks anymore; they are sharing the same toolchain and often the same ideas.

A monthly map of a very wide ecosystem

The Rust OSDev team makes that breadth easier to follow because the monthly issue is openly maintained through GitHub pull requests, and the organization currently lists 31 repositories. That structure matters as much as any single project, because it turns the roundup into a live intake channel for people working on things that might otherwise stay buried in personal blogs or half-finished repos.

That is the real shape of this issue: a public kernel conversation, a timer model that brings async closer to hardware, homebrew projects that make old consoles feel new again, a beginner board designed to welcome first contact, and a compiler release holding the whole thing together. Rust’s systems frontier is not abstract anymore. It is sitting in the open, waiting for you to pick the piece that matches the weekend you have.