Fearless SIMD 1.0 brings stable, safe SIMD to Rust

Fearless SIMD, a Rust library for writing fast number-crunching code without unsafe blocks, reached version 1.0 on September 21, 2026. The release freezes its API, so code written against it today should keep compiling. That matters because more than 1,000 Rust crates already depend on it, directly or through other libraries.

The Linebender project announced the release on its blog on September 22. The version is also listed on docs.rs, the Rust documentation host, with a September 21 date.

What SIMD is, and why Rust makes it hard

SIMD stands for "single instruction, multiple data". A modern processor can add, compare or multiply several numbers with one instruction instead of one at a time. Graphics, audio, compression and image code all lean on it for speed.

In Rust, the direct route to those instructions is through "intrinsics". These are functions that map straight onto one processor instruction. Most of them are marked unsafe, because calling one on a processor that lacks the instruction can crash the program. Rust asks the programmer to promise, by hand, that the check was done.

Each processor family also has its own instruction set. Code written for Intel's AVX-512 does nothing on an Arm phone. Supporting several chips usually means writing the same routine several times.

What Fearless SIMD does

The library wraps both problems in safe code. Its README describes "a way to use SIMD safely, both via intrinsics and safe abstractions, while containing remarkably little unsafe code itself."

It offers four approaches, according to Linebender's post:

• Autovectorization: help the compiler turn ordinary loops into SIMD code.
• Multiversioning: build several copies of one function for different chips and pick the right one when the program runs.
• Portable operations: one set of vector types that work on every supported processor.
• Platform intrinsics: direct access to a chip's own instructions, without unsafe.

That last point is the one Linebender stresses. "Thanks to safe access to intrinsics, there is no performance ceiling," the post says.

Item	Detail
Version	1.0.0, September 21, 2026
Intel and AMD	SSE2 through AVX-512
Arm	NEON
Browsers	WebAssembly SIMD
Other chips	Scalar fallback
Minimum Rust	1.89
Dependencies	None in the core crate
Licence	Apache-2.0 or MIT

An optional companion crate, fearless_simd_macros, adds a #[simd] attribute. The blog post says of it: "Put it on any SIMD function and it Just Works."

What changed in 1.0

The project started as a prototype in 2018, eight years ago, Linebender says. The 1.0 release carries some final breaking changes before the freeze, according to the GitHub repository:

• witness() is renamed token() and moves to a new ExtractToken supertrait.
• SimdBase::N and SimdMask::N are renamed LEN.
• as_array now returns a reference instead of a copy.
• New saturating arithmetic and bit-counting operations.
• New reductions: reduce_min, reduce_max, reduce_sum and reduce_product.
• New fused multiply-add operations.

The repository also sets a support promise. The latest 1.0 release for each minimum Rust version gets security fixes for at least 3 years after that Rust version came out. Future releases may raise the minimum Rust version in minor updates.

What this means for developers

If you use a crate that pulls in Fearless SIMD, check whether it has moved to 1.0. The renames above will break code that called witness(), used N, or relied on as_array returning a copy. They are mechanical fixes, but they are compile errors until you make them.

If you maintain hand-written unsafe SIMD code, this is a good moment to measure it against the library. The main gain is one code path for x86, Arm and WebAssembly instead of three. Benchmark your own hot loops before and after; the project's claim of no performance ceiling is worth testing on your data.

For library authors, the stable API and the security window make Fearless SIMD safer to expose in a public interface. Before 1.0, a dependency's breaking change became your breaking change. Note the Rust 1.89 floor, and check that it fits the oldest compiler your users run.