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

NumRS2 0.2.0 Released — Sovereignty Completed: 100% C/Fortran-Free, End to End

NumRS2 0.2.0 closes the last native escape hatches: the numpy dependency is replaced by scirs2-numpy, OpenBLAS linker flags are gone in favor of the OxiBLAS pure-Rust backend, and the build is hardened to link cleanly with --all-features. A focused COOLJAPAN compliance release.

release numrs2 numpy numerical-computing scirs2 pure-rust linear-algebra oxiblas

The last C/Fortran threads are cut — even the Python bridge is now pure SciRS2.

Today we released NumRS2 0.2.0 — the release where NumRS2 becomes 100% C/Fortran-free from the array core all the way out to the Python bindings.

This is a focused compliance and cleanup release on top of the 0.1.x first-stable line. It does not bolt on new math APIs; instead it finishes a job that 0.1.0 started — bringing the entire dependency surface and build configuration into full alignment with the COOLJAPAN pure-Rust policies. If 0.1.0 made NumRS2 a stable array core, 0.2.0 makes it a sovereign one.

No C. No Fortran. No system BLAS/LAPACK. No Python interpreter overhead. No FFI through native numpy. Just clean, blazing-fast N-dimensional arrays — broadcasting, fancy indexing, SVD, FFT, autodiff and all — that compile to a single static binary (or WASM) and run everywhere: from laptops to browsers to edge devices to cloud clusters.

Why NumRS2 0.2.0 matters

NumPy is the bedrock of scientific Python, but its foundation shows its age. It is built on a tangle of C and Fortran, leans on system BLAS/LAPACK that you have to find and link at install time, fights the GIL the moment you want real parallelism, and pays Python-loop overhead for anything the C kernels do not already cover. Even projects that try to escape it usually keep one native dependency around “just for interop” — and that single thread is enough to drag the whole C/Fortran toolchain back into your build.

NumRS2 0.2.0 cuts that last thread. Concretely:

The result is a numerical library you can drop onto a fresh machine, build with --all-features, and ship — with no apt-get, no Homebrew, no “which BLAS did the CI pick this time” archaeology.

Technical Deep Dive: Closing the Sovereignty Loop

Layer 1 — The dependency surface. The headline change is what is no longer there. The numpy crate has been removed and scirs2-numpy v0.3.0 put in its place. That matters more than it sounds: native numpy pulls a CPython build and the C extension machinery into anything that touches it transitively. Routing interop through scirs2-numpy means NumRS2’s array layer, its Python bridge, and SciRS2’s own array model all speak the same pure-Rust dialect — one buffer model, one set of dtype rules, no impedance mismatch at the FFI boundary.

Layer 2 — Linear algebra on OxiBLAS, and only OxiBLAS. Through 0.1.x, .cargo/config.toml still carried OpenBLAS linker flags as a fallback. With those flags removed, matmul, the decomposition set (SVD, QR, LU, Cholesky, eigenvalue), and the iterative solvers route through OxiBLAS, COOLJAPAN’s pure-Rust BLAS/LAPACK. There is no longer a code path that links a system BLAS — which is exactly why --all-features builds that used to fail at link time now succeed. Sovereignty here is not a slogan; it is the literal absence of a -lopenblas in the build.

Layer 3 — The maturin build path. Dropping the cdylib crate-type removes a subtle source of build fragility. Instead of declaring a dynamic library in Cargo.toml and hoping the extension symbols resolve, the python feature is built into a wheel by maturin. That is the conventional, reproducible way to ship a PyO3-backed extension, and it keeps the native-Rust crate clean for downstream consumers who never touch Python at all.

Layer 4 — Everything you already get, carried over. None of this disturbs the math. The full 0.1.x capability set rides forward unchanged: the N-dimensional Array<T> with NumPy-style broadcasting, fancy indexing, boolean masking, and zero-copy views; SharedArray<T> with O(1) reference-counted cloning and Common Subexpression Elimination; the linear-algebra and sparse stack on OxiBLAS; the math, statistics, signal-processing (FFT/IFFT), and automatic-differentiation layers; and NumPy-compatible .npy/.npz interop. 0.2.0 hardens the foundation under all of it without moving a single API.

Getting Started

cargo add numrs2

use numrs2::prelude::*;

fn main() -> Result<()> {
    // N-dimensional arrays with NumPy-style broadcasting
    let a = Array::from_vec(vec![1.0, 2.0, 3.0, 4.0]).reshape(&[2, 2]);
    let b = Array::from_vec(vec![5.0, 6.0, 7.0, 8.0]).reshape(&[2, 2]);

    let c = a.add(&b);                 // element-wise
    let e = a.matmul(&b)?;             // matrix multiply — on OxiBLAS, no system BLAS
    println!("a + b = {}", c);
    println!("a @ b = {}", e);

    // Linear algebra: SVD and symmetric eigendecomposition, pure Rust
    let (u, s, vt) = a.svd_compute()?;
    let symmetric = Array::from_vec(vec![2.0, 1.0, 1.0, 2.0]).reshape(&[2, 2]);
    let (eigenvalues, _eigenvectors) = symmetric.eigh("lower")?;

    Ok(())
}

No OpenBLAS to install first. No Fortran toolchain. cargo add numrs2 and the linear algebra is already there.

What’s New in 0.2.0

Tips

This is the foundation

NumRS2 is the NumPy-class N-dimensional array core of the COOLJAPAN scientific stack, and 0.2.0 is the release that makes that core fully sovereign. It sits directly beneath SciRS2 — it depends on scirs2-core 0.2.0 for unified SIMD, the adaptive optimizer, and platform detection, and on scirs2-numpy for its Python bridge. Underneath, linear algebra rides on OxiBLAS and serialization on OxiCode, both pure-Rust COOLJAPAN crates.

By February 2026 the broader ecosystem has grown up around it: OptiRS (optimization) and PandRS (dataframes) alongside NumRS2; the OxiFFT, OxiARC, and OxiZ infrastructure crates; and application work spanning VoiRS, TenRSo, TensorLogic, legalis, mecrab, chie, mielin, and oxirag. NumRS2 is the array layer all of them can build on — and now it carries no native baggage for any of them to inherit.

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

Star the repo if you want a NumPy-class numerical foundation without a single line of C or Fortran in the build — not even in the Python bridge.

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

— KitaSan at COOLJAPAN OÜ February 16, 2026

↑ Back to all posts