Magic states at QCE26, and the compilers that chased their true price

This guide follows 31 talks on fault-tolerant compilation and magic states at IEEE Quantum Week 2026 in Toronto. Many priced their results in T gates, and several then showed where that price misleads.

On the morning of Sunday 13 September, in Room 801A of the Metro Toronto Convention Centre, Justin Kalloor of UC Berkeley showed a compiler trick that cut T gates by up to 70 percent. Kalloor then did what a team must do before it can budget for magic state distillation, and laid the same circuits out on a chip. The best case on paper, an amplitude estimation circuit, came out more than half as large again. Every snapped rotation had queued for the same shared register. A saving counted in gates had turned into a cost counted in space and time.

Compiler writers have priced their work in T gates for years, and for good reason. An error-corrected quantum computer can do a fixed menu of operations, the Clifford gates, cheaply. Everything else needs a T gate. Each T gate consumes a magic state, a specially prepared qubit made in a part of the chip called a factory. Magic state distillation, the standard way to make one, refines many noisy copies into a few good ones, and the factories can fill most of the machine. So the T count became the coin in which every fault-tolerant program is priced, the way a shop prices goods in coins.

The 31 talks followed here suggest that coin no longer buys what its face says. A T count leaves out layout, waiting and supply. On the speakers’ own evidence, where the code patches sit on the chip, how long they wait and where each magic state comes from now set much of the price of a fault-tolerant program. Cutting T gates still matters, but a team that budgets in them alone should expect a larger bill.

The case for the old coin is strong, and many speakers made it simply by spending it. Hanyu Wang of UCLA trimmed the T count of common arithmetic blocks by about 5 percent, a small saving that matters, Wang argued, because those blocks recur in every algorithm that uses them. The Xanadu tutorial ended both its notebooks with a T count. A T count is simple and does not depend on any one machine, and it lets two papers be compared on the same terms. Those are real virtues when no talk ran a fault-tolerant program on hardware.

The same talks showed where the coin breaks. On the Sunday afternoon Michał Stęchły of PsiQuantum drew a toy circuit with one T gate and watched the company’s estimator count it as seven. A filter that breaks Toffoli gates into smaller parts made it 29. For the rest of the tutorial Stęchły priced programs in PsiQuantum’s own measure, called active volume. Daniel Nino of Xanadu found a different limit. Extra time steps in a hydrogen estimate bought nothing once a readout register set the error floor. On the Tuesday Yuval Baum of Q-CTRL put the warning on a chart, where an 11,000-qubit factoring design needed 43,000 days to run.

Costin Iancu of Lawrence Berkeley National Laboratory carried the argument from layout to supply. Factories built never to keep the chip waiting swallow most of the machine, Iancu said. Growing states one at a time costs far less. Craig Gidney and colleagues published that method in 2024 and call it cultivation, and it works best when a scheduler picks where to grow each state as the program runs. Tasnuva Farheen of Louisiana State University cut the estimated cost of programs by about a third. Farheen did it just by sharing out the error budget to suit each circuit.

Yet the deeper change may be about who mints the coin. Several of the groups here were closely linked, and several of the tools on show were scored by the same people who had built them, on benchmarks they had chosen. PsiQuantum’s tutorial priced its programs in a measure of the company’s own, and that is a fair choice for one firm. Jieyi Long of Theta Labs showed another way, an open contest with a public verifier that cut the cost score of an elliptic-curve circuit by 86.1 percent in two months. When the common coin stops tracking cost, though, each issuer is free to mint its own. Comparing labs then gets harder at the very moment the bills grow large.

Cutting the T count

Most compiler work still starts by cutting T gates. The T gate is the costly step on an error-corrected machine. Four talks went at it from different directions, from single rotations up to whole blocks of classical arithmetic, and the first also showed what such savings look like once the circuit meets a chip.

Berkeley snaps angles to save up to 70 percent

Justin Kalloor, a PhD student at UC Berkeley, claimed up to 70 percent fewer T gates than the standard method. Kalloor snaps rotation angles to easy values. Kalloor worked with Mathias Weiden, Ed Younis, John Kubiatowicz and Costin Iancu, in joint work with Lawrence Berkeley National Laboratory. A machine of this kind cannot turn a qubit by any angle it likes, so each turn is built from a string of T gates, and the standard tool, gridsynth, needs more of them as the error budget gets tight.

Kalloor’s route is phase kickback. A register of spare qubits holds a ready-made pattern of phases, and an adder kicks the wanted angle onto the target for roughly four T gates per spare qubit. It only works for some angles. They must be simple binary fractions of a half turn, which Kalloor calls dyadic. Their method, dyadic phase fixing, snaps the angle nearest such a value, lets the BQSKit toolkit retune the other angles to absorb the error, and repeats while the circuit stays within budget.

Across 14 benchmarks, Kalloor said their method never did worse than gridsynth. The biggest gain came on the 81-qubit amplitude estimation circuit, while a 129-qubit KNN circuit only matched it. The surprise came at layout. On a surface code, Ising-420q shrank 57 percent, but amplitude estimation grew 55 percent and QFT-40q grew 86 percent. Every kickback rotation needs the one gradient register, so they queue. Their sweep found six such registers gave the smallest footprint, and their advice was to judge a compiler as close to the physical circuit as possible.

Cyclosynth makes whole rotations at once

On the Monday, Costin Iancu opened the BQSKit tutorial by treating every compile as an error budget to be spent. Iancu put the toolkit’s core step, which tunes a template circuit numerically to match a target, at about 10 to 12 qubits and roughly 1,000 settings. Beyond that, large circuits must be cut into blocks. The errors in the budget stack up from approximation steps, gate synthesis and the injection of T states.

Kalloor then showed Cyclosynth. Mathias Weiden wrote it, and it builds a whole single-qubit rotation in one go. The usual route splits one rotation into three Z rotations, and in the team’s example needed 158 gates costing 58 T states. Cyclosynth needed 41 gates costing 18. Its search returns a provably minimal T count, Kalloor said. Cost grows at about a third of gridsynth’s rate as the target error shrinks. A version using square roots of T saved about 27 percent more, even though each one costs about 2.5 T states to make. In a live notebook, dyadic fixing cut a four-qubit hydrogen circuit from 126 Z rotations to 46.

UCLA cuts lookup tables, then rotations

Hanyu Wang of the VAST laboratory at UCLA said their toolkit, QCS, cuts a further 30 percent of T gates. That saving comes on top of a quantum lookup table. Wang opened the last block of a workshop on compiling for machines built from atoms, with Wan-Hsuan Lin, Milan Kornjaca, Daniel Tan, Shengtao Wang and Jason Cong among their collaborators. On their chart, a lookup table called QROM cut the T count a hundredfold from a standard baseline. Wang said the extra 30 percent was the average across tests that included Shor’s algorithm, a chemistry run and AES.

Wang turned next to one small rotation. GridSynth needs 42 T gates for the accuracy shown, and each takes about 13 rounds of error correction. A method called STAR instead injects the rotation directly and repeats until the sign comes out right, which the team put at 16 rounds. On neutral atoms, where the qubits themselves are moved, placement also pays. An optimised move plan needed one round where the plain plan needed nine, because atoms sent the same way over the same distance share one move.

Exact T counts for classical arithmetic

Wang returned the next day with exact T counts for small pieces of classical arithmetic, presenting on behalf of Jason Cong at the distributed quantum computing workshop. Wang’s input is a classical function written as a truth table. It becomes a network of XOR and AND steps, and then Clifford and T gates.

The team showed one small network needing 19 T gates under one mapping and 21 under another. So counting AND steps is a poor guide, Wang said. A later optimiser cannot win back the difference. The group works out exact counts for small pieces in advance, then picks the cheapest way to cover the whole network. Wang said the work appeared at DAC this year and beats the best known counts for standard arithmetic blocks by about 5 percent, with a 5.3 percent geometric mean.

A companion compiler, FLaSH, takes this down to the chip layout. It did best on the modular exponentiation step of Shor’s algorithm, where its average cost was 22.20 qubit-seconds against 130.92 and 38.75 for two lookup-table methods. It did a little worse on a Hamiltonian simulation oracle. There it scored 95.54 against 90.84. Wang asked groups who build split machines to plug in cost models of their own.

Laying circuits onto the chip

On a surface code each logical qubit is a square patch of physical qubits. Gates between distant patches use lattice surgery, which merges and splits patches along a path, and paths that run at the same time cannot share an edge. Five talks worked on fitting logical circuits to what a chip can do.

Milan groups qubits that talk the most

Giacomo Lancellotti, a PhD student at Politecnico di Milano, built a compiler that groups qubits by how often they talk to each other, with partners in Turin and at Italy’s national institute of geophysics and volcanology. Finding the best set of paths is a hard search. Slow tools such as WISQ can take hours, Lancellotti said.

Their compiler reads the circuit’s own structure. It weights each pair of qubits by how many two-qubit gates link them and groups them into communities, then places the communities and puts the busiest qubits nearest their partners. Routing takes gates in layers, shortest path first. Every stage runs in polynomial time, so the run time grows gently with circuit size.

On a standard benchmark set the team reported depth overhead under 1 percent, and zero for several circuits on a hexagonal layout, where each patch has six neighbours. Against WISQ version 0.2.4 the claim was up to 30 percent lower depth and about 5 percent on average. The compiler ran in about 0.3 seconds against 81 to 102 seconds. The gain fades for circuits with weak community structure, and Lancellotti said the cost of the T factory sits below the level the compiler models.

Arizona bends logic to fit the hardware

Jack Weinberg of the University of Arizona showed how to bend a logical step into a form a given machine can run. Weinberg wrote the paper with their advisor, Narayanan Rengaswamy. Their raw material is the energy terms that drive a gate. An algorithm fixes what a logical step does inside the code but leaves what it does outside the code free. So any term that does nothing inside the code can be added without changing the logic, and the right one can bring the step within reach of a real machine.

Their cost functions penalise the parts a machine cannot reach, or weight each term by how hard it is to run. Solved directly, the problem grows exponentially. Weinberg could manage six qubits on a laptop. Narrowing the search to standard code families leaves far fewer candidates, and the improved method handled 800 physical qubits in about 150 seconds with 762.9 MB of memory. Weinberg was open that the only case where it has found a useful term so far is contrived, and said there was no good answer yet for gates outside the Clifford set.

Photonic says a good memory is not yet a computer

Daryus Chandra of Photonic warned that a code with good rate and distance still falls short of a computer. Photonic builds silicon spin qubits linked by telecom photons. Chandra’s case study was a family of qLDPC codes called SHYPS, and the usual scorecard for such a code lists rate, distance, check weight and a memory test.

What it leaves out, Chandra said, is most of what a program needs. The missing items were native logical gates, a way to compile any operation, the check schedule, a decoder that keeps up, the logical clock and whether the whole circuit stays fault-tolerant. Chandra called the list illustrative. The choice of code, in Chandra’s view, reaches from the compiler down to the wiring and the classical control.

QuEra says no single abstraction fits every machine

Pedro Lopes of QuEra Computing argued that no one way of writing programs will serve every fault-tolerant machine. Past the noisy era every step is costly. So a program must know its code, how much it can do at once, where its zones are and how data moves. Each kind of code wants its own programs.

Lopes compared the 2004 Cuccaro adder with Gidney’s later one on surface codes with transversal steps. They had the same space-time volume and the same number of magic-state factories, yet very different numbers of controls firing at once. Only the controls told them apart. In the panel that followed, Lopes guessed at perhaps 10,000 fault-tolerant runs a year within a decade, few enough to tune by hand. A machine may return one string of 100 or 200 bits a day or a week, Lopes said, which rules out uses such as portfolio optimisation unless speeds change.

Stevens steers atom loss away from the parts that matter

Xinyi Li of Stevens Institute of Technology cut the logical error rate of surface codes on neutral atoms to about 0.14 times that of a baseline that simply minimises loss. Moving atoms can lose them. CAST, Li’s compiler pass, keeps the total loss fixed but steers where it lands, away from the rows of the code that matter most for decoding and away from the seams of lattice surgery.

It keeps a ledger of how exposed each row is, then reroutes moves or rebinds rows within a small margin of the original total. On codes of distance 5 to 15, CAST beat plain loss minimisation in 35 of 48 settings. The gains have limits. They appear only when risk is uneven and the compiler has room to reroute, Li said. A second paper found that the smallest allowed spacing of 10 micrometres between gates fired at once leaves crosstalk about 10 times the two-qubit error budget in the worst case.

Magic state distillation and its rivals

A standard factory takes 15 noisy magic states and distils one good one. It ties up 11 logical qubits while it works. Cultivation, which Gidney and colleagues published in 2024, grows one magic state on one logical qubit instead. Five talks asked how to supply magic states more cheaply than magic state distillation, and whether some codes could do without a factory at all by running the costly gate straight on their qubits.

PureMagic grows magic states on idle patches

Maxwell Poster, a fifth-year PhD student at UT Austin new to the BQSKit team, argued on the Monday that magic states should be grown on whatever patches of the chip are idle. Iancu added in the room that a factory sized never to keep the chip waiting can take about 95 percent of it. Growing a state in one patch, Iancu said, costs about a hundred times less.

PureMagic lets every spare patch grow a magic state while it is free. When a route needs the patch, it drops the attempt. Each decision must fit inside one logical cycle. That cycle lasts 17 microseconds at distance 17, and the code stays near one microsecond a round. Small joint steps did best, beating a bus-routing baseline by 43 to 152 percent across 29 circuits, and Poster said the gain over a 2025 method called DASCOT reached about 21 times once real set-up delays were charged.

A second piece, still under review, spends the error budget on purpose. Grown states vary in quality. A score decides which ones to keep. When early states come out cleaner than planned, Poster lowers the bar for the rest. Growth alone stalls near an error of one in ten billion. So small factories still have a place, and against the single factory allowed for each budget the pass cut cycles by 69 percent and space-time volume by 58 percent.

Iancu scores the factory in the bill

On the Friday, Costin Iancu presented the PureMagic paper itself. Their co-authors were Steven Hofmeyr, Mathias Weiden, Justin Kalloor and John Kubiatowicz. Iancu began with the cost of factories. Machines built around the standard 15-to-1 block, Iancu said, put about 99 percent of their qubits into factories, while cultivation grows a state in a mean of about 26 cycles with a tail out to 120.

Iancu argued that older schedulers assume a magic state is always ready and leave the factory out of the score. PureMagic has only data qubits and growers, any free grower supplies a state, and a route that borrows one restarts its growth afterwards. Iancu tested 30 circuits. Each was scored by qubits times cycles. With factories counted, Iancu put PureMagic four or 20 times ahead of a solver that treats magic states as free, and said the mean wait fell from 25 cycles to five. Iancu asked for comparisons with other codes, including bicycle codes, to be rerun with factories included.

INJEQT injects a whole rotation at once

Sayam Sethi, a PhD student at UT Austin, swapped long strings of T gates for one injected rotation. Sethi worked with Sahil Khan, Aditi Awasthi, Abhinav Anand and Jonathan Baker. Their target is a machine built from modules that each hold the gross code, a qLDPC code in which each check touches only a few qubits. Steps between modules are slow and noisy. Sethi said injecting these prepared states can cause up to 90 percent of the errors in a program.

INJEQT prepares a rotation state in a surface code tile and injects it in one go. The rotation fails half the time. A fix-up state of twice the angle must then be ready. Fetching several fix-up states ahead of time removes most of the stall. With distillation factories, Sethi reported up to 12.5 percent less total error and up to seven times better space-time cost for at most 8 percent more physical qubits. A version built on STAR did better still. It reached up to 18 times on error and 16 times on space-time, with up to 11 percent fewer physical qubits.

Sydney tests codes that might skip the factory

Mohammad Rowshan of the University of Technology Sydney set out tests a code must pass to run a three-qubit CCZ gate natively, by acting on its physical qubits directly. Such a code would need no factory for that gate. qLDPC codes can keep their protection growing with their size, which makes a native gate in them attractive. A known theorem rules out a code in which every gate is this easy, so a native CCZ can only arrive if some Clifford gate is missing.

Their running example passed. It had 12 physical qubits, three logical qubits and distance one, and the native gate came out as a circuit of 111 gates that never leaves a single block of the code. One design from the literature passed their script too. The hypergraph-product codes and bivariate bicycle codes Rowshan tried did not. Rowshan had found no known good qLDPC code that passed every test. On their evidence, the factory stays for now.

Alice & Bob’s factory beats cultivation for cat qubits

Élie Gouzien of Alice & Bob took a resource estimate apart step by step. The case was the firm’s 2023 estimate of Shor’s algorithm against elliptic curves on cat qubits, where every stage, from the size of the problem to the windows used for multiplying and looking up values, adds settings to choose. One level of distillation reaches about one error in ten million. That is not enough, so a second is needed.

A SAT solver, a tool that hunts through logic puzzles, found a way to inject four magic states at once. The factory then used 14,688 cat-qubit cycles, against 509,922 for growing a Toffoli state by cultivation, with output errors near 4 to 8 in a trillion. That is 35 times less. Even if the hardware turned up tomorrow, Gouzien said, the field would not be ready to run anything, and a full estimator would amount to a compiler.

What a resource estimate really counts

Resource estimation turns a compiled program into a bill for qubits, hours and magic states on a given machine. PsiQuantum and Xanadu each ran a tutorial in two parts. Both showed the tools at work on worked examples, and one paper showed how much the bill moves when the error budget is split another way. Three more talks and two panels asked what the estimators leave out.

PsiQuantum builds an algorithm in front of the room

Three PsiQuantum staff built a new quantum algorithm live on the Sunday. Mariia Mykhailova, Sean Greenaway and Michał Stęchły used the firm’s free kit and its Workbench package. The model was a toy. A particle hopped around a ring of eight sites, and its matrix cannot be applied by plain gates, so it must sit as one block inside a larger step, which is called block encoding.

Mykhailova coded the parts from ready-made routines PsiQuantum calls qubricks. A built-in test flagged a misplaced gate in their adder. An attendee spotted the fix. Greenaway then checked the block encoding and ran phase estimation, which gave peaks on the ideal phases. Their wider point was that algorithm work is software work. Greenaway said adders and lookup tables have been checked at up to 100,000 qubits, but states in superposition cap simulation near 30 qubits, so some tests may have to run on quantum hardware.

One drawn T gate, seven counted, then 29

In the second half, Stęchły showed how much a resource estimate depends on its settings. Their toy circuit was drawn with one T gate and four rotations. The estimator counted seven T gates, two rotations, two Toffolis and three smaller pieces called elbows, because its default passes break large controlled gates into simpler parts. Greenaway said the defaults make the fewest assumptions they can. Switch on a Toffoli filter and the count rose to 29.

Stęchły then priced the ring model in PsiQuantum’s active volume. A call graph put the total at about 500,000, with the naive adder taking 64 percent. Swapping in Gidney’s adder cut that to about 224,000 but needed 29 qubits. The Cuccaro adder reached about 243,000 within a 26-qubit limit. A sweep found eight hopping steps cost about 9 percent less than seven, because eight equal weights give right-angle turns that cost almost nothing to set up.

Xanadu’s compiler keeps loops intact

Ben Lau of Xanadu taught a first course on PennyLane, the firm’s free software library, and Catalyst, its compiler. Catalyst keeps loops whole. In Lau’s comparison, plain PennyLane took about 100 seconds to compile a circuit 100,000 gates deep, while Catalyst stayed near flat, and on Shor’s algorithm the gain reached roughly 300 times.

Lau cited Xanadu’s battery work with Volkswagen. There Lau showed estimated run time falling from more than 3,000 years in 2021 to about five minutes by 2025. Lau stressed that these were estimates. The session closed on two ways of counting gates, one tool that counts every gate in a written-out circuit and another that works from an algorithm’s structure without running it. Their example came to about 2,968 gates on 5 wires, about 2,772 of them T gates.

A fluid solver’s bill grows 27-fold for one qubit

Daniel Nino of Xanadu ran the second half on two notebooks that each ended in a T count. The first solved a toy fluid equation, a pulse drifting and spreading around a ring on 32 grid points held in 5 qubits. Nino packed the matrix into a larger operation and inverted it with a method called QSVT, using a polynomial of degree 189 that Nino called a brute-force choice. After 40 time steps the quantum, classical and exact solutions agreed.

The estimator put the solver at about 2.34 million T gates on 16 grid points, 43.9 million on 32 and about 1.2 billion on 64. That is a 27-fold rise for one extra qubit. Nino said the jump comes from the polynomial degree in this workflow and is not a general property of QSVT, and called the figures bounds tied to no hardware. Their second notebook estimated a hydrogen molecule’s energy. There, the error flattened near 0.005 hartree however many time steps were added, because an 8-qubit readout register set the floor.

Louisiana shares the error budget to suit the circuit

Tasnuva Farheen of Louisiana State University cut the estimated cost of programs by about a third. Farheen did it by sharing out the error budget to suit each circuit, and presented for their PhD student and co-author Asif Ronggon. The budget is split three ways. A flat rule gives each part a third. On one example their controller chose 10 percent for logical gates, 72 percent for magic states and 18 percent for rotations.

The controller sits on top of Microsoft’s Azure resource estimator without changing it. Two search methods look for the split that minimises qubits times run time. On 433 benchmark circuits, simulated annealing gave about a 35 percent average gain in about 20 minutes, and a swarm search gave 33.84 percent. Adders and multipliers gained most. Farheen said what decides the gain is how far a circuit sits from the flat split.

Xanadu’s estimator stores recipes as gate counts

Jay Soni of Xanadu argued that trying a new decomposition should not mean rewriting a circuit. Soni pointed to more than 25,000 arXiv results for the words quantum algorithms. An exact check on a large molecule will not finish inside one design pass, Soni said. So PennyLane’s estimator holds each decomposition as a template stored as gate counts, such as 50 CNOTs and 25 X gates, which is what makes an estimate come back fast.

In the demo, one way of preparing a state needed 10 logical qubits on its face and about 200 more once the default helper qubits were counted. The helpers dwarfed the job. A user who already knows the Hamiltonian’s one-norm, a measure of its size, can pass it in so the cost updates. The tools sit in an area of PennyLane where code can change without notice.

Northwestern wants estimates built by compilers

Kate Smith, who runs the Quantum Architecture lab at Northwestern University, argued that resource estimates should come from compilers, as layouts do in ordinary chip design. T counts ignore Clifford costs. Those matter once cultivation makes T states nearly as cheap. Gate counts also skip wiring, routing and the time it takes a measurement to reach the controller and come back.

Smith held up FLASQ, a 2025 model that treats helper qubits as a fluid, as progress. It has limits. Against a 2022 Azure study it credits cultivation with a cut of one to two orders of magnitude, but it assumes flat wiring, gives depth and reaction time less weight and studies a model far sparser than phase estimation. Smith would build on open tools such as the TQEC project, which turns block layouts into Stim circuits.

Amazon finds one estimate would take 23 years to compute

Tim (Yi-Ting) Chen, an applied scientist at Amazon Braket, found that a prototype surface-code pipeline built from open research tools would need about 23 years of computing for one logical error rate estimate. The program was a megaquop QAOA run, about a million logical operations. About 80 percent of the time went on Python list appends. A rewrite in C or Rust might gain a factor of 1,000, Chen reckoned, which still leaves hours.

QuEra’s Libra machine is due on Braket in 2028 with about 250 logical qubits. Chen wants the compiled parts of a program kept and linked when it runs, as an operating system links code it has stored, since a program that adapts as it goes changes only small parts from shot to shot. Programs should stop at a set of gadgets whose errors are already known. Going all the way down to physical steps would need terabytes of data.

A long compile is cheap if it shortens the run

Yuval Baum of Q-CTRL told a panel on software and hardware for error correction that a six- or ten-hour compile is almost irrelevant if it cuts a 30-day run to 10. Tim Chen of AWS moderated Baum, John Gamble of IonQ, Roland Guichard of Riverlane, Roger Luo of QuEra Computing and Michał Stęchły of PsiQuantum. Stęchły pictured a machine on which an hour costs 10 million dollars. Each algorithm would get a month of checks.

Most failures are dull, Gamble said. A qubit goes missing from where the circuit expects it, or a noisy pair of gates hides in one code until the qubits are relabelled. A rough digital twin would catch those before a paid run. Guichard said decoder trials live in software for now, because the decoder box Riverlane describes corrects only the surface code. Guichard also doubted that FPGA boxes could take the check data of tens of thousands of qubits at a price anyone would pay.

The error model moves an estimate more than the circuit

Élie Gouzien of Alice & Bob told the closing panel of the estimation workshop that moving the physical error rate from 1 in 1,000 to 2 in 1,000 shifts an estimate far more than any shortcut in the circuit. Kate Smith, Jieyi Long of Theta Labs and Nam Nguyen of Visa Research sat with Gouzien. Gouzien wanted two tools. One would be slow and precise and stand in for a missing machine, and one fast enough to pick the code distance inside the compiler.

Asked which assumptions mislead most, the panel named reaction time, the classical controller, loose error bounds and the physical error model. On AI the panel was wary. Long warned that agents game weak tests, for example by storing 1,000 fixed test inputs as a lookup table, and suggested formal proof in Lean where simulation fails. One panellist would not trust AI anywhere in the workflow.

Resource estimates for chemistry and materials

Many expect chemistry to be the first place a big quantum machine pays its way. Five talks put a price on molecules and materials, from hydrogen to a metal that corrodes in water.

Microsoft finds tighter chemistry barely moves the qubit bill

David Williams-Young of Microsoft showed that asking for a far more exact energy barely changes the qubit count for two iron molecules. The first test was small. It used hydrogen, on a circuit of 26 qubits and 5,929 Toffoli gates, and a run without noise peaked on the right answer.

The larger cases were Fe2S2 and ferrocene. On a model of Majorana hardware at an error rate of one in a million, Fe2S2 sat near 200,000 physical qubits and ferrocene near 400,000. A target under 1 millihartree needed about the same qubits as one of 5 to 10. Williams-Young defined utility as a problem worth more than the cost of computing it, and set aside the word advantage because it drags in a contest with strong classical methods.

Quantum Motion trades qubits for gates in chemistry

Annina Lieberherr and Vasco Ferreira of Quantum Motion taught how to price chemistry on a machine that fixes its own errors. They counted in logical qubits and gates. Lieberherr began with qubitisation, a method that turns a molecule’s energy into a kind of walk. It spends more qubits to save gates. On a surface code of distance d, each logical qubit needs twice d squared, less one, physical ones, and the factories come on top.

Ferreira then ran the choices through QUICHE, the firm’s open package. On a hydrogen example, as the target grew tighter from 1 to one part in 10,000, qubitisation used more qubits than the Trotter method and far fewer gates, and the gap grew. Ferreira called the example a bit artificial. Real circuits run to hundreds or thousands of qubits, more than the simulator can hold.

PsiQuantum cuts a Fermi-Hubbard run 73-fold

Harriet Apel of PsiQuantum reported a 73-fold cut in estimated run time for a 20 by 20 Fermi-Hubbard ground-state problem on a hypothetical photonic device. The model is a grid of electrons that hop between sites and repel when two share one. At this size, classical methods still disagree about its answer. A common baseline puts qubits on a flat grid with links only between neighbours, so idle qubits and routing eat much of the budget.

An active volume machine adds long links, a number that grows only slowly with size, and counts only the work the logic does. That gave a 12.1-fold gain, and compiling with the machine in mind gave a further 3.9-fold. Clifford gates count too. A Toffoli costs 47 blocks on PsiQuantum’s tables and a CNOT 4, and after all the work the Clifford gates carried about half the active volume, Apel said.

Visa prices magnesium corrosion at up to 10 to the 19 T gates

Nam Nguyen of Visa Research, formerly of Boeing Research and Technology, priced a simulation of magnesium corrosion in water. The answer runs from about 10 to the 13 T gates for the smallest model to near 10 to the 19 for the largest. The rate of corrosion hangs on an energy barrier, and depends on it exponentially. So the energies must be very accurate.

The circuits were built and costed with pyLIQTR from MIT Lincoln Laboratory. One way of writing the chemistry, called first quantisation, beat the other in every model. The smallest model, a dimer with two water molecules, needs a few thousand logical qubits. Nguyen put US defence spending on corrosion at about 20 billion dollars a year, and said a lighter alloy could stretch a small helicopter’s range by 10.1 percent.

Los Alamos finds the order of terms can move fidelity tenfold

Brendan Krueger of Los Alamos National Laboratory showed that just putting the terms of a simulation in a different order can change how close it comes to the truth by about ten times. Krueger, standing in for project leader Stephan Eidenbenz, leads the software team. Its open toolkit is for chemists who want an answer within an error budget. They do not want to pick the maths.

Published error bounds can be very loose, Krueger said, citing one study where a common bound overstated the error by about four orders of magnitude. That makes circuits far larger than needed. So the team measures the error on small molecules with ordinary computers and trains models to predict it for larger ones. Krueger cautioned that the examples so far are toy problems of six to eight qubits.

Breaking encryption with fewer qubits

Code-breaking is the estimate everyone quotes. Five talks priced it. The qubit counts fell far below the millions once assumed, and the argument moved to how many days or years the machine would have to run.

Q-CTRL plots qubits against days

Yuval Baum, vice president of quantum computing research at Q-CTRL, argued that a factoring estimate that counts only qubits can look cheap while its run time slips to decades. Baum’s chart set qubits against days for an RSA-style job. Gidney’s 2025 estimate sat at 898,000 qubits and 4.96 days, and Q-NEXUS, Q-CTRL’s own layout mixing qubit types, at 250,000 and 4.9 days.

At the low end sat a design with 11,000 qubits and 43,000 days. That is about 120 years if the machine never stops. Baum called a pure T count a back-of-the-envelope figure that can miss by a factor of two or three, which on a 120-year estimate is the whole result.

Oratomic packs 1,480 logical qubits into about 5,000 atoms

Madelyn Cain, lead scientist at Oratomic, showed a code that holds 1,480 logical qubits in about 5,000 atoms at distance 24. That is a rate near 30 percent. Atoms can be moved in parallel with simple controls, which suits the regular shape of qLDPC codes. Gates that link two atoms have also climbed in fidelity from about 80 percent in 2019 to a record 99.85 percent, Cain said.

Lost atoms cause about 70 percent of the errors. The team simulated block errors down to about one in 100 million, and projected the trend below one in 100 billion. Oratomic’s chart priced breaking 256-bit elliptic-curve keys from about 1,000 days on 9,739 qubits to about 10 days on about 26,000. That assumes one round of checks a millisecond.

Oratomic puts Shor’s algorithm on about 10,000 atoms

A day later Cain told a workshop on real-time decoding that the smallest Oratomic designs run Shor’s algorithm against 256-bit elliptic curves on 9,000 to 13,000 physical qubits in about 264 days. Published estimates for flat chips sit between 500,000 and a million qubits, Cain said. Long links allow codes that pack more in. And the 256-bit curve needs about a hundred times fewer Toffoli gates than RSA-2048.

Magic states are first cultivated in small surface codes, then distilled inside a high-rate block. A faster adder brings the run to about 10 days on some 26,000 qubits. Standard decoders did about a thousand times worse on these codes, so the team built a tiered decoder that Cain admitted can take seconds or minutes for the hardest shots. Cain’s conclusion was that the move to post-quantum cryptography should not wait.

Iceberg fits Pinnacle onto fixed wiring

Sam Smith, a co-founder of Iceberg Quantum, priced factoring RSA-2048 at 120,387 qubits in one month on a chip whose wiring is fixed. Iceberg’s Pinnacle design, published this year, assumes qubits can be moved. Superconducting chips cannot do that. So Smith’s team added measurement gadgets to each code block and used shifts that slide logical operators around inside it, keeping each qubit’s wiring to at most eight links.

That is about 24 percent more than the 97,000 qubits of standard Pinnacle. With Diraq, a silicon spin-qubit company, the team cut shuttling distance by 35 percent through layout, at a 25 percent cost in qubits, and by 30 percent through code choice at no cost, landing at about 102,000 physical qubits. Smith noted that Diraq plans 150,000 physical qubits by 2029.

An open contest cuts an elliptic-curve circuit by 86 percent

Jieyi Long, co-founder and chief technology officer of Theta Labs, reported that an open contest called ECDSA.Fail cut the cost score of the point-addition circuit at the heart of Shor’s attack on elliptic curves by 86.1 percent in two months. That circuit would break the signature scheme used by Bitcoin and Ethereum. The score is peak logical qubits times average Toffoli gates. A public verifier checks it.

The contest grew to 515 promoted entries from 136 solvers, many working with AI coding agents. By the 26 July cutoff the score had fallen from 10.75 billion to 1.496 billion, about 50 percent better than Google’s March figure in Long’s account. Long noted that the benchmark loads one point classically. Loading it in a full Shor circuit added 11 qubits and about 300,000 Toffolis in one test.

What fault-tolerant compilation means for algorithm teams

Anyone reading a fault-tolerant resource estimate should first ask what it was counted in. A T count and a space-time volume can rank two compilations of the same circuit in opposite order. Kalloor’s own table did exactly that. Then ask whether the count survived layout, and whether the factory was in the bill at all, because Iancu’s four or 20 times appeared only once the cost of magic state distillation was counted.

The second question is how the error budget was shared. Farheen’s results suggest a flat split can waste about a third of the cost. Two estimates with different splits are not like for like. For the machines all this feeds, see our guide to fault-tolerant quantum computers, and for the code underneath most of these talks, see what the surface code is.

None of these numbers has yet met a fault-tolerant machine. Every bill here is still an estimate. Until a machine arrives to test them, the T gate stays on the counter as the coin that everyone in the field still quotes when two compilers are compared. Toronto’s compiler writers simply stopped trusting it to settle the account.