◉ COOLJAPAN
← All posts
January 19, 2026 • 6 min read

Kizzasi 0.1.0 Released — A Rust-Native Signal Predictor for the Continuous World

Kizzasi 0.1.0 is the first release of an Autoregressive General-Purpose Signal Predictor (AGSP) in Pure Rust — neuro-symbolic prediction for audio, sensors, robotics, and video that fuses State Space Models (Mamba/RWKV/S4) with TensorLogic constraints.

release kizzasi signal-prediction state-space-models mamba rust neuro-symbolic time-series

Most “language models” never touch a waveform. Kizzasi predicts the continuous world instead.

Today we released Kizzasi 0.1.0 — the first cut of a Rust-native autoregressive predictor for continuous signal streams: audio samples, sensor readings, robotics control loops, and video frames.

No Python runtime. No PyTorch. No CUDA toolkit pinned to a driver version. Kizzasi is written in Rust, compiles to a single static binary (or WASM), and runs the same on a workstation, an edge gateway, or a robot’s onboard controller. The signal stays in-process, the dependency tree stays auditable, and there is no C/C++/Fortran in the default build.

Why 0.1.0 matters

The phrase “Large Language Model” is, frankly, a misnomer. What these systems actually are is general-purpose signal predictors — they take a history and predict the next value. Text tokens are just one kind of signal (discrete vocabulary indices). Audio is a 44.1 kHz waveform. Sensor telemetry is a multivariate time series. Video is a high-dimensional spatio-temporal stream. They can all be served by the same autoregressive idea: predict the next value(s) from history.

Kizzasi (兆し — Japanese for “sign / omen / premonition”) is built around that insight, the AGSP (Autoregressive General-Purpose Signal Predictor) paradigm. And because it targets the physical world, raw next-value prediction is not enough — a predicted joint torque or motor velocity has to respect actual physical and safety limits. So Kizzasi is neuro-symbolic: it pairs the learning capacity of State Space Models with hard constraints, so predictions:

  1. follow statistical likelihoods learned from data,
  2. adhere to physical laws (conservation, causality),
  3. respect safety constraints (bounds, rate limits), and
  4. satisfy domain-specific logical rules.

For a 0.1.0 this is an honest first release — early, but already broad and structured. The workspace is roughly 25,000 lines of Rust across eight crates, every layer present, no unwrap() in production code, and a property-tested suite underneath.

Technical Deep Dive: the layers

Kizzasi is a workspace of focused crates, with a single facade (kizzasi) re-exporting them through an ergonomic prelude.

Getting Started

Add the crate:

cargo add kizzasi

A minimal next-step predictor:

use kizzasi::prelude::*;

fn main() -> KizzasiResult<()> {
    // Configure a predictor with a Mamba2 backend.
    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)?;

    // Single-step prediction — O(1) per step.
    let input = array![0.1, 0.2, 0.3];
    let output = predictor.step(&input)?;

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

And the neuro-symbolic part — predictions that are guaranteed to stay inside your limits:

use kizzasi::prelude::*;

let mut predictor = Kizzasi::new(
    KizzasiConfig::new().model_type(ModelType::Rwkv).input_dim(3).output_dim(3),
)?;

let guardrails = GuardrailSet::new()
    .add(Guardrail::new(
        ConstraintBuilder::new()
            .name("velocity_limit")
            .bound(0, BoundType::Range(-1.0, 1.0)) // clamp channel 0 to [-1, 1]
            .build()?,
    ))
    .add(Guardrail::new(
        ConstraintBuilder::new()
            .name("rate_limit")
            .rate_limit(0.1) // max change per step
            .build()?,
    ));

predictor.set_guardrails(guardrails);

// Every prediction now satisfies the constraints by construction.
let safe_output = predictor.step(&array![0.5, 0.5, 0.5])?;

What’s inside

Tips

This is the foundation

Kizzasi 0.1.0 stands on the COOLJAPAN ecosystem. Its array math, signal processing, and FFTs come from SciRS2 (scirs2-core, scirs2-signal, scirs2-fft), and its constraint layer is built on TensorLogic — the neuro-symbolic engine that gives the “logic” in neuro-symbolic real teeth. Serialization runs through Oxicode. Together with siblings like VoiRS and NumRS2, these form a growing Pure-Rust stack for scientific and signal computing.

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

This is a 0.1.0 — early, but real, and built to grow. Star the repo if a sovereign, neuro-symbolic signal predictor is something you’d reach for. Pure Rust signal prediction is here — fast, safe, and sovereign.

— KitaSan at COOLJAPAN OÜ January 19, 2026

↑ Back to all posts