Why the Linux Kernel Needs More Rust Developers: Insights from Greg Kroah-Hartman

Introduction

In a recent presentation at the Rust Week conference, Greg Kroah-Hartman, one of the most influential figures in the Linux kernel community, issued a clear call for more developers to contribute Rust code to the kernel. Known for his role as the stable kernel maintainer and a key subsystem maintainer, Kroah-Hartman has also been exploring the use of AI and large language models (LLMs) to uncover kernel bugs. His message underscores a significant shift in the Linux development ecosystem: the integration of Rust as a second system-level language alongside C.

The Role of Rust in the Linux Kernel

Memory Safety and Security

Rust's most touted advantage in kernel development is its memory safety guarantees without needing a garbage collector. The Linux kernel, historically written entirely in C, is prone to memory bugs such as buffer overflows, use-after-free errors, and null pointer dereferences. These issues account for a large fraction of security vulnerabilities. Rust’s ownership model and borrow checker enforce strict compile-time rules that virtually eliminate such classes of bugs. By adopting Rust, the kernel can drastically reduce its attack surface, making systems more resilient against exploits.

Performance and Integration

While safety is critical, Rust also offers performance competitive with C. The language compiles to native code and gives developers fine-grained control over memory layout. Moreover, Rust’s interoperability with existing C code is designed to be seamless. The kernel’s existing C infrastructure can call into Rust modules and vice versa, allowing a gradual transition. Early experiments, such as the initial Rust-for-Linux project, have demonstrated that Rust drivers can achieve performance parity with their C counterparts while offering improved safety.

Greg Kroah-Hartman’s Call to Action

The Current State of Rust in the Kernel

Despite the promising potential, the adoption of Rust in the Linux kernel is still in its infancy. As of this writing, only a handful of Rust-based drivers and subsystems have been merged into the mainline kernel. Kroah-Hartman emphasized that while the infrastructure is in place—thanks to the work of maintainers like Miguel Ojeda—more hands are needed to expand Rust’s footprint. He noted that the kernel community is welcoming but that the learning curve for writing safe kernel code in Rust remains steep.

Challenges and Opportunities

One of the primary challenges is the limited number of developers who are proficient in both Rust and the intricate requirements of kernel programming. Additionally, there are ongoing debates about coding standards, tooling, and integration strategies. However, Kroah-Hartman views these as opportunities rather than roadblocks. He encouraged developers to start small—by writing simple drivers or refactoring existing C code—and to engage with the Rust-for-Linux community. The long-term vision is that Rust will eventually become a first-class language for kernel development, enabling more reliable and secure operating systems.

How to Get Involved

Resources for Learning Rust

For those interested in answering the call, Kroah-Hartman recommended several starting points:

• The official Rust Programming Language book (the "Book") for fundamentals.
• The Rust for Linux project website, which provides documentation and sample code.
• Mailing lists and IRC channels where maintainers discuss ongoing work.
• Kernel-focused coding challenges that emphasize safety and performance.

Contributing to the Linux Kernel

To contribute Rust code to the kernel, developers should first familiarize themselves with the standard kernel development process: signing off on patches, following coding style guidelines, and iterating with reviewers. The memory safety and performance benefits of Rust can make patches more appealing, but adherence to community norms is essential. Kroah-Hartman’s presentation also highlighted the use of AI/LLMs to automatically detect bugs, which could be a complementary tool for Rust developers to test their code.

Conclusion

Greg Kroah-Hartman’s appeal at Rust Week is a signal that the Linux kernel is at a pivotal juncture. With the increasing complexity of modern computing and the growing threat of security vulnerabilities, the adoption of a memory-safe language like Rust is not just a technical improvement but a strategic necessity. For developers willing to learn both Rust and kernel internals, there is a unique opportunity to shape the future of one of the world’s most critical software projects. The road ahead will require patience, collaboration, and a willingness to experiment—but as Kroah-Hartman reminded the audience, the kernel community is ready to help those who take the first step.