01 / 04 · LOCAL

An algorithm is written and run on a laptop, and its results come back in seconds.

Quantum algorithms that run better on the machines being built next.

Quantum computers are being built from many connected chips. Limbo compiles your algorithm for them, cutting the operations most likely to fail and sending it to the hardware it fits best.
It starts on your laptop. Write the algorithm in the tools you already use and run it locally in seconds, with no account and no setup.
The result comes back just as the physics predicts, before you ever pay for time on real hardware.

Steps run: 16
Layers: 9
Runs: 1024
Network calls: 0

Crossing chips is the expensive part

On a multi-chip quantum computer, an operation between two chips is ten times more likely to fail than one inside a chip. Most compilers treat them the same. Limbo is built to avoid them.

Operation inside a chip 0.5%

Operation between chips 5.0%

Error rate per operation, drawn to scale.

24/24

head-to-head wins against TKET, Quantinuum's flagship compiler

78%

fewer expensive cross-chip operations in the biggest win

2735×

faster compile in the biggest win

Built for what's next. Leading hardware roadmaps point to multi-chip machines. Limbo already runs end to end on real quantum hardware today, and its multi-chip results are measured under a calibrated model of that hardware.

02 / 04 · PARTITION

Limbo groups the parts of an algorithm that work closely together, places each group on a chip, then fine-tunes the placement until as few operations as possible cross between chips.

Fewer crossings, by design

Limbo maps which parts of your algorithm talk to each other most.
It groups the parts that work closely together, so they can stay on the same chip.
Then it places each group on a chip. Amber lines are the crossings, the expensive part.
Finally it fine-tunes the placement, and every move removes crossings.

Qubits: 32
Connections: 58
Stage: done
Crossings: 10

03 / 04 · TRANSIT

The compiled circuit leaves the laptop, a topology analyser scores three families of hardware against its interaction shape, and the circuit is routed to the best fit.

Sent to the hardware that fits

Your algorithm leaves your laptop. Your cloud accounts stay yours.
Limbo reads the shape of the algorithm.
It scores each type of quantum hardware on how well it fits, across IBM, AWS and Azure. No vendor lock-in.
The best match wins. Here, that's a multi-chip machine.

Candidates: 3
Best fit: 92%
Shape: clustered
Selected: modular

04 / 04 · DEVICE

A four-chip module runs the circuit twice: first as TKET compiled it, then as Limbo compiled it. Amber pulses are cross-chip operations; Limbo's run sends far fewer.

The same circuit, run twice

208

cross-chip 2-qubit operations fired by Limbo's schedule. One 64-qubit benchmark circuit on four chips

Four connected chips. Blue flashes stay inside a chip. Amber pulses cross between them.
First, the algorithm as TKET compiles it: 441 crossings.
Then as Limbo compiles it: 208. Same algorithm, same answer.
53% fewer of the operations most likely to fail.

TKET: 441
Limbo: 208

See the proof

Benchmark Every head-to-head result against TKET. Matrix → Preprint The research behind Limbo. Zenodo → Package Try it on your laptop in minutes. PyPI →

Under construction

Limbo is early and this site is still being built. The compiler, the benchmark matrix and the SDK above are real, and you can run them today.

Want early access, or have a question? jaymin@princeton.edu