Quantum compilers at QCE26 faced a fairer race

This guide follows 40 talks on quantum compilers, circuit synthesis and programming languages at IEEE Quantum Week 2026 in Toronto. Many claimed fewer costly gates than a rival, and the size of those claims often leaned on which rival was picked.

On the last morning of IEEE Quantum Week 2026, Friday 18 September, Jonas Winklmann of the Technical University of Munich took the stage with a paper that pulled apart a published quantum compiler result. An earlier paper had claimed that one compiler for neutral-atom machines beat another by a huge margin. Winklmann’s team made both programs run under the same rules. The lead shrank from 415.8 times to 3.26.

A quantum compiler is the program that turns a circuit as a person writes it into the gates one chip can run. The person assumes a perfect machine, where any qubit can act on any other. A real chip offers a short list of native gates, and on most superconducting chips each qubit touches only its neighbours on a fixed grid. The compiler’s job is to bridge that difference. It rewrites each gate into native ones, picks which physical qubit holds each of the program’s qubits, adds swaps to bring distant qubits together and tidies what it can. IBM’s Qiskit calls this step transpiling.

On today’s noisy machines that work decides whether a result can be used at all. Each two-qubit gate carries a small chance of error, and a single swap costs three of them, so compilers are judged by how few such gates they leave against a rival. The usual rivals are Qiskit and TKET. Taken together, the 40 talks followed here suggest that the choice of rival and settings often moves the headline more than the compiler does. A compiler result is a race, and the starting line matters as much as the runner.

The best case against that view is that the gains are real, and some need no rival at all. In Julien Gacon’s Qiskit tutorial on Thursday 17 September, one compiler setting lifted a test circuit from 718 to 949 right answers in 1,000 runs on a simulated IBM chip. Mar Tejedor of the Barcelona Supercomputing Center made equal circuits run only once. Muhammad Arslan Ansari of TUM reused compiled pieces of a growing chemistry circuit. Each saving sets a tool against itself. No choice of rival can flatter it.

The trouble starts when one compiler is set against another. Kazuma Watanabe of Keio University placed qubits with a Fujitsu digital annealer and reported a circuit cost up to 27.5 percent lower than Qiskit’s. Frans Perkkola of the University of Helsinki built small blocks straight onto a chip’s wiring, and their saving was modest against TKET and large against PennyLane on the same chip. Abhishek Shringi of Penn State found that the best toolkit changed with the circuit and with the stage of compilation. None of these results is dishonest, yet each is a race whose length depends on where the other runner was told to start.

Below the toolkits, most papers chased fewer swaps. Riccardo Valencia Tortora of ParityQC moved parities, the joint value of two qubits, in place of whole qubits, and claimed to beat the previous best on IBM hardware for a key routine, the quantum Fourier transform. Evan McKinney of Yale and IBM built any two-qubit gate from whatever native gate a lab has tuned. Nils Quetschlich of Amazon Braket guessed which algorithm a circuit runs and compiled it with passes made for that kind. Many were scored in simulation, or by a forecast from the chip’s own test data.

Yet the deeper problem sits above the compiler. It lies in what the field agrees a program is, and Winklmann’s team had to write adapter scripts and fix code before the two neutral-atom compilers would run at all. Damian Rovara of TUM argued that whole programs with loops should replace single circuits as the thing a compiler works on. On Friday a Notre Dame paper showed that a familiar programming law fails once measurement enters, and an Extremadura paper proposed programs built from named registers. At a Wednesday panel Sean Greenaway of PsiQuantum said nothing yet deserves the name of a high-level quantum language. A fair race needs an agreed track, and quantum software has not yet laid one down.

Placement and routing, the swap problem

Most of the damage a compiler does comes from swaps. When two qubits that must interact sit far apart, the compiler walks them together one neighbour at a time, and each step costs three two-qubit gates. Three talks attacked that cost from different sides.

Keio hands qubit placement to a digital annealer

Kazuma Watanabe of Keio University turned qubit placement into one large search and solved it on a Fujitsu digital annealer, a chip built for that kind of problem. The search takes the form of a QUBO, a cost set over yes-or-no choices. Watanabe cared most about right answers. In their view, fewer two-qubit gates give a noisy device more of them.

In the best version the annealer placed the qubits and a standard method routed them, and on a 64-qubit grid across seven test circuits it beat Qiskit and TKET on average for four circuits and tied on three. Letting the annealer route as well never helped. On one circuit it gave no usable result in 10 tries. A full run took about 350 seconds, more than half of it spent calling the remote annealer. Their co-authors were Hideaki Kawaguchi, Shin Nishio and Takahiko Satoh.

ParityQC claims a record Fourier transform on IBM hardware

Riccardo Valencia Tortora of ParityQC claimed to beat the previous best quantum Fourier transform on IBM’s Heron r3 chip, with a usable result out to 52 qubits, in work done with IBM Quantum and eight co-authors including Wolfgang Lechner. The transform needs a gate between every pair of qubits. The chip joins only neighbours. ParityQC’s Parity Twine moves a parity with one or two CNOT gates instead of a whole swap.

Valencia Tortora set one in a hundred as the bar for usable fidelity, and said their curve stayed above the best earlier layout, from 2004, out to wider circuits. A second chart counted only the most frequent outputs. Valencia Tortora said plainly that this is a success rate on a subset, which is a weaker measure than fidelity. The company’s Parity Twine optimiser was due as a Qiskit function on Tuesday 15 September, starting with QUBO problems.

ParityQC’s SHAQR router cuts QAOA depth in its own tests

Riccardo Romanello of ParityQC presented SHAQR. It routes one round of QAOA, an optimisation method whose two-qubit steps can run in any order, which gives a router more freedom than usual. Placement starts with the most connected qubit and seats each next one near partners already placed. Routing then builds rounds of swaps and scores its options again after every swap it picks.

Tests used 60-qubit random graphs, 50 at each density, on two common chip layouts, and SHAQR gave the lowest depth in every test against Qiskit’s SABRE router and a QAOA router from IQM. SABRE still won in one setting. At the highest densities on IBM’s heavy-hex layout it used fewer two-qubit gates, which Romanello put down to cancellations their method does not use. Romanello said Claude had first written an update that rescored every option after each swap, when only options touching the swapped pair needed it.

Building gates from the matrix up

Synthesis works from the other end. It takes a block of the program written as a matrix and searches for a short run of native gates that produces it. Seven talks pushed that search toward real chips and cheaper gates.

GULPS builds any two-qubit gate from what a lab has tuned

Evan McKinney built a compiler that accepts whatever entangling gate a lab has calibrated, even part of an iSWAP, and still builds any two-qubit operation from it. McKinney wrote the paper with Lev Bishop, with affiliations at Yale and IBM Quantum. Single-qubit turns hide the core of a two-qubit gate. So McKinney describes that core by three numbers in a region called the Weyl chamber.

GULPS walks from the identity to the target one waypoint at a time. By the team’s figures it ran more than 500 times faster than BQSKit with lower circuit cost, and McKinney put the gap to Qiskit at about 10 to 20 times. McKinney also told the room that linear programming had since been dropped from the package, so the live tool is already faster than the chart.

Helsinki fits synthesis to the chip’s wiring

Frans Perkkola of the University of Helsinki built small blocks straight onto a chip’s wiring and cut CNOT gates by 7 to 36 percent, depending on the rival. Perkkola wrote the paper with Arianne Meijer-van de Griend and Jukka Nurminen. Building a general matrix exactly costs a number of gates that grows fourfold with each added qubit, so the method is kept for small, dense blocks. In one three-qubit example it finished at 5 CNOTs against 10 for the naive build.

Perkkola set random matrices against TKET, Qiskit and PennyLane at their strongest settings, and on IQM’s Garnet chip the average cuts were 7, 27 and 36 percent, with 18, 19 and 34 percent on IBM’s Marrakesh. The spread shows how much the result depends on the rival. The team also counted the cost of error. At Garnet’s listed two-qubit fidelity, a block of about 2,600 gates keeps almost nothing.

Ritsumeikan cuts the costly T gates in phase oracles

David Clarino of Ritsumeikan University cut the T gates in small phase oracles by about 80 percent against a direct build. Clarino works in Shigeru Yamashita’s group. The co-authors were Yamashita, Zanhe Qi and Chitranshu Arya. A phase oracle stamps a yes-or-no answer onto the phase of its input, and its costly part is the T gate, a small phase step that machines which fix their own errors find hard and slow to make.

Clarino keeps a library of all 256 three-bit functions. Larger pieces go to a logic network. Every circuit, their and the rivals’, got the same last clean-up pass, so the gains come from the work done before it. On functions of three inputs their T count fell about 78 to 80 percent against Caterpillar, a direct method, and only about 33 percent against a second baseline, PhaseOracle.

ZXdb moves circuit rewriting into graph databases

Valter Uotila of TU Delft and QuTech moved ZX-calculus rewriting into graph databases. The ZX-calculus draws a circuit as a graph of nodes called spiders, and fixed rules shrink that graph without changing what it computes, much as algebra rules tidy an equation. Their tool, ZXdb, which grew from work at Helsinki and Aalto, loads these graphs into two databases, Memgraph and Neo4j. Each rule becomes a query.

Against PyZX, the standard Python package, removing empty spiders ran about nine times faster on average. Fusing spiders ran six times faster. Some rules ran far slower, and the full pipeline ran at about a tenth of PyZX’s speed. Uotila traced the fast cases to batching, where a query gathers every match before it rewrites anything, and said rules whose matches can overlap resist that trick. A mix of the two would likely be fastest, Uotila agreed.

Munich parks photonic circuits in the best zone of the chip

Tobias Forster of the Technical University of Munich showed that a small photonic circuit runs better when the compiler parks it in one zone of a larger chip. The paper, with Yannick Stade, Andreas Fyrillas, Jean Senellart, Lukas Burgholzer and Robert Wille, won a best-paper award in the photonics track. A linear-optical chip steers photons through a mesh of small beam splitters set by phase shifters. Each one has its own flaws. The usual method pads a small circuit out to fill the whole mesh.

In simulation, on a 24-mode chip with a 4-mode circuit and no phase noise, the share of runs in which the photons reach the detectors together, the coincidence rate, rose from 0.562 to 0.844. The largest gain, 0.332, came on a 48-mode chip at 30 milliradians of phase noise. There was a price. The output strayed a little further from the ideal, and compiling took 0.61 minutes against 0.38. Every figure comes from simulation, though Forster said the first lab results line up with it.

Rice trains short circuits to match a target distribution

Nicholas DiBrita of Rice University trained short circuits to reproduce a target output, and on IBM’s 127-qubit Nazca machine landed two to three times closer to the ideal than circuits built by BQSKit. The co-authors were Jason Han, Krishna Bhatia, Younghyun Cho, Hengrui Luo and Tirthak Patel. The usual score for this task has no smooth slope to follow. Every reading is noisy too, since it rests on a finite number of shots. Gradient methods struggle with both.

Their tool, CircuitTree, uses Bayesian optimisation. A cheap model fitted to past runs picks the next setting worth trying, so each step needs just one new circuit. DiBrita chose regression trees for that model, because the common default grew too slow to retrain once the runs reached thousands. DiBrita also reported 61 percent fewer two-qubit gates than BQSKit and 78 percent less depth, at the cost of a longer search. Every test circuit used four qubits.

DFKI cuts a 12-control Toffoli from T-depth 39 to 16

Till Schnittka of DFKI and the University of Bremen cut the T-depth of a 12-control Toffoli gate from 39 to 16, with the same two spare qubits as the best published build. The paper is by Schnittka, Majd Assaad, Abhoy Kole and Rolf Drechsler. A Toffoli flips a target qubit only when all its controls are on. On machines that fix their own errors T gates set most of the cost, so the number of T layers in a row, the T-depth, largely sets run time.

Five rewriting steps did the work. Relative-phase gates, which add a phase that later cancels, took the depth to 27, and mixing in three-control gates took it to 23. Swapping an undo step for a measurement saved two more. Reusing a spare qubit earlier gave 17, and slotting the parts of neighbouring gates into each other gave the final 16, less than half the start. Schnittka agreed that measurement and feed-forward are slow on most hardware. That step is optional.

Compiling less by remembering more

The cheapest compile is the one you never run. Three talks cut compile time and machine time by spotting work that had been done before.

Barcelona caches circuits that only look different

Mar Tejedor, a PhD student at the Barcelona Supercomputing Center, built a cache that stops a workflow rerunning a circuit it has already run, even when the repeat is written differently. The co-authors were Javier Conejero and Rosa Badia. The cache reduces each circuit to a ZX diagram, simplifies it and hashes it into a short key. The reduction misses some matches, which costs a reuse but never gives a wrong answer.

Wire cutting splits one big circuit into many small ones, and when four cuts were made in a 48-qubit circuit the result was 8,192 pieces, of which only 648 were unique. The hit rate was 91.98 percent. On the MareNostrum 5 supercomputer the speedup was 7.0 times on one node, falling to 1.3 times at 32 nodes. A smaller job on MareNostrum Ona, the centre’s 35-qubit machine, fell from 17.5 minutes to under 6.

TUM reuses compiled pieces of a growing chemistry circuit

Muhammad Arslan Ansari, a PhD student at the Technical University of Munich, compiled a growing chemistry circuit 5.4 to 6.6 times faster in simulation by storing and reusing its compiled pieces. Ansari worked with Salvatore Zammuto and Martin Schulz. The method, ADAPT-VQE, adds one block to its circuit each round and compiles the whole thing again, so the work grows with the square of the rounds. Reuse is safe here. Compiling depends on a circuit’s shape and not on its angles.

Ansari fixes the qubit layout once and gives each new block a key, so a repeat comes straight from the store, and one last pass catches gates that cancel across the joins. On three small molecules over 30 rounds, compile speedups ran from 5.41 to 6.64 times. The energies matched the naive run. All of it ran in simulation.

Amazon Braket compiles by guessing the algorithm

Nils Quetschlich, an applied scientist on the Amazon Braket team at Amazon Web Services, showed that guessing which algorithm a circuit implements lets Braket compile it better. The paper is by Zhixin Song, Aniket Dalvi, Quetschlich, Yi-Ting Chen and Ryan Shaffer. Braket does not keep its users’ circuits, so the team surveyed 74 published papers that used the service. That mix shaped a benchmark of 1,302 circuits, led by chemistry.

A detector reads each circuit’s gates and wiring and guesses whether it is a GHZ, Trotter or QAOA circuit, and each family gets its own pass. Against Qiskit’s top setting on IQM’s Garnet and Emerald chips, the average gain in expected fidelity was about 16 percent for GHZ, 4 for Trotter and 15 for QAOA. Weighted by the survey mix, it came to 4.46 percent. Expected fidelity is worked out from calibration data, and none of it is a measured run.

Inside the compiler toolkits

Most people meet a compiler through a toolkit such as Qiskit, TKET or BQSKit. The talks and tutorials below opened those toolkits up.

QLego finds that no single toolkit wins

Abhishek Shringi, a PhD student at Penn State, found that no single toolkit compiles every circuit best. So the team built QLego, with Ahmed Shokry, Movahhed Sadeghi and Mahmut Kandemir, to chain passes from several toolkits through one shared state that every pass reads and returns. The study was large. It covered 57 passes, 10 circuit families and about 5,200 setups.

On layout, BQSKit’s GeneralizedSABRE won 8 of 10 families. On routing the best toolkit changed with the circuit, and chaining helped, since running BQSKit and then TKet removed a further 64.3 percent of depth once the first toolkit had done all it could. Adding Qiskit third made it worse. The single best order changed in 16 of 19 cases when the chip layout changed, though the top orders kept much the same ranking. Every test circuit had 5 to 20 qubits.

Qiskit’s tutorial shows that settings can decide the answer

Julien Gacon of IBM Quantum, a Qiskit maintainer, opened a two-part tutorial on Thursday 17 September with one test circuit run on IBM hardware, where the compiler’s settings changed everything. With poor qubits and no optimisation, the right answer was not even the most common result. A careful compile put the right answer on top. It took about 89 percent of shots. Matthew Treinish, listed with Gacon, could not come but had prepared about half the material.

On a simulated 133-qubit Torino chip, moving from optimisation level 0 to level 3 lifted correct shots from 718 to 949 in 1,000. Gacon then opened the pass manager. It runs a list of passes through six stages, from init, layout and routing to translation, optimisation and scheduling, and Gacon said faster rival compilers often run five passes where Qiskit runs 213. Qiskit does not yet cache repeated sub-circuits, Gacon added. That will matter more once machines correct their own errors. Ansari’s TUM team had worked on that gap on the Sunday.

How SABRE and VF2 place and route a circuit

After the break Gacon opened two of the costliest steps, the VF2 layout search and SABRE routing. Layout picks which physical qubits carry the circuit, and for a five-qubit chain on a square-grid device the search found 2,572 places it fits, keeping the one with the lowest error. A star-shaped circuit has no exact fit, so SABRE takes over.

SABRE starts from a random layout, tries each swap near the front of the circuit, keeps the cheapest and then routes backward and forward until the layout settles or a set limit is reached. On a 12-qubit star it finished with two swaps. Gathering two-qubit blocks and rebuilding them cut a random eight-qubit circuit from 59 CNOT gates to 53.

JIJ’s Qamomile reports a kernel’s cost as a formula

Keisuke Sato of JIJ showed that a Qamomile kernel whose size n is left open reports its cost as a formula, n plus 1 gates plus an oracle. Qamomile is JIJ’s typed Python library. Wei-Hao Huang and Hiromichi Matsuyama taught it with Sato. Huang described JIJ as a Tokyo startup founded in 2018 with more than 60 staff, and set out the aim, one program that can both price its resources and run on a device.

Matsuyama presented the typing rule. A qubit handle can be used once, which the team ties to the ban on copying quantum states, and passing the same handle to two gates raises an error. At n equals 4, Sato’s example costs 5 gates plus the oracle, with 4 measurements. The oracle’s cost is one the user types in, which Sato said is no measurement from hardware.

Qamomile sends one kernel to five toolkits

In the afternoon the JIJ team showed how one Qamomile kernel goes to Qiskit, CUDA-Q, HUGR, QURI Parts or Amazon Braket, with results returned in one format so the bit order stays fixed. The programme also lists Kuan-Cheng Chen and Rosse Grassie of JIJ. Sizes are fixed when a kernel is transpiled. Angles stay open, so a variational loop can update them without starting over.

The built-in phase estimation and a hand-built one reported the same cost. Both used 4 qubits and 18 gates. On the team’s chart, Qamomile’s estimate took 117 to 213 milliseconds as the counting register grew from 2 to 22 bits, while one Qiskit point took 11.9 seconds. A 12-qubit QAOA run on a small graph-colouring task found a proper colouring among its samples. Against the SCIP solver the QAOA gap stayed at zero up to 5 vertices and rose to 1 at 6, while simulated annealing never missed.

Munich’s MLIR tutorial lets a stock pass delete two Hadamards

The Munich tutorial team showed that once each gate in a quantum program returns a fresh qubit value, MLIR’s standard clean-up pass can delete two Hadamard gates in a row. MLIR is a framework for building compilers out of dialects, each a set of operations and types. The programme lists seven Munich presenters, among them Yannick Stade of the Technical University of Munich and Lukas Burgholzer of TUM and the Munich Quantum Software Company. Many in the full room were new to MLIR.

The quantum dialect, QCO, makes every gate consume a qubit value and hand back a new one, so on a line of Hadamard, Z, Hadamard, Hadamard, Z and Hadamard the canonicalize pass could remove the middle pair. The flow imports OpenQASM, cancels and places gates in QCO and exports to a target such as QIR. The gain is plain. A stock pass written for any dialect does the quantum tidying.

Caching one check sped a mapping pass by 20 percent

Matthias Reumann of the Technical University of Munich found that one harmless-looking interface check in a qubit mapping pass took 10 to 20 percent of its run time. Caching it cut the pass’s run time by 20 percent. Mapping places a circuit on a chip where some qubit pairs are not wired together, and the pass adds swaps to repair that. Their router searches with A star and writes the swaps straight into the program.

A colleague then lowered a teleportation circuit to QIR, an extension of the LLVM compiler format with quantum operations, and sent it to the Munich Quantum Toolkit’s simulator for 1,024 shots. Asked how such a call reaches an IBM or IQM chip, the team said a vendor implements the QIR functions as a shared library. They knew of no hardware that runs QIR natively.

Microsoft’s QDK runs 100 shots of a 20-qubit circuit in under a second

Bill Ticehurst of Microsoft showed a laptop GPU running 100 shots of a 20-qubit Ising circuit in 0.95 seconds with the Quantum Development Kit. One shot on its default sparse simulator took 5.77 seconds. The kit installs with one command as an 8 megabyte package plus a small QIR library. Its open-source code is 66 percent Rust. Q#, OpenQASM 3 and QDK Stim, an extended form of the Stim error correction language, all get editor and debugger support.

Programs compile to QIR, which Quantinuum, IonQ and Rigetti accept. Keeping loops pays. In one chemistry case a circuit flattened into a straight line of gates made gigabyte files, while keeping its loops cut compile time to about a tenth of a second and the program to under 100 kilobytes. Ticehurst said the kit still lacks a Python API for building circuits gate by gate. The neutral-atom machine Microsoft is building for the QuNorth initiative in Denmark should be reachable early next year, Ticehurst added.

A small transformer sets QAOA angles on CUDA-Q

Louis Chen of JIJ trained a transformer of about 10,000 parameters to set QAOA angles, lifting the mean approximation ratio on held-out five-qubit Max-Cut graphs from 0.581 to 0.861. The ratio says how close a cut comes to the best possible. The model was trained on 16 random graphs and checked on 4, with CUDA-Q running batches of circuits on a GPU. Chen said the Adam optimiser would need about 50 rounds to match five refinement steps. Chen called it a proof of concept.

The morning opened with an NVIDIA speaker’s account of CUDA-Q, which treats a quantum processor as one more accelerator beside GPUs and CPUs. NVIDIA builds no qubits. Moving a kernel from a GPU simulator to a Quantinuum machine is a one-line change of target, the team said, and an A100 GPU holds a full state vector of 31 to 32 qubits. The notebooks ran on free Colab GPUs.

Neutral atoms and a fair race

Neutral-atom machines hold atoms in laser traps. They can move the atoms about mid-program, which gives a compiler new tricks to play and new costs to weigh. Seven talks dealt with them. Five built the stacks, interfaces and move planners, one used that freedom to save power, and the last showed how easily a comparison between such compilers can mislead.

QuEra compiles circuits to atom moves to pulses for Libra

Xiu-Zhe (Roger) Luo, QuEra’s director of scientific software, said Libra aims at 256 logical qubits with an error rate of one in a million, built from more than 10,000 physical qubits. Bloqade, QuEra’s tool chain, turns circuits into atom moves and then into pulses. A Gemini machine in Japan already runs programs of up to 10 logical qubits, Luo said.

QuEra has picked fixed lanes for moving atoms, so that each lane can be tuned in advance. Libra will reload atoms and run magic state factories, which make the special states that fault-tolerant gates use up, while a program goes on. Kirin, the in-house compiler, is being rewritten in Rust. Luo helped organise the workshop. It was, Luo said, the first workshop at the conference given over to neutral-atom software.

QDMI lets a compiler ask a neutral-atom machine what it can do

Lukas Burgholzer of the Munich Quantum Software Company and the Technical University of Munich extended QDMI so it can describe neutral-atom machines whose atoms move. QDMI is a C interface that sits between compilers and devices. It lets a compiler log in, send jobs and ask what a device can do. It speaks of sites and operations, where others speak of qubits and gates, because a neutral-atom step may pick up an atom, move it and drop it.

The support lives in the MQT QMAP tool, where a file can describe, for example, a 10 by 10 grid of 100 atoms with a storage zone and an entangling zone. Asked why anyone should learn yet another framework, Burgholzer said the hope is that a new device could join a supercomputing centre without a new software stack.

QuEra’s calibrated lanes keep about half the fidelity of free moves

Phillip Weinberg of QuEra found that a fixed set of 586 calibrated horizontal and vertical atom moves keeps about half the transport fidelity of free moves. Weinberg leads work on the Bloqade SDK. Moving atoms with crossed laser tones is flexible. But the tuning of one move depends on every other tone that is on at the time, so tunings made one at a time do not add up when moves run together. QuEra’s answer is a finite set of tuned moves, written into the contract with the user.

The instruction set has four operations, a shift over chosen lanes, single-qubit gates, a CZ pulse over a region and a measurement. On 18 test circuits from QASMBench, set against the ZAC compiler, a sparse set of 106 buses lost about a factor of 10 in transport fidelity. Free moves would need about 99.65 percent fidelity to beat a perfect lane, Weinberg said. One listener warned that it all hangs on the placement method. The rerun below shows why.

Rice’s entropy search plans atom moves and compiles every circuit

Jason Ludmir of Rice University presented a search for planning lane-based atom moves that tied or beat five other methods in 91 percent of comparisons, on 300 random circuits of 5 to 70 qubits. It compiled every one. The work is with Phillip Weinberg of QuEra, where Ludmir interned, and Ludwig Schmid of TUM. On QuEra’s lanes, atoms must return home after each layer of CZ gates, and they can deadlock as they wait for each other.

Each candidate move is scored on distance to its target and on mobility, the freedom it leaves for later moves. A counter on each layout it visits, called the entropy, rises when the search stalls, and as it rises the search shifts weight from distance to mobility. At a cap it backs up. Then it tries a stored move. Ludmir had not tested circuits of a thousand physical qubits, and expected scaling like that of other greedy methods.

TUM’s diving search places 5,000 qubits in fixed memory

Yannick Stade of the Technical University of Munich showed a search for placing freely moving atoms that keeps its memory use constant and scales to graph-state circuits of about 5,000 qubits. An earlier A star search ran out of memory beyond 40 gigabytes on Stade’s laptop. Working on ZAC with its authors, the group first made moves avoid crossing paths so they can run in parallel.

Iterative diving search goes depth first to a goal, keeps a fixed number of promising nodes and jumps back to them. Three jumps proved enough. Stade said it also improved quality. The compiler sits in the MQT QMAP package, and Stade invited the lane camp to tune it for fixed lanes. Free movement and fixed lanes are two bets on the same hardware.

PaQit packs copies of a circuit to save power

Jason Ludmir of Rice University showed that packing many copies of a circuit onto a neutral-atom machine can cut energy and run time about 16 times, by their team’s power model. Their tool, PaQit, built with Tirthak Patel, sets in advance how much accuracy that costs. The saving comes from power. QuEra’s 256-qubit Aquila draws about 7 kilowatts, and nearly all of that is a fixed cost, paid whether one copy runs or many.

The catch is that atoms make their two-qubit gates through a strong effect between near neighbours called the Rydberg blockade, and the same effect links copies placed side by side. PaQit turns a target fidelity into spacing, copies and batches. For 1,000 shots of a 16-qubit circuit, a target of 0.90 allowed 7 copies at once, while 0.99 allowed 3. On Aquila, fidelity fell as atoms moved closer, matching simulation. The hardware check stopped at 16 atoms.

TUM reruns a 415.8-fold claim and gets 3.26

Jonas Winklmann of TUM, the paper’s third author, presented a rerun of two neutral-atom compilers, Enola and DasAtom, under the same rules. The paper is by Emil Khusainov, Yanbin Chen, Winklmann, Helmut Seidl and Christian Mendl. Both needed adapter scripts to run at all, and Enola needed fixes. Since some earlier papers had counted only two-qubit gates, the team set a shared format and a score that counts how long qubits must hold their state, every gate and each move between kinds of trap.

A published 415.8-fold lead on a 30-qubit Fourier transform fell to 3.26 once the two ran under the same constraints. On two small textbook algorithms, Bernstein-Vazirani and Deutsch-Jozsa, the two were close, and on QAOA DasAtom led while both did poorly. Winklmann named no single winner.

Languages above the compiler

Most quantum code is still written gate by gate, much as early programmers wrote in assembly language. The talks below asked what should sit above the gates.

Rovara wants compilers to take whole programs

Damian Rovara, a PhD student at TUM, argued that a compiler should take in a whole program, with its branches, loops and calls. Today it mostly takes a single circuit. Students who know loops, Rovara said, accept them in a quantum program without fuss, so compilers should stop unrolling every loop and inlining every function.

The paper Rovara pointed to came out the day before, with eleven authors from TUM, Oxford, Quantinuum, Xanadu, MQSC, the Unitary Foundation and UBC. Asked in the panel what to redesign, Rovara chose loops and if-statements. Rovara admitted one doubt. Two X gates that cancel are still easier to spot on a circuit, Rovara said.

PsiQuantum’s Greenaway finds no true high-level language yet

Sean Greenaway of PsiQuantum told a Wednesday panel that nothing yet deserves the name of a high-level quantum language. Greenaway’s test was blunt. A language whose best demo is a Bell state, and which makes users build their own adders, would be laughed at in classical computing. Michał Stęchły of PsiQuantum chaired. Jeanette Miriam Lorenz of Fraunhofer IKS and LMU Munich, Josh Izaac of Xanadu and Olivia Di Matteo of the University of British Columbia also took part.

Greenaway said a fault-tolerant chemistry algorithm of around 10 to the 10 gates will never be stored in OpenQASM. The gap shows in practice. Izaac said turning a resource estimate into a workflow that compiles can take two PhD students six months or more, and PsiQuantum had to discard most of one chemistry estimate because it could not be wired up to run. The panellists wanted a shared library of subroutines with agreed rules. No large company has yet dropped its own tool for a shared one, Greenaway noted.

Qrisp compiles Shor’s algorithm out to 2048-bit integers

Purva Thakre of IQM showed a plot in which Qrisp, with its Jasp module, compiles Shor’s algorithm all the way to 2048-bit integers. Qiskit’s curves stop at a few tens of bits, because compiling grew too slow to finish. The result is unpublished. Qrisp is an open-source Python framework that started at Fraunhofer, takes work from IQM and now sits under the Eclipse Foundation.

Thakre replaced eight chores in modular multiplication, from setting aside spare qubits to cleaning them up after, with a few lines using types such as QuantumFloat and QuantumModulus. In the notebook the order-finding circuit for 15 returned an order of 4. That gives the factors 3 and 5. Matic Petrič of Fraunhofer FOKUS then warned that a block encoding’s chance of success falls with the square of its scale factor. Many papers leave that cost out, Petrič said.

Jasp counts 20 million gates in 44 milliseconds

Pietropaolo Frisoni of IQM showed Qrisp counting 20 million gates for a 10 million qubit program in 43.9 milliseconds. The trick is to trace the program once and swap each quantum step for a plain tally. Speed was the problem. Pure-Python Qrisp had needed about 20 seconds to compile a 35-bit modular multiplication, so the team turned to JAX, Google’s open-source library, which traces a Python function and hands it to the XLA compiler. Jasp adds quantum types to that form.

The same counting lies behind a 2048-bit Shor estimate of about 164 billion T gates. Petrič then built a block encoding of a sparse matrix, the discrete Laplacian, from three shift operations, where a Pauli breakdown of the same matrix needed 96 terms at size 128. The short version came out lower on gate count and on depth. It also works at any size.

Qrisp hides block encodings behind a few calls

Matic Petrič of Fraunhofer FOKUS said Qrisp’s compiler, built on JAX and MLIR, counted every gate of Shor’s algorithm at 2,048 bits in two hours. Qrisp works with typed quantum variables in place of raw qubit registers. Their talk ran through a new BlockEncoding class. It places a matrix inside a larger quantum operation and hides the mathematics behind a few short calls.

In one example a small set of linear equations was solved in a few lines. The answer matched the classical one to two decimal places. Petrič said the short calls let a maths colleague spot a numerical snag that would otherwise have been missed, and Petrič had used Qrisp’s modular arithmetic type to teach period finding to high school students in Ljubljana.

Quanscient asks for a missing application layer

Valtteri Lahtinen, chief scientist and co-founder of Quanscient, said quantum software for aerospace lacks an application layer, the standard joins between classical and quantum parts that an engineering firm needs. Quanscient, as Lahtinen described it, is a physics simulation firm in Tampere. It was founded in 2021 and has 45 staff. A direct simulation of a whole aircraft at cruise would need about 10 to the 18 grid points, Lahtinen said.

Lahtinen would set shared rules for file formats, run records and links to supercomputers. Compilation, error mitigation and state preparation would stay open, so that vendors can still compete on how well they run the gates on their own machines. Plane, ship and car makers are keen, Lahtinen said. The other path is slow, costly wind tunnel testing.

Extremadura wants registers that say what they model

Juan Manuel Murillo Rodríguez of the Universidad de Extremadura argued that quantum programs need registers labelled with what they model, such as a molecule. They also need named steps that join two such registers. A program would then read as a strategy. A circuit taken from the internet showed how hard it is to tell from its gates alone what a program does, let alone which problem it solves.

Murillo Rodríguez set Tom Kilburn’s hand-coded routine for the Manchester Baby, one of the first stored-program computers, beside the same task asked for in plain words today. Quantum programming, on this view, needs the same climb. Murillo Rodríguez is a co-author of the register paper David Chamizo presented on the Friday.

Extremadura wants structured quantum programs

David Chamizo, a PhD student at the University of Extremadura, wants quantum code to gain the structured style that classical code gained in the 1960s. Chamizo wrote the paper with Jose Garcia-Alonso and Juan Murillo. Chamizo showed a Qiskit listing that no reader could parse. Chamizo likened that style to punched tape, where one slip ruins the run.

In their scheme a register stands for a property. Picture a bottle, with one register for its level and one for its salinity, and a threshold test that marks the states that pass, while a combined test marks only the states that pass every test at once. The no-cloning rule forbids copying an unknown quantum state, so a synchronisation step aligns two registers in one shared state. Measurement stays outside, because it can break the entanglement.

Notre Dame finds a classical rule that fails in quantum code

Ulrik de Muelenaere, a PhD student at the University of Notre Dame, showed where a familiar habit of classical programming breaks, in work with Amr Sabry of Indiana University Bloomington and their advisor Peter Kogge. A known law says that an if whose two branches are the same program is just that program. Measurement breaks it.

On a Bell state, measuring a qubit directly gives 00 or 11. Put the same measurement inside both branches of a quantum if, and it matches that outcome only half the time, leaving the state untouched the other half. Sabry thinks no choice of weights can save the law. It holds again once measurement is dropped.

QuEra’s Lopes expects about 10,000 fault-tolerant runs a year

Pedro Lopes of QuEra Computing told a second panel there is no chance of one abstraction serving every machine. Lopes expected perhaps 100 fault-tolerant machines running about 100 workloads each within ten years, about 10,000 runs a year, and offered that as a personal guess. Hand tuning is fine at that scale, Lopes said. Programs on such machines must know the error correction code, the zones and how data moves.

Vlad Stirbu of the University of Jyväskylä chaired, with Juan Manuel Murillo Rodríguez and Francesc Sabater on the panel, and Sabater said IQM must expose every detail while its users are researchers but should let them skip it. Lopes said a fault-tolerant machine may give one bit string of 100 or 200 bits per day or per week. Some software will not survive, Lopes expected. The list included code that cuts CNOT gates for its own sake, and error mitigation.

Sharing one chip between many jobs

Most jobs use a small corner of a big machine. Two Extremadura talks packed more work into each run, and both measured the saving against running circuits one by one.

Extremadura’s quantum islands cut a test bill from $150 to $15

Javier Romero-Alvarez of the University of Extremadura cut the estimated cost of a test run on a 156-qubit IBM chip from $150 to $15 by sharing it between users. Most jobs are small. Studies Romero-Alvarez cited find that jobs use 10.3 qubits on average on machines with more than 100. The group’s QCRAFT tool merges circuits from many users into one larger circuit and splits the results after. But crosstalk between circuits side by side cut fidelity by about 30 percent.

So the group proposed quantum islands, groups of connected qubits kept apart by a set number of unused ones. QCRAFT-QIM reads the provider’s daily calibration, drops the noisiest qubits and places each circuit in a quiet patch. In tests on 30 circuits, a two-qubit gap gave the best balance, with 12 circuits per group, a 90 percent saving and 36 percent less noise than the group’s earlier packed schedule. The method assumes that distance on the chip map stands in for crosstalk, Romero-Alvarez confirmed.

Stacking circuits in time ran 11,025 of them for $92.80

Francisco Moreno of the University of Extremadura ran 11,025 circuits on IBM’s 133-qubit Torino for $92.80, against $16,432 to run them one by one. That is a 99 percent cut. QCRAFT already sets circuits side by side, and Moreno’s multi-batch policy stacks them in time as well. A measurement, a barrier and a reset let the same qubits run a second circuit in one job, which works on IBM machines, Moreno said, while Amazon Braket and Microsoft Azure do not let a qubit be measured twice.

The test ran 75 circuits, among them Grover, Shor and phase estimation, 147 times each in 506 batches. The distance from the expected output held steady across batches. The price was noise. Moreno put the added noise at about 35 percent, against 23 to 24 percent for the group’s side-by-side policies.

Below the gates, pulses and control

A compiler’s last stage hands its work to the control electronics. Three talks looked at what that layer should show the user.

Qilimanjaro’s QProgram speaks to eight vendors’ control kit

Vyron Vasileiadis of Qilimanjaro released QProgram, a pulse-level language the firm has used in house for about two years, so that one program can drive control kit from many vendors. The work is with Flavie Le Bars and David Arcos. Vasileiadis listed eight vendors, from Qblox to Quantum Machines and Zurich Instruments. Each has its own interface.

QProgram swaps ports and channels for logical buses named by purpose, such as a drive line for qubit zero, and a formal grammar governs its files. Waveforms sit in a separate library. A Python library checks a program against what the hardware can do and says which steps run on the FPGA. The language is on GitHub. Asked about an MLIR dialect, Vasileiadis said no plan exists yet.

IQM offers one tool at three depths of control

Francesc Sabater of IQM showed one tool, dynamical decoupling, offered at three depths, as an on-off switch, as preset sequences and as custom pulse plans. It adds pulses to idle qubits so they keep their state. In Sabater’s plot it held a qubit’s chance of staying in state 0 above 0.5 out to about 60 microseconds, while without it the chance fell to about 0.3 within 10 microseconds. The gain is large.

Sabater, who works on product at IQM in Munich, said the industry has not reached commercial quantum advantage and that IQM’s users are researchers. So an end-to-end black box has no value today, in Sabater’s view. Users need to reach in. CSC in Finland has built a circuit knitting library and an error mitigation library on top of IQM’s stack.

Q-CTRL wants a compiler that knows when a value is ready

Jamie Phan of Q-CTRL argued that a compiler for error-corrected machines should know when each value becomes ready for whatever uses it. Hyalite, Q-CTRL’s compiler, is built on LLVM and MLIR. It keeps classical code and pulse control in one C++ program. In error correction a raw signal, a sorted outcome and a decoded logical result each become ready at different moments, so a compiler that knew this could keep control work going while a decoder runs.

Phan’s design gives each result a declared meaning, an identity tied to one run and a deadline set by whatever uses it. The compiler would check types and links between steps. The runtime would watch for readiness. This is a plan, Phan stressed, with nothing built yet. Munir Hasan of Riverlane, later in the same block, put the decoding budget for superconducting machines at 10 microseconds.

What it means for teams choosing a quantum compiler

Anyone choosing one should run the candidates on their own circuits, with matched settings, before trusting a headline. Perkkola’s results alone showed a saving of 7 percent against one rival and 36 percent against another, on the same chip and the same tests. Ask which rival was used. Ask too whether a score is a measured run or a forecast.

Caching pays wherever structure repeats by design. Sharing a chip pays too, and Extremadura’s schedulers cut estimated bills by 90 to 99 percent, though stacking circuits in time added about 35 percent noise. Chip-aware synthesis and routing from Helsinki, Keio, Yale and ParityQC do cut two-qubit gates, by amounts that swing with the comparison, and several language talks are early sketches that point at a bigger job. For the longer view of how quantum code gets written, see our essay on what quantum software can learn from the 1950s.

Winklmann’s 415.8 shrank to 3.26 once both runners started from the same line. Every other number in this field deserves that test.