← all papers

Surface-code QCCD

Scott Jones, Prakash Murali. Architecting Scalable Trapped Ion Quantum Computers using Surface Codes. ASPLOS 2026. arXiv:2510.23519 · their code: scottjones03/PartIIProject (MIT)

A compiler for surface-code rounds on grid, linear and switch QCCD devices, and a design-space study of trap capacity, wiring and logical error.

What this website takes from this paper

The paper's runs are from d235a22, the code behind its Table 2. The authors fixed the gate order of its grid schedules in afbd1b4 (2026-10-22), which also adds the MIT licence file the README already named; those runs are in their own table below.

the padded grid for d = 3: a trap on every lattice edge, capacity 2
configurationstart of the last step: their codeour replaythe paperthe paper's rules
rotated surface code d=2, one round, grid, capacity 2
▶ watch it in the Studio		4,055 µs = ours4,055 µs4,055 µs equalTable 2R26 fails 11 others hold
rotated surface code d=3, one round, grid, capacity 2
▶ watch it in the Studio		4,085 µs = ours4,085 µs4,085 µs equalTable 2R26 fails 11 others hold
rotated surface code d=6, one round, grid, capacity 2
▶ watch it in the Studio		4,080 µs = ours4,080 µs4,085 µs differsTable 2R26 fails 11 others hold
rotated surface code d=12, one round, grid, capacity 2
▶ watch it in the Studio		4,085 µs = ours4,085 µs4,085 µs equalTable 2R26 fails 11 others hold
repetition code d=3, linear, capacity 2
▶ watch it in the Studio		1,535 µs = ours1,535 µs1,535 µs equalTable 2all 12 rules hold
repetition code d=3, linear, capacity 3
▶ watch it in the Studio		1,390 µs = ours1,390 µs1,390 µs equalTable 2all 12 rules hold
repetition code d=3, linear, capacity 4
▶ watch it in the Studio		1,505 µs = ours1,505 µs1,505 µs equalTable 2all 12 rules hold
rotated surface code d=3, switch, capacity 2 (current code)
the switch joins every pair of junctions by two parallel segments, an all-to-all junction network; our language describes surface traps, which cannot hold it, so it is replayed but not drawn		3,690 µs = ours3,690 µs5,325 µs differsTable 2all 12 rules hold
the same, with the code as of 2024 (junction entry and exit 100 µs each)
the switch joins every pair of junctions by two parallel segments, an all-to-all junction network; our language describes surface traps, which cannot hold it, so it is replayed but not drawn		5,325 µs = ours5,325 µs5,325 µs equalTable 2all 12 rules hold
Gate order on the data qubits, fixed by the authorsIn the code behind Table 2 (d235a22) the router works layer by layer, but the benchmark entry point did not hand it the layer barriers, so an ancilla deferred to a later routing pass could be overtaken on a shared data qubit. In the d = 3 schedule, data qubit 17 (the artifact's ion D70) meets X-check ancilla 25 (M80) in routing pass 2, before Z-check ancilla 18 (M61) in pass 3; the circuit has the opposite order. Rebuilt with the CX gates in that order, the noiseless circuit has non-deterministic Z detectors on the grid at d = 2, 3, 6 and 12; the linear and switch schedules keep the circuit's order. The artifact's error-rate simulation follows the circuit as written, so the paper's logical error rates are unaffected; only the timed grid schedules were of a reordered circuit. The authors confirmed this and fixed it in afbd1b4 (2026-10-22): every qubit now keeps the circuit's order, with the same operations and the same routes, in 4,010 µs at every distance (3,405 to 3,415 µs without barriers). Those runs are replayed below and pass every rule, strict order included.
Two timing models in Table 2Table 2's switch row (5,325 µs at d = 3) comes out of the artifact only in its 2024 version, where a junction entry or exit takes 100 µs; the current code, with 50 µs, gives 3,690 µs, while its grid rows are reproduced by the current code. The routing-operation counts agree under both.
Table 2 at d = 6The artifact's own data file and our run both give 4,080 µs; Table 2 prints 4,085.

The same grids with the authors' fix (afbd1b4, 2026-10-22)

afbd1b4 hands the circuit's layer barriers to the router, so every qubit keeps the circuit's gate order; it also adds pass_barriers=False, which orders the same operations by the components' happens-before relation alone, without barriers. Both are run here at every distance, with the same driver as above. The operations, and each ion's route, are the same as at d235a22.

configurationstart of the last step: their codeour replaythe paper's rules
rotated surface code d=2, one round, grid, capacity 2, layer barriers (the default)
▶ watch it in the Studio		4,010 µs = ours4,010 µsall 12 rules hold
rotated surface code d=3, one round, grid, capacity 2, layer barriers (the default)
▶ watch it in the Studio		4,010 µs = ours4,010 µsall 12 rules hold
rotated surface code d=6, one round, grid, capacity 2, layer barriers (the default)
▶ watch it in the Studio		4,010 µs = ours4,010 µsall 12 rules hold
rotated surface code d=12, one round, grid, capacity 2, layer barriers (the default)
▶ watch it in the Studio		4,010 µs = ours4,010 µsall 12 rules hold
rotated surface code d=2, one round, grid, capacity 2, pass_barriers=False
▶ watch it in the Studio		3,405 µs = ours3,405 µsall 12 rules hold
rotated surface code d=3, one round, grid, capacity 2, pass_barriers=False
▶ watch it in the Studio		3,415 µs = ours3,415 µsall 12 rules hold
rotated surface code d=6, one round, grid, capacity 2, pass_barriers=False
▶ watch it in the Studio		3,405 µs = ours3,405 µsall 12 rules hold
rotated surface code d=12, one round, grid, capacity 2, pass_barriers=False
▶ watch it in the Studio		3,415 µs = ours3,415 µsall 12 rules hold
Our schedule on the same machine, under the same rules

Made by sched_jones, a scheduler we wrote for this comparison; it is not the compiler that compiles this website's leaderboard entries. It keeps the paper's device, its placement of qubits in traps, its native decomposition of H and CNOT and its timing law, and changes each ancilla's tour and the scheduling.

The same grid, the same placement of qubits in traps, the paper's operation times and its rule that an operation holds every component it names (a split or merge also holds the junction at the far end of its segment, an entry or exit holds the junction and the segment). Every qubit meets its CNOT partners in the order of the paper's circuit file, even where two CNOTs commute: the order is the circuit's, not ours to change. Each ancilla visits its data in that order instead of going home after every gate: straight from one data qubit to the next when both lie around the same end of its trap, and through its own empty trap when the next lies around the other end; it comes home to be measured. It always leaves a data trap by the end it came in, so no gate swap is needed. There are no barriers: a junction lets ions through in the order of the circuit's CNOT layers, and every ion ends in the trap it started in. Each schedule below is replayed by the same checker as the paper's, with the same timing law and circuit; an operation the paper's law does not price is refused.

configurationstart of the last step: their code, fixed, without barriersourstheir code, fixed, with layer barriersas published (d235a22)the paper's rules
rotated surface code d=2, one round, grid, capacity 2
against: rotated surface code d=2, one round, grid, capacity 2, pass_barriers=False
▶ watch ours in the Studio		3,405 µs2,850 µs1.19× faster4,010 µs1.41× faster4,055 µs *1.42× fasterall 12 rules hold
under the paper's rules, its declared locks included, each qubit's order kept
rotated surface code d=3, one round, grid, capacity 2
against: rotated surface code d=3, one round, grid, capacity 2, pass_barriers=False
▶ watch ours in the Studio		3,415 µs3,010 µs1.13× faster4,010 µs1.33× faster4,085 µs *1.36× fasterall 12 rules hold
under the paper's rules, its declared locks included, each qubit's order kept
rotated surface code d=6, one round, grid, capacity 2
against: rotated surface code d=6, one round, grid, capacity 2, pass_barriers=False
▶ watch ours in the Studio		3,405 µs3,085 µs1.10× faster4,010 µs1.30× faster4,080 µs *1.32× fasterall 12 rules hold
under the paper's rules, its declared locks included, each qubit's order kept
rotated surface code d=12, one round, grid, capacity 2
against: rotated surface code d=12, one round, grid, capacity 2, pass_barriers=False
▶ watch ours in the Studio		3,415 µs3,070 µs1.11× faster4,010 µs1.31× faster4,085 µs *1.33× fasterall 12 rules hold
under the paper's rules, its declared locks included, each qubit's order kept

* that schedule fails the paper's own rules (see the note above), so it is shown for reference only.

Like for like, ours is compared with the authors' fixed code run without barriers (pass_barriers=False), which orders operations by the same happens-before discipline as ours: both keep every qubit's gates in the circuit's order, and each ion's own operations (gates, rotations, measurement, reset) are the same, with the same partners in the same order. The difference is the ancilla tours. Theirs sends each ancilla to one data qubit and back for every CNOT; ours visits its data in turn, with fewer splits, merges and junction crossings (42 of each against 48 at d = 3, 924 against 1,056 at d = 12). In the circuit's order one kind of check ancilla meets both data qubits around one end of its trap and then both around the other (6 trips), while the other kind alternates ends (8 trips); those tours set the round's length, about the same at every distance. The table gives the start of the last operation, the time the paper reports; for every schedule here it is a final reset, 50 µs before the end.

The rules each run is judged by

This paper's model is written as the rule set Surface-code QCCD's rules. Every run above was replayed and each rule of the set evaluated on it. Our schedules are held to the same rules, and also keep each qubit's gates in the circuit's exact order (R25): we may not reorder a circuit, even where its gates commute.

runR0R1R2R3R6bR8R14R24R25R26R27R29R30
rotated surface code d=2, one round, grid, capacity 2✓✓✓✓✓✓✓✓·✗ 1✓✓✓
rotated surface code d=3, one round, grid, capacity 2✓✓✓✓✓✓✓✓·✗ 1✓✓✓
rotated surface code d=6, one round, grid, capacity 2✓✓✓✓✓✓✓✓·✗ 1✓✓✓
rotated surface code d=12, one round, grid, capacity 2✓✓✓✓✓✓✓✓·✗ 1✓✓✓
rotated surface code d=2, one round, grid, capacity 2, layer barriers (the default)✓✓✓✓✓✓✓✓·✓✓✓✓
rotated surface code d=3, one round, grid, capacity 2, layer barriers (the default)✓✓✓✓✓✓✓✓·✓✓✓✓
rotated surface code d=6, one round, grid, capacity 2, layer barriers (the default)✓✓✓✓✓✓✓✓·✓✓✓✓
rotated surface code d=12, one round, grid, capacity 2, layer barriers (the default)✓✓✓✓✓✓✓✓·✓✓✓✓
rotated surface code d=2, one round, grid, capacity 2, pass_barriers=False✓✓✓✓✓✓✓✓·✓✓✓✓
rotated surface code d=3, one round, grid, capacity 2, pass_barriers=False✓✓✓✓✓✓✓✓·✓✓✓✓
rotated surface code d=6, one round, grid, capacity 2, pass_barriers=False✓✓✓✓✓✓✓✓·✓✓✓✓
rotated surface code d=12, one round, grid, capacity 2, pass_barriers=False✓✓✓✓✓✓✓✓·✓✓✓✓
repetition code d=3, linear, capacity 2✓✓✓✓✓✓✓✓·✓✓✓✓
repetition code d=3, linear, capacity 3✓✓✓✓✓✓✓✓·✓✓✓✓
repetition code d=3, linear, capacity 4✓✓✓✓✓✓✓✓·✓✓✓✓
rotated surface code d=3, switch, capacity 2 (current code)✓✓✓✓✓✓✓✓·✓✓✓✓
the same, with the code as of 2024 (junction entry and exit 100 µs each)✓✓✓✓✓✓✓✓·✓✓✓✓
ours: rotated surface code d=2, one round, grid, capacity 2✓✓✓✓✓✓✓✓✓·✓✓✓
ours: rotated surface code d=3, one round, grid, capacity 2✓✓✓✓✓✓✓✓✓·✓✓✓
ours: rotated surface code d=6, one round, grid, capacity 2✓✓✓✓✓✓✓✓✓·✓✓✓
ours: rotated surface code d=12, one round, grid, capacity 2✓✓✓✓✓✓✓✓✓·✓✓✓

✓ the rule holds on that run; ✗ it fails, with the number of counterexamples (hover for the first); – it does not apply to that run (hover for why); · the rule is not in that run's rule set.

what each rule says
R0 Every operation finds its ions where it says they are
setup_ok()
and (for all o in operations: well_formed(o) and found(o))
and (for all i in ions: position(i, final()) != none)
Each operation names its ions and where they are; replaying the execution from the start must find them there, and every ion must end it standing in a site.
R1 A site holds at most its capacity
for all s in sites, t in instants:
  occupancy(s, t) <= capacity(s)
An ion standing in a site, or passing through it, takes one of its places.
R2 A junction holds one ion at a time
for all j in junctions, t in instants:
  occupancy(j, t) <= 1
Where three or more rails meet, only one ion may be at any moment, resting or passing through.
R3 A rail carries at most its capacity
for all r in rails, t in instants:
  occupancy(r, t) <= capacity(r)
No more ions travel along one rail at once than the rail is built for (one, on most devices).
R6b A two-ion gate acts on two ions standing in one site
(for all g in two_qubit_gates, i in ions(g): position(i, start(g)) = site(g))
and (for all g in two_qubit_gates where size(declared_sites(g)) > 0:
       site(g) in declared_sites(g))
Both ions of a two-qubit gate are in the same trap when it starts, and in the trap the programme names for it, if it names one.
R8 An ion does one thing at a time
for all a, b in operations where a != b and simultaneous(a, b):
  disjoint(ions(a), ions(b))
No ion takes part in two operations at once: it cannot be gated in one place while it is carried to another.
R14 A split takes the ion at the end of its chain, or pays to reorder
for all m in splits: at_chain_end(m) or swap_paid(m)
An ion leaves its chain from the end that faces the rail; an ion further in must first be swapped to that end, which costs gates.
R24 Every two-qubit gate of the circuit is performed, and no other
(for all c in circuit_ops where needs_gate(c): gate_count(c) >= 1)
and (for all g in two_qubit_gates: serves_circuit(g))
Each two-qubit gate of the input circuit is carried out, and the execution performs no two-qubit gate the circuit does not ask for.
R25 Each qubit's operations keep the circuit's order
for all c1, c2 in circuit_ops where next_on_qubit(c1, c2) and performed(c1) and performed(c2):
  end(last(c1)) <= start(first(c2))
On every qubit, each operation is over before the next one on that qubit begins, in the order the circuit is written -- even where two of them would commute.
R26 Each qubit's gates keep the circuit's order, up to commuting CNOTs
for all c1, c2 in circuit_ops where next_run(c1, c2) and performed(c1) and performed(c2):
  end(last(c1)) <= start(first(c2))
As R25, except that consecutive CNOTs in which a qubit plays the same role (always the control, or always the target) commute, and may run in any order among themselves.
R27 One operation at a time in a trap
for all a, b in operations where a != b and kind(a) in serial_kinds and kind(b) in serial_kinds
    and site(a) = site(b) and site(a) != none:
  not simultaneous(a, b)
The operations of the kinds listed in serial_kinds hold their trap: two of them in one trap never overlap in time.
R29 Every operation lasts what the clock says
for all o in operations where clocked(o): approx(duration(o), clock(o))
Each operation's duration is the one the model's duration law gives it.
R30 Operations that hold the same component never overlap
for all a, b in operations where a != b and simultaneous(a, b):
  disjoint(locks(a), locks(b))
The schedule states, for every operation, the components it holds while it runs; two operations naming one component never overlap in time.

The Studio's runtime is not the schedule's time. A Studio page plays a schedule as a programme in our language: operations of one kind that start at the same moment are one instruction, and each instruction starts when the one before it has ended, so the runtime in the Studio's price bar is its instructions added up. For rotated surface code d=6, one round, grid, capacity 2, pass_barriers=False that sum is 14,820 µs for Surface-code QCCD's schedule and 24,485 µs for ours; on Surface-code QCCD's clock, where operations overlap whenever the paper's rules allow, the same schedules take 3,405 µs and 3,085 µs (each to the start of its last step, as the paper counts). The tables above, and each Studio page's headline, give the time on the paper's clock; the sums are not times either schedule takes, and do not rank them.

How a paper is checked · all papers