By ByteBot
The Linebender project shipped fearless_simd v1.0 on September 22, delivering safe, stable SIMD to Rust without a single unsafe block. The release freezes the API, ships with a three-year security commitment, and arrives with over 1,000 crates already depending on it — making it the first production-ready SIMD library on stable Rust. If you write performance-sensitive Rust code, this changes your options.
Fearless SIMD Kills the Rust unsafe Tax
SIMD — Single Instruction Multiple Data — is how CPUs process 8, 16, or 32 values in one instruction instead of one. On modern hardware, leaving SIMD on the table means leaving 4–16x throughput behind. Rust developers have always wanted this speed, but extracting it meant writing unsafe code: calling raw platform intrinsics like _mm256_add_ps that the compiler couldn’t statically verify were safe to call on the target CPU.
fearless_simd solves this with two mechanisms. First, Rust 1.87 made most platform intrinsics safe to call via target_feature v1.1 — the compiler can verify at compile time that your target supports the instruction. Second, fearless_simd ships a safe transmute module, inspired by bytemuck, that handles SIMD load/store on raw pointers through Rust’s type system rather than manual pointer casts. The upshot, per the Linebender team: “thanks to safe access to intrinsics, there is no performance ceiling.” Unlike other SIMD abstractions that contain thousands of unsafe blocks, fearless_simd requires auditing only two small, self-contained modules.
Related: Rust 1.98 Algebraic Floats Fix the 8x C++ Speed Gap
The #[simd] Macro Ends Multiversioning Boilerplate
The harder SIMD problem isn’t writing instructions — it’s shipping binaries that work everywhere. A binary compiled for AVX-512 crashes on a machine without it. The traditional fix is multiversioning: write separate function implementations for SSE2, AVX2, and AVX-512, then dispatch at runtime. In practice, this takes dozens of lines and is easy to get wrong.
fearless_simd_macros 0.1.0 ships the #[simd] attribute macro. Annotate a function and the compiler generates all CPU-specific variants automatically, selecting the best one at runtime:
use fearless_simd_macros::simd;
#[simd]
fn dot_product(a: &[f32], b: &[f32]) -> f32 {
a.iter().zip(b).map(|(x, y)| x * y).sum()
}
// Runtime selects: AVX-512 on Ice Lake+, AVX2 on Zen 3, SSE2 as baselineThis is comparable to C’s __attribute__((target_clones(..))) but with Rust’s type safety intact. The macro is designed as a “non-leaky abstraction” — you don’t need to understand compiler mechanics or manually annotate every helper with #[inline(always)].
Stable Where std::simd Isn’t
Here’s the uncomfortable reality about Rust’s official SIMD solution: std::simd is still nightly-only in late 2026, with an API that changes without notice. Crate authors who depend on it must either pin a specific nightly compiler version or accept breaking their users. Neither option is acceptable for published crates.
fearless_simd 1.0 fills that gap directly. The PhastFT FFT library switched to fearless_simd specifically to ship on stable Rust instead of requiring users to install nightly. One developer reported building a byte-search library using fearless_simd that outperforms the well-established memchr crate even for simple lookups. With 1,000+ indirect dependents and a formal security policy committing to three years of backports, fearless_simd is now ecosystem infrastructure — not an experiment.
The One Real Gap: Trigonometry
fearless_simd doesn’t implement trigonometric functions. If your code needs vectorized sin, cos, or tan — common in DSP, 3D math, and some ML inference paths — fearless_simd isn’t a standalone solution. The State of SIMD in Rust 2026 analysis calls trigonometry “the biggest gap” across nearly all SIMD libraries. The practical fix: use wide with sleef for trig-heavy code and fearless_simd for everything else.
Key Takeaways
- fearless_simd v1.0 delivers safe, stable SIMD for Rust — no
unsafeblocks, frozen API, three-year security backport commitment - The
#[simd]macro automates CPU multiversioning: one annotation generates SSE2, AVX2, and AVX-512 variants with runtime dispatch std::simdis still nightly-only — fearless_simd is the practical production choice for stable Rust in 2026- The one real gap is trigonometry — combine fearless_simd with
wideandsleeffor math-heavy workloads
