PennyLane Plugin Now Available on Open Quantum

Written By Bob Wold

We are excited to announce the release of PennyLane integration on the Open Quantum platform. This Python SDK plugin allows developers to run PennyLane circuits directly on real quantum hardware from IonQ, Rigetti, IQM, and AQT.

PennyLane

PennyLane is Xanadu’s open-source framework for differentiable quantum computing and quantum machine learning. It enables developers to train quantum circuits using automatic differentiation, combining quantum programs with modern machine learning workflows.

PennyLane is one of the leading frameworks for:

  • Variational Quantum Eigensolvers (VQE)
  • Quantum Approximate Optimization Algorithm (QAOA)
  • Quantum neural networks
  • Quantum chemistry simulations
  • Differentiable quantum computing
  • Quantum machine learning (QML)

The Open Quantum plugin lets you run all of these workflows on real quantum hardware, bringing PennyLane's differentiable programming model to physical QPUs.

Seamless Integration

The Open Quantum PennyLane Plugin integrates directly into PennyLane's device ecosystem. Existing QNodes and variational circuits run on real hardware without users needing to rewrite code or learn vendor-specific APIs. Standard PennyLane measurements are supported, making it straightforward to train and evaluate parameterized circuits on hardware using familiar optimization loops.

With the plugin, developers can:

  • Run PennyLane circuits on real QPUs
  • Use existing QNodes and variational workflows without modification
  • Execute hybrid quantum-classical algorithms using standard Python tools
  • Access trapped-ion and superconducting hardware through a unified interface
  • Switch hardware providers with a single backend string

PennyLane is designed to be hardware-agnostic. This versatility is great, but the tradeoff is that swapping devices isn't always seamless. Normally each hardware provider ships their own PennyLane plugin, and you have to install and configure them separately. When switching QPUs, you need to download new packages, learn a new SDK (with potentially different supported device strings), set up different environment variables, and more. Running the same circuit across multiple providers to compare results requires maintaining parallel setups.

Open Quantum simplifies this process. Instead of managing separate SDKs, authentication flows, transpilation pipelines, and execution APIs for each provider, developers can access multiple quantum systems through a single interface.

Installation

It's simple. Just run a single line in your terminal:

pip install openquantum-sdk-pennylane

Getting Started

Not sure where to start? Here's a familiar Bell state example:

import os
import pennylane as qml

dev = qml.device(
    "openquantum.device",
    wires=2,
    shots=1024,
    backend="provider:QPU",
    client_id=os.environ["OPENQUANTUM_CLIENT_ID"],
    client_secret=os.environ["OPENQUANTUM_CLIENT_SECRET"]
)

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

print(bell_state())

Check out more examples on the Open Quantum documentation site.

Make Something Today

Wondering what to build next? Here are a few projects you can try today, using Open Quantum's PennyLane plugin:

Small molecule energy estimation with VQE The Variational Quantum Eigensolver is one of the most studied near-term algorithms, designed to work within the constraints of noisy hardware. Pick a molecule with a small active space (H₂, LiH, BeH₂), build the Hamiltonian using PennyLane's quantum chemistry tools, and run a variational optimization loop on real hardware. These are well-benchmarked problems, so you can compare your hardware results against classical reference values.

Combinatorial optimization with QAOA Take a MaxCut or graph partitioning problem on a small graph and run QAOA with a few layers of alternating operators. At this scale, you can classically verify whether the hardware found the right answer. Additionally, you can vary the number of QAOA layers, compare different parameter initialization strategies, and test whether error mitigation actually improves solution quality on hardware.

Variational quantum simulation of spin chains Spin chains are one-dimensional lattice models where particles interact only with their nearest neighbors. Simulate the time evolution of a small Heisenberg or Ising spin chain using a variational ansatz. PennyLane has built-in tools for constructing Hamiltonian evolution circuits, so the setup is easy. You can compare the variational simulation against exact classical diagonalization to see where and how hardware noise degrades the result.

Cross-provider noise benchmarking Run a fixed parameterized circuit (same gates, same parameters, same shot count) across IonQ's trapped-ion system and Rigetti's superconducting hardware (or any 2 providers with different QPU types), and compare the output distributions. PennyLane's unified interface makes the comparison straightforward with no SDK-switching. This kind of benchmarking is hard to do without access to multiple providers through a single interface.

The possibilities are endless, and we're excited to hear about what you all come up with!

Availability

The Open Quantum PennyLane Plugin is available now.

To learn more:

Bob Wold
Next

Rigetti Cepheus-1-108Q QPU Available on Open Quantum