NumRS2 0.3.3 Released — Benchmarks for I/O, Complex, and Sparse, Plus a Dependency Refresh

You can’t keep what you don’t measure — so this release teaches NumRS2 to measure more of itself.

Today we released NumRS2 0.3.3 — a measurement-and-maintenance patch that adds proper benchmark coverage across I/O, complex arithmetic, and sparse matrices, refreshes the dependency tree, clears the warning bar, and pushes the distributed-optimization groundwork a little further.

No C. No Fortran. No system BLAS/LAPACK. NumRS2 is still a single static binary (or WASM) with no Python interpreter overhead and no FFI in the hot path. 0.3.3 doesn’t change that core — it adds the instrumentation that keeps it honest as the ecosystem grows.

Why NumRS2 0.3.3 matters

This is a patch, and a focused one. The numerical core carries over unchanged from the 0.3.x line. The value is in what we can now see and trust:

• New benchmark coverage. We added comprehensive criterion benchmarks for I/O operations, complex-number operations, and sparse-matrix operations. These three areas were under-instrumented; now they’re tracked, so a regression in .npz reading, complex arithmetic, or sparse math shows up as a number rather than a surprise.
• Dependency refresh. Every dependency in Cargo.toml was updated to its latest version, in line with the Latest-crates policy, so NumRS2 sits on current foundations.
• Clippy-clean. We resolved the clippy warnings introduced in the new benchmark files and the distributed-optimization module, holding the zero-warnings bar.
• Distributed optimization, nudged forward. The distributed-optimization module got an enhancement — continued build-out of the distributed-computing groundwork, not a finished distributed stack.

“We measure what we ship” is the whole idea of this release.

What changed under the hood

Three short layers, all on top of the unchanged 0.3.x core (SciRS2 0.3.0 + OxiBLAS):

1. Three new criterion benchmark suites.

   • bench/io_benchmarks.rs exercises the I/O path — the kind of read/write work that backs .npz and array serialization — so file throughput is tracked over time.
   • benches/complex_benchmark.rs measures complex-number operations, the arithmetic that FFT and signal work lean on.
   • benches/sparse_benchmark.rs covers sparse-matrix operations across the supported formats, where memory layout dominates performance.

2. The distributed-optimization module. src/distributed/optimization.rs received an enhancement that advances the distributed-computing groundwork. Treat it as in-progress scaffolding maturing release by release, not a turnkey cluster solver.

3. A clean dependency bump. All crates in Cargo.toml moved to their latest versions, and the clippy warnings that surfaced in the new benchmark and distributed code were cleared — so the refresh landed without loosening the quality bar.

Getting Started

cargo add numrs2

use numrs2::prelude::*;

fn main() -> Result<()> {
    // Dense arrays
    let a = Array::from_vec(vec![1.0, 2.0, 3.0, 4.0]).reshape(&[2, 2]);
    let product = a.matmul(&a)?;
    println!("matmul:\n{}", product);

    // Sparse arrays — the angle 0.3.3's new benchmarks now track
    let mut sparse = SparseArray::new(&[10, 10]);
    sparse.set(&[0, 0], 1.0)?;
    sparse.set(&[5, 5], 2.0)?;
    println!("density: {}", sparse.density());

    Ok(())
}

The new benchmark suites cover exactly this surface — dense I/O, complex arithmetic, and the sparse path shown above — so the operations you write are the operations we measure.

What’s New in 0.3.3

• New benchmarks — comprehensive criterion suites for I/O (bench/io_benchmarks.rs), complex-number operations (benches/complex_benchmark.rs), and sparse-matrix operations (benches/sparse_benchmark.rs).
• Distributed optimization — enhanced the distributed-optimization module (src/distributed/optimization.rs), continuing the distributed-computing build-out.
• Dependency upgrades — updated all dependencies in Cargo.toml to their latest versions.
• Fixed — linter compliance — resolved clippy warnings in the benchmark files and the distributed-optimization module.

The numerical core — N-d arrays with broadcasting, OxiBLAS linear algebra (SVD / QR / LU / Cholesky / eigh), SIMD math, statistics, FFT, .npz with pure-Rust DEFLATE, and PyO3 / maturin Python bindings — carries over from 0.3.x unchanged.

Tips

• Run cargo bench to see the new I/O, complex, and sparse benchmark suites in action — they’re the headline of this release and a good baseline before you optimize.
• Reach for SparseArray (COO / CSR / CSC / DIA) for large sparse data; the new benches/sparse_benchmark.rs exists precisely because this path rewards the right format choice.
• Profiling complex math? benches/complex_benchmark.rs gives you a reference point for the arithmetic FFT and signal pipelines depend on — pair it with signal.fft()? on your own data.
• cargo update aligns cleanly — every dependency was refreshed to latest in 0.3.3, so your lockfile and ours converge with no surprises.
• Catch regressions early. Commit a benchmark baseline now; criterion will flag drift on your next change instead of letting it slip into a release.

This is the foundation

NumRS2 is the array core the wider COOLJAPAN stack computes on, and by mid-April 2026 that stack is broad and clearly maturing:

• SciRS2 — the scientific primitives NumRS2 builds directly on
• OxiBLAS — the pure-Rust linear-algebra backend
• OxiCode — sovereign serialization for the same ecosystem
• ToRSh, sklears, tenflowers, trustformers — tensors and ML built on the array core
• OptiRS, PandRS — optimization and dataframes
• OxiPhysics, OxiCUDA, OxiEML, OxiLLaMa — physics, GPU groundwork, embedded ML, and LLMs joining the stack this spring
• OxiFFT, OxiZ, OxiARC — transforms, solving, and pure-Rust archiving

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

Star the repo if you want numerical computing that is benchmarked, warning-free, and free of NumPy’s C/Fortran baggage.

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

— KitaSan at COOLJAPAN OÜ April 18, 2026