◉ COOLJAPAN
← All posts
August 13, 2026 • 8 min read

Kizzasi 0.2.3 Released — Zero C Downstream Too, Pure-Rust Video, and Safe Metal Acceleration

Kizzasi 0.2.3 removes the last C dependency (Oniguruma) from published crates via a candle fork — fixed for downstream users, not just this workspace. Ships pure-Rust video (OxiMedia Y4M decode + camera capture), pure mqtt-tls, and a new kizzasi-metal crate for safe cross-platform Metal acceleration.

release kizzasi signal-prediction state-space-models pure-rust video gpu metal rust

The one C library that survived every previous purification pass — Oniguruma, pulled in transitively through candle’s tokenizer dependency — is gone, and for the first time the fix reaches everyone who depends on the published crate, not just this workspace.

Today we released Kizzasi 0.2.3 — a purity-and-portability release: the default build now compiles zero C for downstream consumers too, a pure-Rust video backend lands alongside the existing FFmpeg one, and Apple Metal acceleration becomes safe to enable from any host.

No C. No C++. No Fortran. And, as of this release, no Oniguruma even in the crates published to crates.io. Kizzasi still compiles to a single static binary (or WASM) and runs no_std on microcontrollers.
video, video-pure, metal, and mqtt-tls all stay opt-in — the CPU-only, FFmpeg-free, TLS-free default build is unchanged.

Why Kizzasi 0.2.3 is a game changer

Three separate cracks had opened in the “100% Pure Rust” claim:

Kizzasi 0.2.3 ends all of that. The tensor backend moves to a COOLJAPAN fork that drops onig for good — verified from outside this workspace with cargo tree -i onig — a new kizzasi-metal crate makes the Metal feature target-scoped instead of target-blind, and a pure-Rust video backend (the OxiMedia stack) gives video-pure users an FFmpeg-free path for files and cameras alike.

Technical Deep Dive: what changed

Getting Started

Nothing changed in the basic Rust API — add the crate and predict:

cargo add kizzasi

use kizzasi::prelude::*;

fn main() -> KizzasiResult<()> {
    let config = KizzasiConfig::new()
        .model_type(ModelType::Mamba2)
        .input_dim(3)
        .output_dim(3)
        .hidden_dim(256)
        .state_dim(16)
        .num_layers(4)
        .context_window(8192);

    let mut predictor = Kizzasi::new(config)?;
    let output = predictor.step(&array![0.1, 0.2, 0.3])?;
    println!("Predicted: {:?}", output);
    Ok(())
}

New in 0.2.3 — decode a Y4M file or a webcam with zero FFmpeg linkage:

use kizzasi_io::{VideoConfig, VideoReader, VideoBackend};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = VideoConfig::from_file("clip.y4m").with_backend(VideoBackend::Pure);
    let mut reader = VideoReader::new(config).await?;

    while let Some(frame) = reader.read_frame().await? {
        let rgb = frame.to_array()?; // ndarray::Array3<u8>
        println!("frame {}: {:?}", reader.current_frame(), rgb.shape());
    }
    Ok(())
}

And probe the Metal backend directly if you need to know before enabling it end to end:

match kizzasi_metal::new_device(0) {
    Ok(device) => println!("Metal device ready: {device:?}"),
    Err(err) => println!("no Metal device: {err}"),
}

What’s New in 0.2.3

Tips

This is the foundation

Kizzasi 0.2.3 keeps riding SciRS2 0.6 with OxiFFT and Oxicode, and now adds the OxiMedia stack (oximedia-container/-core/-cv/-capture/-codec/-simd) as its pure-Rust video layer and oxitls-rustcrypto-provider as its pure-Rust TLS layer, alongside the WebGPU backend on wgpu and neuro-symbolic constraints on tensorlogic-ir. It shares the deep-learning neighborhood with ToRSh, TensFloweRS, TrustformeRS, and SkleaRS, and sits alongside OxiLLaMa, OxiONNX, and VoiRS — a sovereign alternative to the PyTorch/CUDA/GGML/FFmpeg world for signals that aren’t text.

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

Star the repo if compiling zero C — even for the people who depend on your crate — is something you want from your signal-prediction stack. The era of “it’s pure Rust, except for what your dependents end up pulling in” is over. Pure Rust, all the way down the dependency graph, is here.

— KitaSan at COOLJAPAN OÜ August 13, 2026

↑ Back to all posts