DEV Community

kent-tokyo
kent-tokyo

Posted on

Rust in 2025-2026: From 'Most Loved Language' to Core Infrastructure

#rust #systems #programming #linux

Rust has held the top spot in Stack Overflow's "most admired language" survey since 2016, nearly without interruption. But what happened in 2025 is no longer just about popularity polls. Rust is quietly but steadily becoming the language that underpins critical infrastructure.

"Experimental" Status Removed from the Linux Kernel

In December 2025, at the Kernel Maintainers Summit held in Tokyo, Rust's status in the Linux kernel was elevated from experimental to an officially recognized implementation language.

As LWN.net reported, the outcome was unambiguous: "The consensus among the assembled developers is that Rust in the kernel is no longer experimental — it is now a core part of the kernel and is here to stay." Maintainer Steven Rostedt noted there was zero pushback in the room. About five years after Linus first suggested the possibility in 2020, the matter was settled.

Rust code in the kernel currently stands at around 25,000 lines (compared to 34 million lines of C) — still a small share — but the subsystems adopting it are steadily expanding.

Rust Code Running in Production

Major components using Rust in the kernel today:

  • PHY drivers — network physical layer
  • null block driver — test block device
  • Android Binder driver — kernel-side implementation of Android's IPC mechanism
  • Apple AGX GPU driver — for Apple Silicon, via the Asahi Linux project
  • Nova GPU driver — for NVIDIA Turing-generation hardware (RTX 20 / GTX 16 series)

The Nova driver is architecturally interesting. It is split into two crates: nova-core (hardware initialization and communication) and nova-drm (Linux DRM API implementation), using an adapter pattern that maps different bus types — PCI, platform, USB — to the same types. Note that as of early 2026, full enablement is still in progress; development is ongoing.

Why Rust is Well-Suited for the Kernel

The majority of kernel driver bugs stem from memory safety issues: NULL pointer dereferences, use-after-free, buffer overflows, data races. In C, the only mitigation is "write carefully." Rust eliminates these classes of bugs at compile time, by construction.

Greg Kroah-Hartman has stated that Rust drivers are safer than their C counterparts, and this is exactly why. The 25,000-line figure is small, but it also means Rust is replacing the parts where "bugs would have been guaranteed if written in C."

The Technical Story Behind async closures

Among the stabilizations in 2025, async closures (Rust 1.85) were a deeper change than they appear.

What was wrong with the old workarounds?

Previously, writing an "async closure" looked like this:

// The closure couldn't borrow captured variables inside the Future.
// You had to either move ownership in, or wrap with Arc<Mutex<T>>.
let data = vec![1, 2, 3];
let f = |x: i32| {
    let data = data.clone(); // clone required
    async move { data[x as usize] }
};
Enter fullscreen mode Exit fullscreen mode

The problem with |x| async move { ... } was that the returned Future could not borrow captures from the closure itself. Because the Future has a different lifetime from the closure, you had no way to pass references — you had to either move ownership or clone.

The AsyncFn Trait Hierarchy

The async closures introduced in Rust 1.85 come with a new trait hierarchy internally: AsyncFn / AsyncFnMut / AsyncFnOnce.

AsyncFnOnce
  └─ AsyncFnMut
       └─ AsyncFn
Enter fullscreen mode Exit fullscreen mode

This mirrors the existing Fn* traits, but with a critical difference: the Future returned by an async closure can borrow from the closure itself (lending).

let data = vec![1, 2, 3];

// Rust 1.85+: the Future can borrow data directly
let f = async |x: usize| { data[x] };

// Usage at function boundaries
async fn apply<F: AsyncFn(usize) -> i32>(f: F, x: usize) -> i32 {
    f(x).await
}
Enter fullscreen mode Exit fullscreen mode

This works because AsyncFnMut's CallRefFuture associated type is designed to propagate the &mut self lifetime into the Future. Just as FnMut returns &mut self to the caller, AsyncFnMut lets the Future hold that lifetime.

let chains — Quietly Important

Also stabilized in 2025, let chains (Rust 1.88, Rust 2024 edition only) look simple but are significant: you can now freely combine if let patterns and ordinary bool conditions with &&. Using this requires edition = "2024" in Cargo.toml.

// before: forced to nest or introduce temp variables
if let Some(user) = get_user(id) {
    if user.is_active() {
        if let Some(role) = user.role() {
            println!("{}", role);
        }
    }
}

// after: flatten conditions and pattern matches on one line
if let Some(user) = get_user(id)
    && user.is_active()
    && let Some(role) = user.role()
{
    println!("{}", role);
}
Enter fullscreen mode Exit fullscreen mode

The same syntax works in while let and match guards, visibly reducing nesting depth throughout a codebase.

Safety Certification: A New Frontier

In December 2025, Ferrous Systems obtained IEC 61508 SIL 2 certification from TÜV SÜD for a subset of Rust's core library, under Ferrocene 25.11.0.

What is IEC 61508?

IEC 61508 is an international standard for functional safety of electrical, electronic, and programmable electronic safety-related systems. SIL (Safety Integrity Level) 2 corresponds to a "probability of dangerous failure of 10^-7 to 10^-6 per hour" — the level required in safety-critical domains such as aerospace, medical devices, industrial machinery, and automotive.

Historically, the de facto standard for safety-critical embedded systems has been C/C++ with MISRA. Rust achieving this level of certification means it has officially stepped into the domain where functional safety is required — not just systems programming for general use.

MISRA C 2025 Addendum 6

The same year, MISRA C 2025 Addendum 6 was published: an assessment of how MISRA C rules apply to Rust. The conclusion is that many existing C-specific rules are simply not applicable to Rust — the compiler enforces them by construction via the ownership model. This document also lays the groundwork for a future Rust-specific MISRA rule set.

Production Adoption Approaching 50%

According to JetBrains' State of Rust Ecosystem 2025, roughly half of surveyed organizations are now using Rust in production in non-trivial ways — a significant jump from around 38-39% in 2023.

Microsoft has started rewriting low-level Windows components in Rust, and Google, Amazon, and Meta have each introduced it into OS-level systems.

An Unexpected Fit for the LLM Era

In an era dominated by generative AI, Rust is being reassessed in an unexpected way.

LLM-generated code contains mistakes. Rust's compiler returns those mistakes immediately and concretely as build errors. The type system and borrow checker enumerate the mistakes an AI made — before the code ever runs.

error[E0502]: cannot borrow `data` as mutable because it is also borrowed as immutable
  --> src/main.rs:8:5
   |
6  |     let r = &data;
   |             ----- immutable borrow occurs here
7  |     println!("{}", r);
8  |     data.push(4);
   |     ^^^^^^^^^^^^ mutable borrow occurs here
Enter fullscreen mode Exit fullscreen mode

The tight feedback loop — "if it compiles, memory safety is guaranteed" — is well-suited for pair programming with an LLM. Fixing Rust compile errors has higher reproducibility than debugging Python runtime errors.

The Biggest Concern: Adoption May Plateau

The State of Rust Survey 2025 found that the top concern is not a technical one.

"Not enough adoption in the tech industry" came in first at 42.1% (narrowly ahead of "the language is getting too complex" at 41.6%).

The learning curve remains steep and unresolved. Some feel the language itself is growing more complex over time. In early-stage startups where velocity is critical, Rust's upfront cost is real.

That said, this concern is also the voice of people who want to use Rust more but see adoption lagging. The fact that technical concerns did not dominate the top of the list suggests Rust has reached a meaningful level of maturity.

Summary

In one sentence: as of 2026, Rust is in the early stages of a shift from "the language people love" to "the language people need."

  • Linux kernel — Experimental status removed. Real drivers like Nova and Apple AGX are running.
  • async closures — The AsyncFn trait hierarchy lets Futures borrow from their enclosing closure.
  • let chains — Flatten if let + bool conditions, reducing nesting without temp variables.
  • Ferrocene / IEC 61508 — Rust now has a formal foothold in safety-critical domains.
  • LLM compatibility — The compiler becomes a clear feedback loop for AI-generated code.
  • Top concern is adoption speed — Technical concerns have receded; ecosystem breadth is now the focus.

Sources:

Top comments (0)