Greg Kroah-Hartman, the stable kernel maintainer for Linux, delivered a definitive message at Open Source Summit India in Mumbai on July 15, 2026: Rust is no longer an experiment in the kernel project. It’s a permanent fixture, and for certain subsystems, it will soon be the only language for new code. The announcement doesn’t mean Linux is abandoning C—existing code stays as is—but it marks a strategic pivot toward memory safety at the kernel’s core.

The concrete changes taking hold

Rust’s journey in the kernel began with experimental support merged in Linux 6.1. That label was dropped late last year when kernel maintainers collectively agreed to treat Rust as a first-class language. Now, Kroah-Hartman’s keynote makes the implications tangible. The graphics subsystem, one of the most complex areas in the kernel, will only accept new drivers written in Rust going forward. Android’s Binder IPC mechanism, the communication backbone for billions of devices, already has a Rust implementation that will replace the existing C version completely.

These aren’t tentative pilot projects. Kroah-Hartman described Rust as the default for suitable new work, especially where memory-safety failures carry high costs. The kernel’s leadership isn’t ordering a mass rewrite—they’re explicitly telling contributors to leave stable C code untouched. Instead, Rust will be applied to greenfield development and to subsystems where the risk of common C bugs is unacceptable. Kernel documentation reinforces this: generated bindings expose C interfaces to Rust, while abstractions encapsulate unsafe operations behind safe APIs, making driver and filesystem code less error-prone.

What this means for you, depending on who you are

The Linux kernel doesn’t run on your Windows desktop directly, but it’s everywhere around it. WSL, virtual machines, Docker containers, cloud servers, and Android devices all rely on Linux. As Rust adoption tightens the kernel’s security posture, those gains eventually reach Windows users.

For home users: If you use WSL for development, tinkering, or running Linux tools, future kernel updates will carry increasingly Rust-native components. That translates to fewer crashes and security holes born from trivial C mistakes—use-after-free, missing locks, botched cleanups. You won’t notice a performance difference, but the foundation beneath your Linux environment will grow more resilient.

For IT professionals and sysadmins: Linux servers and cloud infrastructure are headed for a lower CVE burden. Kroah-Hartman estimates that roughly 80% of the kernel CVEs he’s seen over 25 years could be eliminated by Rust’s compile-time checks. Those aren’t exotic exploits; they’re the daily “stupid little tiny things” that consume maintainer hours and force emergency patches. A foreseeable reduction in memory-safety flaws means lighter patch cycles and fewer late-night reboots for trivial pointer mishandling.

For developers: If you write kernel code, the landscape is shifting. Kernel maintainers are optimizing for reviewers—only about 150 people review the majority of patches from over 5,000 contributors. Rust’s ownership, lifetime, and type checks move basic resource-management verification to the compiler, freeing human eyes for logic review. If you plan to contribute drivers for graphics, Binder, or other Rust-mandated subsystems, you’ll need Rust skills. Even if you stick with C, the Rust push has already improved C APIs. To create safe bindings, maintainers reworked tricky interfaces, introducing guard and scoped-allocation patterns that make existing C code safer.

For Windows developers: Directly, nothing changes in the Windows kernel. But if your workflow depends on Linux virtual machines, containers, or Android emulation, you’ll eventually consume a kernel with fewer exploitable memory bugs. That’s a hardening of your toolchain’s supply chain, reducing friction from security incidents.

The road to this decision

The Linux kernel was written in C from its 1991 start. C offers fine-grained control but no built-in safeguards against buffer overflows, use-after-free, or data races. As the kernel swelled past 30 million lines of code, the volume of memory-safety bugs exploded. Kroah-Hartman noted the kernel now averages 13 CVEs per day, nearly nine patches an hour, and most are simple C errors rather than sophisticated logic flaws.

The Rust-for-Linux project began years ago to introduce a language that could prevent many of these errors at compile time. Rust’s ownership model and type system make entire classes of bugs impossible without runtime overhead. After experimental support landed in Linux 6.1 (December 2022), bindings and abstractions matured through community effort. By late 2025, kernel maintainers agreed Rust had proven itself. Kroah-Hartman’s 2026 keynote publicly seals that consensus and outlines enforceable Rust-only paths for new code in sensitive areas.

An important side effect: the act of creating Rust bindings forced maintainers to revisit messy C interfaces, leading to safer patterns that benefit all C code. Kroah-Hartman said, “If Rust were to disappear tomorrow, the kernel’s better off for it.”

What you should do right now

For most Windows users and administrators, no immediate action is required. The changes will trickle through Linux distributions over months and years. However, certain groups can prepare:

  • Kernel developers: If you maintain an out-of-tree driver or intend to submit new drivers for graphics, Binder, or similar subsystems, start learning Rust now. The Rust-for-Linux project’s roadmap is documented at the official Rust Project Goals repository.
  • WSL power users: If you track upstream kernels manually, you may see Rust-instrumented modules sooner. Stay updated via Windows Insider builds or manual kernel updates.
  • Security teams: Monitor Linux CVE trends as Rust adoption increases. Expect a dip in memory-safety CVEs over time, but don’t relax other defenses—logic bugs remain.
  • Educators and students: If you teach or learn systems programming, adding Rust to your curriculum positions you for the kernel’s future.

What to watch next

Rust’s kernel role will expand. Kroah-Hartman hinted that “lots of projects are starting to move toward Rust,” including Git. While a full kernel rewrite remains distant, Rust will become the default for new, complex, or security-sensitive code. For Windows users, the ultimate outcome is a more secure Linux foundation supporting everything from WSL to the cloud. The “fun” Kroah-Hartman rediscovered in coding might just mean fewer headaches for everyone else.