A platform for open-source quantum computing with PennyLane, Catalyst, and Open Quantum Design

A truly end-to-end, open-source, quantum computing platform—where every component from the user-interface, to the compiler, to the control hardware is open—is fundamental for accessibility. Together, Xanadu and Open Quantum Design (OQD) have been working towards this very goal, and PennyLane programs can now compile, through Catalyst, directly to OQD’s trapped-ion hardware control signals. This demonstrates a step towards the first fully open-source quantum computing stack from software to hardware.

Here, Ben Lau and Jake Malliaros will walk through the latest developments in integrating Xanadu’s open-source software to the open-source hardware design and control used by OQD. Learn more about this unique quantum computing stack and initiative in this collaborative blog post!

Democratizing quantum computing

The commitment to being end-to-end open-source reflects OQD's mission: to democratize quantum computing and enable valuable access to a broad research community. Open Quantum Design and Xanadu are collaborating, alongside a larger consortium, on this very challenge.

Because low-level access to quantum hardware is still a fundamental obstacle for many within the quantum ecosystem, it is hard for students and researchers to learn how to actually build a quantum computer–and this is where Xanadu and OQD are helping out. With this collaboration, we are making quantum computing more accessible by having everything–the source code for the software, the designs for the hardware, and the hardware components themselves–open-source. So if you are, for example, in a university lab and have a trapped-ion device, you can utilize this open stack to make your own programmable quantum computer using PennyLane and Catalyst!

Catalyst: connecting PennyLane programs to trapped-ions

PennyLane is one of the most popular quantum open-source software (OSS) packages as captured by Unitary Foundation’s quantum OSS survey. Adding to PennyLane’s front-end capabilities is PennyLane’s Catalyst compiler, which compiles hybrid quantum programs to optimize circuits for execution and lower the program representation to target backend devices. By using trapped-ion technology for our device, the stack benefits from all-to-all qubit connectivity and high gate fidelities, making them natural targets for demonstrating compiler-to-hardware integration without complex routing algorithms. For example, this level of connectivity provides a great testbed for many of those interested in fault-tolerant quantum computing: measurement-based quantum computing and quantum error correction.

The tight integration between the software and hardware layers is something that goes beyond the many device and hardware plug-ins that PennyLane already supports–the PennyLane frontend paired with Catalyst's just-in-time compilation provides the underlying connective tissue that links programs to OQD's low-level hardware instructions. In other words, PennyLane programs that are compiled by Catalyst generate instructions for low-level control–the connection is deeper than a high-level re-mapping of active programming interfaces.

An extensive review of Catalyst's capabilities are beyond the scope of the blog post here and instead, we refer to this dedicated blog post on it. Here, we want to focus on two major features of Catalyst that make it the perfect integration software between PennyLane and OQD's hardware:

1. There is an integrated pipeline between PennyLane and Catalyst (both are developed by Xanadu afterall!) and features for each software are tightly integrated. Changes and improvements to PennyLane and Catalyst are accessible to future platform users with minimal delay.

2. Catalyst can generate optimized code that targets OQD backends by leveraging the mature open-source compiler frameworks, LLVM and Multi-Level Intermediate Representation (MLIR). MLIR’s flexibility and modularity enable easy implementation of domain-specific languages by encapsulating specialized knowledge into dialects. Quantum programming operations can be encoded in these dialects and the resulting hybrid program optimized and lowered to custom quantum devices utilizing the classical compilation framework.

By defining a trapped-ion dialect in MLIR, we can specify the operations the hardware natively supports, such as RX, RY, and RZZ gates. When Catalyst compiles a PennyLane circuit, it transforms these high-level instructions into code that the hardware-level components (ARTIQ and Sinara) can execute. ARTIQ handles the control software layer while Sinara field-programmable gate arrays (FPGAs) generate the actual laser pulses that manipulate the trapped ions.

Integration Pipeline

When you write a quantum circuit in PennyLane, that Python code gets transformed through several stages before reaching the hardware. Catalyst first converts it into MLIR intermediate code for optimization. Following the optimization, ARTIQ timing instructions are inserted into the code, which tell the system when each operation should fire. Finally, Sinara FPGAs use those instructions to generate the laser pulses that manipulate the ions. This process is a bit like taking a high-level plan and then translating it into increasingly precise instructions until you have the exact signals the hardware needs to perform the task.

Consider a practical example: entangle two wires (or qubits) using a CNOT gate. This sounds and looks trivial as a circuit:

However, this apparent simplicity conceals significant complexity; because a CNOT gate is not natively supported at a hardware level, they must first be decomposed into the basic gate operations corresponding to laser pulses, that the trapped-ion hardware can understand and execute. Many coordinated pulses, representing the gates, must be created and scheduled in order to execute the "simple" CNOT operation.

Below is an oscilloscope measurement of the laser pulse instructions for the CNOT gate. This decomposition generates multiple distinct pulse sequences coordinated across microsecond timescales, demonstrating successful compilation from abstract gate to physical control signal.

The work doesn't stop with a CNOT gate, as it is only a small (albeit important) component of quantum programs. So let us consider something a little harder–the so-called Quantum Fourier Transform (QFT). We see that the circuit diagram for preparing a basis state and implementing QFT can be given by:

For this 2-qubit QFT implementation, the circuit has a non-trivial gate depth of 12, which becomes quite complicated when we’re down at the pulse level! A snapshot of the resulting pulse sequence reveals that the hardware has to coordinate significantly more operations than the CNOT example, with each gate in the circuit requiring its own decomposition into native trapped-ion operations.

From Circuit to Control Signals

Here's what this integration looks like in practice, from a programmer's point of view. A simple quantum circuit demonstrating a single-qubit rotation is written in PennyLane, targeting an OQD device, and calling Catalyst to compile for the OQD pipeline through the decorator @qml.qjit:

import pennylane as qml

oqd_dev = qml.device("oqd", backend="default", shots=4, wires=1)

@qml.qjit(pipelines=OQD_PIPELINES)
@qml.qnode(oqd_dev)
def circuit():
    qml.RX(np.pi / 2, wires=0)
    return qml.counts(wires=0)

When the code above runs, Catalyst generates code for ARTIQ and Sinara, allowing for the timed laser pulses (which we showed in the oscilloscope traces) to be executed. The entire pipeline from Python to physical pulses happens through the open-source stack!

Stay tuned!

You can develop expertise in programming and controlling quantum hardware through the integration between PennyLane, Catalyst, and OQD's trapped-ion hardware. This is invaluable experience for researchers that are looking to research and develop their own applications with the FPGA-level controls fully visible. Although this is not necessary for all users, as PennyLane and Catalyst can abstract away many of those layers, the transparency that a fully open-source stack provides is a great step towards democratizing quantum computing. As education and practical utilization of quantum computing ramps up across the world, OQD and Xanadu's efforts provide a foundational basis for enabling the quantum workforce of tomorrow.

The collaboration is ongoing and we are looking to share more as we build out more features (especially with one of our software partners at Haiqu 👀) If you are interested in learning more about OQD’s open-source platform, learn more about it on their website! For those curious about the latest and greatest developments around PennyLane and Catalyst, stay tuned to our notes for the latest release.