SimQ

Quantum computing at Rust speed

SimQ is a high-performance quantum computing SDK written in Rust, cross-validated against Qiskit, qsim, and qulacs, beating Qiskit Aer on 19 of 20 benchmarked workloads and qulacs, the strongest competitor found, on all 12 it covers, with type-safe circuit construction and first-class Python bindings.

Get started → View on GitHub

Rust

use simq::QuantumCircuit;

fn main() {
    // 3-qubit GHZ state
    let mut qc = QuantumCircuit::new(3);
    qc.h(0).cnot(0, 1).cnot(1, 2);

    let result = qc.simulate_with_shots(1024).unwrap();
    println!("{:?}", result.measurements.unwrap().sorted());
    // [("000", 517), ("111", 507)]
}

Python

import simq

builder = simq.CircuitBuilder(2)
builder.h(0)
builder.cx(0, 1)
circuit = builder.build()

simulator = simq.Simulator(simq.SimulatorConfig(shots=1024))
result = simulator.run(circuit)
print(result.state_vector)

Benchmarks

Every number below comes from a cross-validated suite: SimQ’s output is checked against Qiskit (to 1e-12), qsim (to 5e-6), and qulacs (to 1e-12) on identical circuits before any timing is trusted. Full methodology, all 20 workloads, and the one documented loss are in BENCHMARKS.md; ./benchmarks/run.sh reproduces it.

Scroll to see the full chart →

4–16 qubits, VQE / QAOA / GHZ sampling. SimQ beats Qiskit Aer on 19 of 20 workloads in the full suite (1.5–72.6×) and exact Statevector on all 20 (2.7–2534×). The strongest competitor found is qulacs; SimQ still leads it on every covered workload, by 1.0–1.9×.

Scroll to see the full chart →

Same machine, pushed to the edge: 20–30 qubits. SimQ still leads at 28 qubits (4 GiB state), and every simulator hits the same wall at 30: a dense statevector needs 16 GiB, more than the 15 GiB reference box has. That’s physics, not a bug: SimQ fails cleanly with a clear error instead of aborting.

This isn’t cherry-picked: the suite also loses one workload (deep QFT at 16 qubits, where the gate structure is long-range and SimQ’s fusion pass is local), and BENCHMARKS.md documents that loss and why it happens, not just the wins.

Why SimQ?

Measured performance

Beats Qiskit Aer on 19 of 20 benchmarked workloads and qulacs (the strongest competitor found) on all 12 it covers. See Benchmarks above.

Type-safe by construction

Compile-time verification of quantum operations. Invalid circuits are caught before they ever run, often before they even compile.

Memory-aware, not just memory-efficient

Hybrid sparse/dense state representation; Simulator::run derives its qubit cap from available memory and refuses an oversized circuit cleanly. Measured: 29 qubits on 15 GiB of RAM.

Built for variational algorithms

Exact expectation values, automatic gradients, and ready-made VQE/QAOA helpers and optimizers.

Hardware ready

The same circuit runs on the local simulator or real quantum hardware via the backend abstraction (IBM Quantum and more).

First-class Python bindings

A familiar, Qiskit-like Python API backed by the full-speed Rust core, including noise models and visualization.

Explore the documentation

Getting started

Install SimQ and run your first circuit in Rust or Python in under five minutes.

Installation

User guide

Circuits, simulation, observables, VQE/QAOA, the compiler, noise models, and hardware backends.

Building circuits

Examples

Runnable, end-to-end examples: Bell states, teleportation, H₂ ground-state VQE, MaxCut QAOA, and more.

Examples

Architecture

How the eight workspace crates fit together, for contributors and the curious.

Architecture

Contributing

Development setup, coding standards, testing, and how to send your first pull request.

Contributing to SimQ

API reference

Rust API docs (rustdoc) and the Python binding reference.

Rust API reference