PennyLane vs Qiskit and other quantum machine learning frameworks, and where eigenkit sits
Choose PennyLane if you want to train circuits the way you train neural networks: it has the widest set of gradient methods and a PyTorch layer. Choose Qiskit with Qiskit Machine Learning if IBM hardware comes first and you want estimators in the scikit-learn style. CUDA-Q is the pick for GPU simulation with wide QPU access and Qulacs for fast simulation on a CPU, while eigenkit competes with none of them: it is a layer that runs one model on most of them.
Updated
Quantum machine learning frameworks compared
Every cell comes from the project's own documentation or repository, read on 2026-11-03, at the version named in the first column. Frameworks change fast, so check the row you rely on before you commit to it.
| Framework | Licence | Gradients | Hardware reach | PyTorch and scikit-learn |
|---|---|---|---|---|
| PennyLane 0.45.1[1] | Apache 2.0 | Backpropagation and adjoint on simulators; parameter shift, finite differences, Hadamard-test variants, SPSA and device gradients for hardware | Plugins for IBM Quantum, Amazon Braket, IonQ, Rigetti, AQT and others; Cirq and qsim simulators through the Cirq plugin | PyTorch through qml.qnn.TorchLayer; NumPy (autograd) and JAX interfaces too, TensorFlow no longer maintained since 0.44. No scikit-learn estimators |
| Qiskit 2.6.1 with Qiskit Machine Learning 0.9.1[2][3] | Apache 2.0, both | Parameter shift, linear combination of unitaries and SPSA, for expectation values and for sampled probabilities | IBM Quantum through qiskit-ibm-runtime; provider packages for IonQ, AQT, Amazon Braket, Quantinuum and Rigetti | PyTorch through TorchConnector. QSVC extends scikit-learn's SVC; the other models have a scikit-learn-like interface |
| CUDA-Q 0.16.0[4] | Apache 2.0 | Central and forward finite differences, parameter shift (cudaq.gradients) | IonQ, Quantinuum, IQM, OQC, Anyon, TII, Infleqtion, Pasqal, QuEra, ORCA, and cloud access through Amazon Braket, Scaleway and qBraid; GPU and multi-GPU simulators | None in its Python API |
| Amazon Braket SDK 1.127.7[5] | Apache 2.0 | Through the PennyLane plugin: adjoint differentiation on SV1, PennyLane's own methods elsewhere | AQT, IonQ, IQM and Rigetti gate-based QPUs, QuEra for analog Hamiltonian simulation; SV1 and DM1 managed simulators | Through PennyLane, which AWS recommends for hybrid algorithms |
| TensorCircuit-NG 1.10.0[6] | Apache 2.0 | Automatic differentiation on JAX, TensorFlow or PyTorch backends, and a vectorised parameter shift | A cloud module with providers for Tencent's quantum cloud, Quafu and Tianyan | TorchLayer and torch_interface for PyTorch. No scikit-learn estimators |
| Qulacs 0.6.14[7] | MIT | Back-propagation through ParametricQuantumCircuit.backprop(), and GradCalculator | None: a fast C++ simulator with optional GPU support | None built in |
| eigenkit 1.1.0 (a layer above the others)[8] | Apache 2.0 | Adjoint on its NumPy simulator, the backend's own method where there is one, parameter shift elsewhere | Braket (IonQ, Rigetti, IQM, AQT), Qiskit Runtime (IBM Eagle and Heron) and IQM Resonance | interface="torch" circuits and nn.Module layers; every estimator is a scikit-learn BaseEstimator |
Hardware reach lists what each project documents. Access to a device also needs an account with its vendor or cloud, and prices and availability are set there.
PennyLane vs Qiskit
The two are built around different questions. PennyLane starts from how do I differentiate this circuit? A circuit is a function, a QNode, and the framework chooses or lets you choose among more gradient methods than any other library here: backpropagation and the adjoint method on simulators, and on hardware the parameter-shift rule, finite differences, several Hadamard-test variants, SPSA and gradients computed by the device itself[1]. It plugs into PyTorch as a layer and into JAX, and reaches hardware through plugins. It is also the framework in which Xanadu, its developer, wrote a large QML benchmark that found classical models ahead[9].
Qiskit starts from how do I run this circuit on a device? Its core is circuits, transpilation and the Sampler and Estimator primitives that a runtime implements for a given machine, and its first-party runtime is IBM's[2]. Machine learning lives in a separate package, Qiskit Machine Learning, co-maintained by IBM and the Hartree Centre. It provides quantum kernels with QSVC and QSVR, neural networks with EstimatorQNN and SamplerQNN, the VQC and VQR models, gradients by parameter shift, linear combination of unitaries and SPSA, and TorchConnector for PyTorch[3].
In practice: if your work is mostly training hybrid models and comparing gradient methods, PennyLane needs less code. If it is mostly about running on IBM devices, with control over how the transpiler maps and optimises the circuit, start in Qiskit. Both are Apache 2.0, both reach IBM hardware, and PennyLane can run on Qiskit's simulators and devices through its Qiskit plugin, so the choice is less exclusive than the query suggests.
CUDA-Q, Braket, TensorCircuit-NG and Qulacs
CUDA-Q is NVIDIA's platform for GPU-accelerated simulation, including pooling the memory of several GPUs, and it documents a long list of QPU vendors. Its gradients are finite differences and parameter shift, and its Python API has no PyTorch or scikit-learn layer, so connecting it to a PyTorch model is up to you[4].
Amazon Braket is a cloud service first: one account reaches AQT, IonQ, IQM, QuEra and Rigetti devices and the SV1 and DM1 simulators. For machine learning, AWS itself recommends PennyLane through the Braket plugin, which also gives adjoint gradients on SV1[5].
TensorCircuit-NG is a tensor-network simulator built on JAX, TensorFlow and PyTorch, so circuits are differentiated, compiled and vectorised by those frameworks[6][8]. Qulacs is a C++ simulator with Python bindings, MIT-licensed, with a native back-propagation for parametric circuits and no hardware access[7].
How to choose
Start from the hardware you must reach
If the project is tied to one vendor or cloud, take that vendor's framework or the one its documentation recommends, and check the device list above against your contract.
Then the training loop
End-to-end training with PyTorch favours PennyLane, Qiskit Machine Learning with TorchConnector, or TensorCircuit-NG. Scikit-learn pipelines favour Qiskit Machine Learning's QSVC or eigenkit's estimators.
Then the simulator
Statevector simulation on a CPU runs out at a few dozen qubits whatever the framework. Many GPUs (CUDA-Q), tensor networks (TensorCircuit-NG) or a fast C++ core (Qulacs) move that limit or the speed, not the exponential cost. Which one is fastest on your circuit is a question for measurement, and the Benchmarks link near the end of this page times several of them on a training circuit.
Keep the model portable
Write the model once and run it on two backends before you commit. A result that holds on one simulator only is a bug report, not a finding.
Where eigenkit sits
eigenkit is not another simulator competing with these. It defines a circuit once, in its own format, and runs it on a built-in NumPy simulator or on PennyLane, Qiskit and Qiskit Aer, Braket, Qiskit Runtime, IQM, CUDA-Q, TensorCircuit, Qulacs or qsim by changing one argument, provider=[8]. The gradient comes from the backend's own method where it has one, the adjoint method on the built-in simulator and parameter shift elsewhere.
That is useful for two things the table cannot settle for you: checking that a result does not depend on one simulator, and moving a model trained on a simulator to a QPU without rewriting it. On top of the circuits it adds scikit-learn estimators (quantum kernels, hybrid networks, reservoirs) and a benchmark that runs them next to classical baselines. The code below runs the same four-qubit circuit on three providers.
One circuit, three frameworks
import numpy as np
from eigenkit import Circuit, Encoding, Variational, all_z
blocks = [Encoding(in_features=4, rotation="RX"), Variational(depth=2)]
weights = np.linspace(0.1, 0.8, 8)
x = np.array([0.1, 0.2, 0.3, 0.4])
for provider in ("numpy", "pennylane", "qiskit"):
circuit = Circuit(blocks, observables=all_z(4), provider=provider)
print(provider, circuit(weights, x).round(4), circuit.jacobian(weights, x).shape)
# numpy [0.8596 0.6842 0.4816 0.2628] (4, 8)
# pennylane [0.8596 0.6842 0.4816 0.2628] (4, 8)
# qiskit [0.8596 0.6842 0.4816 0.2628] (4, 8)Needs pip install "eigenkit[pennylane,qiskit]". The four expectation values agree on every provider, and so does the Jacobian, computed by the adjoint method, by PennyLane and by parameter shift respectively.
Run it on a real QPU with EigenOrbit RouterThe same model on real QPUs from several vendors, with one account instead of one per vendor.In eigenkit: pip install "eigenkit[router]", then provider=RouterConfig(device=...) (docs).
Questions
Is PennyLane or Qiskit better for quantum machine learning?
PennyLane is the more direct choice for training hybrid models: it has more gradient methods and a PyTorch layer. Qiskit with Qiskit Machine Learning is the better start if you work mainly on IBM hardware and want scikit-learn-style estimators. Both are open source under Apache 2.0, and PennyLane can run on Qiskit backends through a plugin.
What is the best quantum machine learning library in Python?
There is no single best one. PennyLane leads on differentiation, Qiskit on IBM hardware, CUDA-Q on GPU simulation and the number of QPU vendors, TensorCircuit-NG on tensor-network simulation with JAX, and Qulacs on fast CPU simulation. Choose by the hardware you must reach and the training loop you use.
Can PennyLane run on IBM quantum computers?
Yes, through its Qiskit plugin, which gives access to the devices available through qiskit-ibm-runtime. You need an IBM Quantum account for them.
Does Qiskit work with PyTorch?
Yes. Qiskit Machine Learning has TorchConnector, which wraps a Qiskit quantum neural network as a PyTorch module so that it trains with autograd inside a larger network.
What is eigenkit, and does it replace PennyLane or Qiskit?
eigenkit is an open-source Python library by EigenOrbit that defines a quantum model once and runs it on PennyLane, Qiskit, Braket, CUDA-Q, TensorCircuit, Qulacs, qsim, IQM or its own NumPy simulator by changing one argument. It uses those frameworks as backends, so it does not replace them, and their features outside its circuit format stay in the frameworks themselves.
Sources
- Xanadu. PennyLane 0.45.1 documentation: Gradients and training; Interfaces; qml.qnn.TorchLayer; Devices. docs.pennylane.ai and pennylane.ai/devices, read 2026-11-03, 2026.
- IBM and the Qiskit contributors. Qiskit 2.6.1: README (runtime primitives and hardware providers) and licence. github.com/Qiskit/qiskit, read 2026-11-03, 2026.
- IBM and the Hartree Centre (STFC). Qiskit Machine Learning 0.9.1 documentation: algorithms, gradients, TorchConnector. stfc.github.io/qiskit-machine-learning, read 2026-11-03, 2026.
- NVIDIA. CUDA-Q 0.16.0 documentation: backends and the Python API (cudaq.gradients). nvidia.github.io/cuda-quantum, read 2026-11-03, 2026.
- Amazon Web Services. Amazon Braket Developer Guide: supported devices; Using PennyLane with Amazon Braket. docs.aws.amazon.com/braket, read 2026-11-03, 2026.
- The TensorCircuit-NG developers. TensorCircuit-NG 1.10.0: README, tensorcircuit.interfaces and tensorcircuit.cloud. github.com/tensorcircuit/tensorcircuit-ng and tensorcircuit-ng.readthedocs.io, read 2026-11-03, 2026.
- QunaSys, Osaka University, NTT and Fujitsu. Qulacs 0.6.14: README and Python advanced guide (gradients of parametric circuits). github.com/qulacs/qulacs and docs.qulacs.org, read 2026-11-03, 2026.
- EigenOrbit. eigenkit 1.1.0 documentation: Providers (backend matrix), QPU and cloud workflows, Estimators. docs.kit.eigenorbit.com, read 2026-11-03, 2026.
- J. Bowles, S. Ahmed, M. Schuld. Better than classical? The subtle art of benchmarking quantum machine learning models. arXiv preprint, 2024. arXiv:2403.07059.
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