Reduce, Reuse, Recycle, for Helium’s Sake
When was the last time you knowingly encountered helium, the gas that makes balloons float and children—OK, adults too—giggle and talk in high, squeaky voices after inhaling it? Likely at a birthday party, wedding, or another celebration, right?
Helium, however, has many applications beyond party balloons. Pure, high-quality helium is critical to several industries and technologies, including quantum computing.
“Many quantum computing technologies use helium,” said Steve Sanders, director of engineering at Quantinuum, which develops trapped-ion quantum computing technologies. “We use it to keep our ion traps very cold because they operate better below 50 degrees Kelvin. The helium also has the effect of lowering the gas pressure inside our physics packages and keeping the few remaining gas atoms cold. Fewer gas atoms mean fewer collisions with our ions. And cold gas atoms have far less energy, so even if they collide with our ions, they don’t disturb them.”
Found among the stars, helium is one of the most abundant elements in the universe, second only to hydrogen. On earth, where it’s formed from alpha-particles of radioactive elements decaying beneath the surface, helium is a finite resource. And that’s why Quantinuum has significantly invested in staff and infrastructure to reuse as much helium as possible.
“We recognize the physical and socioeconomic impacts of both limited natural resources and climate change, so it’s crucial for us to operate as sustainably as possible,” said Tony Uttley, president and chief operating officer at Quantinuum.
Andy Miller, an engineer at Quantinuum, spends his days managing and maintaining the extensive helium recovery system at the company’s Colorado campus. (Quantinuum has a smaller system at its laboratory space in Minnesota.)
“Our helium liquefaction system is a process plant that converts helium from a gas into a liquid. That liquid is then moved into the labs where it provides cooling to the quantum computing application. As it provides cooling, it becomes a gas again and then is transported into our recovery pipeline, which is installed throughout the facility, and the recovery piping leads to a big gasbag,” Miller explains.
“This gasbag is a giant balloon that fills up with gaseous helium. And as that balloon fills up with helium, it is monitored by a level sensor that measures the size of the gas bag. Once the bag inflates to a certain volume, it turns on a high-pressure compressor. The high-pressure compressor then pulls helium from the gas bag and sends the helium over to high-pressure storage. The helium is stored in high-pressure cylinders which are 20 feet in length and two feet in diameter. It's stored as a high-pressure gas until it's ready to be liquefied again and sent back to the labs to continue the cooling and recycle process.”
This process enables the team to recover and reuse large amounts of helium.
“Helium is an absolutely 100% nonrenewable resource,” Miller emphasizes. “Once we pull helium out of the ground, it is so light that it will float up out of the atmosphere. It’s important we recover and reuse as much of it as possible.”
About Quantinuum
Quantinuum, the world’s largest integrated quantum company, pioneers powerful quantum computers and advanced software solutions. Quantinuum’s technology drives breakthroughs in materials discovery, cybersecurity, and next-gen quantum AI. With over 500 employees, including 370+ scientists and engineers, Quantinuum leads the quantum computing revolution across continents.
Visit Quantinuum at SC26 – Booth 4838
Quantinuum is heading to SC26 in Chicago, and we'd love to see you at Booth 4838 in the Quantum Junction. Stop by during exhibit hours to catch partner theater sessions throughout the day, see what's new with Helios and Nexus, and talk with our team about how quantum computing is expanding its footprint in the HPC datacenter, including hybrid quantum-classical applications.
In our booth:
Join our experts and partners at our kiosks and for short sessions in our theater running throughout the day. Topics include:
- Next Gen Enterprise Computing Partners – how leading enterprises are bringing quantum into their computing strategy
- Error Correction: The Path to Fault Tolerance – where quantum error correction stands today and what comes next
- Develop for the Fault Tolerant Era with Nexus – building, running, and managing quantum workflows on the Nexus platfor
- Helios: The Most Accurate Quantum Computer – a closer look at our latest system and what its performance makes possible
- Startup Partners: Accelerating Quantum Ecosystem Innovation – how startups are building on Quantinuum technology
- Real Commercial Impact – quantum applications in pharma, chemicals, materials, and finance
Coffee and cookies on us
Need a break from the show floor? Our barista will be serving up coffee, and we'll have fresh cookies every afternoon. Grab a cup, pull up a seat for a theater session, and chat with the team.
Catch Quantinuum in the SC26 program
Our experts are also speaking in the SC26 technical program. Add these sessions to your schedule (all times CST):
Speaking Sessions
November 15th
9:45 – 10:00am | Room: W178a
Quantum-HPC Workflows Across Multiple Quantum Computing Platforms: Two Case Studies – part of the 2nd International Workshop for Software Frameworks and Workload Management on Quantum-HPC Ecosystems
Presenting: Philipp Seitz
November 16th
3:30 – 4:00pm | Room: W179a
Software for Large Scale Application – part of the 2nd Annual Workshop on Large-Scale Quantum-Classical Computing (LSQCC)
Presenting: Juan Pederson
November 19th
3:30 – 4:00pm | Room: W181abc
Bringing Quantum Computing to the HPC Datacenter
Presenting: Kentaro Yamamoto
See you in Chicago
Whether you're exploring quantum for the first time or planning how to integrate it with your HPC environment, our team is ready to talk. Find us at Booth 4838 in the Quantum Junction, November 16–19.
Fault-tolerant quantum computing is entering a new phase. At Quantinuum, we have demonstrated almost every piece needed for large-scale fault tolerant hardware, from a universal fault tolerant gate set, to a proven fault tolerant architecture, to large-scale materials simulations with encoded qubits, at world-leading fidelity.
However, that’s only half the battle. Developers need practical tools that make this technology accessible without needing to become experts in quantum error correction.
A good quantum computing software stack should capture and reuse QEC1 expertise, turning the complexity of fault tolerance into capabilities that developers can build with.
"Our ambition is for Nexus to be the platform developers turn to for the fault-tolerant era." - Dr. Rajeeb Hazra, President & CEO, Quantinuum
Here at Quantinuum, we are working hard to make that a reality. Since its launch in 2024, Nexus has grown from managing cloud-based quantum workflows into an environment for end-to-end application development and deployment. Our new multi-year roadmap builds on that foundation, connecting software capabilities with each generation of Quantinuum hardware through Apollo, our universal, fault-tolerant quantum computer planned for 2029. Nexus will progressively handle more of the complexity of fault-tolerant development, helping developers build applications that grow in capability as the hardware advances.
With Nexus, you can explore quantum chemistry and materials using InQuanto, and you can make it fault tolerant using our pre-built fault tolerant primitives. You can use GPUs to decode errors in real time, while benefitting from hardware enabled error suppression like Leakage Repump or Dynamical Decoupling. You can also connect your HPC to our QPUs and use Nexus’ Hybrid workflow management system to enjoy the best of both worlds seamlessly.
Of course, all of the above needs a language framework that is fault tolerant in the first place. That’s why we are thrilled to introduce Guppy FT – Nexus’ fault tolerant quantum programming framework, and Guppy Algorithms, Nexus’ library of reusable algorithmic primitives.
Developing for the fault tolerant era: Guppy FT
“The field of QEC is quite abstract, and it is hard for non-experts to gauge what is feasible on current devices. Guppy FT promotes a game-changing paradigm: QEC is no longer just theory, it is also engineering, it is something you can use.” - the Guppy FT team
As we have been saying, the NISQ2 era is coming to an end. The next challenge is to turn fault tolerance from a hardware milestone into a capability developers can use.
We have built the physical QEC architecture: high-fidelity physical qubits, distance scaling and low logical error rates, all-to-all connectivity and reconfigurable qubits, all the primitives working harmoniously, real-time decoding, circuit optimization, and so on. The next step is ensuring our users can easily enjoy the above: with a fault tolerant programming language framework (Guppy FT) inside a fault tolerant user platform (Nexus).
Guppy FT brings three complementary capabilities together:
- A framework for QEC experts to define fault-tolerant architectures.
- Automatic compilation that takes programs written in standard Guppy and turns them into programs running on fault-tolerant architectures.
- Proprietary codes from our own QEC experts that get you the best performance out of our world-leading hardware.
The result is a programming experience in which developers can write quantum algorithms without having to understand the details of the underlying error-correction architecture, while QEC experts retain the ability to define and optimize the architectures that power those programs.
This separation between what the program does and how it is made fault tolerant is central to the approach.
With Guppy FT, QEC experts define the fault-tolerant architecture once, and application developers can program on it without needing to become QEC experts themselves. Developers can continue to write programs in standard, QEC-agnostic Guppy. The Guppy FT framework then automatically lowers those programs into an encoded, fault-tolerant form suitable for execution.
As fault-tolerant techniques improve, the same high-level programming model can therefore serve as a stable interface between applications and increasingly sophisticated QEC implementations. This approach also makes it possible to evolve the underlying architecture without requiring every application developer to rewrite their programs around its implementation details – a crucial benefit as we stay at the forefront of a quickly evolving field.
Available to users today, Guppy FT is an important step toward software designed for the fault-tolerant era. You can use already-perfected codes, like our high-rate quantum error detection code, through Nexus, with more codes coming online as they are developed.
Optimize your work with Guppy Algorithms & Realtime Analytics
We want you doing more than just writing fault tolerant programs – we want to help you write quickly and optimally.
With Guppy Algorithms, you can save needless repetition of work by constructing complex application-level software workflows in an application-agnostic way. Built on Guppy, Guppy Algorithms combines type-safe Guppy primitives with Python builders to help developers construct quantum algorithms out of already optimized building blocks. Guppy Algorithms is also QEC agnostic, enabling users to evolve their fault tolerance approach as the platform grows, without needing to re-write finished programs.
Current highlights include primitives that help you with:
- Trotterisation for Hamiltonian Simulation
- Quantum linear algebra
- Quantum arithmetic
Using Guppy Algorithms is simple. First, you build your abstract (application-specific) algorithm. Then, you simply compose it with Guppy Algorithms: import your desired implementations of circuit sub-components and bring your workflow to life.
"Guppy FT and Guppy Algorithms add a necessary abstraction on top of Guppy’s flexible programming model, so that application development and QEC research can advance in lockstep without either having to bake in assumptions about the other.” - Seyon Sivarajah, Chief Architect of Developer Tools
Soon, we plan to expand Guppy Algorithms to include end-to-end workflows of reusable components.
Of course, a set of optimized building blocks isn’t enough to ensure every program you write is optimal for execution. To that end, Nexus is introducing two tools to help users understand and optimize hardware execution:
- Real-time metrics that provide execution statistics, including gate counts and shot duration.
- ShotPlot, our tool for visualizing gate scheduling, helping users identify idle periods and improve circuit layout.
With these functionalities, you can try new approaches to minimizing gate counts or runtime with real-time feedback that helps you further optimize your result. Taken together, these new tools ensure that Nexus provides an optimal programming experience, from the circuit level to the user experience.
Using Guppy FT to reduce errors on quantum hardware: an end-to-end demonstration on Helios
To demonstrate Guppy FT, the team ran a Steane-encoded quantum algorithm, HHL, on Quantinuum’s Helios quantum computer.
The team compared three versions of the HHL program, with different settings for Guppy FT’s Steane code ([[7, 1, 3]]) encoding, each with 500 shots. The first used no explicit QEC cycles and performed on-demand, sequential state preparation. The second used Guppy FT’s state factories to parallelize state preparation, and the third also applied three QEC cycles to each of the five qubits.
Each shot is comprised of three stages: the HHL program, mid-circuit error detection, and the inverse of the HHL program. Mid-circuit error detection measures the ancilla qubits used by the HHL program, which it ought to disentangle from the data qubits. If an error is detected, the shot is discarded; otherwise, it moves on to the final stage and is marked as accepted. Fidelity is computed as the proportion of accepted shots that the inverse HHL program successfully returns to the initial state.
The results show that both QEC cycles and parallelized state preparation improve performance. QEC cycles actively correct errors while parallelization shortens execution time, reducing the chance of errors. Together, these results demonstrate how Guppy FT can implement fault-tolerant architectures for practical, end-to-end programs running on real quantum hardware.
Deploy Your Hybrid Quantum-Classical Application
The future of quantum computing is more than fault tolerant: it’s hybrid. Close co-ordination between classical and quantum computing resources will be essential for most killer use-cases, with a combination of AI, HPC, and QPU each working on the sub-components they are best suited for.
We’ve been perfecting hybridization for years now, including hybridizing our QPUs with the Fugaku supercomputer at RIKEN. Along the way, we have developed a robust event-based hybrid compute runtime, now available through Nexus. Our updated hybrid compute framework features:
- Multiple storage implementations
- Workflow attempts and restart improvements
- Runtime configuration files
- OTEL tracing and observability
- Workflow cancellation
- SQLite based state management
Quantinuum Nexus: A foundation for what comes next
Nexus brings together the capabilities and infrastructure needed to develop, analyze, run, and manage hybrid quantum-classical programs across the stack. By unifying quantum programming, validation, fault tolerance, compilation, and execution in one place, with interoperability across third-party environments, Nexus is making fault tolerance a practical reality.
Nexus users are already using our quantum processors to explore applications in finance, nuclear physics, particle physics, benchmarking, computational chemistry, and more. As our Nexus roadmap evolves, we plan on deploying ecosystem tools and libraries, as well as an applications marketplace where developers can monetize their work.
“Quantum computers are on the brink of achieving fault tolerance at scale. It's exciting: we are entering terra incognita for what we can compute. The new challenge is putting our high-level quantum algorithms into the right form to successfully run on error-corrected hardware. Developer platforms like Nexus help us bridge that gap between quantum algorithm design and deployment
-José Ignacio Latorre, Director, Centre for Quantum Technologies at the National University of Singapore at the National University of Singapore
By bringing everything together, Nexus is becoming a robust platform in which fault tolerance is a feature, rather than a barrier to entry.
Get ready for the fault tolerant future.
1 Quantum Error Correction
2 Noisy Intermediate Scale Quantum
By Chris Langer
Trustworthy answers are a prerequisite for useful quantum computing. First build machines that deliver answers reliably. Then focus on delivering them quickly.
A trustworthy answer also needs to arrive soon enough to be useful. But understanding how long that takes requires looking beyond the speed of any single operation.
Think about your commute: a car’s 0–60 time doesn’t tell you when you’ll arrive. Traffic, detours, and bottlenecks all affect the journey. Quantum computing works much the same way. No isolated metric, including gate speed, indicates how quickly the entire system can get the job done.
The goal of quantum computing is to solve valuable problems reliably and soon enough to matter.
At Quantinuum, we are pursuing that goal by scaling our systems and removing bottlenecks. Speed depends on how much work is required to make a computation reliable and how much of that work can happen simultaneously. We are improving how we build and operate logical qubits—an essential mechanism for complex computations—through more efficient error correction, faster qubit movement, and more parallel operations.
Understanding how these advances translate into faster answers starts with looking beyond the speed of a single gate.
The Gap Between Fast Gates and Useful Answers
Gate speed reveals how quickly a single step happens in a quantum calculation. It does not tell us how many steps are needed, how many can happen together, or how often a computation must be repeated.
An example illustrates the distinction.
Researchers from the University of Tokyo ran a small, three-qubit circuit on superconducting and trapped-ion systems.1 Armed with faster gates, the superconducting machine executed the circuit roughly 200 times faster. But it needed about 50 times more repetitions to reach comparable accuracy, reducing its practical speed advantage to approximately four times.
Faster gates led to faster answers in this example, but the headline execution speed overstated the advantage dramatically.
Even on a modestly larger circuit, the fourfold advantage could disappear entirely. A more complicated circuit means more room for errors and significantly more repetitions to overcome them. Now consider what is required of the systems, larger still, to solve real-world challenges. This calls for a move to logical qubits, which spread information across multiple physical qubits so that errors can be detected and corrected without loss.
At that scale, the question becomes how quickly the system can do useful work while keeping errors under control. The metric that tracks the rate of useful work is logical throughput, the amount of useful work a system completes per second.
What Drives Logical Throughput and Faster Answers
Logical throughput depends on logical clock rate (how quickly logical operations happen) and parallelism (how many can happen at once).
Consider two hypothetical machines: the first completes one logical operation at a time, each taking a microsecond. The second performs 1,000 independent logical operations simultaneously, each taking a millisecond. In one millisecond, each machine completes 1,000 operations. The second machine’s operations take 1,000 times longer, but parallelism offsets the difference.
Error correction takes time and physical qubits. Using both more efficiently can speed up logical operations and enable more work in parallel.
Three levers help improve that throughput:
Connectivity. Better connectivity enables error correction that is more efficient in time and space. Faster correction improves logical clock rate; fewer physical qubits per logical qubit leave room for more logical qubits. Connectivity also enables logical operations to work in parallel.
Fidelity. More reliable physical operations reduce the resources needed for error correction. This improves efficiency in space: fewer physical qubits can deliver the required logical reliability, leaving capacity for more logical qubits.
Scale. More physical qubits create room for more logical qubits. Efficient error correction, strong connectivity, and enough places to perform operations help turn that added capacity into more work happening at once. As systems scale to 1,000 logical qubits and beyond, putting more qubits to work simultaneously can help offset slower individual operations.
How Quantinuum Is Turning Scale into Speed
Faster gates, better connectivity, efficient error correction, and greater parallelism must work together. That is the thinking behind Quantinuum’s approach to scaling.
We are working to accelerate gate execution, qubit movement, and other factors while reducing unnecessary operations and improving error-correction efficiency. More efficient error correction lets us reach the required reliability with fewer resources. That means we can exploit parallelism and spend more of our extra qubits on speed.
Superconducting systems, by contrast, boast faster clock speeds, but limited connectivity forces more operations to run in sequence. That constrains the parallel capabilities of these systems, the other side of the throughput equation. Put simply, completing each step faster does not guarantee finishing the job sooner if more steps must wait their turn. Greater error-correction overhead also leaves fewer logical qubits available for computation from a given number of physical qubits. Even with more logical qubits, connectivity remains a separate constraint on how many operations can run in parallel. Together, these factors limit how effectively faster physical gates translate into faster computation.
Quantinuum’s architecture allows us to scale logical qubits and facilitate greater throughput. Maximizing the value of qubits remains an engineering challenge, which our roadmap to larger, faster machines addresses in three steps:
First, improve how qubits move. Sol, planned to launch in 2027, is our expected proving ground for a two-dimensional architecture that allows more efficient, parallel rearrangement of qubits as the system grows. Our prototypes have already demonstrated our two-dimensional geometry, operating concepts, and scalable controls work.2 We continue to improve the speed of qubit movement.
Second, create more places to work simultaneously. Adding operating zones enables more operations to run at once, increasing throughput by leveraging space.
Third, increase scale. Our planned progression from Sol to Apollo (targeted to launch in 2029) and then Lumos in the decade ahead is intended to increase physical qubit counts from approximately 200 to thousands and eventually millions.
On these larger systems, efficient error correction and connectivity-enabled parallelism will allow us to turn more qubits into dramatically higher computational throughput.
Measure the Time to a Useful Answer
As quantum computers grow, they must solve larger problems in a useful amount of time. Fast gates can’t guarantee that. Any speed advantage on a small, uncorrected circuit could vanish at the logical level. For superconducting systems, scaling this small-scale edge would mean overcoming architectural limits on connectivity and efficient error correction, which is no small feat.
For users and investors, the speed equation includes how much work the system requires, how efficiently it corrects errors, and how much computation it can perform at once. Additional qubits deliver their full value when these capabilities translate scale into increased logical throughput.
It doesn’t matter how fast you get to the wrong answer. What matters is getting the right answers efficiently. Returning to the commute analogy, we’re adding horsepower to our car and identifying the traffic detours on the road. The measure of progress will be how quickly we arrive at the destination.
References:
[1] E. Lötstedt and K. Yamanouchi, “Comparison of current quantum devices for quantum computing of Heisenberg spin chain dynamics,” Chemical Physics Letters, vol. 856, Art. no. 141817, Feb. 2024, doi: 10.1016/j.cplett.2023.141817.
[2] R. D. Delaney et al., “Scalable Multispecies Ion Transport in a Grid-Based Surface-Electrode Trap,” Physical Review X, vol. 14, no. 4, p. 041028, 2024, doi: 10.1103/PhysRevX.14.041028.
Forward-Looking Statements
This post contains forward-looking statements within the meaning of the Private Securities Litigation Reform Act of 1995. These include statements about Quantinuum's technology and product roadmap; the expected timing, capabilities, and performance of future systems, including Sol, Apollo, and Lumos; anticipated improvements in error correction, qubit transport, parallelism, and logical throughput; and the potential applications of quantum computing. Words such as "will," "intend," "plan," "expect," "target," "designed to," "may," "can," "could," and similar expressions identify forward-looking statements.
These statements are based on current expectations and assumptions and are subject to risks and uncertainties that could cause actual results to differ materially. These risks include technical challenges in scaling quantum hardware and error correction; delays in development, manufacturing, or supply of components; the pace of customer adoption; competition and advances in alternative technologies; our ability to fund research and development; and the other risks described under "Risk Factors" in the prospectus for our initial public offering and in our most recent Quarterly Report on Form 10-Q, each filed with the Securities and Exchange Commission. Forward-looking statements speak only as of the date of this post, and we undertake no obligation to update them, except as required by law.