7 Key Features to Know in Rust 1.95.0

Introduction

Rust 1.95.0 has arrived, bringing fresh tools and refinements to the language that powers reliable, efficient software. Whether you're building systems, applications, or embedded projects, this release streamlines compile-time conditional code, sharpens pattern matching, and expands the standard library's ergonomics. If you already have Rust installed via rustup, simply run:

$ rustup update stable

Newcomers can grab rustup from the official website. Eager beavers testing future releases can switch to the beta or nightly channels with rustup default beta or rustup default nightly—don't forget to report bugs!

Let’s dive into the seven highlights that make Rust 1.95.0 shine.

1. The New cfg_select! Macro

Conditional compilation gets a clean, native syntax with the cfg_select! macro. Think of it as a compile-time match on configuration predicates—like the popular cfg-if crate, but built-in. You write a series of arms; the macro expands to the right-hand side of the first arm whose predicate is true. For example:

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

You can also use it in value contexts, like let is_windows_str = cfg_select! { windows => "windows", _ => "not windows" };. This macro reduces boilerplate and makes conditional logic more readable, all without external dependencies.

2. if-let Guards in Match Arms

Following the stabilization of let chains in Rust 1.88, if let guards now work inside match arms. This lets you match on a pattern and then run a secondary pattern match as a condition. For instance:

match value {
    Some(x) if let Ok(y) = compute(x) => {
        // Both `x` and `y` are available here
        println!("{}, {}", x, y);
    }
    _ => {}
}

Note that the compiler does not consider the condition's patterns in exhaustiveness checking—just like regular if guards. This feature simplifies complex pattern matching and enhances code clarity.

3. Enhanced MaybeUninit Conversions and References

Working with uninitialized memory gets smoother. The standard library now provides From conversions between MaybeUninit<[T; N]> and [MaybeUninit<T>; N], along with AsRef and AsMut implementations for accessing slices. For example, you can convert a fixed-size array of MaybeUninit to a fully uninitialized array with ease. These additions reduce unsafe code overhead when dealing with low-level memory layouts.

4. Atomic Update and Try-Update Methods

Atomic types—AtomicPtr, AtomicBool, and all Atomic{In,Un} (i.e., atomic integers and unsigned integers)—now have update and try_update methods. These operations allow you to atomically read and modify a value using a closure, with the ability to retry if the value changes concurrently. try_update returns the old value if the update fails, offering non-blocking flexibility. This is a boon for lock-free data structures.

5. New push_mut and insert_mut Methods for Collections

Several popular collections gain zero-cost mutable element access during push/insert operations. Vec::push_mut and Vec::insert_mut return a mutable reference to the newly added element. Similarly, VecDeque gets push_front_mut, push_back_mut, and insert_mut, and LinkedList gets push_front_mut. These methods eliminate the need for after-the-fact last_mut() or index-based access, making code more direct and efficient.

6. New core::range Module

The core::range module introduces RangeInclusive and RangeInclusiveIter types. While these types existed in core::ops before, they are now re-exported from core::range for better organization. Additionally, the cold_path hint in core::hint marks code paths as unlikely to execute, helping the optimizer.

7. Miscellaneous Stabilizations and Pointer Methods

Rounding out the release are several API stabilizations: bool::TryFrom<{integer}> for safe conversion from integers, <*const T>::as_ref_unchecked and <*mut T>::as_ref_unchecked/as_mut_unchecked for dereferencing raw pointers without safety checks (for advanced use). The Cell type also gains AsRef implementations for arrays and slices. These additions fill gaps in the standard library, providing more ergonomic and safe abstractions.

Conclusion

Rust 1.95.0 continues the language's tradition of incremental improvement—adding native compile-time conditionals, richer pattern matching, and practical library enhancements. Whether you're a systems programmer or a web developer, these features simplify everyday coding tasks. Upgrade today via rustup update stable and explore the full release notes. Happy coding!