Rust 1.85.0: A Comprehensive Guide to the Latest Rust Release

The Rust programming language continues to set the standard for safety, performance, and developer productivity. With the release of Rust 1.85.0 on February 20, 2025, the language introduces a host of new features, enhancements, and improvements. This release is particularly significant as it stabilizes the Rust 2024 Edition, bringing with it a range of language refinements and tooling upgrades. In this detailed guide, we’ll explore everything new in Rust 1.85.0, how it impacts developers, and how you can upgrade to take advantage of these features.

For more details about this release, you can refer to the official Rust 1.85.0 blog post.

Rust 2024 Edition: Key Language Enhancements

The Rust 2024 Edition is now officially stabilized in Rust 1.85.0. This edition introduces several language improvements designed to enhance safety, ergonomics, and performance. Here’s a breakdown of the most notable changes:

1. RPIT Lifetime Capture Rules

Rust has refined how Return-Position Impl Trait (RPIT) types capture lifetimes when use<..> is not specified. This change ensures better control over lifetimes and improves type inference.

Comparison:

Rust 1.84.0:

fn example() -> impl Fn() {
    let x = String::from("Hello");
    move || println!("{}", x)
}

Rust 1.85.0:

fn example() -> impl Fn() + 'static {
    let x = String::from("Hello");
    move || println!("{}", x)
}

In Rust 1.85.0, explicitly specifying 'static helps the compiler infer lifetimes more accurately, reducing potential borrowing issues.

2. Temporary Scope Changes

Rust 1.85.0 introduces refined scoping rules for temporaries in two key areas:

• if let Temporary Scope: Temporaries inside if let expressions now have a more predictable scope, preventing unexpected lifetime issues.
• Tail Expression Scope: Temporaries created in the final expression of a block now have a more precise scope, reducing unwanted borrowing conflicts.

These changes make Rust’s lifetime system more intuitive and less prone to subtle bugs.

3. Match Ergonomics Reservations

To pave the way for future improvements, Rust is reserving certain pattern-matching combinations. This ensures that the language can evolve without breaking existing code, while also enabling better compiler optimizations and clearer code.

4. Unsafe Code Modifications

Rust continues to strengthen its safety guarantees with changes to unsafe code:

• extern Blocks Now Require unsafe Keyword: This makes it explicit when code interacts with external functions.
• Attributes Marked unsafe: Attributes like export_name, link_section, and no_mangle must now be placed inside an unsafe block, reinforcing Rust’s commitment to safety.

5. Lint Updates

Rust 1.85.0 introduces several lint updates to improve code safety:

• unsafe_op_in_unsafe_fn Now Warns by Default: Functions marked unsafe must explicitly use unsafe {} blocks when performing unsafe operations.
• Static Mutability Restrictions: Direct references to static mut variables are now denied by default, reducing the risk of data races.

6. Never Type Fallback Adjustments

The ! (never type) now has an updated fallback mechanism. The never_type_fallback_flowing_into_unsafe lint is set to "deny," preventing unintended behavior when using the never type in certain contexts.

7. Macro Fragment Specifier Enhancements

The expr macro fragment specifier now matches const and _ expressions, expanding its usability in macro_rules! macros.

8. Reserved Syntax for Future Features

Rust is reserving new syntax elements for future language evolution:

• gen Keyword: Reserved for upcoming generator blocks.
• ## and #"foo"# String Formats: Reserved for potential future enhancements.

Standard Library Enhancements

1. Prelude Additions

The Future and IntoFuture traits are now included in Rust’s prelude, making asynchronous programming more ergonomic.

2. Improved Iterators

Box<[T]> now implements IntoIterator, allowing boxed slices to be directly used in for loops.

Example:

Rust 1.84.0:

let boxed = Box::new([1, 2, 3]);
for x in boxed.iter() {
    println!("{}", x);
}

Rust 1.85.0

let boxed = Box::new([1, 2, 3]);
for x in boxed {
    println!("{}", x);
}

This change makes iteration over boxed slices more natural and intuitive.

3. Function Safety Changes

Several functions, such as std::env::set_var, std::env::remove_var, and before_exec, now require the unsafe keyword. This ensures that these potentially dangerous operations are handled with care.

Async Closures: AsyncFn, AsyncFnMut, and AsyncFnOnce

Rust 1.85.0 introduces support for async closures with three distinct traits:

• AsyncFn: For reusable closures.
• AsyncFnMut: For mutable closures.
• AsyncFnOnce: For one-time execution closures.

These traits provide better control over asynchronous behavior in closures.

Example:

Using AsyncFn:

use std::future::Future;

async fn run<F, Fut>(f: F)
where
    F: AsyncFn<(), Output = Fut>,
    Fut: Future<Output = ()>,
{
    f().await;
}

let closure = async || println!("Hello from async closure!");
run(closure).await;

Using AsyncFnMut:

use std::future::Future;

async fn run_mut<F, Fut>(mut f: F)
where
    F: AsyncFnMut<(), Output = Fut>,
    Fut: Future<Output = ()>,
{
    f().await;
}

let mut counter = 0;
let mut closure = async || {
    counter += 1;
    println!("Counter: {}", counter);
};
run_mut(&mut closure).await;

Using AsyncFnOnce:

use std::future::Future;

async fn run_once<F, Fut>(f: F)
where
    F: AsyncFnOnce<(), Output = Fut>,
    Fut: Future<Output = ()>,
{
    f().await;
}

let closure = async || {
    let msg = String::from("Consumed once!");
    println!("{}", msg);
};
run_once(closure).await;

These new traits enhance Rust’s async ecosystem, offering more flexibility and control.

How to Upgrade to Rust 1.85.0

Upgrading to Rust 1.85.0 is straightforward. Simply run the following command:

rustup update stable

For projects targeting the Rust 2024 Edition, refer to the official Rust edition guide for migration tips.

Conclusion

Rust 1.85.0 is a landmark release, introducing the stabilized Rust 2024 Edition and a host of new features that enhance safety, performance, and developer productivity. From refined lifetime capture rules to improved async closures, this release continues Rust’s tradition of innovation and stability.

Whether you’re a seasoned Rustacean or new to the language, Rust 1.85.0 offers something for everyone. Upgrade today and experience the future of systems programming!

For more details about this release, check out the official Rust 1.85.0 blog post.