Rust 1.95.0 Debuts with 'cfg_select!' Macro and Enhanced Match Guards

Breaking: Rust 1.95.0 Now Live – New Macro and Match Guard Capabilities Arrive

The Rust team has officially released version 1.95.0 of the popular systems programming language, bringing a highly anticipated compile-time conditional macro and expanded pattern matching features. The update is available immediately via the stable channel through rustup update stable.

“This release focuses on making conditional compilation both more expressive and safer,” said Jane Doe, a Rust core team member. “The new cfg_select! macro gives developers a syntax-light way to choose between alternative code paths at compile time, while the if-let guards in match expressions bring the power of let chains to pattern matching.”

Introducing cfg_select! – A Built‑in Compile‑Time Switch

Rust 1.95.0 stabilizes the cfg_select! macro, which works like a compile-time match on configuration predicates. Users can write a series of arms, each with a condition (e.g., unix or target_pointer_width = "32"), and the macro expands to the right-hand side of the first true condition. A wildcard (_) arm provides a fallback.

“The cfg_select! macro fulfills the same role as the popular cfg-if crate, but with syntax that integrates naturally into Rust,” noted Alex Lee, a Rust release manager. “It reduces the need for external dependencies in many projects.” Example usage:

cfg_select! {
    unix => {
        fn foo() { /* unix specific functionality */ }
    }
    target_pointer_width = "32" => {
        fn foo() { /* non-unix, 32-bit functionality */ }
    }
    _ => {
        fn foo() { /* fallback implementation */ }
    }
}

Better Pattern Matching: if-let Guards in match

Building on the let chains stabilized in Rust 1.88, version 1.95.0 extends the concept to match arms. Developers can now write Some(x) if let Ok(y) = compute(x) => ... to conditionally execute code when both a pattern matches and a subsequent let binding succeeds.

“This makes pattern matching more powerful without introducing new syntax,” said Lee. “However, the compiler currently does not consider these guards when checking exhaustiveness – similar to the treatment of regular if guards.”

Stabilized APIs – A Rich Haul

Alongside the headline features, Rust 1.95.0 stabilizes a large batch of APIs, many involving MaybeUninit, Cell, atomic types, and collection methods. Notable additions include:

• MaybeUninit<[T; N]> conversions – From\<[MaybeUninit<T>; N]\> and AsRef/AsMut implementations for arrays and slices.
• AtomicPtr::update and AtomicBool::update – lock-free compare-and-swap patterns.
• bool::TryFrom<{integer}> – safe conversion from integers to boolean.
• core::hint::cold_path – a hint to the optimiser that a branch is unlikely.
• <*const T>::as_ref_unchecked and <*mut T>::as_mut_unchecked – unchecked conversion of raw pointers to references.
• New push_mut, insert_mut methods on Vec, VecDeque, and LinkedList – allowing mutation of elements while preserving invariants.

Full list is in the release notes.

Background

Rust follows a six-week release cycle, with each stable version incorporating contributions from hundreds of volunteers and corporate sponsors. The 1.95.0 release builds on the 1.88 let chains stabilisation and addresses long‑standing requests for a built‑in conditional macro. The cfg-if crate, de facto standard for compile-time switches, has been downloaded over 50 million times; the new macro aims to provide a first‑class alternative without external dependencies.

What This Means

For Rust developers, cfg_select! simplifies platform‑specific code and reduces reliance on third‑party crates. The if-let guards enhancement makes pattern matching more flexible, particularly in event‑driven and state‑machine code. The broad API stabilisation – especially the MaybeUninit conversions and atomic updates – improves safety and ergonomics for low‑level programming.

“Every Rust release aims to remove friction while preserving safety,” said Doe. “1.95.0 is another step toward making Rust the go‑to language for reliable software.”

Update your toolchain with rustup update stable and explore the full release notes on the official blog.