◉ COOLJAPAN
← All posts
February 18, 2026 • 7 min read

OptiRS 0.2.0 Released — Apache-2.0 Licensing and SciRS2 0.2.0 Alignment for the Pure Rust Optimizer Suite

OptiRS is the Pure Rust ML optimizer suite (19 optimizers) built exclusively on SciRS2-Core. The 0.2.0 release relicenses to Apache-2.0 only and upgrades to SciRS2 v0.2.0 across every crate — fully backward compatible, with no API changes and no breaking changes. A one-line dependency bump.

release optirs ml-optimization scirs2 adam apache-2 pure-rust machine-learning optimizer

The optimizer suite you already know, now settling into a maturing ecosystem — same API, cleaner license, fresh SciRS2 foundation.

Today we released OptiRS 0.2.0 — relicensed to Apache-2.0 only and aligned with SciRS2 v0.2.0 across every crate.

This is a maturity and alignment release, plain and simple. There are no new optimizers, no new benchmarks, and no API changes. What changed is the foundation underneath: OptiRS now tracks the SciRS2 0.2.0 line and ships under a single, unambiguous license. If you are running OptiRS 0.1.0 today, upgrading is a one-line dependency bump — your code does not change.

No Python. No PyTorch optimizers. No external crates. OptiRS is the torch.optim/optax-class optimizer layer of the COOLJAPAN ML stack, built exclusively as an extension of SciRS2-Core. There is no torch.optim import, no optax shim, and no fragile C++/CUDA optimizer wrapped behind FFI. There is no direct dependency on ndarray, rand, rayon, or wide either — every array, every random draw, every SIMD lane, and every parallel batch flows through scirs2-core. The result compiles to a single static binary (or WASM) with no system optimizer runtime to install, version-match, or apologize for.

Why 0.2.0 matters

When OptiRS 0.1.0 shipped, the COOLJAPAN ecosystem was young. SciRS2 was the foundation, and a handful of siblings were finding their footing. That ecosystem has since grown steadily, and as it matured two things became worth standardizing: the license and the SciRS2 baseline.

So OptiRS 0.2.0 does exactly that. The license moves to Apache-2.0 only, matching SciRS2 and the broader stack — one license file, one set of terms, no dual-license ambiguity for downstream legal review. And the entire dependency tree moves onto the SciRS2 v0.2.0 line, so OptiRS rides the same primitives, the same numerics, and the same release cadence as the foundation it is built on.

What does not change is the public API. It is unchanged from 0.1.0 and fully backward compatible. The suite you already know is all still here: 19 optimizers, SIMD acceleration in the 2-4x range, parallel batches in the 4-8x range. None of that moved. The new news is licensing and the SciRS2 0.2.0 foundation — not features. That is deliberate. A release that says “nothing in your code needs to change” is a release you can adopt on a Friday afternoon.

Technical Deep Dive: the architecture that carries over

The internals are unchanged from 0.1.0 — but every layer now rides on SciRS2 v0.2.0 primitives. Here is how the suite is organized.

Core optimizers (optirs-core). The heart of the suite: 19 optimizers covering the space you actually reach for. Seventeen first-order methods — SGD, SimdSGD, Adam, AdamW, RMSprop, Adagrad, AdaDelta, AdaBound, LAMB, LARS, Lion, Lookahead, RAdam, Ranger, SAM, SparseAdam, and GroupedAdam — plus two second-order methods, L-BFGS and Newton-CG. Each implements a common Optimizer trait, so swapping Adam for Lion is a single line.

Learning-rate schedulers. Five schedulers ship alongside the optimizers: ExponentialDecay, StepDecay, CosineAnnealing, LinearWarmup, and OneCycle. They compose with any optimizer in the suite, because the schedule is decoupled from the update rule.

SIMD, parallel, and GPU frameworks. SIMD-accelerated update paths (2-4x on the supported kernels) go through scirs2_core::simd_ops. Parallel batch processing (4-8x) goes through scirs2_core::parallel_ops. The GPU framework (optirs-gpu) targets CUDA, Metal, OpenCL, and WebGPU. All of it now sits on the SciRS2 v0.2.0 abstractions rather than reaching for hardware crates directly.

Metrics and tooling. Optimization metrics export to JSON and CSV for offline analysis, and the benchmark crate (optirs-bench) lets you measure your own configurations. The companion crates — optirs-tpu, optirs-learned, and optirs-nas — round out the suite for TPU targets, learned optimizers, and neural architecture search.

Every one of these layers was already real in 0.1.0. The 0.2.0 work was to lift the whole stack onto SciRS2 v0.2.0 and confirm it still behaves. The tests continue to pass.

Getting Started

Add OptiRS and its required foundation:

cargo add optirs-core scirs2-core

Or, in your [dependencies] block:

optirs-core = "0.2.0"
scirs2-core = "0.2.0"  # required foundation, now on the 0.2.0 line

A minimal Adam step looks like this:

use optirs_core::optimizers::{Adam, Optimizer};
// ALWAYS use scirs2_core for arrays — NEVER direct ndarray!
use scirs2_core::ndarray::Array1;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let params = Array1::from_vec(vec![1.0, 2.0, 3.0, 4.0]);
    let gradients = Array1::from_vec(vec![0.1, 0.2, 0.15, 0.08]);

    let mut optimizer = Adam::new(0.001);
    let updated_params = optimizer.step(&params, &gradients)?;

    println!("Updated parameters: {:?}", updated_params);
    Ok(())
}

That example is identical to the one you would have written against 0.1.0 — because the API did not move.

What’s New in 0.2.0

Tips

This is the foundation

OptiRS is the optimizer layer of the COOLJAPAN ML stack, and 0.2.0 is it maturing in step with the foundation beneath it. That foundation is SciRS2, now on its own 0.2.0 line — OptiRS depends on scirs2-core, scirs2-optimize, scirs2-neural, scirs2-stats, and more, so everything OptiRS does is anchored there.

Around SciRS2, the ecosystem has grown into a steady, real stack: NumRS2 and PandRS for arrays and dataframes; OxiBLAS for linear algebra under SciRS2; Oxicode for serialization; OxiFFT for transforms; OxiZ for SMT solving; OxiARC for Pure Rust compression; Legalis-RS for legal technology; MeCrab, Chie, and Mielin; OxiRAG for retrieval; and Spintronics, VoiRS, Tenrso, and TensorLogic. OptiRS sits in that lineup as the place where gradients become parameter updates — and as of 0.2.0, it shares the same license and the same SciRS2 baseline as the rest of them.

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

Star the repo if you want Pure Rust ML optimization that upgrades on a one-line bump and never asks you to install a CUDA toolchain first. More to come as the stack keeps growing.

— KitaSan at COOLJAPAN OÜ February 18, 2026

↑ Back to all posts