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

Kizzasi 0.2.2 Released — WebGPU Acceleration, Real Neuro-Symbolic Constraints, and a Training Loop That Finally Trains

Kizzasi 0.2.2 ships a WebGPU acceleration backend, real tensorlogic-ir constraint compilation, PEAQ perceptual audio quality evaluation, and multi-speaker tokenization — alongside a wide correctness sweep that fixes training, SSM recurrences, and weight serialization that were silently broken since 0.2.1. 2,744 tests passing, 100% Pure Rust.

release kizzasi signal-prediction state-space-models webgpu gpu neuro-symbolic rust pure-rust

The bugs that made Kizzasi’s training loop a no-op, and its “SafeTensors” checkpoints an unreadable lie, are gone — and the neuro-symbolic constraint layer the project always meant to ship is finally real.

Today we released Kizzasi 0.2.2 — the largest correctness pass the project has had, shipped alongside a genuinely new WebGPU acceleration backend, real tensorlogic-ir neuro-symbolic constraints, and perceptual audio quality evaluation.

No C. No C++. No Fortran. No Python interpreter required to run a model, no CUDA toolkit pinned to a driver version. Kizzasi is still Rust end to end — it compiles to a single static binary (or WASM), runs no_std on microcontrollers, and now optionally offloads SSM kernels to the GPU through wgpu, Pure Rust the whole way down.
The webgpu feature is off by default — no GPU, no problem, the CPU backend is always there.

Why Kizzasi 0.2.2 is a game changer

0.2.1 turned Kizzasi from an inference engine into a train-and-deploy stack. What that release didn’t surface: several of the load-bearing pieces of that stack were quietly broken.

Kizzasi 0.2.2 ends all of that. Every one of these — and dozens more across kizzasi-core, kizzasi-model, kizzasi-tokenizer, kizzasi-logic, and kizzasi-inference — is fixed and covered by a regression test. On top of the correctness sweep, this release ships the neuro-symbolic constraint layer for real: tensorlogic-ir now compiles and evaluates TLExpr constraints directly, replacing a placeholder that had been commented out since the beginning. And a new WebGPU backend gives the SSM scan somewhere to run besides the CPU.

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 input = array![0.1, 0.2, 0.3];
    let output = predictor.step(&input)?;

    println!("Predicted: {:?}", output);
    Ok(())
}

New in 0.2.2 for the Python side — sampling strategies over raw logits:

pip install kizzasi

import numpy as np
import kizzasi

config = kizzasi.SamplingConfig()   # default: strategy="greedy", temperature=1.0
config.strategy("top_k")
config.top_k(3)
config.seed(42)

sampler = kizzasi.Sampler(config)

logits = np.array([1.0, 3.0, 0.5, 2.5, 1.8], dtype=np.float32)
sampler.sample(logits)              # -> float, single sampled value

batch_logits = np.random.randn(8, 5).astype(np.float32)
sampler.sample_batch(batch_logits)  # -> np.ndarray shape (8,)

What’s New in 0.2.2

Tips

This is the foundation

Kizzasi 0.2.2 sits in a Pure-Rust ecosystem that keeps filling out. Its math and signal layers now ride SciRS2 0.6 with OxiFFT for transforms (used directly by both kizzasi-core and the new perceptual quantizer in kizzasi-tokenizer) and Oxicode for serialization, while the WebGPU backend runs on wgpu. The neuro-symbolic constraints build on tensorlogic-ir, now wired in for real instead of stubbed out. It shares the deep-learning neighborhood with ToRSh, TensFloweRS, TrustformeRS, and SkleaRS, and slots into the broader stack alongside OxiLLaMa, OxiONNX, and VoiRS — a coherent, sovereign alternative to the PyTorch/CUDA/GGML world for signals that aren’t text.

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

Star the repo if a signal predictor that trains, constrains, and now GPU-accelerates — all in Pure Rust — is something you want in your stack. The era of trusting a checkpoint format you can’t verify is over. Pure Rust signal prediction is here — fast, safe, and sovereign.

— KitaSan at COOLJAPAN OÜ August 10, 2026

↑ Back to all posts