Rust 1.80: What's New, Release History & Support Lifecycle

What Is New in Rust 1.80

How do LazyLock and LazyCell simplify static initialization?

LazyLock and LazyCell let you embed the initializer directly in the cell, removing the need for separate get_or_init calls.

Both types are drop-in replacements for the classic OnceLock/OnceCell pattern, but they store the closure that creates the value. LazyLock is thread-safe and can be used in static items, while LazyCell is single-threaded and works well with thread_local! storage.

use std::sync::LazyLock;
use std::time::Instant;

static LAZY_TIME: LazyLock<Instant> = LazyLock::new(Instant::now);

fn main() {
    let start = Instant::now();
    std::thread::scope(|s| {
        s.spawn(|| {
            println!("Thread lazy time: {:?}", LAZY_TIME.duration_since(start));
        });
        println!("Main lazy time: {:?}", LAZY_TIME.duration_since(start));
    });
}

In practice this reduces boilerplate and guarantees that the initialization runs exactly once, whichever thread accesses the static first.

What is the new exclusive range syntax in pattern matching?

Rust now allows exclusive endpoints in pattern ranges using a..b or ..b, mirroring the expression syntax of Range and RangeTo.

This lets you reuse the same constant for the end of one arm and the start of the next without subtracting one.

pub fn size_prefix(n: u32) -> &'static str {
    const K: u32 = 10u32.pow(3);
    const M: u32 = 10u32.pow(6);
    const G: u32 = 10u32.pow(9);
    match n {
        ..K => "",
        K..M => "k",
        M..G => "M",
        G.. => "G",
    }
}

Exhaustiveness checking has been tightened, and new lints (non_contiguous_range_endpoints, overlapping_range_endpoints) help you avoid accidental off-by-one errors.

How does Cargo's cfg checking help catch configuration mistakes?

Cargo 1.80 now enables --check-cfg for all known configuration names and values, emitting the unexpected_cfgs warning when a typo or unknown feature is used.

The warning points out the misspelled cfg, suggests the correct value, and even offers a quick fix by adding the missing feature to Cargo.toml. You can extend the known list via the [lints] table in the manifest.

[lints.rust]
unexpected_cfgs = { level = "warn", check-cfg = ['cfg(foo, values("bar"))'] }

This early feedback prevents subtle build failures and keeps CI pipelines clean.

Which APIs are now usable in const contexts?

Several standard-library functions have been stabilized for use inside const blocks, expanding the compile-time capabilities of Rust.

Typical examples include methods on primitive wrappers and collection types that previously required runtime evaluation. This change enables more expressive const generics and compile-time calculations without resorting to nightly features.

In practice you can now write const fn that calls these newly const-stable APIs, simplifying embedded and no-std codebases.