The Numbers Tell a Story That Started Quiet
When Rust support landed in Linux kernel 6.1 back in late 2022, it arrived with roughly 13,000 lines of code. A modest footprint. The kind of thing that sparked passionate debate on the kernel mailing list but didn’t fundamentally reshape how anyone was building systems. Most of us watched with cautious interest, the kind you reserve for experimental subsystems. We’ve seen too many grand visions fail at the intersection of systems programming and real-world constraints.
By early 2026, the picture had shifted in ways that deserve serious attention. The kernel now contains over 600,000 lines of Rust code spread across drivers, filesystem abstractions, and core subsystem bindings. That’s not a gradual accumulation. That’s acceleration. The Nova GPU driver for NVIDIA’s open-source firmware is the high-water mark here, an all-Rust driver effort that Linus Torvalds himself highlighted in a December 2025 kernel mailing list post as evidence that the language transition was actually producing results.
What matters most is that this growth happened not because of top-down mandate, but because developers started choosing Rust for new code. That’s the kind of adoption pattern that tells you something structural has changed in how engineers think about writing systems-level software.
The Security Argument Stopped Being Theoretical
Here’s the uncomfortable truth about C: it gives you nearly infinite ways to corrupt memory, and most of them look correct until they don’t. We’ve built extraordinary mitigation techniques—address sanitizers, CFI, hardened allocators—but we’ve been working backward from a language that makes memory safety mistakes the default path.
A 2025 study from the University of Waterloo examined 150 kernel CVEs spanning 2020 through 2024. Their finding deserves to be underlined: 67 percent of those vulnerabilities fell into memory safety categories that Rust’s ownership model structurally prevents. These aren’t edge cases or hypotheticals. These are real bugs in shipped code that reached real systems, use-after-free vulnerabilities, buffer overflows, and data races, the classics that continue to haunt the C ecosystem.
The research provided something Rust advocates had been missing: empirical weight. You could no longer argue that memory safety was a nice-to-have. The data suggested it was preventing the majority of critical kernel vulnerabilities.
Google’s Android team published their own findings in early 2025, and they paint an even starker picture. Across the Android operating system, 77 percent of new code written for systems-level work now uses memory-safe languages, with Rust accounting for the majority of that shift. More importantly: memory safety vulnerabilities dropped below 24 percent of total CVEs for the first time. That’s not incremental improvement. That’s a structural reduction in an entire class of failure modes.
The Critique That Made People Actually Think
But here’s where the story gets interesting in a way that most tech narratives gloss over. Success in systems programming doesn’t mean universal agreement. In late 2025, Ted Ts’o, a veteran C kernel maintainer with decades of credibility, posted a detailed technical critique to the kernel mailing list that reignited conversation about Rust’s actual costs.
His argument wasn’t that Rust was bad. It was more surgical than that. He contended that Rust’s abstraction layers were creating hidden performance regressions in I/O paths that standard benchmarks weren’t capturing. The abstractions that make Rust safer, he suggested, were introducing overhead that you only saw under specific workload patterns. The kind of patterns that show up in production after you’ve already shipped.
This is the kind of critique that matters because it’s not reflexive opposition. Ts’o wasn’t saying “Rust is wrong.” He was saying “we need to measure this more carefully, and we’re not.” That distinction matters enormously. It meant the conversation shifted from ideology to engineering.
The response from the Rust side wasn’t defensive. Contributors started profiling those I/O paths with genuine rigor. Some of the alleged regressions held up under scrutiny. Others didn’t. A few sparked actual improvements to the abstractions themselves. This is how technical communities should work when they’re functioning well.
What This Actually Means for You
If you’re writing systems software or infrastructure code, the inflection point has arrived. The question isn’t whether Rust will be used in the Linux kernel anymore. The question is which pieces of your stack will be written in Rust, which will remain C, and how you’ll manage that transition without breaking the ecosystem you depend on.
The Linux kernel Rust documentation is now comprehensive enough that you can actually ship production code using these abstractions. The maturity levels have shifted. The patterns have hardened. The performance questions are being asked and answered with actual data rather than speculation.
Google Security Blog on memory safety in Android documented in detail how large-scale systems with millions of devices running the code have begun the transition. They didn’t do it because they read a blog post. They did it because the mathematics of vulnerability prevention at scale made the investment worthwhile.
The Underscore Moment
Here’s what interests me most about this moment. We’re past the phase where Rust in the kernel is a special project or a research exercise. We’re past the phase where the mailing list debates are about whether this should happen. The debates now are about how to do it well, how to measure the tradeoffs, and where to invest next.
That transition from “should we” to “how should we” is quiet. It doesn’t generate headlines. It generates merge commits. It generates driver pull requests and filesystem improvements and subsystem bindings that just work. It generates the kind of sustained engineering effort that actually changes how systems get built.
Two years after the merge, the story isn’t that Rust won or that C is dead. The story is that a large, unruly, distributed engineering community found a way to add a new tool while maintaining the existing one. That’s harder than it sounds. If you’re building systems software, it’s worth studying how they did it.