SciRS2 0.1.5 Released — A Consistency & Dependency-Hygiene Follow-up to 0.1.4

A quick consistency-and-polish follow-up to last week’s 0.1.4 — fewer dependencies, stricter imports, and a workspace that lines up end to end.

Today we released SciRS2 0.1.5 — a fast follow-up that tightens workspace consistency and dependency hygiene across all 27 crates.

No C. No Fortran. No NumPy system dependencies. Where the scientific Python stack leans on NumPy, SciPy, FFTW, and OpenBLAS — each pulling in its own native toolchain — SciRS2 is 100% Pure Rust by default. BLAS and LAPACK run through OxiBLAS (no OpenBLAS, no MKL), FFT runs through OxiFFT (no FFTW, no C), and everything stays memory-safe. It compiles to a single static binary (or WASM) and runs everywhere — Linux, macOS, Windows, and the browser.

Why 0.1.5 matters

Right after the larger 0.1.4 release — which landed the SIMD work, Delaunay improvements, and the move to OxiFFT — we wanted a cleanup pass before moving on. 0.1.5 is exactly that: it makes the workspace fully consistent and lean, with nothing new to learn and nothing to migrate.

Here is why a maintenance release earns its own version:

• Reproducible builds. A single workspace-wide bump to 0.1.5, with versions, docs, and README headers aligned across every member crate, means there is no version skew to chase down. What you pin is what you get, everywhere.
• Faster, smaller builds. We trimmed the dependency tree — dropping an unused plotters benchmark dependency, a stale oxicode reference, and a redundant flate2 — so compiles are quicker and the tree is smaller, with no change to functionality.
• One place for ndarray and rand. The SCIRS2 import-policy work continued: doc examples in scirs2-neural’s batch linear-algebra operations now route their array imports through scirs2_core::ndarray instead of ndarray directly, so the whole workspace funnels numeric array and RNG imports through scirs2-core.
• GPU wiring that actually works. scirs2-neural’s gpu feature now correctly propagates to the core GPU feature instead of being a dangling no-op.

Technical Deep Dive: The scirs2-core single-dependency architecture

SciRS2 is built around one rule we call the SCIRS2 POLICY: scirs2-core is the only crate allowed to carry external dependencies. Every other crate in the workspace imports ndarray, rand, and friends through core — scirs2_core::ndarray for array types, scirs2_core::random for RNGs — rather than depending on those crates directly.

The payoff is that there is exactly one place where the version of ndarray (or rand) is decided. No member crate can drift onto a different version, no transitive duplicate sneaks in, and upgrading the whole stack is a single edit in one Cargo.toml. It also means the public surface every crate uses is the abstraction scirs2-core exposes, not whatever the upstream crate happens to ship that week.

0.1.5 finishes enforcing this in one of the last places it had slipped: scirs2-neural’s batch operations. Their doc examples previously wrote use ndarray::...; now they write use scirs2_core::ndarray::..., bringing neural fully in line with the rest of the workspace.

On top of core sit 27 crates, organized by Cargo feature flags through the scirs2 meta-crate:

• standard — the default feature set, the common scientific-computing surface.
• full — everything.
• ai — the AI/ML-oriented groups.
• Individual toggles like linalg, stats, fft, neural, autograd, and more, so you pull in only what you use.

The FFT backend follows the same Pure-Rust-by-default principle established in 0.1.4: OxiFFT is the default, 100% Pure Rust, and rustfft remains available behind an optional feature purely for backward compatibility. You opt into the C-adjacent path; you never get it by accident.

This release ships with 11,400+ tests passing, ~1.69M lines of Rust (1.95M total), and zero warnings.

Getting Started

cargo add scirs2

That pulls in the standard feature set by default. For optional performance backends:

cargo add scirs2 --features oxifft,cuda

A small example using the umbrella crate — array types come through scirs2_core::ndarray, staying policy-compliant:

use scirs2_core::ndarray::array;
use scirs2::stats::{mean, std};

fn main() {
    let data = array![2.0_f64, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0];

    let m = mean(&data.view()).expect("mean");
    let s = std(&data.view(), 0).expect("std");

    println!("mean = {m:.3}, std = {s:.3}");
}

What’s New in 0.1.5

• Workspace version-consistency pass. All 27 member crates bumped to 0.1.5 with versions, docs, and README headers aligned.
• Import-policy migration in neural batch ops. Doc examples in scirs2-neural’s batch linear-algebra operations moved from use ndarray::... to use scirs2_core::ndarray::....
• GPU feature now propagates to core. scirs2-neural’s gpu feature is wired to scirs2-core/gpu instead of being a no-op.
• Leaner dependency tree. Removed an unused plotters benchmark dependency (criterion already covers benchmarking), a stale oxicode comment reference in scirs2-graph, and a redundant direct flate2 in scirs2-datasets (already available transitively).
• OxiFFT remains the Pure Rust default. rustfft stays optional, behind a feature, for backward compatibility.

Tips

• Always import array types via scirs2_core::ndarray (and RNGs via scirs2_core::random) to stay policy-compliant and avoid version skew:

  use scirs2_core::ndarray::Array2;
  use scirs2_core::random::Rng;
  

• Turn on the neural gpu feature for GPU paths — it now correctly forwards to the core GPU feature, so it does what the name implies.

• Pin to scirs2 = "0.1.5" to pick up the consistency fixes and the trimmed dependency tree.

• Keep builds lean by selecting feature groups (standard, full, ai) and individual toggles like linalg or stats rather than pulling everything.

• You don’t need rustfft. OxiFFT is already the default Pure Rust FFT backend; reach for the rustfft feature only if you have a specific backward-compatibility reason.

This is the foundation

SciRS2 sits in the growing COOLJAPAN pure-Rust stack. Its numeric foundations are OxiBLAS (BLAS/LAPACK) and OxiFFT (FFT) — both 100% Pure Rust — and optimization lives in the independent OptiRS project (the former scirs2-optim now has its own home). Alongside NumRS2 and PandRS, it’s part of a coherent, C-free scientific computing ecosystem in Rust.

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

Star the repo if you want a scientific computing stack that compiles to a single static binary with no native toolchain in sight.

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

— KitaSan at COOLJAPAN OÜ February 8, 2026