Choosing a quantum simulator is less about finding a single “best” tool and more about matching a simulation method to the workload. This guide shows how to compare statevector, shot-based, noisy, tensor-network, and GPU-accelerated approaches; estimate memory, runtime, and cost; and create a repeatable benchmark your team can reuse as circuits, SDKs, and infrastructure change.
Overview
A quantum simulator reproduces some part of a quantum circuit on classical hardware. That makes it useful for circuit development, debugging, algorithm experiments, regression testing, and preparing jobs for a real quantum processing unit (QPU). However, simulators do not all solve the same problem. A statevector simulator, for example, is designed to represent the full quantum state, while a tensor-network simulator may exploit structural properties in a circuit. A noisy simulator adds modeled errors, and a shot-based workflow estimates measurement results by executing a circuit repeatedly.
The right choice depends on five questions:
- Do you need exact amplitudes or only measurement samples?
- Will the circuit include noise, mid-circuit measurements, or device-specific behavior?
- Is the circuit dense and highly entangled, or does it have exploitable structure?
- Do you have access to sufficient CPU memory, GPUs, or cloud compute?
- Are you optimizing for local development, reproducibility, throughput, or cost?
Common simulator families can be compared as follows:
| Simulator approach | Best fit | Primary constraint | Noise support | Acceleration and API considerations |
|---|---|---|---|---|
| Statevector | Small-to-medium pure-state circuits, amplitude inspection, algorithm debugging | Memory grows exponentially with qubit count | Usually possible through configured noise or trajectory methods, depending on the implementation | Often available through major SDKs; CPU and GPU options vary by package and release |
| Shot-based or sampled | Measurement distributions, application prototypes, realistic execution loops | Statistical error and repeated circuit execution | Often supported through a noise model or sampled channel | Easy to integrate into SDK workflows; runtime depends on shots, circuit depth, and parallelism |
| Tensor network | Structured circuits with limited entanglement or favorable connectivity | Performance can decline sharply when entanglement or tensor dimensions grow | Support varies; check the selected method rather than assuming it | May scale differently from statevector simulation; configuration is often more specialized |
| Stabilizer or Clifford-oriented | Circuits dominated by operations that have efficient classical representations | Non-Clifford gates can reduce the advantage | Some restricted noise models may be available | Useful for fast tests, but not a universal replacement for general simulation |
| GPU-accelerated | Large batches, repeated shots, or workloads suited to parallel numerical computation | GPU memory, data movement, and hardware availability | Depends on the underlying simulation method | Can reduce runtime for compatible workloads, but installation and reproducibility require extra care |
This table is a starting framework, not a permanent ranking. A release may add a method, change a supported gate set, alter memory behavior, or introduce a different licensing or cloud-pricing model. Record the exact package version, backend, hardware, and configuration in every benchmark.
How to estimate
Start by describing the workload rather than naming a simulator. Record the circuit width, depth, gate mix, entanglement pattern, number of shots, noise model, and number of circuits. Then estimate the resources for the simplest method that can answer the question.
1. Estimate statevector memory
A full statevector for n qubits contains 2n complex amplitudes. If each complex amplitude uses b bytes, the raw state memory is:
Raw memory ≈ 2n × b
This is only a lower-bound estimate. The process may require additional workspace for temporary buffers, multiple states, measurement handling, gradients, or parallel execution. Leave an operational margin instead of allocating exactly the raw number. If an algorithm evaluates many parameter settings simultaneously, multiply the estimate by the number of concurrent states or batches.
2. Estimate shot-based work
For sampled execution, a simple workload estimate is:
Total circuit evaluations = number of circuits × shots per circuit × repetitions
Use this value to compare throughput. A noisy simulation may perform additional internal work for each shot, especially when it uses trajectories or applies channels gate by gate. Runtime should therefore be measured rather than inferred from shot count alone.
3. Estimate cloud cost without assuming a fixed price
When a simulator runs in the cloud, separate the billable components:
Estimated cost = compute time × rate + storage + data transfer + other provider-specific charges
Use the current provider documentation or billing console for rates. Keep the calculation in a spreadsheet with fields for region, machine type, runtime, parallel workers, storage duration, and any minimum billing unit. This makes the estimate easy to update when pricing inputs change. A local benchmark can also reveal whether a more expensive GPU instance actually reduces total cost for your workload.
4. Measure outcome quality
Performance is not only elapsed time. Track whether the simulator produces the information your algorithm needs. Useful measures include distribution distance between runs, expectation-value error, fidelity where appropriate, gradient stability, compilation overhead, and reproducibility across repeated executions. A fast backend that cannot represent the required noise model may be less useful than a slower, faithful one.
Inputs and assumptions
A fair quantum simulator comparison needs controlled inputs. Use the same circuit source, transpilation or compilation policy, shot count, precision, random seed policy, and measurement format when comparing tools. If the tools use different compilation paths, report that difference instead of presenting the results as a pure simulator benchmark.
Capture these fields in a benchmark file:
- Software: SDK name, simulator package, version, operating system, language runtime, and optional plugins.
- Hardware: CPU model, core count, RAM, GPU model, GPU memory, driver, and execution environment.
- Circuit: qubit count, depth before and after compilation, gate counts, connectivity, parameters, and entanglement pattern.
- Execution: statevector or sampling mode, shots, repetitions, batch size, precision, noise channels, and random seeds.
- Operational data: queue time, startup time, compilation time, execution time, peak memory, failures, and total billable duration.
- Validation: expected result, tolerance, comparison method, and whether results were cross-checked with another backend.
Memory requirements are especially easy to underestimate. A circuit that fits in theory may fail because the operating system, SDK, simulator, and temporary arrays also need memory. For GPU runs, confirm that the complete working set fits on the selected device; a GPU with insufficient memory may fall back to slower behavior or fail rather than scale gracefully.
Reproducibility also needs an explicit assumption. Fix seeds where the simulator permits it, but do not treat a seed as a substitute for recording the noise model and software environment. For stochastic simulations, run enough repeated trials to distinguish ordinary variation from a meaningful performance difference.
Worked examples
Example 1: Debugging a parameterized circuit
Suppose a developer is checking whether a parameterized circuit produces the expected amplitudes before adding noise. The priority is inspectability, deterministic debugging, and fast iteration. A statevector simulator is a reasonable first candidate if the circuit fits comfortably in available memory. The benchmark should compare initialization time, execution time, peak memory, and the time required to evaluate one parameter setting and a small batch of settings.
If the circuit approaches the local memory limit, do not simply increase the machine size without measuring. Test a smaller circuit, a reduced precision mode if the algorithm permits it, or a structured method such as tensor-network simulation. Validate that the alternative returns the same observable quantities within the chosen tolerance.
Example 2: Comparing noise models
Now consider an error-mitigation experiment that requires repeated measurements under a defined noise model. The relevant unit is not “one circuit run” but total sampled evaluations. Use the same noise channels, gate ordering, shots, and random-seed policy across candidate backends. Report both runtime and the difference between the simulated distribution and the expected reference distribution, if one is available.
A method that finishes quickly with an oversimplified noise model should not be compared directly with a slower method that represents the required channels. Label the model fidelity and treat it as a selection criterion alongside speed.
Example 3: Choosing local CPU or GPU execution
Assume a team runs many related circuits for a variational algorithm. It tests a CPU backend and a GPU-capable backend using identical circuit batches. Record one-time setup separately from steady-state execution. Calculate:
Cost per useful result = total execution cost ÷ validated results produced
“Useful result” should mean a completed run that passes validation, not merely a submitted job. A GPU may be preferable when the workload is sufficiently parallel and fits in device memory. A CPU may remain preferable for small circuits, interactive development, or environments where GPU setup and transfer overhead dominate. The benchmark, rather than a general hardware assumption, should decide.
Reusable results template
For each candidate, record: backend and version; circuit name; qubits; depth; gate count; shots; noise model; hardware; compilation time; execution time; peak RAM or GPU memory; validation error; failures; estimated cost; and notes on reproducibility. Add a decision column such as “development,” “regression,” “large batch,” or “not suitable.” This turns a one-time test into an infrastructure record.
When to recalculate
Revisit the benchmark whenever a decision input changes. The most important triggers are a simulator or SDK release, a new compilation target, a change in circuit width or depth, a new noise model, a different CPU or GPU, a move from local execution to a cloud platform, or a change in provider pricing. Recalculate when shot counts, batch sizes, precision, or parallel workers change as well.
For a team project, keep a small benchmark suite under version control. Include a smoke test for every commit, a representative workload for routine comparisons, and a larger workload for capacity planning. Run the suite in the same environment used by production or research jobs, and preserve the raw results rather than only publishing a final score.
Before selecting a simulator, complete this checklist:
- Define the observable, distribution, or debugging result you need.
- Classify the workload as statevector, sampled, noisy, structured, or highly parallel.
- Estimate memory and total circuit evaluations before choosing hardware.
- Run identical, validated circuits on at least two plausible backends when practical.
- Compare accuracy, peak memory, setup time, throughput, reproducibility, and cost.
- Record versions, assumptions, and pricing inputs so the decision can be repeated.
Use this process alongside a broader quantum cloud platform comparison when provider access matters, and review simulator-versus-QPU testing guidance before moving a validated circuit to hardware. A disciplined benchmark will not predict every future workload, but it will make simulator choices explainable, measurable, and easier to update.