Simulate 1,000-qubit quantum circuits on classical hardware. Exact results. No GPU. No quantum hardware required.

Qumulator is a cloud API — and this is its Python client — for simulating quantum circuits, spin systems, photonic amplitudes, and molecular properties on standard classical hardware. It does not require a quantum computer, a GPU, or any special hardware. It runs in the cloud (Google Cloud Run, 4 vCPU, 16 GB RAM) and returns results over HTTP.

The key numbers: a 1,000-qubit circuit at depth 3 runs in under 1 second using 1 MB of memory — where the equivalent statevector would require $2^{1000}$ bytes (more atoms than exist in the observable universe). A 105-qubit Willow-layout circuit at depth 5 completes in under 0.5 s. Results are exact within the stated truncation error, not statistical estimates.

The simulation engine is built on the KLT Engine, a proprietary classical simulation framework that routes each problem to the most efficient representation — tensor network, cluster-exact, Gaussian covariance matrix, nexus graph, or full statevector — based on the entanglement structure of the specific circuit. Callers select a mode with a single parameter; the engine handles routing automatically.

Measured on a standard cloud CPU (4 vCPU, no GPU). "Exact" means output agrees with full statevector simulation to double-precision floating point (< 10⁻¹⁴ L² error on the amplitude vector).

Bond dimension $\chi = 2^\text{depth}$; all tiers keep peak memory under 400 MB.

Depth is counted in entangling layers only — single-qubit gates (H, Rz, T, etc.) do not count toward the depth limit and are not restricted. Requests exceeding the tier depth limit return HTTP 422 with a self-documenting error message.

Statevector mode: max 20 qubits at any depth.

pip install qumulator-sdk

Optional extras:

pip install "qumulator-sdk[qiskit]"   # Qiskit drop-in backend
pip install "qumulator-sdk[cirq]"     # Cirq drop-in simulator
pip install "qumulator-sdk[all]"      # everything

Mac / Linux

curl -s -X POST https://api.qumulator.com/keys \
     -H "Content-Type: application/json" \
     -d '{"name": "my-key"}'

Windows (PowerShell)

Invoke-WebRequest `
  -Uri "https://api.qumulator.com/keys" `
  -Method POST `
  -ContentType "application/json" `
  -Body '{"name":"my-key"}' `
  -UseBasicParsing

Or via the CLI (after install):

import os
from qumulator import QumulatorClient

client = QumulatorClient(
    api_url="https://api.qumulator.com",
    api_key=os.environ["QUMULATOR_API_KEY"],
)

# 500 parallel Bell pairs across 1,000 qubits (depth 1)
eng = client.circuit.engine(n_qubits=1000)
for i in range(0, 1000, 2):
    eng.apply("h", i)           # Hadamard on even qubits (parallel)
for i in range(0, 1000, 2):
    eng.apply("cx", [i, i + 1]) # entangle each pair (parallel)

result = eng.sample(shots=10)
print(result.counts)       # e.g. {'0101100110...': 1, '1010011001...': 1, ...}
print(result.most_probable)
# Exact result. No quantum hardware. No GPU. Standard cloud CPU.

Run the built-in demo against the live API:

qumulator demo           # 1000-qubit GHZ
qumulator demo --willow  # 105-qubit Willow-layout RCS

result = client.circuit.run_qasm("""
OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
creg c[2];
h q[0];
cx q[0], q[1];
measure q -> c;
""", shots=1024)

print(result.counts)       # {'00': ~512, '11': ~512}
print(result.entropy_map)  # [0.999, 0.999] — entanglement per qubit

from qumulator.backends.qiskit_backend import QumulatorBackend
from qiskit import transpile

backend = QumulatorBackend(client)               # replaces AerSimulator()
job     = backend.run(transpile(qc, backend), shots=1024)
counts  = job.result().get_counts()

Everything else in your Qiskit workflow is unchanged.

from qumulator.backends.cirq_simulator import QumulatorSimulator

sim    = QumulatorSimulator(client)              # replaces cirq.Simulator()
result = sim.run(circuit, repetitions=1024)

Pass mode= to any run() call. The server selects auto by default.

# Molecular HOMO/LUMO frontier orbital energies (SMILES input)
homo = client.homo.run("Oc1ccc(/C=C/c2cc(O)cc(O)c2)cc1")
print(homo.homo_E_eV, homo.lumo_E_eV, homo.gap_eV)

# Ground-state energy of a spin Hamiltonian (Ising / Heisenberg / general)
import numpy as np
J = np.random.randn(8, 8); J = (J + J.T) / 2
result = client.klt.run(J.tolist())
print(result.energy)

# Hafnian / GBS photonic amplitude
A = np.random.randn(8, 8); A = (A + A.T) / 2
h = client.hafnian.run(A.tolist())
print(h.value)

Paid plans start at $99/month (10,000 CU). See qumulator.com/#pricing.

Click to open in Google Colab — no install required, just add your API key:

qumulator demo               # 1000-qubit GHZ demo vs. the public API
qumulator demo --willow      # 105-qubit Willow-layout benchmark
qumulator demo --wormhole    # holographic wormhole
qumulator demo --anyon       # anyon braiding
qumulator key                # instructions to get a free API key
qumulator run circuit.qasm   # submit a QASM file and print the result