Untangling the Mysteries of Knots with Quantum Computers

Today, the Quantinuum software team is excited to announce Guppy, a new quantum programming language for the next generation of quantum computing—designed to work with upcoming hardware like Helios, our most powerful system yet. You can download Guppy today and start experimenting with it using our custom-built Selene emulator. Both Guppy and Selene are open source and are capable of handling everything from traditional circuits to dynamic, measurement-dependent programs such as quantum error correction protocols.

What is Guppy?

Guppy is a quantum-first programming language designed from the ground up to meet the needs of state-of-the-art quantum computers. Embedded in Python, it uses syntax that closely resembles Python, making it instantly familiar to developers. Guppy also provides powerful abstractions and compile-time safety that go far beyond traditional circuit builders like pytket or Qiskit.

Key Features

• Pythonic & Embedded
  ‍Guppy integrates seamlessly with existing Python codebases and libraries, offering a concise and expressive alternative to imperative builder patterns. Its source language approach supports higher levels of abstraction—unlocking algorithmic innovations that may not be discovered otherwise.

• Safety by Design
  Quantum computers are scarce, and access is limited—often involving long queues to run programs. Debugging runtime errors on real hardware isn't just time-consuming; it's costly. Guppy is statically compiled and strongly typed, helping catch bugs early in development. It enforces principles like no-cloning, prevents qubit memory leaks, and offers clear, actionable error messages.

• Beyond Circuits: The Quantum Kernel
  Guppy programs are more than circuit descriptions—they are quantum kernels, supporting rich control flow based on measurement outcomes, function calls, and complex data types. This is essential for implementing adaptive quantum algorithms.

Example Program

Guppy is designed to be readable and expressive, while enabling precise, low-level quantum programming.

This example implements the gate V3 = (I + 2iZ)/√5 using a probabilistic repeat-until-success scheme^[1].

If both X-basis measurements on the top two qubits return 0, the V₃ gate is successfully applied to the input state |ψ⟩; otherwise, the identity is applied. Since this succeeds with a probability of 5/8, we can repeat the procedure until success.

Let’s implement this in Guppy.

First, we’ll define a helper function to prepare a scratch qubit in the |+⟩ state:

@guppy
def plus_q() -> qubit:
    """Allocate and prepare a qubit in the |+> state"""
    q = qubit()
    h(q)
    return q

Next, a function for performing X-basis measurement:

@guppy
def x_measure(q: qubit @ owned) -> bool:
    """Measure the qubit in the X basis and return the result."""
    h(q)
    return measure(q)

The @owned annotation tells the Guppy compiler that we’re taking ownership of the qubit, not just borrowing it—a concept familiar to Rust programmers. This is required because measurement deallocates the qubit, and the compiler uses this information to track lifetimes and prevent memory leaks.

The @guppy decorator marks functions as Guppy source code. Oustide these functions, we can use regular Python - like setting a maximum attempt limit:

MAX_ATTEMPTS = 1000

With these pieces in place, we can now implement the full protocol:

@guppy
def v3_rus(q: qubit) -> int:
    attempt = 0
    while attempt < comptime(MAX_ATTEMPTS):
        attempt += 1
        a, b = plus_q(), plus_q()

        toffoli(a, b, q)
        s(q)
        toffoli(a, b, q)

        a_x, b_x = x_measure(a), x_measure(b)

        if not (a_x or b_x):
            break

        z(q)

    return attempt

What’s happening here?

Learn More

There's a lot more to Guppy, including:

• Polymorphism and generics
• Linear typing and ownership tracking
• Statically sized arrays and custom data types 
• Compile-time metaprogramming via Python

Explore more in the Guppy documentation

Why We Built Guppy for Helios

Helios represents a major leap forward for Quantinuum hardware—with more qubits, lower error rates, and advanced runtime features that require a new class of programming tools. Guppy provides the expressive power needed to fully harness Helios's capabilities—features that traditional circuit-building tools simply can't support.

See our latest roadmap update for more on Helios and what's coming.

Simulate Today with Selene

Quantum hardware access is limited—but development shouldn't be. Selene is our new open-source emulator, designed to run compiled Guppy programs accurately—including support for noise modeling. Unlike generic simulators, Selene models advanced runtime behavior unique to Helios, such as measurement-dependent control flow and hybrid quantum-classical logic.

Selene supports multiple simulation backends:

• Statevector simulation (via Quest)
• Stabilizer simulation (via Stim)
• Classical replay: replay simple programs by providing measurement outcomes
• More plugins coming soon.

Whether you're prototyping new algorithms or testing low-level error correction, Selene offers a realistic, flexible environment to build and iterate.

Get Started

Guppy is available now on GitHub and PyPi under the Apache 2 license. Try it out with Selene, read the docs, and start building for the future of quantum computing today.

👉 Getting started with Guppy and Selene

‍

1. Paetznick, A., & Svore, K. M. (2014). Repeat-Until-Success: Non-deterministic decomposition of single-qubit unitaries. arXiv preprint arXiv:1311.1074 ↩ 

Our next-generation quantum computer, Helios, will come online this year as more than a new chip. It will arrive as a full-stack platform that sets a new standard for the industry.

With our current and previous generation systems, H2 and H1, we have set industry records for the highest fidelities, pioneered the teleportation of logical qubits, and introduced the world’s first commercial application for quantum computers. Much of this success stems from the deep integration between our software and hardware.

Today, we are excited to share the details of our new software stack. Its features and benefits, outlined below, enable a lower barrier to entry, faster time-to-solution, industry-standard access, and the best possible user experience on Helios.

Most importantly, this stack is designed with the future in mind as Quantinuum advances toward universal, fully fault-tolerant quantum computing.

Register for our September 18^th webinar on our new software stack

Our Next-Generation Software Stack: What’s New

Our Current Generation Software Stack
Currently, the solutions our customers explore on our quantum hardware, which span cybersecurity, quantum chemistry, and quantum AI, plus third-party programs, are all powered by two middleware technologies: 

• TKET, an open-source tool kit used by developers to build quantum software programs; and
• Nexus, a cloud-based SaaS platform, is the pathway to access our hardware, as well as third-party hardware. Nexus is our all-in-one computing platform, the entry point to everything quantum.

Our Next Generation Software Stack
The launch of Helios will come with an upgraded software stack with new features. We’re introducing two key additions to the stack, specifically:

• Guppy, a new, open-source programming language based on Python, one of the most popular general-use programming languages for classical computing; and 
• Selene, a platform that partially emulates Helios, is used to perform program analysis and verification. Selene can be seen almost as a “digital sister” for Helios. 

Moving forward, users will now leverage Guppy to run software applications on Helios and our future systems. TKET will be used solely as a compiler tool chain and for the optimization of Guppy programs.

Nexus, which remains as the default pathway to access our hardware, and third-party hardware, has been upgraded to support Guppy and provide access to Selene. Nexus also supports Quantum Intermediate Representation (QIR), an industry standard, which enables developers to program with languages like NVIDIA CUDA-Q, ensuring our stack stays accessible to the whole ecosystem.

With this new stack running on our next generation Helios system, several benefits will be delivered to the end user, including, but not limited to, improved time-to-solution and reduced memory error for programs critical to quantum error correction and utility-scale algorithms.

Below, we dive deeper into these upgrades and what they mean for our customers.

Introducing Guppy: A Purpose-Built Language for Quantum Programming

‍

‍

Designed for the Next Era of Quantum Computing
Guppy is a new programming language hosted in Python, providing developers with a familiar, accessible entry point into the next era of quantum computing.

As Quantinuum leads the transition from the noisy intermediate scale quantum (NISQ) era to fault-tolerant quantum computing, Guppy represents a fundamental departure from legacy circuit-building tools. Instead of forcing developers to construct programs gate-by-gate, a tedious and error-prone process, Guppy treats quantum programs as structured, dynamic software.

With native support for real-time feedback and common programming constructs like ‘if’ statements and ‘for’loops, Guppy enables developers to write complex, readable programs that adapt as the quantum system evolves. This approach unlocks unprecedented power and clarity, far surpassing traditional tools.

Designed with fault-tolerance in mind, Guppy also optimizes qubit resource management automatically, improving efficiency and reducing developer overhead.

All Guppy programs can be seamlessly submitted and managed through Nexus, our all-in-one quantum computing platform.

Find out more at guppylang.org

The Most Flexible Approach to Quantum Error Correction
When it comes to quantum error correction (QEC), flexibility is everything. That is why we designed Guppy to reduce barriers to entry to access necessary features for QEC.

Unlike platforms locked into rigid, hardware-specific codes, Quantinuum’s QCCD architecture gives developers the freedom to implement any QEC code. In a rapidly evolving field, this adaptability is critical: the ability to test and deploy the latest techniques can mean the difference between achieving quantum advantage and falling behind.

With Guppy, developers can implement advanced protocols such as magic state distillation and injection, quantum teleportation, and other measurement-based routines, all executed dynamically through our real-time control system. This creates an environment where researchers can push the limits of fault-tolerance now—not years from now.

In addition, users can employ NVIDIA’s CUDA-QX for out-of-the-box QEC, without needing to worry about writing their own decoders, simplifying the development of novel QEC codes.

By enabling a modular, programmable approach to QEC, our stack accelerates the path to fault-tolerance and positions us to scale quickly as more efficient codes emerge from the research frontier.

Real-Time Control for True Quantum Computing
Integrated seamlessly with Guppy is a next-generation control system powered by a new real-time engine, a key breakthrough for large-scale quantum computing.

This control layer makes our software stack the first commercial system to deliver full measurement-dependent control with undefined sequence length. In practical terms, that means operations can now be guided dynamically by quantum measurements as they occur—a critical step toward truly adaptive, fault-tolerant algorithms.

At the hardware level, features like real-time transport enable dynamic software capabilities, such as conditionals, loops, and recursion, which are all foundational for scaling from thousands to millions of qubits.

These advances deliver tangible performance gains, including faster time-to-solution, reduced memory error, and greater algorithmic efficiency, providing the foundational support required to convert algorithmic advances into useful real-world applications.

Meet Selene: A “Digital Sister” for Helios and Beyond 

Quantum hardware access is limited, but development shouldn't be. Selene is our new open-source emulator, built to model realistic, entangled quantum behavior with exceptional detail and speed.

Unlike generic simulators, Selene captures advanced runtime behavior unique to Helios, including measurement-dependent control flow and hybrid quantum-classical logic. It runs Guppy programs out of the box, allowing developers to start building and testing immediately without waiting for machine time.  

Selene supports multiple simulation backends, giving users state-of-the-art options for their specific needs, including backends optimized for matrix product state and tensor network simulations using NVIDIA GPUs and cuQuantum. This ensures maximum performance both on the quantum processor and in simulation.

Nexus: Bringing It All Together

These new features, and more, are available through Nexus, our all-in-one quantum computing platform.

Nexus serves as the middle layer that connects every part of the stack, providing a cloud-native SaaS environment for full-stack workflows, including server-side Selene instances. Users can manage Guppy programs, analyze results, and collaborate with others, all within a single, streamlined platform.

Further, Selene users who submit quantum state-vector simulations—the most complete and powerful method to simulate a general quantum circuit on a classical computer—through Nexus will be leveraging the NVIDIA cuQuantum library for efficient GPU-powered simulation.

Bringing Us All Together

Our entire stack, including Nexus and Selene, supports the industry-standard Quantum Intermediate Representation (QIR) as input, allowing users to program in their preferred programming language. QIR provides a common format for accessing a range of quantum computing backends, and Quantinuum Helios will support the full Adaptive Profile QIR This means developers can generate programs for Helios using tools like NVIDIA CUDA-Q, Microsoft Q#, and ORNL XACC.

Always Looking Forward

Our customers choose Quantinuum as their top quantum computing partner because no one else matches our team or our results. We remain the leaders in quantum computing and the only provider of integrated quantum resources that will address our society’s most complex problems.

That future is already taking shape. With Helios and our new software stack, we are building the foundation for scalable, programmable, real-time quantum computing.

Wherever you’re sitting right now, you’re probably surrounded by the fruits of modern semiconductor technology. Chips aren't only in your laptops and cell phones – they're in your car, your doorbell, your thermostat, and even your toaster. Importantly, semiconductor-based chips are also in the heart of most quantum computers.

While quantum computing holds transformative potential, it faces two major challenges: first, achieving low error operations (say one in a billion), and second, scaling systems to enough qubits to address complex, real-world problems (say, on the order of a million). Quantinuum is proud to lead the industry in providing the lowest error rates in the business, but some continue to question whether our chosen modality, trapped-ion technology, can scale to meet these ambitious goals.

Why the doubt? Well, early demonstrations of trapped-ion quantum computers relied on bulky, expensive laser sources, large glass optics, and sizeable ion traps assembled by hand. By comparison, other modalities, such as semiconductor and superconductor qubits, resemble conventional computer chips. However, our quantum-charge-coupled device (QCCD) architecture shares the same path to scaling: at their core, our quantum computers are also chip-based. By leveraging modern microfabrication techniques, we can scale effectively while maintaining the advantage of low error rates that trapped ions provide.

Fortunately, we are at a point in history where QCCD quantum computing is already more compact compared to the early days. Traditional oversized laser sources have already been replaced by tiny diode lasers based on semiconductor chips, and our ion traps have already evolved from bulky, hand-assembled objects to traps fabricated on silicon wafers. The biggest remaining challenge lies in the control and manipulation of laser light.

For this next stage in our journey, we have turned to Infineon. Infineon not only builds some of the world’s leading classical computer chips, but they also bring in-house expertise in ion-trap quantum computing. Together, we are developing a chip with integrated photonics, bringing the control and manipulation of light fully onto our chips. This innovation drastically reduces system complexity and paves the way for serious scaling.

Since beginning work with Infineon, our pace of innovation has accelerated. Their expertise in fabricating waveguides, building grating couplers, and optimizing deposition processes for ultra-low optical loss gives us a significant advantage. In fact, Infineon has already developed deposition processes with the lowest optical losses in the world—a critical capability for building high-performance photonic systems.

Their impressive suite of failure analysis tools, such as electron microscopes, SIMS, FIB, AFMs, and Kelvin probes, allow us to diagnose and correct failures in days rather than weeks. Some of these tools are in-line, meaning analysis can be performed without removing devices from the cleanroom environment, minimizing contamination risk and further accelerating development.

Together, we are demonstrating that QCCD quantum computing is fundamentally a semiconductor technology—just like conventional computers. While seeming like it’s a world away, quantum computing is now closer to home than ever.