The Numbers That Matter
Let’s start with the thing that makes purists nervous and pragmatists sit up straight: the Linux kernel now contains over 600,000 lines of Rust code. That’s not a typo. We went from roughly 13,000 lines when Rust support officially merged in kernel 6.1 back in late 2022 to more than 600,000 lines by early 2026. If you’ve been half-paying attention to the kernel mailing list drama, you know that trajectory should feel impossible. And yet here we are.
The acceleration matters because it suggests something shifted from “interesting experiment” to “structural inevitability.” When a change compounds that fast in a codebase as conservative as the Linux kernel, it’s not hype driving it. People building real systems started actually using it. That’s the signal buried under the noise of the debates.
The Debate You Probably Missed (But Should Care About)
The mailing list drama in late 2025 crystallized around something deceptively simple: are Rust abstractions in the kernel hiding performance problems? Ted Ts’o, a veteran C maintainer whose opinions carry weight precisely because he doesn’t throw them around, posted a detailed technical critique arguing that Rust’s abstraction layers were creating subtle performance regressions in I/O paths that conventional benchmarks weren’t capturing. It wasn’t ideological. It was granular. It was the kind of argument that makes you actually look at the generated assembly.
What made it interesting rather than just another flame war: the response wasn’t dismissal. Contributors started digging. Some benchmarks got re-run. Some abstractions got revisited. This is how good kernel development actually works, even when people disagree sharply. The conversation proved something important about the Rust-in-kernel community: it has enough technical maturity to argue about second-order effects instead of first principles.
The Security Data That’s Actually Compelling
A 2025 study from the University of Waterloo analyzed 150 kernel CVEs from the 2020-2024 window and found that 67% fell into memory safety categories that Rust’s ownership model structurally prevents. That’s not hypothetical. That’s forensic. Two-thirds of the vulnerabilities that people actually exploited in the real world vanish as a category if you write the code in Rust instead of C.
The Android team put real numbers on what that means operationally. Google Security Blog on memory safety in Android reported that the proportion of new Android OS code written in memory-safe languages reached 77%, with Rust accounting for most systems-level additions. Memory safety vulnerabilities in Android dropped to below 24% of total CVEs for the first time. That’s not a marginal improvement. That’s a genuine shift, and it happened because they made a deliberate technical choice and stuck with it.
Where the Real Work Lives Now
Linus confirmed in December 2025 that Rust driver contributions accelerated significantly. The highest-profile all-Rust driver effort to date is the Nova GPU driver for NVIDIA open-source firmware. This matters because drivers are where abstraction layers meet real hardware constraints. If Rust works there at scale, it works. The Nova driver isn’t toy code. It’s addressing a genuine gap in the open-source graphics stack.
The Linux kernel Rust documentation has matured into something you can actually follow without maintaining a mental model of the entire language ecosystem. Less “here’s why we’re doing this philosophically,” more “here’s how you abstract a spinlock, here’s what the borrow checker wants from your IOMMU binding.” The documentation gap was real, and watching it close is genuinely satisfying if you’ve worked in system-level code long enough to appreciate the friction it reduces.
What This Actually Signals
The kernel mailing list drama tells you something important if you know how to read it: the Rust transition isn’t being imposed from above. It’s emerging from below. Driver maintainers are adopting it. Security teams are seeing the empirical gains. The abstractions are getting better because people who understand kernel internals are building them, not language designers guessing at what the kernel needs.
The remaining friction isn’t ideological purity on either side anymore. It’s genuinely hard technical questions about performance visibility, compile-time overhead, and how you teach people who’ve spent two decades reasoning about C memory models to reason about ownership instead. Those are solvable problems. They’re engineering, not philosophy.
If you’ve been sitting on the sidelines treating Rust in the kernel as theater, this is the moment to actually look at what’s shipping. The numbers have crossed a threshold. The security data is credible. The code is real. This isn’t speculation about the future anymore. What do you see when you actually dig into it?