Rust is no longer an experiment in the Linux kernel: the maintainers gathered at the December 2025 Maintainers Summit agreed that it is now a permanent part of the kernel, and Miguel Ojeda, who leads the Rust for Linux project, removed the “experimental” label from the documentation with a patch that summed up the decision in one line: the experiment is done, i.e. Rust is here to stay. Getting there took five years, one of the harshest disputes in recent kernel history and the departure of at least two well-known developers from their roles.

Rust in the Linux kernel in 20 seconds

Rust landed in Linux 6.1, released in December 2022, with about 12,600 lines of basic infrastructure.
In December 2025, maintainers declared the experiment over and made Rust a stable part of the kernel.
Rust code already ships in production, and the first Rust CVE arrived in December 2025.

The goal was never to rewrite the kernel. Rust for Linux was created so that new code, mainly drivers, could be written in a language that prevents by design many memory management bugs, such as out-of-bounds accesses or use-after-free errors. Microsoft and the Chromium project have reported that this class of bugs accounts for around 70% of their serious security vulnerabilities. C remains the kernel’s main language, and Rust lives alongside it. This English version is based on the report published by administraciondesistemas.com, which has followed the project for years.

From the 2020 proposal to Linux 6.1

The idea was presented at the 2020 Linux Plumbers Conference, and Miguel Ojeda posted the first patch series in 2021. After a year and a half in linux-next and several revisions, Ojeda and Kees Cook sent Linus Torvalds the pull request for Linux 6.1 on 1 October 2022: about 12,600 lines providing the bare minimum to build Rust code inside the kernel, with no drivers yet. Since then, each release has added abstractions, the layers that let Rust code safely use each subsystem’s C interfaces.

The pace has kept picking up. According to LWN’s coverage of the 2025 Maintainers Summit, the amount of Rust code in the kernel grew roughly fivefold in a single year. For a broader view of how the language got here, see how Rust went from orphaned project to Windows, Linux and Android and why the transition can no longer be stopped.

The 2025 fight over the DMA code

The tensest moment came in early 2025. Christoph Hellwig, maintainer of the DMA mapping code, objected to adding Rust abstractions that new drivers needed on top of his subsystem. On the kernel mailing list he went as far as calling the spread of a cross-language codebase into core subsystems a “cancer”, clarifying that he meant the mix of languages rather than Rust itself. On 21 February, Torvalds settled the matter: C maintainers are not forced to accept or care about Rust code, but they cannot stop others from using their interfaces from Rust. The abstractions moved forward and, days later, Hellwig stepped down as DMA mapping maintainer, leaving the code to Marek Szyprowski.

The dispute had another casualty. Hector Martin, lead of Asahi Linux, the project that brings Linux to Apple Silicon Macs, stepped down in February 2025 as kernel maintainer for that hardware and shortly afterwards as project lead. In his farewell he pointed to accumulated burnout and criticised how the conflict over Rust had been handled.

December 2025: the end of the experiment

At the December 2025 Maintainers Summit, in a session led by Ojeda, the consensus was that the experiment had succeeded. Torvalds said that, after almost five years, the time had come to drop the experimental status. Greg Kroah-Hartman, who runs the stable releases, said he had seen far fewer integration problems than expected and that Rust drivers are proving much safer than C ones. On 12 December, Ojeda posted the patch removing the section on the experiment from the documentation.

A few days later, on 17 December, the first CVE was assigned to Rust code in the kernel, CVE-2025-68260: a race condition in unsafe code in the Android Binder driver that could corrupt pointers and crash the system, with no remote code execution. It is a reminder that Rust greatly reduces memory bugs but does not eliminate them when unsafe blocks are needed to talk to the rest of the kernel.

What it means for sysadmins

Rust is no longer just a build option. The Rust Binder driver landed in Linux 6.18, Android 16 devices on the 6.12 kernel ship the Rust-written ashmem module, and parts of Nova, the new driver for NVIDIA GPUs, have been merged. According to LWN, the DRM graphics subsystem is about a year away from requiring Rust for new drivers. Debian has enabled Rust in the kernels for its next release, forky, and the agreed policy is that the kernel must build with the Rust version in Debian stable. At the end of 2025 the minimum was Rust 1.78, and Ojeda proposed raising it to 1.85.

In practice, anyone building their own kernels will need the Rust compiler and bindgen in addition to GCC or Clang, while those using distribution kernels will see more Rust modules appear without doing anything. Rust is also reaching user space, as shown by Ubuntu 26.10 and its Rust coreutils. There are still limits: gccrs, the GCC-based Rust compiler, can now compile the kernel’s Rust code but does not yet always produce correct output, and support remains limited on some niche architectures.

Frequently asked questions

Is Rust going to replace C in the Linux kernel?

No. The plan is to use Rust mainly for new code, such as drivers, while C remains the main language. Both coexist.

Since when has Rust been in the kernel?

Since Linux 6.1, released in December 2022. It officially stopped being experimental in December 2025.

Is kernel Rust code free of vulnerabilities?

It has far fewer memory bugs, but it is not immune. The first CVE in kernel Rust code, CVE-2025-68260, affected the Binder driver in December 2025 and could crash the system.