At Quantinuum, we pay attention to every detail. From quantum gates to teleportation, we work hard every day to ensure our quantum computers operate as effectively as possible. This means not only building the most advanced hardware and software, but that we constantly innovate new ways to make the most of our systems.

A key step in any computation is preparing the initial state of the qubits. Like lining up dominoes, you first need a special setup to get meaningful results. This process, known as state preparation or “state prep,” is an open field of research that can mean the difference between realizing the next breakthrough or falling short. Done ineffectively, state prep can carry steep computational costs, scaling exponentially with the qubit number.

Recently, our algorithm teams have been tackling this challenge from all angles. We’ve published three new papers on state prep, covering state prep for chemistry, materials, and fault tolerance.

In the first paper, our team tackled the issue of preparing states for quantum chemistry. Representing chemical systems on gate-based quantum computers is a tricky task; partly because you often want to prepare multiconfigurational states, which are very complex. Preparing states like this can cost a lot of resources, so our team worked to ensure we can do it without breaking the (quantum) bank.

To do this, our team investigated two different state prep methods. The first method uses Givens rotations, implemented to save computational costs. The second method exploits the sparsity of the molecular wavefunction to maximize efficiency.

Once the team perfected the two methods, they implemented them in InQuanto to explore the benefits across a range of applications, including calculating the ground and excited states of a strongly correlated molecule (twisted C_2 H_4). The results showed that the “sparse state preparation” scheme performed especially well, requiring fewer gates and shorter runtimes than alternative methods.

In the second paper, our team focused on state prep for materials simulation. Generally, it’s much easier for computers to simulate materials that are at zero temperature, which is, obviously, unrealistic. Much more relevant to most scientists is what happens when a material is not at zero temperature. In this case, you have two options: when the material is steadily at a given temperature, which scientists call thermal equilibrium, or when the material is going through some change, also known as out of equilibrium. Both are much harder for classical computers to work with.

In this paper, our team looked to solve an outstanding problem: there is no standard protocol for preparing thermal states. In this work, our team only targeted equilibrium states but, interestingly, they used an out of equilibrium protocol to do the work. By slowly and gently evolving from a simple state that we know how to prepare, they were able to prepare the desired thermal states in a way that was remarkably insensitive to noise.

Ultimately, this work could prove crucial for studying materials like superconductors. After all, no practical superconductor will ever be used at zero temperature. In fact, we want to use them at room temperature – and approaches like this are what will allow us to perform the necessary studies to one day get us there.

Finally, as we advance toward the fault-tolerant era, we encounter a new set of challenges: making computations fault-tolerant at every step can be an expensive venture, eating up qubits and gates. In the third paper, our team made fault-tolerant state preparation—the critical first step in any fault-tolerant algorithm—roughly twice as efficient. With our new “flag at origin” technique, gate counts are significantly reduced, bringing fault-tolerant computation closer to an everyday reality.

The method our researchers developed is highly modular: in the past, to perform optimized state prep like this, developers needed to solve one big expensive optimization problem. In this new work, we’ve figured out how to break the problem up into smaller pieces, in the sense that one now needs to solve a set of much smaller problems. This means that now, for the first time, developers can prepare fault-tolerant states for much larger error correction codes, a crucial step forward in the early-fault-tolerant era.

On top of this, our new method is highly general: it applies to almost any QEC code one can imagine. Normally, fault-tolerant state prep techniques must be anchored to a single code (or a family of codes), making it so that when you want to use a different code, you need a new state prep method. Now, thanks to our team’s work, developers have a single, general-purpose, fault-tolerant state prep method that can be widely applied and ported between different error correction codes. Like the modularity, this is a huge advance for the whole ecosystem—and is quite timely given our recent advances into true fault-tolerance.

This generality isn’t just applicable to different codes, it’s also applicable to the states that you are preparing: while other methods are optimized for preparing only the |0> state, this method is useful for a wide variety of states that are needed to set up a fault tolerant computation. This “state diversity” is especially valuable when working with the best codes – codes that give you many logical qubits per physical qubit. This new approach to fault-tolerant state prep will likely be the method used for fault-tolerant computations across the industry, and if not, it will inform new approaches moving forward.

From the initial state preparation to the final readout, we are ensuring that not only is our hardware the best, but that every single operation is as close to perfect as we can get it.

• The Sanger Institute illustrates the value of quantum computing to genomics research
• Quantinuum supports developments in a field that promises to deliver a profound and positive societal impact

Twenty-five years ago, scientists accomplished a task likened to a biological moonshot: the sequencing of the entire human genome.

The Human Genome Project revealed a complete human blueprint comprising around 3 billion base pairs, the chemical building blocks of DNA. It led to breakthrough medical treatments, scientific discoveries, and a new understanding of the biological functions of our body.

Thanks to technological advances in the quarter-century since, what took 13 years and cost $2.7 billion then can now be done in under 12 minutes for a few hundred dollars. Improved instruments such as next-generation sequencers and a better understanding of the human genome – including the availability of a “reference genome” – have aided progress, alongside enormous advances in algorithms and computing power.

But even today, some genomic challenges remain so complex that they stretch beyond the capabilities of the most powerful classical computers operating in isolation. This has sparked a bold search for new computational paradigms, and in particular, quantum computing.

Quantum Challenge: Accepted

The Wellcome Leap Quantum for Bio (Q4Bio) challenge is pioneering this new frontier. The program funds research to develop quantum algorithms that can overcome current computational bottlenecks. It aims to test the classical boundaries of computational genetics in the next 3-5 years.

One consortium – led by the University of Oxford and supported by prestigious partners including the Wellcome Sanger Institute, the Universities of Cambridge, Melbourne, and Kyiv Academic University – is taking a leading role.

“The overall goal of the team’s project is to perform a range of genomic processing tasks for the most complex and variable genomes and sequences – a task that can go beyond the capabilities of current classical computers” – Wellcome Sanger Institute press release, July 2025

Selecting Quantinuum

Earlier this year, the Sanger Institute selected Quantinuum as a technology partner in their bid to succeed in the Q4Bio challenge.

Our flagship quantum computer, System H2, has for many years led the field of commercially available systems for qubit fidelity and consistently holds the global record for Quantum Volume, currently benchmarked at 8,388,608 (2²³).

In this collaboration, the scientific research team can take advantage of Quantinuum’s full stack approach to technology development, including hardware, software, and deep expertise in quantum algorithm development.

“We were honored to be selected by the Sanger Institute to partner in tackling some of the most complex challenges in genomics. By bringing the world’s highest performing quantum computers to this collaboration, we will help the team push the limits of genomics research with quantum algorithms and open new possibilities for health and medical science.” – Rajeeb Hazra, President and CEO of Quantinuum

Quantum for Biology

At the heart of this endeavor, the consortium has announced a bold central mission for the coming year: to encode and process an entire genome using a quantum computer. This achievement would be a potential world-first and provide evidence for quantum computing’s readiness for tackling real-world use cases.

Their chosen genome, the bacteriophage PhiX174, carries symbolic weight, as its sequencing earned Fred Sanger his second Nobel Prize for Chemistry in 1980. Successfully encoding this genome quantum mechanically would represent a significant milestone for both genomics and quantum computing.

Sooner than many expect, quantum computing may play an essential role in tackling genomic challenges at the very frontier of human health. The Sanger Institute and Quantinuum’s partnership reminds us that we may soon reach an important step forward in human health research – one that could change medicine and computational biology as dramatically as the original Human Genome Project did a quarter-century ago.

“Quantum computational biology has long inspired us at Quantinuum, as it has the potential to transform global health and empower people everywhere to lead longer, healthier, and more dignified lives.” – Ilyas Khan, Founder and Chief Product Officer of Quantinuum

Every year, The IEEE International Conference on Quantum Computing and Engineering – or IEEE Quantum Week – brings together engineers, scientists, researchers, students, and others to learn about advancements in quantum computing.

This year’s conference from August 31st – September 5th, is being held in Albuquerque, New Mexico, a burgeoning epicenter for quantum technology innovation and the home to our new location that will support ongoing collaborative efforts to advance the photonics technologies critical to furthering our product development.

Throughout IEEE Quantum Week, our quantum experts will be on-site to share insights on upgrades to our hardware, enhancements to our software stack, our path to error correction, and more.

Meet our team at Booth #507 and join the below sessions to discover how Quantinuum is forging the path to fault-tolerant quantum computing with our integrated full-stack.

September 2^nd

Quantum Software Workshop
Quantum Software 2.1: Open Problems, New Ideas, and Paths to Scale
1:15 – 2:10pm MDT | Mesilla

We recently shared the details of our new software stack for our next-generation systems, including Helios (launching in 2025). Quantinuum’s Agustín Borgna will deliver a lighting talk to introduce Guppy, our new, open-source programming language based on Python, one of the most popular general-use programming languages for classical computing.

September 3^rd

PAN08: Progress and Platforms in the Era of Reliable Quantum Computing
1:00 – 2:30pm MDT | Apache

We are entering the era of reliable quantum computing. Across the industry, quantum hardware and software innovators are enabling this transformation by creating reliable logical qubits and building integrated technology stacks that span the application layer, middleware and hardware. Attendees will hear about current and near-term developments from Microsoft, Quantinuum and Atom Computing. They will also gain insights into challenges and potential solutions from across the ecosystem, learn about Microsoft’s qubit-virtualization system, and get a peek into future developments from Quantinuum and Microsoft.

BOF03: Exploring Distributed Quantum Simulators on Exa-scale HPC Systems
3:00 – 4:30pm MDT | Apache

The core agenda of the session is dedicated to addressing key technical and collaborative challenges in this rapidly evolving field. Discussions will concentrate on innovative algorithm design tailored for HPC environments, the development of sophisticated hybrid frameworks that seamlessly combine classical and quantum computational resources, and the crucial task of establishing robust performance benchmarks on large-scale CPU/GPU HPC infrastructures.

September 4^th

PAN11: Real-time Quantum Error Correction: Achievements and Challenges
1:00 – 2:30pm MDT | La Cienega

This panel will explore the current state of real-time quantum error correction, identifying key challenges and opportunities as we move toward large-scale, fault-tolerant systems. Real-time decoding is a multi-layered challenge involving algorithms, software, compilation, and computational hardware that must work in tandem to meet the speed, accuracy, and scalability demands of FTQC. We will examine how these challenges manifest for multi-logical qubit operations, and discuss steps needed to extend the decoding infrastructure from intermediate-scale systems to full-scale quantum processors.

September 5^th

Keynote by NVIDIA
8:00 – 9:30am MDT | Kiva Auditorium

During his keynote talk, NVIDIA’s Head of Quantum Computing Product, Sam Stanwyck, will detail our partnership to fast-track commercially scalable quantum supercomputers. Discover how Quantinuum and NVIDIA are pushing the boundaries to deliver on the power of hybrid quantum and classical compute – from integrating NVIDIA’s CUDA-Q Platform with access to Quantinuum’s industry-leading hardware to the recently announced NVIDIA Quantum Research Center (NVAQC).

Featured Research at the IEEE Poster Session:

Visible Photonic Component Development for Trapped-Ion Quantum Computing
September 2^nd from 6:30 - 8:00pm MDT | September 3^rd from 9:30 - 10:00am MDT | September 4^th from 11:30 - 12:30pm MDT
‍Authors: Elliot Lehman, Molly Krogstad, Molly P. Andersen, Sara Cambell, Kirk Cook, Bryan DeBono, Christopher Ertsgaard, Azure Hansen, Duc Nguyen, Adam Ollanik, Daniel Ouellette, Michael Plascak, Justin T. Schultz, Johanna Zultak, Nicholas Boynton, Christopher DeRose,Michael Gehl, and Nicholas Karl

Scaling Up Trapped-Ion Quantum Processors with Integrated Photonics
September 2^nd from 6:30 - 8:00pm MDT and 2:30 - 3:00pm MDT | September 4^th from 9:30 - 10:00am MDT
Authors: Molly Andersen, Bryan DeBono, Sara Campbell, Kirk Cook, David Gaudiosi, Christopher Ertsgaard, Azure Hansen, Todd Klein, Molly Krogstad, Elliot Lehman, Gregory MacCabe, Duc Nguyen, Nhung Nguyen, Adam Ollanik, Daniel Ouellette, Brendan Paver, Michael Plascak, Justin Schultz and Johanna Zultak

Research Collaborations with the Local Ecosystem

In a partnership that is part of a long-standing relationship with Los Alamos National Laboratory, we have been working on new methods to make quantum computing operations more efficient, and ultimately, scalable.

Learn more in our Research Paper: Classical shadows with symmetries

Our teams collaborated with Sandia National Laboratories demonstrating our leadership in benchmarking. In this paper, we implemented a technique devised by researchers at Sandia to measure errors in mid-circuit measurement and reset. Understanding these errors helps us to reduce them while helping our customers understand what to expect while using our hardware.

Learn more in our Research Paper: Measuring error rates of mid-circuit measurements

From machine learning to quantum physics, tensor networks have been quietly powering the breakthroughs that will reshape our society. Originally developed by the legendary Nobel laureate Roger Penrose, they were first used to tackle esoteric problems in physics that were previously unsolvable.

Today, tensor networks have become indispensable in a huge number of fields, including both classical and quantum computing, where they are used everywhere from quantum error correction (QEC) decoding to quantum machine learning.

In this latest paper, we teamed up with luminaries from the University of British Columbia, California Institute of Technology, University of Jyväskylä, KBR Inc, NASA, Google Quantum AI, NVIDIA, JPMorgan Chase, the University of Sherbrooke, and Terra Quantum AG to provide a comprehensive overview of the use of tensor networks in quantum computing.

Standing on the shoulders of giants

Part of what drives our leadership in quantum computing is our commitment to building the best scientific team in the world. This is precisely why we hired Dr. Reza Haghshenas, one of the world’s leading experts in tensor networks, and a co-author on the paper.

Dr. Haghshenas has been researching tensor networks for over a decade across both academia and industry. Dr. Haghshenas did postdoctoral work under Professor Garnet Chan at Caltech, a leading figure in the use of tensor networks for quantum physics and chemistry.

“Working with Dr. Garnet Chan at Caltech was a formative experience for me”, remarked Dr. Haghshenas. “While there, I contributed to the development of quantum simulation algorithms and advanced classical methods like tensor networks to help interpret and simulate many-body physics.”

Since joining Quantinuum, Dr. Haghshenas has led projects that bring tensor network methods into direct collaboration with experimental hardware teams — exploring quantum magnetism on real quantum devices and helping demonstrate early signs of quantum advantage. He also contributes to widely used simulation tools like QUIMB, helping the broader research community access these methods.

Dr. Haghshenas’ work sits in a broad and vibrant ecosystem exploring novel uses of tensor networks. Collaborations with researchers like Dr. Chan at Caltech, and NVIDIA have brought GPU-accelerated tools to bear on the forefront of applying tensor networks to quantum chemistry, quantum physics, and quantum computing.

A powerful simulation tool

Of particular interest to those of us in quantum computing, the best methods (that we know of) for simulating quantum computers with classical computers rely on tensor networks. Tensor networks provide a nice way of representing the entanglement in a quantum algorithm and how it spreads, which is crucial but generally quite difficult for classical algorithms. In fact, it’s partly tensor networks’ ability to represent entanglement that makes them so powerful for quantum simulation. Importantly, it is our in-house expertise with tensor networks that makes us confident we are indeed moving past classical capabilities.

A theory of evolution

Tensor networks are not only crucial to cutting-edge simulation techniques.  At Quantinuum, we're working on understanding and implementing quantum versions of classical tensor network algorithms, from quantum matrix product states to holographic simulation methods. In doing this, we are leveraging decades of classical algorithm development to advance quantum computing.

A topic of growing interest is the role of tensor networks in QEC, particularly in a process known as decoding. QEC works by encoding information into an entangled state of multiple qubits and using syndrome measurements to detect errors. These measurements must then be decoded to identify the specific error and determine the appropriate correction. This decoding step is challenging—it must be both fast (within the qubit’s coherence time) and accurate (correctly identifying and fixing errors). Tensor networks are emerging as one of the most effective tools for tackling this task.

Looking forward (and backwards, and sideways...)

Tensor networks are more than just a powerful computational tool — they are a bridge between classical and quantum thinking. As this new paper shows, the community’s understanding of tensor networks has matured into a robust foundation for advancing quantum computing, touching everything from simulation and machine learning to error correction and circuit design.

At Quantinuum, we see this as an evolutionary step, not just in theory, but in practice. By collaborating with top minds across academia and industry, we're charting a path forward that builds on decades of classical progress while embracing the full potential of quantum mechanics. This transition is not only conceptual but algorithmic, advancing how we formulate and implement methods utilizing efficiently both classical and quantum computing. Tensor networks aren’t just helping us keep pace with classical computing; they’re helping us to transcend it.

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.