NumRS2 0.3.2 Released — Clean PyPI Wheels and Tidier Packaging for the Pure Rust NumPy

The fastest way to make people use your numerical library is to make it trivially easy to install.

Today we released NumRS2 0.3.2 — a small, polish-focused patch that makes the Python wheels publish and install cleanly from PyPI and tidies up an output-size constraint in packaging.

No C. No Fortran. No system BLAS/LAPACK. No Python interpreter pinned to a fragile native extension chain — NumRS2 still compiles down to a single static binary (or WASM) and runs everywhere. This release does not touch that story; it just makes getting NumRS2 in front of Python users a lot smoother.

Why NumRS2 0.3.2 matters

Let’s be honest about what this release is and isn’t. The numerical core is exactly the same as 0.3.1 — there is no new math here. What 0.3.2 buys you is a cleaner on-ramp:

• PyPI compatibility. We improved the PyPI publishing configuration so the maturin-built wheels for the Python bindings distribute properly. The practical effect: pip install numrs2 works the way you expect, and wheel distribution stops being a source of friction.
• Minimum Output Size (MOS) fix. We resolved a minimum-output-size constraint in the build and packaging path. This is a packaging-and-output-sizing fix — it makes the produced artifacts behave correctly, not a change to numerical results.

If you live in Rust, 0.3.2 changes very little for you day to day. If you live in Python — or you ship NumRS2 to colleagues who do — this is the release that makes “just install it” actually be just install it.

What changed under the hood

Three short layers, all sitting on the unchanged 0.3.x core:

1. The PyPI / maturin packaging path. NumRS2’s Python bindings are built with PyO3 and packaged as wheels via maturin. 0.3.2 cleans up the publishing configuration so those wheels are produced and uploaded in a shape that PyPI and pip are happy with across the supported targets.

2. The scirs2-numpy bridge. The Python side of NumRS2 leans on scirs2-numpy to bridge array data between the Rust core and the NumPy-shaped world Python users already know. Smoother PyPI distribution means that bridge is now reachable with a single pip install instead of a build-from-source detour.

3. The MOS (Minimum Output Size) fix. The minimum-output-size constraint that previously tripped up packaging is resolved, so the distributed artifacts are correctly sized. The numerical core — N-d arrays, OxiBLAS linear algebra, SIMD math — is byte-for-byte the same engine you already had in 0.3.1.

Getting Started

From Rust:

cargo add numrs2

use numrs2::prelude::*;

fn main() -> Result<()> {
    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);
    let product = a.matmul(&b)?;

    println!("sum:\n{}", c);
    println!("matmul:\n{}", product);
    Ok(())
}

And — the headline of this release — from Python, now via a clean PyPI install:

pip install numrs2

import numrs2 as nr

a = nr.array([[1.0, 2.0], [3.0, 4.0]])
print(a @ a)

The bindings flow through PyO3 / maturin and the scirs2-numpy bridge, so the array you get back behaves the way a NumPy refugee expects.

What’s New in 0.3.2

• PyPI compatibility — improved the PyPI publishing configuration for smoother pip install and wheel distribution of the Python bindings.
• Fixed — Minimum Output Size (MOS) — resolved a minimum-output-size constraint in the build/packaging path.
• Version bumped to v0.3.2 (a patch on top of 0.3.1).

What you already get, carried over from the 0.3.x line (not new in 0.3.2): N-dimensional arrays with broadcasting, OxiBLAS-backed linear algebra (SVD, QR, LU, Cholesky, eigh), SIMD-vectorized math, statistics, FFT, .npz I/O with pure-Rust DEFLATE, and Python bindings via PyO3 / maturin.

Tips

• pip install numrs2 now works cleanly. If a previous attempt left you fighting wheels, upgrade — that path is what 0.3.2 fixes.
• Building your own wheels? Use maturin (maturin build --release) against the updated configuration; the published wheel layout is what 0.3.2 standardizes.
• Bridging to NumPy-shaped code? Interop runs through scirs2-numpy, so you can hand arrays back and forth without copying through Python lists.
• Pure-Rust users lose nothing. The numerical core is identical to 0.3.1 — no need to change a line; cargo update to pick up the patch and carry on.
• Verify the round trip with a one-liner like the Python snippet above before wiring NumRS2 into a larger Python pipeline.

This is the foundation

NumRS2 is the N-dimensional array core the rest of the COOLJAPAN scientific stack computes on, and as of late March 2026 that stack is clearly maturing:

• SciRS2 — the scientific computing primitives NumRS2 builds directly on
• OxiBLAS — the pure-Rust linear-algebra backend behind SVD / QR / LU / Cholesky / eigh
• OxiCode — pure-Rust serialization in the same sovereign spirit
• scirs2-numpy — the bridge that makes today’s clean pip install reach Python
• OptiRS, PandRS, sklears, tenflowers, trustformers — higher-level numerics, dataframes, and ML that lean on the array core
• OxiFFT, OxiZ, OxiARC — transforms, solving, and pure-Rust archiving across the ecosystem

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

Star the repo if you want NumPy-grade numerical computing that now installs from PyPI as cleanly as it compiles in Rust.

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

— KitaSan at COOLJAPAN OÜ March 27, 2026