Classiq's new compiler turns abstract quantum code into chip-aware execution plans

Classiq, a quantum software company, published a Fault Tolerance Engine on September 30, 2026 that turns high-level quantum programs into execution plans for chips that, for the most part, do not yet exist in useful form. That is not a contradiction. It is the shape of the work.

Quantum software engineers today write code in abstract, hardware-agnostic languages. Real machines, when they run anything substantial, will need error correction: a fault-tolerant layer of redundant physical qubits, called "logical qubits," whose collective state is checked and corrected often enough that the computation actually finishes. The translation between the abstract program and the corrected, scheduled, geometry-aware execution on a fault-tolerant chip is the job the Fault Tolerance Engine is built to do. The wider field calls this the compilation problem, and it has been the quiet bottleneck under every roadmap to useful quantum computing.

The release is documented in a Classiq technical blog post and a Quantum Computing Report summary. The engine lives inside Classiq's existing development environment, which means a user already working in that workflow does not have to switch tools. The exported output is a Clifford+T circuit (the standard universal gate set for error-corrected quantum computing), routed and laid out on a 3D surface code: two spatial axes for the layout, plus a time axis measured in error-correction cycles. The package includes a reusable logical noise model built from assumed physical noise, scheduling that interleaves magic-state cultivation (a slow subroutine that prepares a key resource state for non-Clifford gates) with Clifford operations, and an estimator for total logical errors.

Those are the engineering choices. The demonstration is a single workload: a chemistry calculation using tensor hypercontraction, a method that compresses the otherwise enormous tensors that describe how electrons interact in a molecule. Classiq reports compiling this workload to approximately 219 logical qubits and 2.5 to 2.6 million logical gates, including roughly 1.25 to 1.3 million two-qubit CX interactions, in about one hour of routing time on a workstation. The one hour is the compiler's time, not a runtime: the program was not run on a fault-tolerant quantum computer, and the resource counts depend on the assumed noise model, code distance, and chosen layout.

Two limits in the public material are worth holding onto. First, Classiq itself describes the result as scalability evidence rather than an absolute record, and notes that compilation models, workload choice, and resource assumptions make like-for-like comparison with earlier published estimates difficult. Second, the company markets the engine as "modality-agnostic," meaning the same compiled plan can target superconducting, neutral-atom, trapped-ion, and silicon-spin hardware. The blog documents the compilation abstractions that make this claim meaningful. Independent confirmation that the plans compile and run equivalently on each of those four modalities is not part of the release.

The work matters because the bottleneck in fault-tolerant quantum computing is not just hardware. The hardware roadmap is large and slow, and there is little point in reaching a useful logical-qubit count if no one can write the program that will run on it. The compilation layer is the piece that lets a quantum chemist or a cryptographer write a high-level description today, with confidence that someone else's compiler will sort out the layout, the magic states, and the error budget. Classiq's release is one concrete data point in that layer's build-out, with inspectable artifacts (an end-to-end notebook, a user guide, and SDK reference) attached. The next serious checkpoint is whether the same plans compile and simulate cleanly on a fault-tolerant target outside the vendor's own environment, and whether the resource estimates track what real devices eventually deliver.