Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
Rust is part of mainline Linux, but that does not mean the kernel provides a general-purpose async Rust runtime or a supported async driver API. The current upstream status of those interfaces is not established by the available kernel documentation. Rust’s async and await language features need an executor to poll futures; they do not supply one automatically.
What “async Rust in the Linux kernel” means
The phrase can refer to two different things: using Rust to write code that runs inside the Linux kernel, or using Rust’s asynchronous programming model—futures and async/await—inside that kernel code. The first is supported: Rust entered mainline Linux in version 6.1. The second is a separate question. Kernel Rust support alone does not demonstrate that an in-kernel executor or an async driver framework is available.
Rust’s await language reference explains that awaiting a future suspends execution until an executor has run the future to completion. The language feature describes how code expresses asynchronous work; it does not identify a Linux kernel executor. The documented kernel driver API likewise does not, by itself, establish an async execution model.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →What Rust support Linux provides
The kernel’s Rust documentation for Linux 6.16 addresses kernel developers and maintainers working on abstractions, drivers, infrastructure, and tools. Rust support is integrated into the kernel development process rather than offered as one universal framework that every subsystem must adopt.
#1 Best Overall
The Rust for Linux policy says individual subsystems may choose whether and how to adopt Rust. The RUST subsystem maintains selected core facilities; it does not own every Rust component. As a result, a Rust interface available for one bus or subsystem should not be assumed to exist across the kernel.
The kernel’s generated driver API documentation describes a bus-specific Driver trait and registration model. That documentation is useful evidence of the driver integration that is documented there, but it is not evidence of a general async driver API.
Rank #2
Is there a supported async Rust runtime or driver API?
The documented sources do not establish that upstream Linux currently provides a general-purpose async Rust runtime or a supported async Rust driver API. That is an unresolved status, not proof that async Rust in kernel code is impossible. A definitive answer for a particular subsystem requires checking that subsystem’s current upstream API and maintainer guidance.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
In practice, a developer evaluating asynchronous work needs to answer questions beyond whether Rust syntax compiles:
- Execution: What component polls the future, and when does it run?
- Kernel integration: How does the work fit with the subsystem’s existing callbacks, work scheduling, and lifecycle?
- Cancellation and lifetimes: What happens to pending work when a device is removed, a request ends, or resources are released?
- API coverage: Does the specific bus or subsystem expose the necessary Rust interfaces?
- Toolchain support: Does the target architecture and compiler configuration support the required Rust features?
These are evaluation criteria, not claims that upstream offers several established async implementations to choose from. Without an executor and subsystem integration, writing an async function does not by itself make kernel work asynchronous.
What the “experiment is done” statement means
At the 2025 Linux Plumbers Conference, Rust for Linux maintainer Miguel Ojeda reported that the Linux Kernel Maintainers Summit had deemed the Rust experiment concluded. He summarized the point as: “But the experiment is done, i.e. Rust is here to stay.” The statement refers to Rust’s place in Linux; it is not a declaration that every Rust feature, configuration, architecture, or driver API is complete.
The same LPC 2025 presentation cautioned that support was not uniform across all configurations, architectures, and toolchains, and that work continued across the kernel, Rust, GCC, and other projects. The appropriate distinction is that the experiment label has ended while engineering and compatibility work continue.
Language and compiler work is still evolving
Rust for Linux continues to depend on some unstable language and compiler features. The Rust Project’s 2026–2027 goal for stabilizing Rust for Linux compiler features discusses work needed for kernel use, including architecture flags, sanitizers, mitigations, and optimization features. That goal is evidence of ongoing stabilization effort, not a promise that all relevant features are already stable or universally available.
The Rust Project’s 2026 Rust for Linux roadmap also lists “Guaranteed destructors” as a 2026–2027 exploration that could enable patterns such as safe scoped spawning for async. This is a language-roadmap exploration; it does not show that Linux currently exposes safe scoped async spawning or a kernel executor.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.How to assess an async kernel use case
- Identify the exact subsystem and target kernel version. Rust adoption is subsystem-specific, so begin with that subsystem’s upstream documentation and current driver interfaces rather than assuming a kernel-wide API.
- Confirm the execution mechanism. Determine which executor or kernel mechanism would drive the future. Rust’s
awaitsyntax alone does not run it. - Trace the lifecycle. Establish how pending work is stopped or completed during cancellation, device removal, shutdown, and error handling; ensure the design fits the subsystem’s ownership and callback rules.
- Check the build environment. Verify the kernel configuration, architecture, compiler, and Rust feature requirements for the code you intend to build. Project-wide Rust support does not guarantee every combination works.
- Check current maintainer guidance. Because kernel APIs and Rust support evolve, confirm the subsystem’s current upstream documentation or maintainer discussion before treating an approach as supported.
Bottom line on current availability
Rust is an established part of mainline Linux, and Rust drivers are documented in a bus-specific model. But the existence of kernel Rust support and Rust’s async/await syntax does not establish a general-purpose in-kernel async runtime or supported async driver framework. Treat availability as subsystem- and version-specific until current upstream documentation confirms the exact API and execution model you need.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
