Superstaq

Background and History

Superstaq originated at Super.tech, a quantum software startup founded in 2020 by Pranav Gokhale and Fred Chong at the University of Chicago. The company’s research focused on cross-platform quantum compilation, building on academic work in hardware-aware circuit optimization that Gokhale and Chong had published as part of the EPiQC (Enabling Practical-scale Quantum Computation) research center. The core idea was that application-level performance on quantum hardware depends heavily on the quality of compilation, and a specialized compiler that understands each hardware target’s native gate set, connectivity, and error characteristics can extract significantly better results than generic decomposition.

In 2022, Super.tech was acquired by ColdQuanta, a quantum technology company based in Boulder, Colorado, which subsequently rebranded as Infleqtion. The acquisition brought Superstaq under a company that operates its own neutral atom quantum hardware using cesium atoms, alongside a broader portfolio of quantum sensing and atomic clock products. Under Infleqtion, Superstaq continued development as a cloud-hosted compilation and execution service.

Superstaq is accessed through a cloud API, with Python client libraries available for both standalone use (pip install superstaq) and as plugins for existing frameworks (qiskit-superstaq and cirq-superstaq). Users submit circuits through Superstaq’s service, which compiles them to the native gate set of the target hardware and applies proprietary optimizations before forwarding the job for execution. Supported hardware targets span multiple providers, including IonQ, Quantinuum, IBM, Rigetti, AQT, and Infleqtion’s own neutral atom systems.

The compiler’s cross-platform nature is its primary differentiator. Rather than building circuits directly in a hardware vendor’s SDK, users can write circuits in Qiskit or Cirq and route them to any supported backend through Superstaq, receiving hardware-optimized compiled circuits in return. As of 2025, Superstaq is actively maintained by Infleqtion, with the client libraries hosted as open source on GitHub. The service is used by both academic researchers and enterprise teams who need to benchmark algorithms across multiple hardware platforms without rewriting compilation pipelines for each target.

Installation

pip install superstaq

Superstaq also integrates with Qiskit and Cirq workflows:

pip install qiskit-superstaq   # Qiskit provider plugin
pip install cirq-superstaq     # Cirq service integration

Key Imports

import superstaq
import qiskit_superstaq         # if using the Qiskit integration
import cirq_superstaq           # if using the Cirq integration

Authentication

Superstaq requires an API key from Infleqtion. Set it as an environment variable or pass it directly:

import os
os.environ["SUPERSTAQ_API_KEY"] = "your-api-key-here"

# Or pass directly when creating a provider
provider = qiskit_superstaq.superstaq_provider.SuperstaqProvider(api_key="your-key")

Using Superstaq with Qiskit

from qiskit import QuantumCircuit
import qiskit_superstaq

provider = qiskit_superstaq.SuperstaqProvider()

# List available backends
print(provider.backends())

# Get a specific backend
backend = provider.get_backend("ionq_simulator")

# Build a circuit with standard Qiskit
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])

# Submit via Superstaq -- it compiles and optimizes for the target
job = backend.run(qc, shots=1024)
result = job.result()
print(result.get_counts())

Using Superstaq with Cirq

import cirq
import cirq_superstaq

service = cirq_superstaq.Service()

q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit([
    cirq.H(q0),
    cirq.CNOT(q0, q1),
    cirq.measure(q0, q1, key='m'),
])

# Compile to a specific backend's native gate set
compiled = service.compile(circuit, target="ionq_aria-1_qpu")
print(compiled.circuit)

# Submit for execution
result = service.run(circuit, target="ionq_simulator", repetitions=1024)
print(result.histogram(key='m'))

Hardware-Aware Compilation

Superstaq’s core feature is compiling abstract circuits into a backend’s native gate set, reducing overhead from generic decomposition.

# Inspect what native gates the compiled circuit uses
compiled = service.compile(circuit, target="quantinuum_h1-1_qpu")
print(compiled.circuit)
# Output will use Quantinuum native gates (ZZ, RZ, U1q, etc.)

Supported Backends

Backend string	Provider	Technology
ionq_aria-1_qpu	IonQ	Trapped ion
ionq_forte-1_qpu	IonQ	Trapped ion
ionq_simulator	IonQ	Cloud simulator
quantinuum_h1-1_qpu	Quantinuum	Trapped ion
quantinuum_h1-1e_emulator	Quantinuum	Emulator
ibmq_*	IBM	Superconducting
rigetti_*	Rigetti	Superconducting
aqt_*	AQT	Trapped ion
cq_*	Infleqtion	Neutral atom (Cs)

Use provider.backends() or service.get_targets() for the current list of available targets.

Infleqtion Hardware

Infleqtion’s own quantum hardware uses cesium (Cs) neutral atoms. Access it through the cq_ prefixed targets. Neutral atom hardware supports native mid-circuit measurement and qubit reuse.

# Compile for Infleqtion's neutral atom hardware
compiled = service.compile(circuit, target="cq_sqale_qpu")

Common Patterns

Check job status asynchronously

job = backend.run(qc, shots=500)
print(job.status())         # check without blocking
result = job.result()       # block until complete

Compare compiled circuits across backends

targets = ["ionq_simulator", "quantinuum_h1-1e_emulator"]
for target in targets:
    compiled = service.compile(circuit, target=target)
    print(f"{target}: {compiled.circuit}")

Superstaq vs Building on the Vendor Transpiler Directly

Qiskit’s transpile() and Cirq’s own compilation passes already decompose circuits into a target’s native gate set, so Superstaq is not the only way to get a runnable circuit. Its value is in the proprietary optimization layered on top: hardware-aware passes tuned per backend that can reduce gate count or depth beyond what a generic transpiler produces, plus the ability to route the same circuit to IonQ, Quantinuum, IBM, Rigetti, or Infleqtion hardware without re-learning each vendor’s submission flow. Reach for Superstaq when you are benchmarking the same algorithm across multiple hardware providers or specifically need its compilation quality gains. If you are only ever targeting one vendor’s hardware, that vendor’s own SDK and transpiler are simpler and remove Superstaq as an extra dependency and API key to manage. Superstaq also sits at a lower level of abstraction than a synthesis platform like Classiq: it optimizes circuits you already built, rather than generating them from a high-level functional description.