Rust 1.94 Ships Array Windows and AVX-512 FP16 as 65 Project Goals Chart the Language's 2026 Roadmap
Rust 1.94.0 stabilizes array_windows and AVX-512 FP16 intrinsics as the project finalizes 65 goals for 2026 targeting faster compilation, trait overhauls, and deeper Linux kernel integration.
Overview
The Rust project released version 1.94.0 on March 5, 2026, delivering a set of targeted improvements to the standard library and Cargo toolchain. The headline additions are array_windows, a compile-time-sized slice iterator that eliminates bounds checks, and the stabilization of hardware floating-point intrinsics for both x86 and AArch64 platforms.
The release arrives as the Rust project prepares to open its 2026 project goals RFC in March, with 65 proposed goals and 12 flagship initiatives that aim to reshape the language’s trait system, accelerate compilation, and extend Rust’s reach into higher-level application domains.
Array Windows: Bounds-Check-Free Slice Iteration
The most anticipated API addition in Rust 1.94 is array_windows, a method on slices that returns an iterator over overlapping windows of a fixed, compile-time-known size. Unlike the existing windows() method, which returns dynamically-sized &[T] slices, array_windows yields &[T; N] references where N is a const generic parameter.
The practical consequence is that the compiler can eliminate bounds checks entirely because it knows the window size at compile time. In performance-sensitive code paths such as signal processing, rolling averages, and pattern matching over byte streams, this distinction matters. The window length can often be inferred from how the iterator is used, reducing boilerplate.
The feature had been tracked as an unstable API since 2020 and its stabilization closes one of the longer-running standard library requests in the project’s history.
Hardware Intrinsics Reach Stable
Rust 1.94 promotes two sets of hardware floating-point intrinsics to stable status. The x86 AVX-512 FP16 intrinsics, supported on Intel Xeon Scalable processors from the Sapphire Rapids generation onward, enable half-precision floating-point operations that are increasingly important for AI inference workloads running on commodity server hardware. The AArch64 NEON FP16 intrinsics provide equivalent capabilities on Arm-based platforms.
Stabilizing these intrinsics means that crate authors can now ship half-precision math libraries without requiring users to opt into nightly Rust, removing a friction point for adoption in production environments.
Cargo Configuration and TOML Improvements
Cargo, the Rust package manager, gains two configuration improvements in this release. The include key in .cargo/config.toml files is now stable, allowing teams to split Cargo configuration across multiple files and share common settings between projects. This addresses a longstanding organizational pain point for monorepo setups and CI/CD pipelines.
Cargo also now parses TOML v1.1 for both manifests and configuration files. The updated specification allows inline tables to span multiple lines and include trailing commas, aligning Cargo’s TOML dialect with the format’s latest standard.
Standard Library Additions
Beyond array_windows, Rust 1.94 stabilizes 17 APIs. Mathematical constants including EULER_GAMMA and GOLDEN_RATIO are now available for both f32 and f64 types. LazyCell::get and LazyLock::get allow checking whether a lazy value has been initialized without forcing evaluation, which is useful for conditional logic around cached values in concurrent code.
2026 Project Goals: 65 Proposals Across Four Themes
While Rust 1.94 represents incremental progress, the project’s broader ambitions are visible in its 2026 goal slate. The slate comprises 65 proposed goals organized under 12 flagship initiatives, which themselves fall into four themes.
The first theme, “Beyond the &,” aims to make user-defined smart pointers as ergonomic as Rust’s built-in references. The second, “Unblocking Dormant Traits,” targets extensions to the trait system that would enable language interop, lending iterators, and other features that have been requested for years but blocked by compiler limitations. The third theme, “Flexible, Fast(er) Compilation,” addresses what community surveys consistently identify as Rust’s primary productivity bottleneck: compile times. Parallel benchmarking of the compiler has already halved benchmark latency from roughly 80 minutes to 40 minutes. The fourth theme, “Higher-Level Rust,” seeks to make common application-level patterns easier to express.
The project has shifted from six-month to annual goal periods for 2026, giving teams more time to plan and execute on larger initiatives. The RFC is expected to open in March, with team leads reviewing feasibility before implementation begins in April.
Rust in the Linux Kernel: From Experimental to Permanent
The 2026 roadmap’s emphasis on systems-level improvements coincides with Rust’s expanding role in the Linux kernel. At the 2025 Kernel Maintainer Summit in Tokyo, the Rust for Linux project’s experimental status was formally ended, with lead developer Miguel Ojeda declaring that “the experiment is done” and Rust is a permanent part of the kernel.
As of early 2026, the kernel contains over 600,000 lines of production Rust code across drivers, filesystem abstractions, and core subsystem bindings. High-profile driver projects include Nova for NVIDIA open-source firmware, Tyr for Arm Mali GPUs, and the Asahi driver for Apple Silicon graphics. Dave Airlie, maintainer of the kernel’s Direct Rendering Manager subsystem, stated at the Tokyo summit that DRM was approximately one year from requiring Rust for all new drivers and disallowing C for new contributions.
Android 16 devices, built on Linux kernel 6.12, already ship with the ashmem memory allocator rewritten entirely in Rust, meaning millions of consumer devices worldwide are running production Rust code in their kernels today.
Looking Ahead
Rust 1.95 is expected in mid-April 2026, with Linux 7.0 already preparing for Rust 1.95 support. The Rust Foundation has committed $650,000 in direct funding to the project for 2026, hired a second Program Manager, and announced that RustConf 2026 will take place in Quebec, Canada. With the 2026 goals RFC opening imminently, the next twelve months will determine whether Rust can close the compilation speed and ergonomics gaps that remain its most commonly cited barriers to broader adoption.