Startseite/Simulatoren

Kostenlose Quantensimulatoren

Führen Sie Quantenschaltkreise auf leistungsstarken Simulatoren aus — lokal auf Ihrem Rechner oder in der Cloud. Alle folgenden Optionen sind vollständig kostenlos.

Alles kostenlosLokal & CloudGPU-beschleunigt (teilweise)

⬛

Qiskit Aer

KostenlosLokalBis zu 30+ Qubits

Der Hochleistungs-Quantenschaltkreis-Simulator von IBM. Aer umfasst mehrere Simulationsmethoden: Statevector, Stabilizer, Dichtematrix, MPS und Extended Stabilizer. GPU-Beschleunigung ist über AerCuda verfügbar.

Max. Qubits

30+ (Statevector)

Backend

CPU / GPU

Kosten

Kostenlos

Plattform

Lokal

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}

Offene Plattform SDK-Leitfaden

☁️

IBM Quantum (Cloud-Simulatoren)

KostenlosCloudBis zu 5000 Qubits

Die IBM Quantum Platform stellt kostenlose, in der Cloud gehostete Simulatoren bereit. Der ibmq_qasm_simulator kann bis zu 32 Qubits simulieren, während der Statevector-Simulator große Schaltkreise bewältigt. Registrieren Sie sich für ein kostenloses IBM-Quantum-Konto.

Max. Qubits

5000 (MPS-Modus)

Backend

IBM Cloud

Kosten

Kostenlose Stufe

Konto

Erforderlich

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()

Offene Plattform SDK-Leitfaden

🔵

Google Cirq (Simulator)

KostenlosLokalStatevector

Der integrierte Simulator von Cirq bietet lokal exakte Statevector-Simulation und Dichtematrix-Simulation. cirq.Simulator und cirq.DensityMatrixSimulator sind einfach zu verwenden, und cirq.CliffordSimulator bearbeitet Stabilizer-Schaltkreise effizient.

Max. Qubits

~25 (Statevector)

Backend

CPU (NumPy)

Kosten

Kostenlos

Plattform

Lokal

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'))

Offene Plattform SDK-Leitfaden

🪙

PennyLane (default.qubit)

KostenlosLokalJAX/PyTorchDifferenzierbar

PennyLanes default.qubit ist ein reiner NumPy-Simulator, ideal für die QML-Forschung. Verwenden Sie lightning.qubit für C++-Beschleunigung oder lightning.gpu für NVIDIA-GPU-Beschleunigung. Alle sind kostenlos, lokal und differenzierbar.

Max. Qubits

20+ (default.qubit)

Backend

NumPy / C++ / GPU

Kosten

Kostenlos

Plattform

Lokal

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]

Offene Plattform SDK-Leitfaden

🟢

NVIDIA CUDA-Q

KostenlosGPUCPUMulti-GPU

Die quelloffene Quantencomputing-Plattform von NVIDIA. CUDA-Q bietet GPU-beschleunigte Simulation, die Schaltkreise mit 30+ Qubits um Größenordnungen schneller bewältigen kann als CPU-Simulatoren. Läuft kostenlos lokal auf jeder NVIDIA-GPU.

Max. Qubits

34+ (einzelne GPU)

Backend

NVIDIA GPU

Kosten

Kostenlos (Open Source)

Beschleunigung

100-10000× ggü. 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 }

Offene Plattform SDK-Leitfaden

🟠

Amazon Braket (Cloud-Simulatoren)

KostenlosCloudSV1 / DM1 / TN1

AWS Braket bietet drei verwaltete Cloud-Simulatoren: SV1 (Statevector, bis zu 34 Qubits), DM1 (Dichtematrix, bis zu 17 Qubits) und TN1 (Tensornetzwerk, bis zu 50 Qubits). Der lokale Simulator ist vollständig kostenlos; Cloud-Simulatoren kosten ~0,075 $/Task + Rechenzeit.

SV1 max. Qubits

TN1 max. Qubits

Lokaler Sim

Kostenlos (unbegrenzt)

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)

Offene Plattform SDK-Leitfaden

💡

Verwenden Sie HLQuantum, um jeden Simulator anzusteuern

Anstatt die Simulator-API jedes einzelnen SDK separat zu erlernen, verwenden Sie HLQuantum, um einen einzigen Schaltkreis zu schreiben und mit nur einem Flag zwischen Qiskit Aer, Cirq, PennyLane, CUDA-Q und weiteren zu wechseln.

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-Leitfaden