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

What Is New in Rust 1.87

How can I combine stdout and stderr of a child process using anonymous pipes?

You can combine stdout and stderr by directing both streams into a single anonymous pipe created with std::io::pipe().

use std::process::Command;
use std::io::Read;

let (mut recv, send) = std::io::pipe()?;

let mut child = Command::new("my_program")
    .stdout(send.try_clone()?)
    .stderr(send)
    .spawn()?;

let mut output = Vec::new();
recv.read_to_end(&mut output)?;
assert!(child.wait()?.success());

What safety improvements were made to architecture intrinsics in Rust 1.87?

Most std::arch intrinsics that were unsafe only because they required a specific CPU feature are now callable from safe code when that feature is enabled.

#![forbid(unsafe_op_in_unsafe_fn)]
use std::arch::x86_64::*;

fn sum(slice: &[u32]) -> u32 {
    if is_x86_feature_detected!("avx2") {
        // Safe because the feature is known to be present.
        return sum_avx2(slice);
    }
    slice.iter().sum()
}

#[target_feature(enable = "avx2")]
unsafe fn sum_avx2(slice: &[u32]) -> u32 {
    // Intrinsics themselves are now safe; only the surrounding function is unsafe.
    let mut acc = _mm256_setzero_si256();
    for chunk in slice.chunks_exact(8) {
        let vec = _mm256_loadu_si256(chunk.as_ptr() as *const __m256i);
        acc = _mm256_add_epi32(acc, vec);
    }
    // Transmute is still unsafe, but the core loop is safe.
    let arr: [u32; 8] = std::mem::transmute(acc);
    arr.iter().sum()
}

How does the asm! macro now support jumping to Rust code?

The asm! macro can now jump to a labeled Rust block, allowing inline assembly to transfer control back into safe Rust.

unsafe {
    asm!(
        "jmp {}",
        label {
            println!("Returned from assembly jump");
        }
    );
}

What does precise capturing in impl Trait enable for trait definitions?

It lets you specify exactly which generic types and lifetimes are captured by an impl Trait return type inside a trait, removing the need for hidden associated types.

trait Processor {
    fn process<'a>(&'a self) -> impl Sized + use;
}

In practice this desugars to an explicit associated type that does not depend on the method's lifetime parameters, making the API clearer for downstream crates.

What breaking change affects Windows 32-bit targets in Rust 1.87?

The i586-pc-windows-msvc target has been removed; projects must switch to i686-pc-windows-msvc because Windows 10 requires SSE2 support.