FreeQuantum
Home/Simulators

Free Quantum Simulators

Run quantum circuits on powerful simulators — locally on your machine or in the cloud. All options below are completely free.

All FreeLocal & CloudGPU Accelerated (some)
⬛

Qiskit Aer

FreeLocalUp to 30+ qubits

IBM's high-performance quantum circuit simulator. Aer includes multiple simulation methods: statevector, stabilizer, density matrix, MPS, and extended stabilizer. GPU acceleration available via AerCuda.

Max qubits
30+ (statevector)
Backend
CPU / GPU
Cost
Free
Platform
Local
bash
pip install qiskit-aer        # CPU
pip install qiskit-aer-gpu    # GPU (CUDA)
python
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])

sim = AerSimulator()
job = sim.run(qc, shots=1000)
result = job.result()
print(result.get_counts())  # {'00': 501, '11': 499}
Open Platform SDK Guide
☁️

IBM Quantum (Cloud Simulators)

FreeCloudUp to 5000 qubits

IBM Quantum Platform provides free cloud-hosted simulators. The ibmq_qasm_simulator can simulate up to 32 qubits while the Statevector simulator handles large circuits. Register for a free IBM Quantum account.

Max qubits
5000 (MPS mode)
Backend
IBM Cloud
Cost
Free tier
Account
Required
bash
pip install qiskit
pip install qiskit-ibm-runtime
python
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import SamplerV2 as Sampler

# Free IBM Quantum account needed
service = QiskitRuntimeService(channel="ibm_quantum")
backend = service.least_busy(simulator=True)

sampler = Sampler(mode=backend)
job = sampler.run([qc])
result = job.result()
Open Platform SDK Guide
🔵

Google Cirq (Simulator)

FreeLocalState vector

Cirq's built-in Simulator provides exact statevector simulation and density matrix simulation locally. The cirq.Simulator and cirq.DensityMatrixSimulator are simple to use, and cirq.CliffordSimulator handles stabilizer circuits efficiently.

Max qubits
~25 (statevector)
Backend
CPU (NumPy)
Cost
Free
Platform
Local
bash
pip install cirq
python
import cirq

q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
    cirq.H(q0),
    cirq.CNOT(q0, q1),
    cirq.measure(q0, q1, key='result')
)

sim = cirq.Simulator()
result = sim.run(circuit, repetitions=1000)
print(result.histogram(key='result'))
Open Platform SDK Guide
🪙

PennyLane (default.qubit)

FreeLocalJAX/PyTorchDifferentiable

PennyLane's default.qubit is a pure NumPy simulator ideal for quantum ML research. Use lightning.qubit for C++ acceleration or lightning.gpu for NVIDIA GPU acceleration. All are free, local, and differentiable.

Max qubits
20+ (default.qubit)
Backend
NumPy / C++ / GPU
Cost
Free
Platform
Local
bash
pip install pennylane              # default.qubit
pip install pennylane-lightning     # lightning.qubit (C++)
pip install pennylane-lightning-gpu  # GPU
python
import pennylane as qml
import numpy as np

dev = qml.device("default.qubit", wires=2)
# For GPU: qml.device("lightning.gpu", wires=2)

@qml.qnode(dev)
def bell_state():
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])
    return qml.probs(wires=[0, 1])

print(bell_state())  # [0.5, 0., 0., 0.5]
Open Platform SDK Guide
🟢

NVIDIA CUDA-Q

FreeGPUCPUMulti-GPU

NVIDIA's open-source quantum computing platform. CUDA-Q provides GPU-accelerated simulation that can handle 30+ qubit circuits orders of magnitude faster than CPU simulators. Runs free locally on any NVIDIA GPU.

Max qubits
34+ (single GPU)
Backend
NVIDIA GPU
Cost
Free (open source)
Speedup
100-10000× vs CPU
bash
pip install cudaq  # Requires CUDA-capable GPU
# Or use Docker: nvcr.io/nvidia/nightly/cuda-quantum
python
import cudaq

@cudaq.kernel
def bell_state():
    qvec = cudaq.qvector(2)
    h(qvec[0])
    cx(qvec[0], qvec[1])
    mz(qvec)

counts = cudaq.sample(bell_state, shots_count=1000)
print(counts)  # { 00:507 11:493 }
Open Platform SDK Guide
🟠

Amazon Braket (Cloud Simulators)

FreeCloudSV1 / DM1 / TN1

AWS Braket offers three managed cloud simulators: SV1 (statevector, up to 34 qubits), DM1 (density matrix, up to 17 qubits), and TN1 (tensor network, up to 50 qubits). The local simulator is completely free; cloud simulators cost ~$0.075/task + compute.

SV1 max qubits
34
TN1 max qubits
50
Local sim
Free (unlimited)
Cloud sim
~$0.075/task
bash
pip install amazon-braket-sdk
python
from braket.circuits import Circuit
from braket.devices import LocalSimulator

# Completely free local simulator
device = LocalSimulator()

circuit = Circuit().h(0).cnot(0, 1)
task = device.run(circuit, shots=1000)
result = task.result()
print(result.measurement_counts)
Open Platform SDK Guide
💡

Use HLQuantum to target any simulator

Instead of learning each SDK's simulator API separately, use HLQuantum to write one circuit and switch between Qiskit Aer, Cirq, PennyLane, CUDA-Q and more with a single flag.

python
hlq.run(qc, backend="qiskit") # Qiskit Aer hlq.run(qc, backend="cirq") # Cirq simulator hlq.run(qc, backend="cudaq") # NVIDIA GPU sim hlq.run(qc, backend="pennylane") # Lightning.qubit
HLQuantum Guide