Ever written a string processing function where you need to grab four bytes from a window, dealing with index access and bounds checks, and by the end you can’t even understand your own code?

I was exactly like that, until I saw Rust 1.94.

Sliding Windows: Direct “Unboxing”

Rust 1.94, released on March 5th, brings us a super useful new toy: array_windows().

Previously, if you wanted to check if a string contains an “ABBA” palindrome pattern, you had to write it like this:

fn has_abba_old(s: &str) -> bool {
    s.as_bytes()
        .windows(4)
        .any(|w| w[0] != w[1] && w[0] == w[3] && w[1] == w[2])
}

Seeing w[0], w[1], w[2], w[3] is a bit dizzying, right? In complex scenarios, you might end up with a whole row of w[n].

Now with array_windows(), the world is much cleaner:

fn has_abba(s: &str) -> bool {
    s.as_bytes()
        .array_windows()
        .any(|[a1, b1, b2, a2]| (a1 != b1) && (a1 == a2) && (b1 == b2))
}

The compiler automatically infers the window size—all you need is to write how many variables you want in the closure, and it unpacks them for you. The [a1, b1, b2, a2] pattern makes the four variable names crystal clear, a hundred times more friendly than mysterious numbers like w[0] and w[1].

And because it’s a fixed-size array, the compiler can directly optimize bounds checking, making the code both safe and beautiful.

This feature is incredibly friendly for algorithm problem solvers. Sliding window problems are especially common in LeetCode and Advent of Code. What used to take forever with index operations is now just one line.

windows vs array_windows

Cargo.toml Finally Supports “Line Breaks”

The second update affects more people: TOML 1.1 is here.

Previously, inline tables in Cargo.toml had to fit on a single line, like this:

serde = { version = "1.0", features = ["derive"] }

If a dependency has many fields, that one line could go on forever.

Now with TOML 1.1, multi-line inline tables are supported:

contact = {
    personal = {
        name = "Donald Duck",
        email = "donald@duckburg.com",
    },
    work = {
        name = "Coin cleaner",
        email = "donald@ScroogeCorp.com",
    },
}

So much better.

One thing to note: if you use TOML 1.1’s new syntax in your project, your MSRV (Minimum Supported Rust Version) directly becomes 1.94. This means contributors fixing bugs will also need to upgrade Rust. Of course, when publishing to crates.io, Cargo automatically rewrites the manifest to stay compatible with older parsers, so your crate users are fine. But your development team needs to sync up internally.

After 10 Years: Golden Ratio Finally Arrives

This final update might seem minor, but it really took a while.

Rust’s standard library already had constants like PI, E, and TAU, but GOLDEN_RATIO (φ ≈ 1.6180) and EULER_GAMMA (γ ≈ 0.5772) took ten years to be added.

use std::f64::consts::{GOLDEN_RATIO, EULER_GAMMA};

println!("φ = {}", GOLDEN_RATIO);  // 1.618033988749895
println!("γ = {}", EULER_GAMMA);   // 0.5772156649015329

How classic these constants are doesn’t need explanation. Golden ratio appears everywhere in Fibonacci sequences, spiral patterns, and UI layouts; Euler-Mascheroni constant is a frequent visitor in number theory and probability distributions. Before, if you needed them, you had to define them yourself or pull in a third-party library. Now it’s finally complete.

Sliding window working principle

Other Notable Updates

Quick mentions of other updates:

  • Trait’s dead_code lint now inherits to implementations
  • 29 RISC-V target features stabilized, including most of RVA22U64/RVA23U64 profiles
  • Unicode 17 support
  • LazyCell and LazyLock gain get, get_mut, and force_mut methods

How to Update

Just one command:

rustup update stable

Then verify with rustc --version to confirm it’s 1.94.0. Done.

Summary

These three Rust 1.94 updates, while not “explosive,” are all very practical. Sliding window destructuring makes code more readable, TOML multi-line tables finally make config files bearable, and mathematical constants fill the gap in the standard library. Upgrading has no downside—get to it!

FAQ

Q: What’s the difference between array_windows and windows?

A: windows(4) returns &[T] and requires index access; array_windows() returns &[T; N] and can be directly destructured into named variables like [a, b, c, d]. The compiler can also infer the window size from your destructuring pattern, making the code safer.

Q: What are the risks of using TOML 1.1 new features?

A: The main risk is raising your project’s MSRV. If your project depends on third-party libraries that haven’t upgraded to Rust 1.94 yet, problems may arise. Evaluate before enabling new syntax.

Q: What are GOLDEN_RATIO and EULER_GAMMA used for?

A: GOLDEN_RATIO is commonly used in UI design, image processing, and Fibonacci-related calculations; EULER_GAMMA is mainly used in number theory, probability theory, and harmonic series analysis. Regular business code rarely uses them directly, but they’re handy for low-level computing or scientific calculations.