Zero Kelvin Simulation Foundry
Quantum Computing as a Service
Rent real quantum hardware
22 engines · 6 quantum processors
Quantum hardware and acceleration
- Neutral atom
- QuEraAquila · 256 qubits
- Superconducting
- RigettiCepheus-1 · 108 qubitsIQMEmerald, Garnet · 54 qubits
- Trapped ion
- IonQForte Enterprise 1 · 36 qubitsAQTIBEX Q1 · 12 qubits
- GPU
- NVIDIA141 GB GPUs · 32 qubits
- TPU
- GoogleTPU v5e, v6e · 40 spins
The numbers you are looking for
What quantum computing can and cannot do for you:
The numbers you are looking for
Artificial intelligence
QGAN and synthetic data
Adversarial generation against a discriminator that is learning at the same time
More in this industryscroll →
QuandelaQPU
qpu.quandela.belenos · 3 modes
2,686 coincidences in 100,000 attempts, 97.4% of them on the four target outcomes
$0.4584billed for this runRead more →
IQMQPU
qpu.iqm.garnet · 2 qubits
TVD 0.240 for the converged generator at 1,000 shots
$1.7500billed for this runRead more →
Quantum computing is still at the “is this real for my problem, or am I being sold a story?” stage. This is how you get to “I can test this myself this week”.
Live Lab Orbit
Foundry health checks at work
For institutions and individuals
Rent real quantum hardware, or dry-run the same circuit on TPU, GPU and CPU simulators first. Every result is certified and every job is priced before it runs
Python SDK
Three lines from a circuit to a certified result, and every engine is reachable from code: gate circuits, pulse sequences, linear optics and parameter sweeps driven by your own optimiser.
import qsim_sdk client = qsim_sdk.Client(token="...") result = client.run(your_circuit)
PennyLane
Name a different device. A parameter sweep goes in one request, because PennyLane hands the device a batch of circuits whenever it broadcasts. Gate circuits.
import pennylane as qml
dev = qml.device("zksf.simulator", wires=3, shots=1024)
dev.error_info() # the accuracy statement for that run
PyTorch
A parameterised quantum program as a differentiable layer, trained by the same optimiser as the rest of your model. Forward is one job; backward is one job carrying two points per parameter, batched as a single sweep.
from qsim_sdk.ml import PhotonicLayer layer = PhotonicLayer(client, circuit, [1, 0, 1]) loss = criterion(layer(), target); loss.backward()
Web console
No install and no code. Choose from 22 engines or start with six pre-built templates with live circuit diagrams baked in. Top up your balance from as low as $20. Your first real circuit is a couple of clicks away.
Android app
The first mobile app to run circuits on real quantum hardware, with six QPUs from five manufacturers and all 22 engines in your pocket. Download and share certificates for completed runs. One login with the web console, so jobs and history stay in sync.
Quantum computing pricing, from $0.0001
Published rates, or agreed terms. Either way, pay only for the seconds your jobs actually run
Solo or small teams
Sign up, top up, run
- CPU Simulation
- from $0.0001
- GPU, 24 GB
- $3
- GPU, 96 or 141 GB
- $8
- TPU Simulation
- $1.85
- QPU (6 devices)
- from $0.30
for circuits <1s · then metered $0.69 per CPU hour
Error correction at $0.69/hr optional
per GPU-hour, per-second billing · to 30 qubits
per GPU-hour, per-second billing · 31 to 32 qubits
$0.25 for the first 480s, then $1.85 per hour
per chip-hour on v5e or v6e, per-second billing
per submission · provider list price, no markup
Academic
Universities, schools and students
- Discounted CPU and GPU rates
- Priority same-day support
- 2FA sign-in
- Private certificates per job
- Instructor view of student consoles
- Shareable job links
- Dedicated CPU clusters
- Dedicated TPU clusters
- Priority 96 GB GPU clusters
- Priority 141 GB GPU clusters
Scoped per engagement
Talk to usEnterprise
Teams buying centrally
- Bulk rates
- Dedicated relationship manager
- 2FA sign-in
- Private certificates per job
- Admin view across team accounts
- Shareable job links
- Dedicated CPU clusters
- Dedicated v6e TPU clusters
- No queue 96 GB GPU clusters
- No queue 141 GB GPU clusters
- Team accounts with SSO
- Sovereign or on-prem deployment
Scoped per engagement
Contact salesEvery plan includes
- Free estimate before you run
- Certified bound on every result
- Billed by the second
- 24 / 7 email support
ZCC-v0.1 | ZHF-v0.1 | ZQEC-v0.1 Certified
Certified Quantum Computing
Every result carries a measured bound. ZCC-v0.1 reports the error a simulation actually discarded, ZHF-v0.1 the Hellinger fidelity of a hardware run against its exact reference, and ZQEC-v0.1 a logical error rate with its 95% interval
Every result carries a certificate with a public URL. Try it on the App
ZCC-v0.1View →
1.94e-07
Error bound on every outcome probability
mps.quimb.cpu
- Certificate
- Simulation Accuracy
- Discarded weight
- 1.89e-14
- Max bond dimension
- 64
- Shots
- 256
- Issued
- 4 September 2026
ZHF-v0.1View →
0.9666
Hellinger fidelity against the exact reference
qpu.quandela.belenos
- Certificate
- Hardware Fidelity
- Coincidence events
- 271 of 10,000
- Unconditioned fidelity
- 0.0262
- Photons sent
- 2
- Issued
- 7 September 2026
ZHF-v0.1View →
0.9774
Hellinger fidelity against the exact reference
qpu.ionq
- Certificate
- Hardware Fidelity
- Device
- Forte-1
- Modality
- Trapped ion
- Shots
- 100
- Issued
- 9 July 2026
ZQEC-v0.1View →
2.00e-04
Logical error rate, 95% CI [7.78e-05, 5.14e-04]
exact.cpu
- Certificate
- Logical Error Rate
- Logical failures
- 4 of 20,000
- Physical error rate
- 0.001
- Rounds
- 5
- Issued
- 20 September 2026
Every certificate has a permanent public URL that anyone can check, with no account.
One API. Four kinds of compute
CPU simulation
- Statevector29 qubits
- Clifford5,000+ qubits
- Tensor network, quimb100+ qubits
- Tensor network, Aer100+ qubits
- Pauli expectations100+ qubits
- Noisy simulationwith ZNE
- Analog pulser14 atoms
- Photonic SLOS12 modes
GPU simulation
- Statevector, 24 GB30 qubits
- Statevector, 96/141 GB32 qubits
- Photonic24 modes
- Analog pulser20 atoms
- Neural40 spins
- Auto-routedby qubit count
TPU simulation
- Statevector29 qubits
- Neural40 spins
- Google TPUv5e or v6e
- Sweeps on one chip
- Variance-bounded
- Unmixed chains refused
Real quantum hardware
- QuEra Aquila256 qubits
- Rigetti Cepheus-1108 qubits
- IQM Emerald54 qubits
- IQM Garnet20 qubits
- IonQ Forte Enterprise 136 qubits
- AQT IBEX Q112 qubits
Sample test runs: QPU, TPU, GPU, CPU
The same GHZ circuit on real quantum hardware and on our CPU and GPU simulators. The two machines that take no gates, one photonic and one neutral-atom, carry a certified fidelity against our own exact simulation instead
Quantum hardware, the same GHZ on every gate machine
| Device | Width | Shots in the expected states | Turnaround |
|---|---|---|---|
| Rigetti Cepheus-1-108Qsuperconducting | 3 qubits | 45 / 5090%5 shots device noise | ~53 min |
| IQM Garnetsuperconducting | 3 qubits | 48 / 5096%2 shots device noise | ~25 s |
| IQM Emeraldsuperconducting | 3 qubits | 48 / 5096%2 shots device noise | ~60 min |
| IonQ Forte Enterprise 1trapped ion | 3 qubits | 95 / 10095%5 shots device noise certificate | ~5 min |
| AQT IBEX Q1trapped ion | 3 qubits | 20 / 20100%0 shots device noise | ~80 min |
| Quandela Belenosphotonic | 3 modes, 2 photons | 230 / 24195%two-photon detections in the two bunched states | 42.5 s |
| QuEra Aquilaneutral atom | 4 atoms | 0.6294ZHF fidelity certificate | ~2 h in window |
TPU neural simulation
| Hamiltonian | Device | Result | Wall time |
|---|---|---|---|
| Transverse-field Ising ring, 8 spins | TPU v5e | ceiling -10.2499758, above the exact ground state -10.2516623 certificate | 60.4 s |
GPU simulation
| Circuit | Width | Result | Wall time |
|---|---|---|---|
| GHZ, 1,000 shots | 8 qubits | 502 / 498 across the two GHZ states, ideal 500 / 500 | 0.5 s |
| GHZ, 100 shots (exact statevector) | 32 qubits | 54 / 46 across the two GHZ states, ideal 50 / 50; 64 GiB statevector certificate | 8.2 s |
CPU simulation
| Circuit | Width | Accuracy | Wall time |
|---|---|---|---|
| GHZ (Clifford) | 5,000 qubits | exact | 0.56 s |
| GHZ (MPS, tensor network) | 2,000 qubits | converged, error bound 2.1e-8 | 873 s |
| QAOA ring, p=1 (non-Clifford rotations) | 1,000 qubits | converged, error bound 3.2e-7 | 312 s |
| Transverse-field Ising, Trotter p=4 | 1,000 qubits | error bound 2.5e-5 | 203 s |
| QAOA MaxCut, p=3, depth 304 | 100 qubits | converged, deviation 0.0 | 5.9 s |
| GHZ, Pauli propagation, all-Z observable | 192 qubits | expectation 1.000, error bound 0.00 certificate | < 1 min |
Turnaround is the provider’s queue, not our latency, and is not billed. Counts are raw; error mitigation is opt-in. See live status and the docs.
ZKSF QCaaS features
What it costs, what it runs, and what every job gets back: an error estimate, a price before you run, and a certificate you can cite
- Error estimate on every resultEvery approximate run reports its own convergence error
- Citable accuracy certificatesZCC-v0.1, ZHF-v0.1 and ZQEC-v0.1, downloadable with any job
- The auto-router reads your circuitInspects structure and picks the most appropriate engine
- Free estimate before you runPrice and feasibility, instantly, on every job
- Jobs from $0.0001Prepaid credit. No subscription and no seat licence
- Billed by the second, as it runsNothing taken up front. Jobs stop when your balance reaches $0.05
- Clear rejectionsIf we cannot run it, we say why and what to change
- Clifford circuits beyond 1,000 qubitsStabiliser simulation at scale, included
- Structured circuits at 100+ qubitsTensor networks, with an accuracy statement attached
- Expectation values to 200 qubitsPauli propagation for observables on wide circuits
- Device-noise previewModel the hardware before you pay for it
- Error mitigation with a stated uncertaintyZNE and ZCC-Estimate-v0.2, on simulators and hardware
- One API, many frameworksQiskit, Cirq, PennyLane and more, same endpoint
- Real quantum hardwareSix processors, five manufacturers, three modalities
- Nine industries, benchmarkedAI, Finance, Chemicals, Logistics, Space, and more
- Eight AI cases, four on QPUsGANs, QML, NNQS and more
- Provider list price on QPUsYou pay the hardware vendor's published rate
- Sub-second small jobsSmall circuits come back in under a second
- Quantum programs as trainable layersA parameterised circuit as a torch nn.Module, gradients included
- QPU, TPU, GPU and CPU under one roofFour kinds of compute, one API, all certified
- Ground states, not only circuitsNeural network quantum states, bounded by their own variance
- Error correction you can measurePhysical qubits per logical qubit, at your own error rate
Run our open benchmark suite to verify any of these figures independently
Frequently asked questions
The essentials. For engine internals, API reference, and worked examples, see the documentation
Who can use the ZKSF Lab?
- Effectively anyone with a reason to run a quantum circuit
- Academic and industrial researchers use it for everyday simulation and hardware access; organisations preparing for post-quantum cryptography use it to study the algorithms behind that transition; and students, educators, and independent enthusiasts use it to build a working understanding of the physics
- No institutional affiliation or specialised infrastructure is required
I am a beginner to quantum computing. Where do I start?
- Start with the six built-in circuit templates in the console: GHZ entanglement, Grover search, QAOA optimization, VQE chemistry, Bernstein-Vazirani, and quantum teleportation
- Each loads in a single click with the right engine already chosen and a live circuit diagram, so you can run a real quantum circuit without writing any code
- The documentation explains how to use each one, and every template has a full walkthrough in Research
What is quantum computing (and what is a QPU)?
- Quantum computing uses the physics of tiny particles, superposition and entanglement, to process information in ways an ordinary computer cannot
- A QPU (quantum processing unit) is the actual quantum chip that does this, the quantum world's counterpart to a CPU or GPU
- Most quantum work today is written and tested in simulation first, then run on a real QPU when the physics calls for it, which is exactly the workflow ZKSF gives you
What is ZKSF?
- ZKSF (Zero Kelvin Simulation Foundry) is Quantum Computing as a Service
- It runs each job on the cheapest compute suited to it: CPU, GPU and TPU simulators, or real quantum hardware from Rigetti, IQM, IonQ, AQT and QuEra
- Every approximate result carries a certified error estimate
Can I train a model with this?
- Yes. Install the ml extra (
pip install "qsim-sdk[ml]") and a parameterised quantum program becomes a differentiable PyTorch layer, trained by the same optimiser as the rest of your model - A forward pass is one job; a backward pass is one job carrying two points per parameter, batched into a single sweep rather than submitted separately
- The layers cover photonic programs and analog pulse sequences; for gate circuits the same training loop runs through parameterised sweeps, one program and N bindings in a single job
Does quantum machine learning actually work yet?
- Partly, and it is worth being precise about which part. The tooling works
- You can train a parameterised quantum program today and get gradients
- The advantage does not. A quantum feature map does not generally beat a classical baseline on real data, published quantum generative models work at 28 by 28 greyscale benchmark scale, and variational circuits run into barren plateaus where gradients vanish as the circuit widens
- Anyone claiming otherwise should be asked what they produced, at what size, measured how. Train the classical model alongside and report the gap
Do I need a real quantum computer?
That is your call, and both paths are here. Many research circuits (QAOA, ansatze, Clifford codes, bounded-entanglement dynamics) simulate accurately; when you want hardware, six processors are available: QuEra Aquila (256 neutral-atom qubits), analog; Rigetti Cepheus (108 superconducting qubits), IQM Emerald (54) and IQM Garnet (20), IonQ Forte Enterprise 1 (36 trapped-ion) and AQT IBEX Q1 (12 trapped-ion)
What kinds of quantum computer can I run on?
- Three hardware modalities and three program kinds. Superconducting and trapped-ion QPUs take ordinary gate circuits. A photonic program is a linear-optics circuit plus an input photon state, and runs on our photonic simulators
- The third kind is analog neutral-atom sequences, where you write a register of atoms and a pulse schedule instead of a circuit; those run on QuEra Aquila, and on an exact local simulator that provides the reference a hardware run is certified against
- Twenty-two engines in total, one API, and the same accuracy statement on every result. The documentation covers each kind
Do you also support TPU runs?
- Yes, two engines on Google TPUs. exact.tpu runs ordinary gate circuits to 29 qubits
- neural.tpu runs neural network quantum states, which take a Hamiltonian rather than a circuit and go through POST /solve
- TPU time is $0.25 per task for the first 480 seconds, then $1.85 per chip-hour, billed by the second. The docs cover both
How many qubits can you simulate?
- It depends on the circuit, not a single number. Exact statevector reaches 29 qubits on CPU, 32 on the GPU tier and 29 on a Google TPU; Clifford circuits run to 5,000+ qubits; low-entanglement structured circuits go past 100 qubits with tensor-network MPS; and Pauli propagation returns expectation values from 100 to 200 qubits
- The router picks the method that fits; the docs explain how it decides
How do I know the results are accurate?
- Every approximate result carries an accuracy statement. The default is a convergence check
- The circuit is re-run at a higher resource budget and the shift in the answer is reported, where zero movement is evidence the approximation has saturated
- The certified path instead returns a bound measured within the single run
- Either way the statement can be exported as a public certificate and checked by anyone using zcc-verify , an open-source tool that recomputes the declared bound from the reported measurement and needs no account
- That establishes the certificate is self-consistent; it does not by itself establish that the measurement was honestly made. The methodology is detailed in the docs
What are ZCC-v0.1, ZHF-v0.1 and ZQEC-v0.1 certificates?
- ZCC-v0.1 states the accuracy of an approximate simulation. The default level is a convergence check: the circuit is re-run at a higher bond dimension and the shift in the leading outcomes is reported. The certified level returns a bound measured inside the single run, read from the weight the simulation actually discarded
- ZHF-v0.1 states the fidelity of a run on real quantum hardware. Where the circuit is small enough to also simulate exactly, the measured counts are compared against that exact distribution and the Hellinger fidelity is reported, rather than a self-reported device specification
- ZQEC-v0.1 states the logical error rate of an error correction run, with a 95% confidence interval. The interval is the claim: a rate measured from a finite number of shots reads exactly zero when nothing failed, and no finite experiment establishes that a code never fails
- Every finished job can be exported as a public certificate under whichever protocol applies, checkable by anyone with no account. The full specification is on the certification page
Error mitigation with a ZCC-Estimate?
- Yes, as an opt-in. Enabling zero-noise error mitigation runs your circuit at several amplified noise levels and extrapolates the chosen observable back to the zero-noise limit, on the simulator or on real hardware, where it submits three runs and so bills three times
- The result is a mitigated value reported with a ZCC-Estimate-v0.2 uncertainty, a statistical estimate stated as such rather than the measured bound of the certified simulation paths
- Most providers return a mitigated number with no error statement at all. The methodology is in the certification page
How does billing work?
- Pure pay-per-use: no subscriptions, no minimum spend. Simulations are billed by the second as they run, and nothing is taken up front. CPU is $0.0001 per circuit for circuits under one second, then $0.69 per CPU hour; GPU $3/GPU-hour to 30 qubits and $8/GPU-hour for 31 to 32 qubits (the larger card costs more to run); TPU $0.25 per task for the first 480 seconds, then $1.85 per chip-hour; and quantum hardware at provider list price, $0.30 per task plus a per-shot fee that varies by device (Rigetti $0.000425, IQM Garnet $0.00145, IQM Emerald $0.0016, QuEra Aquila $0.01, AQT $0.0235, IonQ $0.08)
- Every job shows a cost estimate before it runs, at no charge, and the cost calculator prices a run without an account
Can I use my existing Qiskit circuits?
- Yes. The SDK accepts Qiskit circuits directly:
client.run(your_qiskit_circuit); install withpip install qsim-sdkand see the quickstart - Or keep your code and switch backends with the Qiskit provider; PennyLane code runs through the PennyLane device
Can I run VQE or QAOA without thousands of requests?
- Yes. Those are parameter sweeps, and gradient methods need two circuit evaluations per parameter per step, so a 20-parameter, 50-step run sent one job at a time is 2,000 submissions.
client.run_sweep(circuit, bindings)sends them in one request, roughly an order of magnitude faster - A binding that turns out too entangled to simulate comes back marked and unbilled rather than failing the whole sweep, so your optimizer treats it as a bad point and carries on. Check the docs for parameter sweeps
Is there a mobile app?
- Yes. The ZKSF Android app is the first mobile app to run circuits on real quantum hardware. From your phone it reaches six quantum processors from five manufacturers and every other engine here, NVIDIA GPUs, Google TPUs and CPUs included. Write or upload a circuit, pick an engine and read the certified result on the go
- It uses the same login as the web app, so your jobs and history stay in sync across both. Get it on Google Play. iOS coming soon
What if my circuit is too hard to simulate?
We reject it instead of burning your budget on a wrong answer. The rejection comes with a diagnostic explaining why, and what would work: a different formulation, a smaller instance, or real hardware
When can I run on real quantum hardware?
- Right now. Sign in and choose a device:
qpu.rigetti,qpu.iqm.emeraldorqpu.iqm.garnetfor superconducting,qpu.ionqorqpu.aqt.ibexfor trapped ion, andqpu.quera.aquilafor neutral atom - The neutral-atom machine takes an analog pulse sequence rather than a gate circuit. Your program runs on the real device
Can I compute up to 200 qubits?
- For expectation values, yes. Select the
pauli.cpuengine and pass the observable you want to measure as a list of Pauli terms, then callclient.run(circuit, engine="pauli.cpu", observable=[[1.0, "Z"*192]]) - Instead of tracking the full state, it propagates the observable back through the circuit in the Heisenberg picture, so cost scales with circuit structure rather than qubit count and reaches well past 100 qubits where a statevector runs out of memory
- You get the expectation value plus the total discarded weight as a truncation-error statement
- This returns expectation values, not bitstring samples, which is exactly what variational and energy-estimation workloads need