SciRS2 0.1.4 Released — SIMD Phase 60-69, Pure Rust OxiFFT by Default, and Autograd Optimizers That Actually Update

Scientific computing should not require a C compiler, a Fortran toolchain, or a prayer to your system package manager.

Today we released SciRS2 0.1.4 — a SIMD-expanded, spatially-enhanced milestone that makes the high-performance FFT path 100% Pure Rust by default and fixes autograd so your optimizers finally update in place.

No C. No Fortran. No NumPy system dependencies. The native incumbents — NumPy, SciPy, FFTW, OpenBLAS — all lean on decades of C and Fortran that you have to find, link, and hope match your platform. SciRS2 replaces that foundation with Pure Rust: BLAS/LAPACK through OxiBLAS, FFT through OxiFFT, random distributions implemented from scratch in safe Rust. The result compiles to a single static binary (or WASM) and runs everywhere.

Why SciRS2 0.1.4 matters

If you have ever shipped a NumPy/SciPy stack, you know the pain: pinning OpenBLAS against the right glibc, debugging an FFTW link error on macOS, watching a segfault surface from a C extension you cannot read, and discovering that none of it runs in the browser. The scientific Python stack is fast, but its speed is borrowed from native code that is memory-unsafe and hostile to WASM.

SciRS2 0.1.4 keeps the speed and drops the baggage. A few concrete wins in this release:

• SIMD Phase 60-69 adds 8 new advanced AVX2/NEON operation modules with zero-allocation, in-place kernels — special functions, interpolation, geometry, and array ops all get the hardware-accelerated treatment.
• Pure Rust FFT is now the default. SciRS2 migrated from FFTW to OxiFFT, so the FFT path is 100% Pure Rust with no C toolchain required.
• Optimizers actually work out of the box. The autograd Issue #100 fix means Optimizer::update() writes new values back into the variable environment instead of silently discarding them.
• Robust spatial geometry. A modular Bowyer-Watson Delaunay triangulation (2D / 3D / N-D, plus constrained) replaces the previous implementation with better robustness and far broader test coverage.

This is still an early 0.1.x — but it is an early 0.1.x with 11,400+ tests passing, a zero-warnings policy, and a foundation we are confident building on.

Technical Deep Dive: A Pure Rust Scientific Stack, Layer by Layer

SciRS2 is a 27-crate Cargo workspace — roughly 1.95M total lines (~1.69M of Rust code) — organized into layers that mirror SciPy and scikit-learn while owning every line down to the SIMD intrinsics.

1. The core layer — scirs2-core. This is where the unified SIMD abstraction lives. AVX2 on x86-64 and NEON on aarch64 are exposed through a single API, so the 8 new Phase 60-69 modules (beta functions, cubic/bicubic/tricubic interpolation kernels, geometric operations, smootherstep, distribution CDF/PDF/quantiles, FMA and polynomial evaluation, log/exp families, and cumsum/cumprod/diff/gradient) all dispatch to the right instruction set at runtime. The kernels are written to operate in place with zero allocation, which is what makes them safe to call inside hot loops.

2. The scientific layer. scirs2-linalg sits on OxiBLAS for Pure Rust BLAS/LAPACK; scirs2-fft now sits on OxiFFT, with an advanced coordinator architecture for composing complex FFT pipelines. scirs2-spatial carries the refactored Delaunay engine. scirs2-special and scirs2-interpolate round out the numerics — interpolation in this release gains PCHIP with linear extrapolation, and special functions ship new interactive learning and derivation-studio examples.

3. The AI/ML layer. scirs2-neural provides the network building blocks and scirs2-autograd provides reverse-mode automatic differentiation. After the Issue #100 fix, all four optimizers — SGD, Adam, RMSprop, and AdaGrad — correctly mutate variables in the VariableEnvironment, and the old “Index out of bounds in ComputeContext::input” warning spam is gone.

4. The meta-crate. The top-level scirs2 crate ties it together with a feature-flag design. The default standard set covers everyday numerics; full pulls in everything; ai selects the neural + autograd path; and individual module flags (linalg, stats, fft, signal, sparse, spatial, neural, autograd) let you compile exactly what you need.

Getting Started

cargo add scirs2
# optional high-performance Pure Rust FFT + GPU:
cargo add scirs2 --features oxifft,cuda

A small taste — a dot product and a quick FFT through the umbrella crate:

use scirs2::linalg::dot;
use scirs2::fft::fft;

fn main() {
    // Pure Rust linear algebra on OxiBLAS
    let a = vec![1.0_f64, 2.0, 3.0, 4.0];
    let b = vec![4.0_f64, 3.0, 2.0, 1.0];
    let d = dot(&a, &b);
    println!("dot(a, b) = {d}"); // 20.0

    // Pure Rust FFT on OxiFFT — no FFTW, no C
    let signal = vec![1.0_f64, 0.0, -1.0, 0.0];
    let spectrum = fft(&signal);
    println!("spectrum = {spectrum:?}");
}

What’s New in 0.1.4

• SIMD Phase 60-69: 8 new AVX2/NEON modules — beta functions, advanced interpolation kernels (cubic/bicubic/tricubic/Catmull-Rom), geometric ops (cross product, angle, triangle area), smootherstep, probability distributions (CDF/PDF/quantile), advanced math (FMA, polynomial eval, copysign, nextafter), log/exp ops (log2/log10/exp2/expm1/log1p), and array ops (cumsum/cumprod/diff/gradient) — all zero-allocation and in-place.
• Modular Bowyer-Watson Delaunay: complete refactoring into 2D / 3D / N-D implementations, with constrained Delaunay support and enhanced queries (point location, nearest neighbors, circumcircle tests).
• OxiFFT is the default FFT: migrated from FFTW to a 100% Pure Rust backend, plus an advanced coordinator architecture for complex pipelines.
• Autograd Issue #100 fix: Optimizer::update() now writes results back to the variable environment; SGD/Adam/RMSprop/AdaGrad all work correctly, and the index-out-of-bounds warning spam is eliminated.
• scirs2-text: new multilingual support module and a paraphrasing module.
• Interpolation: PCHIP enhanced with linear extrapolation.
• Special functions: new interactive learning modules and an advanced derivation-studio example set.
• Build system: improved manylinux compatibility for Python wheel distribution.

Tips

• Turn on the fast FFT. Add the oxifft feature for the high-performance Pure Rust FFT path: cargo add scirs2 --features oxifft.
• Right-size your build with feature groups. Stay on the default standard set for general numerics, reach for full when you want everything, and pick ai when you only need neural + autograd. Smaller feature sets mean faster compiles.
• Delete your optimizer workarounds. With the Issue #100 fix, optimizers update variables in place — if you were manually mutating variables after update(), remove that code.
• Use constrained Delaunay for meshing. The new modular triangulation supports constrained edges, so boundary-respecting meshes work directly without post-processing.
• Keep SIMD ops in your hot loops. The Phase 60-69 kernels are zero-allocation and in-place, so calling them repeatedly inside tight loops will not churn the allocator.
• Build wheels with confidence. The improved manylinux compatibility means Python wheel distribution is smoother across Linux targets.

This is the foundation

SciRS2 builds on the Pure Rust foundations of OxiBLAS (BLAS/LAPACK core) and OxiFFT (FFT core), and stands alongside OptiRS — the independent optimizer project that the old scirs2-optim graduated into. It is part of the growing COOLJAPAN pure-Rust stack that also includes NumRS2 and PandRS, a set of libraries reimagining the scientific Python toolbox without a single line of C or Fortran.

Repository: https://github.com/cool-japan/scirs

Star the repo if you believe scientific computing belongs in a memory-safe language that runs everywhere — from your laptop to the browser — without a native toolchain in sight.

Pure Rust scientific computing is here — fast, safe, and sovereign.

— KitaSan at COOLJAPAN OÜ February 7, 2026