Rust in the Linux Kernel: From Experiment to Core Component

Rust in the Linux Kernel: From Experiment to Core Component

After years of debate and careful integration, Rust has achieved a significant milestone in the Linux kernel ecosystem.

At the December 2025 Linux Kernel Maintainers Summit, developers reached a consensus that marks a turning point for the programming language’s role in one of the world’s most critical software projects.

Essential Security Measures to Implement Immediately After Linux OS Installation

The End of “Experimental” Status

The summit’s key decision was straightforward but profound: Rust is no longer considered experimental within the Linux kernel.

The “experimental” label that has accompanied Rust since its initial introduction will be removed, and the language is now recognized as a core component of the kernel with long-term support commitments.

This represents a fundamental shift in how the kernel community views Rust—not as a temporary addition or proof of concept, but as an established technology direction that will continue evolving alongside traditional C code.

Why servers with Linux OS are much more than Windows server?

Real-World Implementation Takes Shape

The transition from experimental to essential isn’t just about changing labels. Concrete progress demonstrates Rust’s practical viability in kernel development. The first “genuine” Rust driver—developed for the Applied Micro QT2025 PHY device—has been successfully merged into the kernel. This milestone proves that Rust can handle real hardware interfacing tasks, not just theoretical applications.

Looking ahead, developers plan to extend Rust support to critical kernel features including high-resolution timers and module parameters. These are fundamental building blocks that countless kernel subsystems depend on, signaling confidence in Rust’s readiness for mission-critical responsibilities.

Choosing Between Debian and Ubuntu for Your Cloud Server

Performance and Safety: The Best of Both Worlds

Early results from Rust-written drivers show promising characteristics. Performance benchmarks indicate that Rust drivers operate at comparable speeds to their C counterparts, dispelling concerns that memory safety features might introduce significant overhead. More importantly, Rust’s compile-time memory safety guarantees have demonstrated their value by reducing system crash risks—a perpetual challenge in kernel development where memory errors have historically caused countless bugs and security vulnerabilities.

Several major kernel subsystems have begun accepting Rust code, with the virtual file system (VFS) and block layer leading the way. Sub-maintainers have been designated specifically to handle Rust-related patches in these areas. Notably, block subsystem maintainers report that integrating Rust code hasn’t significantly increased their workload, and when issues arise, fixes are implemented quickly—a testament to both the language’s robustness and the growing expertise of Rust kernel developers.

How to securely harden Ubuntu Cloud Server?

Toolchain Integration: Rust and C in Harmony

Perhaps one of the most telling signs of Rust’s maturation within the kernel is the evolution of the build system. The Linux kernel build system (Kbuild) now supports simultaneous specification of both Rust and C compiler versions, allowing developers to select compatible toolchains—for example, pairing rustc 1.75+ with gcc 12+. This infrastructure improvement reflects a pragmatic acceptance that the kernel’s future involves both languages working side by side.

This coexistence represents more than technical compatibility; it demonstrates a philosophical shift within the kernel community. Rather than viewing Rust as a replacement for C, developers increasingly see it as a complementary tool that can be deployed where its safety guarantees provide the most value, while C continues handling areas where its characteristics remain optimal.

When and Why You Need Antivirus on Linux (and How to Install ClamAV)

What This Means for Linux’s Future

The recognition of Rust as a core kernel component opens new possibilities for Linux development. New contributors who prefer Rust’s modern language features now have a clear path to meaningful kernel contributions. Security-conscious organizations gain additional tools for reducing memory-related vulnerabilities, which account for a substantial portion of kernel security issues.

However, challenges remain. The kernel community must continue building out Rust infrastructure, documentation, and abstractions to make kernel development in Rust as accessible as it is in C. Training and knowledge transfer will be essential as more subsystems adopt Rust code.

The December 2025 maintainers summit will likely be remembered as the moment Rust’s position in the Linux kernel solidified from promising experiment to established reality. As more drivers, subsystems, and core features incorporate Rust, the kernel gains both the performance heritage of C and the safety guarantees of modern systems programming—a combination that could define the next era of Linux development.