Quantum Framework Migration Guide

Common Migration Paths

Not every migration is equally common. These are the five transitions practitioners encounter most often, with the main reasons behind each.

• Qiskit

  →

  Cirq

  Moving to Google hardware (Sycamore, Willow) or needing lower-level control over qubit placement and gate timing. Cirq exposes individual qubit objects and moment structure that Qiskit abstracts away. The main cost is rewriting qubit indexing from integers to LineQubit or GridQubit objects.

• Qiskit

  →

  PennyLane

  Adding quantum machine learning, hybrid classical-quantum models, or differentiable programming. PennyLane circuits are Python functions decorated with @qml.qnode, which makes gradient computation via parameter-shift rules or autograd feel natural. Gate names are mostly one-to-one: qc.h(0) becomes qml.Hadamard(wires=0).

• Qiskit

  →

  Braket

  Deploying on AWS infrastructure or accessing hardware from IonQ, Rigetti, QuEra, and IQM through a single SDK. Braket uses a Circuit class with method chaining. Gate names differ slightly: cx becomes cnot, and parameterized circuits use FreeParameter instead of Qiskit's Parameter.

• PyQuil

  →

  Qiskit

  Rigetti's public cloud access has been curtailed and the IBM ecosystem is significantly larger. The main concept change is from Quil Program (list of Quil instructions) to Qiskit QuantumCircuit (a structured circuit object). Classical registers and measurement are handled differently: Qiskit requires explicit ClassicalRegister allocation.

• Any framework

  →

  tket

  Adding hardware-agnostic circuit optimisation without abandoning your current framework. tket sits as a compilation layer: import your Qiskit or Cirq circuit, apply optimisation passes, and submit to any supported backend. You do not need to rewrite your circuit construction logic, only add the compilation step.

Key Conceptual Differences

These are the mental model shifts that trip up developers most often when switching frameworks. Getting these right prevents most migration bugs.

tket as a Universal Compiler Layer

tket (from Quantinuum) can sit between any high-level framework and any hardware backend. Instead of rewriting your circuits, you import them into tket, apply optimisation passes, and submit to whichever backend you need. This means you can keep writing Qiskit or Cirq code and still benefit from tket's compiler passes.

from qiskit import QuantumCircuit
from pytket.extensions.qiskit import qiskit_to_tk, AerBackend
from pytket.passes import (
    SequencePass, FullPeepholeOptimise, DecomposeBoxes
)

# 1. Write the circuit in Qiskit as normal
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])

# 2. Convert to a tket Circuit
tk_circ = qiskit_to_tk(qc)

# 3. Apply optimisation passes
optimiser = SequencePass([
    DecomposeBoxes(),
    FullPeepholeOptimise(),
])
optimiser.apply(tk_circ)

# 4. Submit to a backend (here: Aer via tket)
backend = AerBackend()
compiled = backend.get_compiled_circuit(tk_circ)
result = backend.run_circuit(compiled, n_shots=1024)
print(result.get_counts())

Install with: pip install pytket pytket-qiskit. For Cirq circuits use pytket-cirq and cirq_to_tk(). Backends exist for IBM, IonQ, Quantinuum, Braket, Rigetti, and more.

Braket and PyQuil Migration Notes

• Migrating to Amazon Braket

  Braket has its own Circuit class that is structurally similar to Qiskit but with different naming conventions and a fluent chaining API.

  • QuantumCircuit(n, n) becomes Circuit() (no classical bits declared upfront)
  • qc.cx(0, 1) becomes circuit.cnot(0, 1)
  • qc.rx(theta, 0) becomes circuit.rx(0, theta) (qubit index first, angle second)
  • Parameterized gates use FreeParameter('theta') instead of Qiskit's Parameter('theta')
  • Measurement is implicit; no .measure() call required for the local simulator
  • Circuits are run via device.run(circuit, shots=N).result()

  from braket.circuits import Circuit
  from braket.devices import LocalSimulator
  
  circuit = Circuit().h(0).cnot(0, 1)
  
  device = LocalSimulator()
  result = device.run(circuit, shots=1024).result()
  print(result.measurement_counts)

  Full Braket reference →

• Migrating from PyQuil

  PyQuil uses Quil, an assembly-like instruction set. Migrating to Qiskit or Cirq means moving from a list of instruction objects to a structured circuit abstraction.

  • PyQuil's Program() is a list of gate and measurement instructions; Qiskit's QuantumCircuit is a graph-based circuit object
  • Gates are imported individually from pyquil.gates (e.g. H(0), CNOT(0, 1)); in Qiskit they are methods on the circuit object
  • Classical registers must be declared explicitly in Qiskit: QuantumCircuit(2, 2)
  • PyQuil's quilc compiler is called via get_qc(); Qiskit uses transpile(qc, backend)
  • PyQuil's WavefunctionSimulator corresponds to Qiskit's Statevector class
  • Parametric gates use p.declare('angle', 'REAL'); Qiskit uses Parameter('theta')

  from pyquil import Program
  from pyquil.gates import H, CNOT, MEASURE
  
  p = Program()
  ro = p.declare('ro', 'BIT', 2)
  p += H(0)
  p += CNOT(0, 1)
  p += MEASURE(0, ro[0])
  p += MEASURE(1, ro[1])
  p.wrap_in_numshots_loop(1024)

  Full PyQuil reference →