Rust in the Linux Kernel – What the "Official" Support Really Means

en / languages / rust — 2025-12-10 00:00:00

In December 2025 the Linux kernel maintainers effectively promoted Rust from an experimental add-on to a fully accepted language for kernel development – on the same official level as C and assembler.:contentReference[oaicite:0]{index=0}

That doesn’t mean the kernel is suddenly “written in Rust”, but it is an important milestone for systems programming, for Rust, and for the future of Linux.

What exactly was decided?

At the Kernel Maintainers Summit, key kernel developers (including Linus Torvalds) agreed that Rust support should lose its “experimental” label and become an officially supported language for kernel code.:contentReference[oaicite:1]{index=1}

In practice this means:

  • Rust is now considered a first-class language for new in-kernel code.
  • The Rust-for-Linux infrastructure is stable enough to be maintained long-term.
  • Distributions and architectures are expected to provide a usable Rust toolchain if they want to stay relevant.:contentReference[oaicite:2]{index=2}

This is a political and organisational green light: it tells companies, distro maintainers and driver authors that “Rust in the kernel is here to stay”.

Why Rust in the kernel at all?

Most serious Linux security bugs are still memory-safety issues in low-level C code: buffer overflows, use-after-free, double free, data races… all the classics.:contentReference[oaicite:3]{index=3}

Rust helps here because:

  • It enforces memory safety at compile time (ownership, borrowing, lifetimes).
  • It avoids whole classes of bugs without a garbage collector.
  • Safe Rust code is much easier to refactor and review.
  • The language comes with modern tooling, testing and documentation support.

The idea is not to rewrite the whole kernel. Instead, new drivers and subsystems that would normally be written in C can now be written in Rust, reducing the future bug load.

What it does not mean (yet)

It’s important to be realistic. “Official Rust support” does not mean:

  • That any developer can just go ahead and write any driver in Rust.
  • That all subsystems already provide idiomatic Rust APIs.
  • That the C parts of the kernel suddenly become memory safe.

Several things still need a lot of work:

  • Many subsystems (e.g. wireless, PCIe) still lack complete bridging code so Rust drivers can plug into the existing C infrastructure.:contentReference[oaicite:4]{index=4}
  • The Rust abstractions have to be carefully designed so they are safe and don’t hide performance details.
  • Kernel maintainers have to gain experience reviewing Rust patches.

So this step is more like: “Rust is now an official tool – please help us use it well.”

What does this mean for developers?

If you are a systems programmer, this changes the landscape:

  • Learning Rust + kernel internals becomes a concrete career path.
  • Modern languages are no longer limited to user space; kernel work is becoming more accessible to a new generation of developers.
  • Companies shipping Linux-based products (servers, mobile, embedded) now have a strong argument to invest in Rust code for safety-critical drivers.

For C programmers this is not the end of the world. C will stay dominant in the kernel for a long time. But new code, especially new drivers, will increasingly be written in Rust when it makes sense.

How to get started with Rust for Linux

If you want to experiment, a few good starting points:

  1. Rust for Linux project
    The main project that maintains the Rust support in the kernel tree, with documentation and example drivers.:contentReference[oaicite:5]{index=5}

  2. Read about memory safety and kernel security
    Articles and reports explaining why memory-safe languages dramatically reduce whole classes of bugs in low-level code.:contentReference[oaicite:6]{index=6}

  3. Practice Rust in user space first

  4. Write small CLI tools.
  5. Experiment with async I/O and low-level crates.

  6. Get used to ownership and borrowing before diving into kernel development.

  7. Follow kernel-Rust news

  8. Heise, LWN, Rust-for-Linux blog, security blogs: they regularly report about new drivers, abstractions and success stories.:contentReference[oaicite:7]{index=7}

Closing thoughts

For years, “systems programming” meant almost automatically “C (plus a bit of assembler)”.
With Rust becoming an officially supported language in the Linux kernel, that mental model finally starts to change.

We now have a realistic path to keep the performance and control of low-level code, without accepting all the traditional memory-safety bugs as inevitable.

On this blog I’ll be following the Rust-in-Linux story closely – and, over time, I hope to write about:

  • setting up a Rust-for-Linux development environment,
  • reading real Rust kernel code,
  • and comparing similar drivers written in C and Rust.

Stay tuned – the next decade of Linux kernel development is going to be interesting.