Qiskit vs Cirq vs PennyLane: which quantum SDK to choose
Choose Qiskit if you want to run circuits on real hardware, IBM's first of all, and need a compiler that fits a circuit to a device. Choose PennyLane if your work is training circuits, in machine learning, chemistry or optimisation, and you want gradients without writing them. Choose Cirq if you work close to the hardware, on noise, calibration or error correction, and want Google's research tools around it. All three are free, Apache 2.0 and written for Python, and a circuit can be moved between them.
Updated
Qiskit, Cirq and PennyLane compared
Every cell comes from the project's own repository, documentation or package page, read on 2026-11-17, at the version named in the first row. These projects release often, so check the row you rely on before you commit to it.
| What | Qiskit | Cirq | PennyLane |
|---|---|---|---|
| Version and maintainer | 2.6.2 (November 2026), IBM[1] | 1.7.0 (June 2026), Google Quantum AI[2] | 0.45.1 (June 2026), Xanadu[5] |
| Licence and Python | Apache 2.0, Python 3.10 or later | Apache 2.0, Python 3.11 or later | Apache 2.0, Python 3.11 or later |
| What it calls itself | An SDK for working with quantum computers at the level of extended quantum circuits, operators and primitives | A package for writing, manipulating and running quantum circuits on quantum computers and simulators, built for noisy intermediate-scale devices | A quantum software platform for quantum computing, quantum machine learning and quantum chemistry |
| The central object | QuantumCircuit, run through the Sampler and Estimator primitives | Circuit, a list of moments of operations on qubit objects | The QNode: a Python function that is a circuit and can be differentiated |
| Compiling for a device | A transpiler with passes for synthesis, optimisation, mapping and scheduling, against a description of the target device | Circuit transformers and device models; gate sets and qubit layouts are explicit in the circuit | Compilation transforms, and the Catalyst compiler for just-in-time compiled hybrid programs |
| Gradients | Not in the core; in Qiskit Machine Learning and Qiskit Algorithms | None of its own; TensorFlow Quantum is the route its README names for machine learning | Built in: backpropagation and adjoint on simulators, parameter shift and others on hardware |
| First-party hardware | IBM Quantum, through qiskit-ibm-runtime | Google's processors, with access restricted to an approved group[3] | None: Xanadu's SDK reaches hardware through plugins |
| Other hardware | Provider packages for IonQ, AQT, Amazon Braket, Quantinuum and Rigetti | Modules or guides for AQT, IonQ, Pasqal and Azure Quantum[4] | Plugins for IBM Quantum, Amazon Braket, IonQ, Rigetti, AQT and others[6] |
| Simulators | Reference primitives in the core; Qiskit Aer for speed, noise and GPUs | Built-in state vector and density matrix simulators; qsim for large circuits, Stim for Clifford circuits | default.qubit in the core; the Lightning simulators for CPUs, GPUs and clusters |
| What sits around it | IBM Quantum Platform, Qiskit Aer, Qiskit addons, a C API to the Rust core | qsim, Stim, OpenFermion, Qualtran, TensorFlow Quantum, ReCirq | Lightning, Catalyst, a chemistry module, resource estimation, a large library of demos |
Hardware rows list what each project documents. Access to a device also needs an account with its vendor or cloud, and prices and availability are set there.
Qiskit: from a circuit to a device
Qiskit is organised around running a circuit on a machine. You build a QuantumCircuit, describe what you want from it, samples or expectation values, and hand it to a primitive, Sampler or Estimator. A runtime implements those primitives for a given platform, and may add error suppression and mitigation on the way[1]. IBM's runtime is the first-party one, and provider packages connect Qiskit to IonQ, AQT, Quantinuum, Rigetti and the devices on Amazon Braket.
Its distinctive part is the transpiler. A real device has a fixed set of gates and a fixed map of which qubits can interact, and a circuit written without them in mind has to be rewritten: gates decomposed, qubits routed, the result optimised and scheduled. Qiskit does this against a description of the target, and exposes each stage for those who want to control it[1]. Since version 2.0 the core data model is written in Rust and has a C API beside the Python one.
The cost of this focus is that the core is deliberately narrow. Fast and noisy simulation lives in Qiskit Aer, machine learning and algorithms in separate packages, and tutorials written for versions before 1.0 no longer run without changes. Choose Qiskit when hardware runs are the point of the project, and above all when the hardware is IBM's.
Cirq: close to the hardware
Cirq was written for experiments on noisy devices, where, in its own words, the details of the hardware are vital to the result[2]. Qubits are objects with a position, a line or a grid, and a circuit is a sequence of moments: sets of operations that happen at the same time. That makes timing, crosstalk and layout things you write down and not things a compiler decides for you. Custom gates, noise models and device models are part of the core.
Around it is Google Quantum AI's research stack: qsim for fast state-vector simulation, Stim for circuits with thousands of qubits and millions of Clifford operations, which is the standard tool in error correction research, OpenFermion for chemistry and Qualtran for fault-tolerant algorithms[2]. If you work on error correction or on reproducing Google's experiments, this is where the tools are.
The limit is hardware reach. Google's own processors are open only to an approved group, usually with a Google sponsor[3]. Cirq documents access to AQT, IonQ and Pasqal devices and to Azure Quantum[4], a shorter list than the other two SDKs have. It has no gradient interface of its own, and releases come about once a quarter. Choose Cirq for hardware-level research, not as the shortest way to a cloud QPU.
PennyLane: circuits you can differentiate
PennyLane starts from a different question: how do I train this circuit? A circuit is a Python function, a QNode, that returns expectation values, and the library differentiates it. On simulators that is backpropagation or the adjoint method; on hardware it is the parameter-shift rule and its relatives. The QNode plugs into PyTorch and JAX, so a quantum circuit can be one layer of a classical model[6].
It owns no general-purpose QPU access. Devices are plugins: IBM Quantum through the Qiskit plugin, Amazon Braket, IonQ, Rigetti, AQT and others, and Cirq's simulators through the Cirq plugin[6]. Speed comes from the Lightning simulators, on CPUs, GPUs and clusters, and from Catalyst, a compiler for hybrid programs[5]. It also carries a chemistry module, resource estimation and what its README calls the world's largest library of research demos.
The cost is one more layer between you and the device. When a run on hardware misbehaves, the place to look is often the plugin or the vendor's SDK under it. Choose PennyLane when the work is variational: VQE, QAOA, quantum machine learning. For that last case there is a closer comparison on quantum machine learning frameworks.
The same circuit in all three
import numpy as np
# Qiskit: a circuit, an observable, the Estimator primitive
from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorEstimator
from qiskit.quantum_info import SparsePauliOp
qc = QuantumCircuit(2)
qc.ry(0.6, 0)
qc.cx(0, 1)
job = StatevectorEstimator().run([(qc, SparsePauliOp("ZI"))])
print("qiskit ", round(float(job.result()[0].data.evs), 4))
# Cirq: qubits are objects, gates are applied to them
import cirq
a, b = cirq.LineQubit.range(2)
circuit = cirq.Circuit(cirq.ry(0.6)(a), cirq.CNOT(a, b))
value = cirq.Simulator().simulate_expectation_values(circuit, [cirq.Z(b)])[0]
print("cirq ", round(float(np.real(value)), 4))
# PennyLane: the circuit is a function, and it has a gradient
import pennylane as qml
from pennylane import numpy as pnp
@qml.qnode(qml.device("default.qubit", wires=2))
def f(theta):
qml.RY(theta, wires=0)
qml.CNOT(wires=[0, 1])
return qml.expval(qml.PauliZ(1))
theta = pnp.array(0.6, requires_grad=True)
print("pennylane", round(float(f(theta)), 4), round(float(qml.grad(f)(theta)), 4))
# qiskit 0.8253
# cirq 0.8253
# pennylane 0.8253 -0.5646A rotation by 0.6 on one qubit, a CNOT, and the expectation value of Z on the second qubit, which is . Run with Qiskit 2.1.2, Cirq 1.7.0 and PennyLane 0.45.1. Two things to notice. Qiskit writes Pauli strings from the last qubit to the first, so Z on qubit 1 of two is "ZI", a common source of silent errors when porting. And only PennyLane returns the derivative, , without more code.
Which SDK for which job
| If the job is | Start with | Why |
|---|---|---|
| Running on IBM quantum computers | Qiskit | The first-party runtime, with error mitigation in the primitives, and the transpiler built for those devices |
| Running on IonQ, Rigetti, IQM or AQT through one cloud account | Qiskit or PennyLane with the Braket plugin | Both reach Amazon Braket; pick by what the rest of the code needs |
| Training a variational circuit or a hybrid model | PennyLane | Gradients are built in, and the circuit is a layer in PyTorch or JAX |
| Fitting a circuit to a device's gates and connectivity | Qiskit | The transpiler does routing, synthesis and optimisation against a target, stage by stage |
| Error correction research | Cirq with Stim | Stim simulates Clifford circuits with thousands of qubits, and the decoders sit next to it |
| Noise and calibration experiments | Cirq | Moments, device models and noise models are explicit in the circuit |
| Quantum chemistry | PennyLane, or Cirq with OpenFermion | Both carry molecular Hamiltonians and fermion-to-qubit mappings |
| Learning quantum computing | Qiskit or PennyLane | The largest sets of courses, tutorials and worked examples |
| Not being tied to one of them | A layer above: eigenkit | One circuit definition, run on any of the three by changing one argument |
How to choose
Start from the hardware you must reach
If the project is tied to a vendor or a cloud, take the SDK that vendor maintains or recommends. For IBM that is Qiskit. For Amazon Braket it is the Braket SDK, with PennyLane recommended for hybrid algorithms. Google's hardware is not a reason to pick Cirq unless you already have access.
Then ask whether you train anything
If the circuit has parameters that an optimiser will tune, gradients decide how much code you write. PennyLane has them in the core; Qiskit has them in add-on packages; with Cirq you bring your own or use TensorFlow Quantum.
Then look at who else uses it in your field
Code from papers is the fastest way in. Error correction papers ship Stim and Cirq code, IBM hardware papers ship Qiskit, and variational and machine learning papers lean towards PennyLane.
Do not let the simulator decide
Each SDK has a fast simulator within reach, and which is fastest depends on the circuit. EigenOrbit Benchmarks times Qiskit Aer, qsim, PennyLane's simulators and others on the same circuits.
Keep a way out
Circuits move between the three through OpenQASM and through plugins, and PennyLane can run on Qiskit and Cirq devices. Write the model once, run it on two backends, and the choice stops being permanent.
Where eigenkit sits
eigenkit is not a fourth option in this comparison. It is a layer above the three: a circuit is defined once in eigenkit's format and run on its built-in NumPy simulator, on Qiskit and Qiskit Aer, on PennyLane, on qsim, which is Cirq's fast simulator, and on CUDA-Q, Qulacs and TensorCircuit by changing the provider= argument. The same definition goes to real devices through Qiskit Runtime, Amazon Braket and IQM[7].
It does not replace any of them for what is specific to each. Qiskit's transpiler stages, Cirq's moments and device models and PennyLane's full set of gradient methods are reached by using those SDKs directly. What eigenkit adds is on top: scikit-learn estimators, solvers such as VQE, QAOA, HHL and amplitude estimation, and a benchmark that runs a quantum model next to its classical baseline.
Run it on a real QPU with EigenOrbit RouterThe same circuit on QPUs from several vendors, with one account instead of one SDK and one account per vendor.In eigenkit: pip install "eigenkit[router]", then provider=RouterConfig(device=...) (docs).
Questions
Which is better, Qiskit, Cirq or PennyLane?
None is better across the board. Qiskit is the strongest for running on real hardware, IBM's above all, and for compiling a circuit to a device. PennyLane is the strongest for training circuits, because gradients are built in. Cirq is the strongest for hardware-level and error correction research. Pick by the hardware you must reach and by whether you train anything.
What is the difference between Qiskit and Cirq?
Qiskit is IBM's SDK and is organised around running circuits through Sampler and Estimator primitives, with a transpiler that fits a circuit to a device. Cirq is Google's and keeps hardware details explicit: qubits have positions and a circuit is a sequence of moments. Qiskit reaches more cloud hardware; Cirq has Stim, qsim and OpenFermion around it.
Is PennyLane better than Qiskit?
For variational algorithms and quantum machine learning PennyLane needs less code, because it differentiates circuits and plugs into PyTorch and JAX. For running on IBM hardware with control over transpilation, Qiskit is the direct route. PennyLane can run on IBM devices through its Qiskit plugin, so the two are often used together.
Which quantum SDK is best for beginners?
Qiskit or PennyLane. Both have large sets of tutorials, courses and worked examples, and both run on a laptop with one pip install. Qiskit suits someone who wants to run on a real device early; PennyLane suits someone coming from machine learning.
Can I run Cirq circuits on IBM quantum computers?
Not directly. Cirq has no IBM backend. A circuit can be exported from Cirq as OpenQASM and imported into Qiskit, which then runs it on IBM hardware. Cirq itself documents access to AQT, IonQ and Pasqal devices and to Azure Quantum.
Can I use Google's quantum computers with Cirq?
Only with approved access. Cirq's documentation says access to Google hardware is restricted to an approved group and usually needs a Google sponsor. Most Cirq users run on simulators or on other vendors' devices.
Are Qiskit, Cirq and PennyLane free?
Yes. All three are open source under the Apache 2.0 licence. Simulating on your own computer costs nothing. Running on a real quantum computer is billed by the hardware vendor or the cloud that hosts it.
Do I have to choose one SDK?
No. Circuits move between them through OpenQASM and plugins, and layers such as eigenkit run one circuit definition on Qiskit, PennyLane, qsim and other backends by changing one argument. Running a model on two backends is also a useful check on the result.
Sources
- IBM and the Qiskit contributors. Qiskit 2.6.2: README (Python and C APIs, transpiler, primitives, runtime and provider packages). github.com/Qiskit/qiskit and pypi.org/project/qiskit, read 2026-11-17, 2026.
- Google Quantum AI and the Cirq contributors. Cirq 1.7.0: README (features, integrations, release cadence). github.com/quantumlib/Cirq and pypi.org/project/cirq, read 2026-11-17, 2026.
- Google Quantum AI. Cirq documentation: Access and authentication (Google hardware). quantumai.google/cirq, read 2026-11-17, 2026.
- Google Quantum AI. Cirq documentation: Hardware (AQT, Azure Quantum, IonQ, Pasqal). quantumai.google/cirq, read 2026-11-17, 2026.
- Xanadu and the PennyLane contributors. PennyLane 0.45.1: README (key features, Lightning simulators, Catalyst compiler). github.com/PennyLaneAI/pennylane and pypi.org/project/pennylane, read 2026-11-17, 2026.
- Xanadu. PennyLane 0.45.1 documentation: Gradients and training; Interfaces; Devices. docs.pennylane.ai and pennylane.ai/devices, read 2026-11-17, 2026.
- EigenOrbit. eigenkit 1.2.2 documentation: Providers (backend matrix). docs.kit.eigenorbit.com, read 2026-11-17, 2026.
Run it yourself with eigenkit
eigenkit is EigenOrbit's open-source Python library: write a circuit once, run it on any simulator or QPU, and test it against a classical baseline on your own data before you invest in it or rule it out.
$ pip install eigenkit