◉ COOLJAPAN
← All posts
February 16, 2026 • 7 min read

SciRS2 0.2.0 Released — Complete Workspace Restoration, Pure-Rust OxiFFT by Default, and the First WebAssembly Bindings

SciRS2 is the pure-Rust SciPy/NumPy replacement. 0.2.0 restores the entire workspace to zero compile errors, makes Pure Rust OxiFFT the default FFT backend (rustfft now optional), rebuilds the neural stack, and ships the first WebAssembly bindings. ~11,400 tests, zero warnings. No C. No Fortran.

release scirs2 scientific-computing ai machine-learning pure-rust oxifft webassembly numpy scipy

SciRS2 0.2.0 is a stabilization leap: 200+ compilation errors driven to zero, a 100% Pure Rust FFT backend by default, and the first time SciRS2 runs in your browser.

Today we released SciRS2 0.2.0 — a complete workspace restoration that takes the whole stack to zero compile errors, makes Pure Rust OxiFFT the default FFT backend, and ships the first WebAssembly bindings.

No C. No Fortran. No NumPy system dependencies. No build hell. No version conflicts. For decades, scientific computing has meant fighting the same toolchain: NumPy and SciPy bolted onto OpenBLAS, FFTW, and a tangle of native shared libraries that break differently on every machine. SciRS2 throws that out. It is a pure-Rust scientific computing and AI/ML library — a NumPy, SciPy, and scikit-learn replacement — that compiles to a single static binary (or WASM) and runs everywhere: from laptops to browsers to edge devices to cloud clusters.

Why SciRS2 0.2.0 is a game changer

The incumbents make you pay a tax before you write a single line of math. Installing the SciPy stack means C and Fortran build chains, system BLAS hunts, FFTW linkage, and version conflicts that surface only in production. The native libraries underneath are memory-unsafe by construction, and none of them target the browser — WASM-hostile C code is a wall, not a path.

SciRS2 0.2.0 removes the tax and adds reach. Concrete wins from this release:

And the most important part for existing users: there are zero breaking changes. Every fix maintains backward compatibility. No migration required.

Technical Deep Dive: How We Rebuilt the Stack to Zero Errors in Pure Rust

0.2.0 was a ground-up reconstruction across four layers of the workspace, all of it in Pure Rust.

Layer 1 — Core (scirs2-core). The foundation was modernized end to end: migrated to the OpenTelemetry 0.30 API, gave GpuBuffer<T> proper Debug and Clone (Arc-based sharing), added Debug for GpuContext, and introduced 16 new GPU methods for autograd compatibility, along with enhanced GPU backend reductions and manipulation. Underneath it all, the trait discipline was tightened — SimdUnifiedOps and NumAssign bounds were added systematically so the type system, not runtime checks, guarantees correctness.

Layer 2 — FFT and scientific computing. The headline of this layer is the full OxiFFT migration. Ten FFT files (~1,707 lines changed) moved off rustfft: nufft, plan_cache, large_fft, optimized_fft, strided_fft, memory_efficient, plan_serialization, auto_tuning, performance_profiler, and algorithm_selector. Plan caching, SIMD acceleration, and memory efficiency were all preserved, with zero breaking changes to public APIs. rustfft is now strictly opt-in via rustfft-backend. Linear algebra (scirs2-linalg) continues to run on OxiBLAS, so the entire scientific path — BLAS, LAPACK, and FFT — is now Pure Rust by default.

Layer 3 — AI/ML. scirs2-neural was the largest reconstruction: 2,097 NumAssign trait-bound errors fixed across 46 files, the transformer encoder/decoder rebuilt, the Loss trait API corrected (compute → forward, gradient → backward), every optimizer fixed, and the BERT/GPT/CLIP/Mamba/ViT/MLPMixer architectures repaired. Alongside it, scirs2-autograd got real higher-order differentiation fixes — proper ReduceSum gradient broadcasting and Concat gradient splitting, plus corrected Hessian (diagonal/trace/HVP) and nth-order gradient tests — improving to 313/315 tests passing.

Layer 4 — WASM and integration. Two new workspace members landed. scirs2-wasm provides the first official WebAssembly target for SciRS2, with WasmMatrix, WASM SIMD, and web-worker parallelism for the browser and Node.js. scirs2-integration-tests adds a cross-crate integration suite so the whole stack is validated together, not just per crate. Across the board, code quality was modernized for Rust 2024: all rng.gen() calls became rng.random(), and the drop(&ref) anti-pattern was fixed.

Getting Started

cargo add scirs2

That is the whole install. No system BLAS, no FFTW, no Fortran compiler — the default standard feature set is 100% Pure Rust.

use scirs2::linalg::{matmul, solve};
use scirs2::stats::{mean, std_dev};
use scirs2::fft::fft;
use ndarray::array;

fn main() {
    // Linear algebra on OxiBLAS — no OpenBLAS required.
    let a = array![[2.0_f64, 1.0], [1.0, 3.0]];
    let b = array![[1.0_f64], [2.0]];
    let x = solve(&a.view(), &b.view()).expect("solve failed");
    println!("solution = {:?}", x);

    let product = matmul(&a.view(), &a.view()).expect("matmul failed");
    println!("a * a = {:?}", product);

    // Basic statistics.
    let samples = array![1.0_f64, 2.0, 3.0, 4.0, 5.0];
    println!("mean = {:.3}, std = {:.3}",
        mean(&samples.view()).expect("mean failed"),
        std_dev(&samples.view(), 1).expect("std failed"));

    // FFT on the Pure Rust OxiFFT backend — no FFTW.
    let signal = array![0.0_f64, 1.0, 0.0, -1.0];
    let spectrum = fft(&signal.view(), None).expect("fft failed");
    println!("spectrum = {:?}", spectrum);
}

Want GPU acceleration or the legacy FFT backend? Opt in:

cargo add scirs2 --features oxifft,cuda

What’s New in 0.2.0

Tips

This is the foundation

SciRS2 sits at the center of the growing COOLJAPAN pure-Rust stack. It builds on OxiBLAS for BLAS and LAPACK and on OxiFFT for FFT — the Pure Rust foundations that, as of this release, power SciRS2 by default. It pairs naturally with OptiRS, the independent optimizer project (the former scirs2-optim), and with the wider pure-Rust data and numerics ecosystem alongside NumRS2 and PandRS. One language, one toolchain, no native build hell — all the way down.

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

Star the repo if you believe scientific computing should be memory-safe, dependency-free, and run anywhere — from the cloud to the browser.

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

— KitaSan at COOLJAPAN OÜ February 16, 2026

↑ Back to all posts