A quantum compiler that keeps error correction in view

What must a quantum compiler remember besides the operations an algorithm requests? For an error-corrected computer, it must also track how information is protected, what measurements reveal errors, and which operations need additional resources. Losing those details during translation makes it harder to check a program or estimate its physical cost.

In a November 2026 preprint, Narasinga Rao Miniskar and colleagues at Oak Ridge National Laboratory describe FTQC, an open-source compiler framework designed to retain that information. The contribution is not a new error-correcting code or decoding algorithm. It is a way to represent these ingredients explicitly inside a compiler—and connect them to analysis, simulation and hardware execution.

Keeping protection attached to the program

Quantum error correction distributes one logical qubit—the unit an algorithm operates on—across several physical qubits. Additional measurements produce a syndrome: information used to infer errors without directly reading out the protected quantum state.

FTQC builds on MLIR, a compiler infrastructure that supports specialized intermediate representations. These are the working forms a program takes between its original description and executable instructions. In FTQC, a logical qubit’s type records its error-correcting code family and code distance, a parameter related to its protection against errors.

That lets the compiler reject certain incompatible operations before translating them further. For example, a two-qubit operation cannot simply combine a Steane-code qubit with a surface-code qubit when its rules require matching encodings. This catches a representation mismatch; it does not prove that the resulting physical computation will be fault tolerant.

The framework also explicitly represents syndromes, special resource states called magic states, and Pauli frames. A Pauli frame tracks certain corrections classically rather than immediately applying physical gates. Keeping these objects visible lets compiler transformations reason about more than an undifferentiated sequence of gates.

The design separates logical operations from an expanded physical-qubit representation, with output paths for quantum programming formats, simulation and IQM hardware. But those paths have different capabilities. The paper’s logical OpenQASM validation path turns correction operations into comments, while its QIR Base Profile path cannot execute the mid-circuit measurement and feedback needed for syndrome correction. Producing executable output is therefore not the same as exercising the whole protection scheme.

When the support machinery dominates

A resource estimate for a three-qubit quantum Fourier transform makes the overhead concrete. Under the paper’s Steane-code accounting, its encoded circuit requires 39 physical qubits, including auxiliary qubits used for error checks.

Its six T gates need a further resource: magic states, which enable operations outside the Clifford gate set. The modeled distillation factory processes noisy resource states to produce a cleaner one. One factory, reused serially, adds 195 physical qubits—five times the encoded circuit’s footprint—bringing the estimate to 234.

That is a peak-space estimate, not a complete operating budget. It omits factory throughput, latency, input-state preparation and failed attempts requiring retries. Reducing T-gate demand could reduce factory work, but this particular model charges the same factory footprint regardless of how many outputs it produces.

Hardware progress, with a clear boundary

The team tested logical behavior with simulators and studied noisy syndrome extraction using Stim and the PyMatching decoder. These checks answer different questions. Stim cannot represent the non-Clifford T gate in these experiments, so the researchers substitute a Clifford operation. Those simulations probe error extraction and decoding along the resulting schedule, not the fidelity of the original non-Clifford algorithm.

The compiler also reached Pathfinder, a 20-qubit IQM superconducting machine at Oak Ridge. For a single encoded logical-zero experiment, classical decoding of the seven data-qubit measurements raised the correct logical-zero fraction from 79.3% using raw parity to 93.8%. The authors report this as a 3.3-fold reduction in readout error. Decoding also improved the measured correlations in a two-logical-qubit Bell-state experiment.

These were individual 512-shot runs, without confidence intervals or an unencoded baseline. They demonstrate hardware targeting and improved encoded-readout statistics, not fault-tolerant error suppression. Establishing that stronger result would require experiments across code distances and substantially more shots.

FTQC’s central result is thus a compiler representation that keeps error-correction decisions inspectable. Its hardware demonstrations and resource estimates show why that visibility matters, while leaving end-to-end fault tolerance and complete space-time costing unestablished.