◉ COOLJAPAN
← All posts
January 21, 2026 • 7 min read

QuantRS2 0.1.0 Released — Pure Rust Quantum Computing, From State Vectors to Real Hardware

QuantRS2 is a pure-Rust quantum computing framework — type-safe circuits, state-vector/stabilizer/tensor-network simulators, Grover/QFT/VQE/QAOA, and IBM/Azure/AWS/D-Wave hardware integration. This is the first stable release.

release quantrs2 quantum-computing rust simulation qaoa qiskit pure-rust

Quantum computing in Rust, with no Python runtime and no C++ build chain — just cargo add.

Today we released QuantRS2 0.1.0 — a comprehensive, modular, pure-Rust quantum computing framework spanning simulation, algorithm development, and real hardware interaction. This is the first stable release: early, but solid, and already useful end to end.

QuantRS2 (pronounced /kwɒntərz tu:/) is a deliberate alternative to the way quantum software is usually built today. The mainstream stack is Python at the front (Qiskit, Cirq, PennyLane) glued onto C++/CUDA at the back (Stim, cuQuantum). That works, but it brings fragile environments, version-pinned wheels, and a build chain you fight before you ever simulate a qubit. QuantRS2 takes the other path. No C. No Fortran. No CUDA toolkit. No Python runtime. It compiles to a single static binary — or to WASM — and runs the same on Linux, macOS (including Apple Silicon), and Windows. Even the symbolic mathematics is sovereign: quantrs2-symengine-pure is a from-scratch, 100% Rust symbolic engine that replaces SymEngine’s C++ bindings outright.

Why QuantRS2 0.1.0 matters

The incumbent’s pain is well known: a quantum program is rarely just a quantum program. It is Python glue over a C++/CUDA core, an environment that breaks when a transitive dependency moves, and a deployment story that assumes a full scientific Python install is present. Reproducing a result a year later can be harder than writing it.

QuantRS2 trades that for a compiled, type-checked, self-contained framework. A few concrete wins from the 0.1.0 benchmarks, measured on Apple Silicon:

Technical Deep Dive: Inside QuantRS2

QuantRS2 is organized as a Cargo workspace, with each layer in its own crate.

Type-safe circuits (quantrs2-core, quantrs2-circuit). The core crate defines the types, traits, and abstractions; the circuit crate provides a circuit DSL and gate library on top. The signature feature here is the use of Rust const generics for compile-time verification of qubit counts. A Circuit::<2> is a two-qubit circuit, statically — so an out-of-range qubit index is a type error, not a runtime panic.

The simulator family (quantrs2-sim). A single crate ships four complementary engines. The state-vector simulator is the general workhorse (30+ qubits). The stabilizer simulator uses the O(n²) tableau formalism to reach 50+ qubits — ideal for Clifford circuits and quantum error correction. The tensor-network simulator targets low-entanglement circuits (50+ qubits, circuit-dependent) and includes specialized contraction-path optimization for QFT and QAOA. The density-matrix simulator handles mixed states and open systems, and a quantum reservoir computing engine rounds out the set.

Hardware and annealing (quantrs2-device, quantrs2-anneal, quantrs2-tytan). The device crate connects circuits to real quantum hardware: IBM Quantum (Qiskit-compatible auth, transpilation, job submission, and result processing), Azure Quantum, and AWS Braket. On the annealing side, quantrs2-anneal integrates with D-Wave, and quantrs2-tytan is a high-level annealing library on top.

The numerical foundation and symbolic engine. Underneath everything sits SciRS2, the scientific-computing core this release is built directly on. And as noted above, quantrs2-symengine-pure provides symbolic mathematics in pure Rust — no C++ dependency anywhere in the default build.

Getting Started

Add the three crates from the README’s own quickstart:

cargo add quantrs2-core quantrs2-circuit quantrs2-sim

Then build and simulate a Bell state:

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

fn main() {
    // Create a circuit with 2 qubits
    let mut circuit = Circuit::<2>::new();

    // Build a Bell state circuit: H(0) followed by CNOT(0, 1)
    circuit.h(0).unwrap()
           .cnot(0, 1).unwrap();

    // Run the circuit on the state vector simulator
    let simulator = StateVectorSimulator::new();
    let result = circuit.run(simulator).unwrap();

    // Print the resulting probabilities
    for (i, prob) in result.probabilities().iter().enumerate() {
        let bits = format!("{:02b}", i);
        println!("|{}⟩: {:.6}", bits, prob);
    }
}

Prefer Python? The bindings (built with PyO3 via quantrs2-py) are available as a package: pip install quantrs2.

What’s inside

This is 0.1.0, so here is what ships in the box:

Tips

Built on SciRS2

QuantRS2 does not stand alone — it sits on the SciRS2 scientific-computing ecosystem (v0.1.2). Array operations come from scirs2-core::ndarray, randomness from scirs2-core::random, Complex64/Complex32 from scirs2_core, SIMD from scirs2-core::simd_ops, parallelism from scirs2-core::parallel_ops, and GPU from scirs2-core::gpu. This release also depends on optirs-core (the optimization layer behind VQE/QAOA), numrs2, pandrs, and oxicode.

That places QuantRS2 squarely in the young, sovereign, pure-Rust COOLJAPAN stack — alongside SciRS2 at the center, with NumRS2 for numerics, OptiRS for ML/optimization, Oxicode in place of bincode, OxiZ in place of Z3, and OxiFFT in place of rustfft. The ecosystem is early, but it is real, and QuantRS2 is built on it from the ground up.

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

Star the repo if a pure-Rust quantum framework is something you want to see grow — this is the first stable release, and there is a long road ahead.

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

— KitaSan at COOLJAPAN OÜ January 21, 2026

↑ Back to all posts