⚛️ quantum physics

Investigating Retargetability Claims for Quantum Compilers

This paper introduces a metric to evaluate the retargetability of quantum compilers and applies it to Tket, Qiskit, and ProjectQ, finding that Tket offers the highest cross-platform adaptability followed by Qiskit, while ProjectQ lags behind.

Original authors: Luke Southall, Joshua Ammermann, Rinor Kelmendi, Domenik Eichhorn, Ina Schaefer

Published 2026-01-26

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Luke Southall, Joshua Ammermann, Rinor Kelmendi, Domenik Eichhorn, Ina Schaefer

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a chef who has perfected a complex recipe. In the world of classical computing, if you wanted to cook this dish in a different kitchen, you might just need to swap out a specific brand of oven or adjust the heat slightly. The basic tools (knives, pans, stoves) are mostly the same everywhere.

But in the world of quantum computing, every kitchen is built completely differently. One kitchen might have floating islands, another might have walls made of glass, and a third might only have one specific type of stove. If you try to cook your recipe in these different kitchens without changing anything, the food will burn, or the ingredients will vanish.

This is the problem the paper tackles: Retargetability. This is a fancy word for "how easily can we take a quantum program written for one machine and make it work on a totally different machine?"

The authors of this paper wanted to answer a simple question: Which of the three most popular "quantum translators" (compilers) is the best at helping us cook our recipe in any kitchen?

The Three Contenders

The researchers tested three specific tools used by developers to translate quantum code:

Tket
Qiskit
ProjectQ

How They Tested Them

Instead of just reading the manuals, the researchers created a "report card" with five specific categories to grade these tools. Think of it like judging a car not just on how fast it goes, but on how easy it is to drive, how many spare parts are available, and how well it fits different roads.

Here are the five categories they used:

Flexibility (The Control Panel): Can the user tweak the translation process? Can they tell the compiler exactly how to handle the hardware's quirks?
Standardization (Speaking the Same Language): Does the tool speak the common languages of the industry (like OpenQASM or QIR)? If it only speaks its own private language, it's hard to use with other tools.
Community & Ecosystem (The Support Network): Is there a big team of people helping? Are there lots of other hardware companies that already work with this tool? Is the community active, or is the project abandoned?
Hardware Agnosticism (The Universal Adapter): Is the tool built to be neutral, or is it secretly designed for just one specific brand of computer?
The "Human" Test (Documentation & API): This was the most practical test. The researchers hired six students (who knew a little bit about quantum coding) and gave them a real job: Build a new "backend" (a translator) for a specific simulator.
- They had to follow the instructions and use the tools provided.
- They rated how confusing the manuals were, how easy the code was to understand, and how much they needed "hints" to get the job done.

The Results: Who Won?

The researchers combined the "Report Card" scores with the "Human Test" results to give each tool a final score out of 5.

🏆 The Winner: Tket (Score: ~4.65)

The Metaphor: Tket is like a Master Chef's Universal Toolkit.
Why: It was incredibly flexible, spoke all the standard languages, had a huge, active community, and was built to work with any hardware.
The Human Test: The students found it the easiest to use. The documentation was clear, the tools were intuitive, and they barely needed any hints to build their new translator. It felt like the tool was designed with the developer in mind.

🥈 The Runner-Up: Qiskit (Score: ~4.33)

The Metaphor: Qiskit is like a Very Popular, Well-Equipped Kitchen.
Why: It is extremely popular and has great flexibility. However, it sometimes feels a bit more tied to its original "home" (IBM hardware) than Tket.
The Human Test: The students did well, but they found the documentation slightly less clear than Tket's. Interestingly, the students who started with Tket found Qiskit easier, suggesting that Tket teaches you the concepts better.

🥉 Third Place: ProjectQ (Score: ~2.68)

The Metaphor: ProjectQ is like an Old, Rusty Workshop.
Why: While the core idea was good (it was designed to be hardware-neutral), it fell short in the real world. It lacked support for modern standards, the community had gone quiet (the project was inactive for over a year), and the documentation was sparse.
The Human Test: This was a struggle for the students. They felt unprepared even after doing the other two tasks. The manuals were confusing, the tools were hard to navigate, and they needed a lot of hints just to get started. The skills they learned from the other tools didn't transfer well here.

The Bottom Line

The paper concludes that if you want to write quantum software that can run on different machines in the future, Tket is currently your best bet, followed closely by Qiskit. ProjectQ, while once promising, currently lags behind in terms of being "retargetable" because it lacks the active support, modern standards, and clear documentation needed to make the job easy for developers.

The authors emphasize that this is just the beginning. They created a new way to measure these tools, and they hope other researchers will use this "report card" to test even more tools in the future.

Technical Summary: Investigating Retargetability Claims for Quantum Compilers

Problem Statement

In the Noisy Intermediate-Scale Quantum (NISQ) era, the quantum computing landscape is characterized by significant hardware heterogeneity. Different manufacturers employ distinct physical implementations, resulting in varied qubit connectivities, gate sets, error characteristics, and environmental requirements. Unlike the classical computing domain, which benefits from ubiquitous standardized architectures (e.g., x86, ARM), the quantum field lacks such uniformity. This diversity creates a substantial barrier for quantum software engineering, specifically regarding retargetability—the ability to compile quantum programs for different hardware platforms without extensive rewriting. While various quantum compilers claim to offer retargetable solutions, there is currently no standardized methodology to empirically assess or compare the validity of these claims.

Methodology

To address the lack of standardized assessment, the authors propose a novel, two-pronged methodology to evaluate the retargetability of quantum compilers. This approach combines a quantitative metric-based assessment with a qualitative user study.

1. Metric-Based Assessment

The authors define a retargetability metric evaluated across four distinct dimensions, each rated on a five-point Likert scale:

Compilation Strategy Flexibility: Evaluates the granularity of user control over compilation passes, the configurability of optimization pipelines, the availability of presets, and the ability to create custom passes.
Standardization Compliance: Assesses support for emerging standards such as OpenQASM (versions 2 and 3) and QIR (Quantum Intermediate Representation), support for interchangeable formats (e.g., Quil), active involvement in standardization bodies, and interoperability with other quantum software tools.
Community and Ecosystem Integration: Measures the depth of integration with hardware providers, the growth of supported backends, the ease of extending the compiler (plugin systems), the distribution of custom backends, and the activity level of the surrounding developer community.
Device-Agnostic Compiler Architecture: Analyzes the modularity of the codebase, the degree of hardware-agnostic design, adaptability to diverse gate sets, and the prioritization of hardware independence. This dimension is supplemented by a static code analysis using SonarQube to evaluate security, reliability, and maintainability.

2. User Study (Documentation and API Quality)

The fifth dimension, Documentation and API Quality, is evaluated through a practical user study.

Task: Six participants (computer science students with basic quantum software knowledge) were tasked with implementing a new backend for a quantum simulator (Stim) for three different compilers.
Protocol: Participants followed standardized instructions and were restricted from using external search engines, relying only on provided documentation and links. They received hints only if necessary, simulating community forum support.
Evaluation: After implementation, participants rated the compilers on documentation comprehensiveness, API clarity, organization, tutorial quality, hint utility, and overall implementation difficulty.

3. Scoring Mechanism

A final retargetability score is calculated as a weighted arithmetic mean of the five dimensions. For this study, equal weights ( $w_i = 0.2$ ) were assigned to all dimensions to ensure a balanced initial assessment.

Key Contributions

Methodological Framework: The paper introduces a structured methodology to measure quantum compiler retargetability, addressing a gap in existing literature where performance benchmarks (e.g., gate counts, circuit depth) often overlook the ease of adapting compilers to new backends.
Empirical Evaluation: The authors apply this framework to three prominent compilers: Tket, Qiskit, and ProjectQ.
Comparative Analysis: The study provides a detailed, dimension-by-dimension comparison of these tools, highlighting specific strengths and weaknesses in their architectures and ecosystems.

Results

The study yielded the following comparative findings:

Tket: Demonstrated the highest overall retargetability score (4.65). It excelled in all metric dimensions, particularly in compilation strategy flexibility, standardization compliance (active participation in OpenQASM and QIR efforts), and ecosystem integration. In the user study, it received the highest scores for documentation quality and API usability, with participants finding the implementation process moderately difficult and hints largely unnecessary.
Qiskit: Achieved a strong second place with a score of 4.33. It showed excellent flexibility and community integration (high contributor count and GitHub activity). However, it scored lower than Tket in standardization compliance (notably regarding QIR support and OpenQASM 2 import/export inconsistencies) and documentation clarity. Participants found the implementation slightly easier than Tket, likely due to prior familiarity, but required more hints.
ProjectQ: Received the lowest score (2.68). While it performed well in device-agnostic architecture (modular design), it lagged significantly in standardization compliance (lack of QIR/OpenQASM support), ecosystem integration (project inactivity on GitHub for over a year), and documentation. The user study revealed that skills gained from implementing Tket and Qiskit backends did not transfer effectively to ProjectQ, resulting in high implementation difficulty and poor documentation ratings.

Significance and Claims

The paper claims to provide the first systematic, empirical assessment of retargetability claims in quantum compilers. The authors assert that their findings offer actionable insights for quantum software developers selecting compilers for specific use-cases and highlight critical areas for improvement in compiler design.

The study concludes that while Tket currently leads in retargetability, Qiskit remains a strong contender, whereas ProjectQ faces significant challenges in practical usability and ecosystem support. The authors emphasize that future compilers must prioritize standardization and documentation to achieve true cross-platform compatibility. They note that their methodology serves as a baseline, suggesting that future work should involve more compilers (such as the recently released Weaver) and potentially refine the weighting of dimensions based on specific user needs. The paper maintains a modest tone, acknowledging limitations such as the small sample size of the user study (six participants) and the subjective nature of the evaluation, while calling for further contributions to standardize the assessment of quantum compiler retargetability.