QuantRS2 0.1.2 Released — Python Bindings Polished, Symbolic Math Goes Fully Pure Rust

A few days after launch, the first round of polish lands.

Today we released QuantRS2 0.1.2 — a small polish patch that refines the Python bindings, refreshes the docs, and completes the move to a fully pure-Rust symbolic engine.

No C. No Fortran. No CUDA toolkit. With 0.1.2, the last of the legacy C++ SymEngine build scaffolding is gone — symbolic math is now 100% Rust via quantrs2-symengine-pure. QuantRS2 (/kwɒntərz tu:/) stays what it set out to be: a comprehensive, modular, pure-Rust quantum computing framework — simulation, algorithm development, hardware interaction — that compiles down to a single static binary, or to WASM, with nothing to install on the system underneath it.

Why 0.1.2 matters

QuantRS2 serves both Rust and Python users. The PyO3 bindings and the PennyLane plugin mean you can drive the same pure-Rust core from a Python notebook, and 0.1.2 is all about tightening that experience. The Python-binding bugfix, the refreshed packaging metadata across pip / Homebrew / snap, and the documentation pass make the framework smoother to install and use from either language. Dependency-compatibility bumps round it out. It is a quality-of-life patch — no new algorithms, no public Rust API changes — and, importantly, there is no longer a C++ SymEngine toolchain to wrestle with on the way in.

Getting Started

Add the core crates:

cargo add quantrs2-core quantrs2-circuit quantrs2-sim

A two-qubit Bell state, simulated end to end:

use quantrs2_circuit::builder::Circuit;
use quantrs2_sim::statevector::StateVectorSimulator;

fn main() {
    let mut circuit = Circuit::<2>::new();
    circuit.h(0).unwrap()
           .cnot(0, 1).unwrap();
    let simulator = StateVectorSimulator::new();
    let result = circuit.run(simulator).unwrap();
    for (i, prob) in result.probabilities().iter().enumerate() {
        let bits = format!("{:02b}", i);
        println!("|{}⟩: {:.6}", bits, prob);
    }
}

Python users get the framework from PyPI:

pip install quantrs2

import quantrs2
# build and run a 2-qubit Bell-state circuit, then read probabilities
# (install with: pip install quantrs2)

What’s New in 0.1.2

• Python-bindings bugfix — fixes across the PyO3 layer and the Python-side package files (init, core, IDE plugin, PennyLane plugin, property-testing helpers), plus packaging metadata for pip, Homebrew, and snap.
• Documentation refresh — updates across crate READMEs and the SciRS2 integration guides, so the install and integration story matches the code.
• Dependency version bumps — refreshed pins for better compatibility and fewer version conflicts.
• Legacy C++ SymEngine tooling removed — the old SymEngine C++ install scripts are gone; symbolic math is now fully pure-Rust via quantrs2-symengine-pure.

Tips

• Python is a one-liner now. pip install quantrs2 — there is no SymEngine C++ build step anymore, so installs are quicker and less fragile.
• The symbolic engine ships pure. quantrs2-symengine-pure is a 100%-Rust SymEngine replacement — no system dependency to find, build, or link.
• PennyLane works out of the box. A PennyLane plugin ships on the Python side if you want to wire QuantRS2 into a PennyLane workflow.
• Keep your deps fresh. 0.1.2’s compatibility bumps smooth out version conflicts — re-run cargo update (or reinstall the Python package) to pick them up.
• Read the refreshed SciRS2 guide. The updated integration docs explain how arrays, RNG, and Complex64 flow in from scirs2-core — useful when you start mixing QuantRS2 with the rest of the stack.

Built on SciRS2

QuantRS2 rides on the SciRS2 ecosystem (v0.1.2) for arrays, linalg, parallel, and GPU — scirs2-core provides ndarray, random, Complex64, SIMD, and parallel building blocks. It sits alongside NumRS2, OptiRS, and Oxicode in the young pure-Rust COOLJAPAN stack.

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

Star the repo if a pure-Rust quantum framework — one you can pip-install or cargo-add without a C++ toolchain in sight — is something you want to see grow.

Pure Rust quantum computing is here — fast, safe, and sovereign.

— KitaSan at COOLJAPAN OÜ January 23, 2026