Rust 1.85 is a new update in the 2024 release that further enhances memory safety and concurrency models, aiming to provide a better and more reliable tool for developing performance-critical systems. However, Rust adoption has faced the greatest challenges precisely where it has the most legitimacy: in Linux kernel development.
The changes, addressing both syntactic and semantic aspects, have been introduced with backward compatibility in mind, allowing updates to be integrated into projects without destabilizing existing codebases. The language’s design and the philosophies surrounding it suggest that Rust is a language worth working with at the kernel level.
Key Rust 2024 Changes
Return Position Impl Trait Lifetime Fixing Rules
One of the most significant changes concerns the lifetime fixing rules for return position impl Trait
(RPIT) types. The 2024 release modifies the default lifetime resolution
behavior, preventing implicit parameter fixing unless explicitly
requested using the use<...> syntax. This change
helps avoid accidental lifetime extension scenarios that previously led
to subtle bugs in asynchronous functions and trait implementations.
Developers migrating older codebases should review return type
signatures, especially in contexts where generic parameters are combined
with asynchronous operations.
Temporal Scope Adjustments
This release introduces refined temporal scope rules for if let expressions and block tail expressions. Time scopes created in if let conditions are now preserved throughout the entire if let
block, eliminating a category of post-use errors that previously
occurred when referencing values across multiple pattern matches.
Similarly, tail expressions in blocks now have an extended lifetime,
allowing for more natural expression chaining without requiring
artificial let bindings. These changes highlight Rust’s maturity in safely handling complex control flow patterns.
Support for Native Asynchronous Closures
Rust 1.85.0 delivers on the long-awaited promise of asynchronous closures by stabilizing the async || {}
syntax. This feature fills a critical gap in Rust’s parallelism toolkit
by enabling closures to capture their context while generating futures.
The implementation introduces three new standard library traits—AsyncFn, AsyncFnMut, and AsyncFnOnce—which mirror their synchronous counterparts but return impl Future.
The impact on asynchronous codebases is profound. Consider this HTTP server middleware example:
async fn handle_request(req: Request) -> Response {
let auth_token = req.headers().get("Authorization");
let authenticate = async || {
let db = connect_to_database().await;
db.validate_token(auth_token.unwrap()).await
};
if authenticate().await.is_ok() {
process_request(req).await
} else {
Response::unauthorized()
}
}This syntax eliminates boilerplate associated with manually wrapping futures while preserving Rust’s strict ownership guarantees across asynchronous boundaries.
Rust-Version-Aware Dependency Resolution
Cargo’s dependency resolver in 1.85.0 introduces Rust-version awareness by leveraging the rust-version field in Cargo.toml
manifests. This feature prevents dependency resolution from requiring a
newer Rust version than specified, effectively eliminating a class of
toolchain compatibility issues. For workspace maintainers, the resolver
now strictly enforces default-features=false declarations for inherited dependencies, ensuring consistency across large project configurations.
Style Releases in Rustfmt
Rustfmt now introduces style releases independent of language releases,
allowing teams to adopt modern formatting rules without committing to a
full language version upgrade. Release 1.85.0 includes improved
identifier sorting algorithms that handle raw identifiers (r#foo) and numeric suffixes consistently across projects.
The Linux Kernel Drama
The Linux kernel has traditionally been developed in C, but since 2021, Rust has been gradually introduced with the promise of improved memory safety and reduced vulnerability to common programming errors. However, from the very beginning, several developers, including veteran kernel maintainers, have questioned whether mixing different programming languages in such a critical component as the kernel is advisable. The debate even took on ideological and almost religious overtones.
The controversy reached a boiling point earlier this year when Christoph Hellwig, maintainer of the kernel’s DMA (Direct Memory Access) utilities, rejected patches that would have allowed Rust drivers to interoperate with his C-based subsystems. Hellwig argued that cross-language integration complicates maintenance and fragments critical infrastructure, comparing Rust’s encroachment into his development work to a "cancerous tumor."
The Rust developers did not let this go unchallenged, as Hellwig had clearly imposed restrictions on the implementation of subsystems beyond his maintainership. The Rust community initially sought support on social media before appealing to Linus Torvalds to intervene. However, Linus was displeased with the Rust developers—led by Hector Martin—turning to social media. When Linus refused to side with Martin and even named him as the source of the issue, Martin resigned as a maintainer, expressing disappointment with the project's leadership.
Ultimately, the drama took a positive turn when cooperation guidelines were formalized, and Rust’s improvements were acknowledged. Going forward, C code will no longer be allowed to modify APIs in ways that break existing Rust enhancements. Linus ultimately overruled Hellwig’s blockade, ensuring Rust's continued integration into the kernel.
