◉ COOLJAPAN
← All posts
April 27, 2026 • 5 min read

sklears 0.1.1 Released — Correctness Fixes for HDBSCAN, Streaming, and Pipelines

sklears 0.1.1 is a correctness patch for pure-Rust scikit-learn: HDBSCAN cluster-persistence fix, streaming scaler/imputer Default cleanups, a pipeline lifetime fix, and serialization fixes — 11,586+ tests across 36 crates, >99% scikit-learn API coverage held.

release sklears machine-learning scikit-learn rust classical-ml clustering scirs2

Stable means stable — so the first thing after 0.1.0 is making the edges as trustworthy as the core.

Today we released sklears 0.1.1 — a correctness and stability patch that hardens clustering, streaming preprocessing, pipelines, and serialization across the pure-Rust scikit-learn surface.

sklears is the pure-Rust alternative to scikit-learn, and the sovereignty story is unchanged: No C. No Fortran. No Cython. No GIL. scikit-learn leans on a tower of compiled extensions; sklears is plain Rust on top of the SciRS2 stack, with OxiBLAS for BLAS/LAPACK and Oxicode for serialization. This release does not move that line — it polishes what already sits behind it.

Why 0.1.1 matters

0.1.0 was a big release: 36 crates, type-safe Untrained → Trained state machines, builder APIs, SIMD via std::simd, Rayon work-stealing parallelism, and >99% scikit-learn API coverage end-to-end against scikit-learn’s ~v1.5 feature set. Shipping that much surface in one stable cut means the next job is the hardening pass — finding the corners where behavior was subtly wrong and nailing them down. That is exactly what 0.1.1 is, and the test suite that guards it still stands at 11,586+ tests passing across 36 crates with coverage held at >99%.

Here is what got fixed, and why each one matters:

None of this adds an algorithm. All of it makes the algorithms you already had behave the way the docs promised.

What’s New in 0.1.1

In plain language, this is a bug-fix release plus the version bump — no new estimators:

Getting Started

Install:

cargo add sklears

The example below exercises the two areas 0.1.1 hardened — density clustering (the HDBSCAN/persistence fix) and the pipeline path:

use sklears::prelude::*;
use sklears::cluster::HDBSCAN;

fn main() -> Result<()> {
    // Load a small dataset
    let dataset = sklears::dataset::make_blobs(300, 2, 3, 0.6)?;

    // 0.1.1 fixes HDBSCAN cluster-persistence extraction (root detection + ordering)
    let labels = HDBSCAN::new()
        .min_cluster_size(10)
        .fit_predict(&dataset.data)?;

    let n_clusters = labels.iter().filter(|&&l| l >= 0).max().map_or(0, |m| m + 1);
    println!("found {} clusters", n_clusters);
    Ok(())
}

The same release also smooths the preprocessing-into-model flow — a Pipeline chaining a StandardScaler into a LinearRegression, with get_step_mut now available to reach back into a fitted step:

use sklears::prelude::*;
use sklears::pipeline::Pipeline;

let mut pipe = Pipeline::new()
    .add_step("scale", StandardScaler::new())
    .add_step("model", LinearRegression::new());

pipe.fit(&x, &y)?;

// 0.1.1 fixes get_step_mut lifetime elision for `dyn PipelineStep`
if let Some(step) = pipe.get_step_mut("scale") {
    // mutate the fitted step in place
}

Tips

A maturing foundation

As of 2026-04-27, sklears sits squarely inside the COOLJAPAN ecosystem: built on SciRS2 0.4.2 with OxiBLAS for linear algebra and Oxicode for serialization, drawing on NumRS2 and PandRS for array and dataframe work. sklears covers classical machine learning, alongside TenfloweRS and TrustformeRS for deep learning — one pure-Rust stack from data wrangling through models. 0.1.1 is the kind of quiet release that makes the rest of that stack worth standing on.

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

Star the repo if a pure-Rust, no-GIL scikit-learn is something you want to build on — every star helps the ecosystem grow. Thanks for reading, and happy clustering.

— KitaSan at COOLJAPAN OÜ April 27, 2026

↑ Back to all posts