◉ COOLJAPAN
← All posts
May 3, 2026 • 7 min read

SciRS2 0.4.3 Released — Pure-Rust Symbolic Math Arrives with the New scirs2-symbolic Crate + Full WASM TypeScript Bindings

SciRS2 is the pure-Rust SciPy/scikit-learn replacement. 0.4.3 introduces the brand-new scirs2-symbolic crate (symbolic differentiation + algebraic simplification), full WASM TypeScript declarations & React hooks, an inverse wavelet packet transform, and modernized dependencies — 34,883 tests, 2.94M lines, 32 crates, zero warnings.

release scirs2 scientific-computing symbolic-math pure-rust wasm typescript ai

Symbolic math, in pure Rust, with no C, no Fortran, and no Python in the loop — that is what ships today.

Today we released SciRS2 0.4.3 — a stability and refactoring release whose headline is the brand-new pure-Rust scirs2-symbolic crate, joined by a full WebAssembly TypeScript binding story and a sweep of dependency modernization.

No C. No Fortran. No NumPy system dependencies. SciRS2 is a scientific computing stack for Rust that aims to replace NumPy, SciPy, and scikit-learn without dragging along a decades-old native toolchain. The same code compiles to a single static binary on the server and to WebAssembly in the browser — no pip install, no shared-library hunt, no surprise ABI breaks.

Why SciRS2 0.4.3 matters

If you have shipped numerical Python to production, you know the pain points. NumPy and SciPy lean on system BLAS/LAPACK, Fortran runtimes, and a tangle of native wheels that differ per platform. scikit-learn pins you to a CPython interpreter and the GIL. Symbolic work usually means reaching for yet another heavyweight dependency. Reproducing a build six months later can be an archaeology project.

SciRS2 0.4.3 chips away at all of that with concrete wins:

And SciRS2 is not slow because it is safe. Established SciRS2 benchmarks against NumPy include element-wise operations at 14.17x, convolution at 25x, bootstrap resampling at 30x, and fractional FFT at 24.9x. Safety and speed are not a trade here.

Technical Deep Dive

Layer 1 — scirs2-core. The foundation provides a NUMA-aware work scheduler, GPU backends for Metal (MPS) and WGPU, and hand-tuned SIMD kernels. In 0.4.3 the GPU backends, JIT path, memory views, and random-ecosystem integration were refactored, and five new SIMD example programs were added so you can benchmark the kernels directly on your own hardware.

Layer 2 — scirs2-symbolic (new). This is the marquee addition. It models math as an expression tree and offers:

It is pure Rust with thiserror as its only dependency — small, auditable, and dependency-light by design.

Layer 3 — scirs2-wasm. The WASM story grew up. The crate now ships TypeScript declarations (ts-src/index.d.ts, 1425 lines, roughly 96 exported symbols) spanning 19 API sections: stats, signal processing, linear algebra, FFT, a WasmMatrix class, the SciRS2 facade, ML models (WasmKMeans, WasmNaiveBayes), streaming primitives (OnlineStats, RollingWindow, StreamingFFT), eight SIMD128 ops (dot_product, matmul, softmax, relu, sigmoid, add, mul, l2_norm), and Web Worker utilities (TransferableArray, WorkerPool). On top of that sit React hooks (useScirs2, useScirs2Compute, useScirs2Array), Web Worker helpers (js/worker.js), and FinalizationRegistry-based WASM memory management. A Node.js usage example and a browser benchmark against TF.js-WASM round it out.

Layer 4 — the Pure-Rust foundation. Underneath everything, SciRS2 stands on COOLJAPAN’s pure-Rust building blocks: OxiBLAS for BLAS/LAPACK, OxiFFT (oxifft 0.1.4) for FFTs, and oxiarc-* 0.2.7 for compression. Python interop goes through PyO3; the browser path uses a WebGPU backend. There is no native math library to install and no Fortran in sight.

Getting Started

Add SciRS2 to your project:

cargo add scirs2

Here is a minimal example using the new scirs2-symbolic API — build x^2 + sin(x), differentiate it, simplify the result, and evaluate it at a point:

use scirs2::symbolic::{Expr, diff, simplify, eval};

fn main() {
    // Build the expression: x^2 + sin(x)
    let x = Expr::var("x");
    let expr = x.pow(2) + Expr::sin(x.clone());

    // Symbolically differentiate with respect to x:
    //   d/dx (x^2 + sin(x)) = 2*x + cos(x)
    let derivative = diff(&expr, "x");

    // Simplify the derivative algebraically
    let simplified = simplify(&derivative);
    println!("d/dx = {}", simplified);

    // Evaluate the derivative at x = 0  ->  2*0 + cos(0) = 1
    let value = eval(&simplified, &[("x", 0.0)]);
    println!("value at x=0: {}", value);
}

Everything above is pure Rust — no Python, no native symbolic engine, and it compiles straight to a static binary or to WASM.

What’s New in 0.4.3

Added

Changed

Fixed

Tips

Part of the COOLJAPAN ecosystem

SciRS2 is the scientific-computing core of the COOLJAPAN pure-Rust ecosystem. It rests directly on OxiBLAS (BLAS/LAPACK), OxiFFT (FFT), and oxiarc (compression), with oxicode for serialization — all pure Rust, all without native toolchains. It sits alongside peers like optirs (optimization), numrs (n-dimensional arrays), pandrs (dataframes), and torsh (tensors), so you can assemble a complete numerical and ML stack that never leaves Rust.

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

Star the repo if you want symbolic math, SciPy-grade numerics, and browser-ready ML without a single line of C or Fortran.

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

— KitaSan at COOLJAPAN OÜ May 3, 2026

↑ Back to all posts