Qiskit vs PennyLane: Which Should You Learn?

The short answer

Most learners should start with Qiskit. Here is when each framework is the better choice:

Side-by-side comparison

The same circuit in both frameworks

The clearest way to feel the difference is to write the same program in each. Below is a Bell state, the simplest entangled two-qubit circuit, built and sampled 1,000 times in Qiskit and in PennyLane. Both produce roughly half 00 and half 11 outcomes. Notice how Qiskit separates the circuit from the primitive that runs it, while PennyLane wraps the circuit in a decorated function that behaves like any other Python callable.

from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorSampler

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

sampler = StatevectorSampler()
result = sampler.run([qc], shots=1000).result()
counts = result[0].data.meas.get_counts()
print(counts)  # ~ {'00': 500, '11': 500}

import pennylane as qml

dev = qml.device("default.qubit", wires=2, shots=1000)

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

print(bell())  # ~ {'00': 500, '11': 500}

For circuits this small the two look similar. The gap widens with quantum machine learning: in PennyLane, adding a trainable parameter and a gradient-based optimizer is a few lines because the qnode is differentiable end to end, whereas in Qiskit you wire the circuit into a separate optimization loop. Work through both hands-on with our free Qiskit Hello World and PennyLane Hello World tutorials.

Decision tree: which should you pick?

Answer these in order. Stop at the first match.

1. Is your main goal quantum machine learning, or training variational circuits with PyTorch, JAX, or TensorFlow? Yes, go with PennyLane.
2. Are you brand new to quantum computing and want the smoothest on-ramp with the most tutorials and community help? Yes, go with Qiskit.
3. Do you need free access to real quantum hardware out of the box? Yes, go with Qiskit (IBM's free Open Plan includes runtime on real devices).
4. Do you need to run the same code across many hardware vendors without rewriting it? Yes, lean PennyLane (backend-agnostic by design).
5. Still unsure? Start with Qiskit for the fundamentals, then add PennyLane when you reach variational algorithms or QML. Most practitioners end up using both.

Qiskit: strengths and weaknesses

Qiskit is the most widely used quantum computing framework by a large margin. Built and maintained by IBM, it is the official SDK for accessing IBM's real quantum computers.

PennyLane: strengths and weaknesses

PennyLane, built by Xanadu, was designed from the ground up around differentiable programming -- treating quantum circuits as machine learning layers that can be trained with gradient descent.

Where do Cirq, Braket, and other frameworks fit?

Qiskit and PennyLane are the two most common starting points, but they are not the only frameworks, and picking one does not lock you out of the others. Here is how the rest of the landscape relates to this decision.

• Cirq (Google). A general-purpose circuit framework like Qiskit, built for low-level control and Google's hardware. If you are choosing a general SDK and not tied to IBM, Cirq is the main alternative to Qiskit. See the Google quantum platform and our Cirq Hello World tutorial.
• Amazon Braket. Not really a competing framework but a cloud service that gives one paid API to many hardware vendors (IonQ, IQM, Rigetti, QuEra). You often write circuits in PennyLane or Braket's SDK and submit them through Braket. See the AWS quantum platform.
• Cirq vs PennyLane, Braket vs Qiskit, and so on. Because PennyLane is backend-agnostic and Qiskit, Cirq, and Braket all expose hardware, these frameworks interoperate more than they compete. PennyLane can run circuits on IBM, Google, and Braket backends through plugins.

For a full neutral breakdown across every major framework and platform, see our framework and platform comparison.

Can you learn both?

Yes, and many practitioners do. The core concepts of quantum circuits -- qubits, gates, measurement, superposition, entanglement -- are the same across frameworks. Once you understand them in one framework, picking up the other takes days, not months.

The recommended path for most learners: start with Qiskit for the foundations (2-4 months), then add PennyLane if you find yourself working on variational algorithms, QML, or multi-backend deployments. If you know you want to focus on QML from the start, you can go PennyLane-first, but expect a steeper early ramp due to fewer beginner resources.

Browse all Qiskit resources or all PennyLane resources for a comprehensive view of what is available on each platform.