00Quantum compiler research

qmesh

The quantum substrate of the Neura Parse stack.

qmesh carries one typed program across gate, neutral-atom, photonic-CV, and pulse routes. Every run ends in a signed, chained manifest.

View the repository ↗Roadmap ↗

Typed compilation pathIR v1

Frontends

qiskit · cirq · pennylane · pasqal · sf · bloqade

qmesh.ir — typed, content-hashed

QPUPrimitive · ClassicalTask · ChannelOp · DAG

FT mode — single flag

surface · BB qLDPC · cultivation

Backends — ed25519-signed manifest

Aer · Stim · QutipEmulator · OpenPulse · IBM · IonQ

One typed IR from any frontend to a compatible backend; every run is signed.

Passing tests: 157
Shipped: Phases 1–6
CLI commands: 16
Open licence: Apache-2.0

01Why qmesh, why 2026

Quantum crossed three thresholds. The toolchain didn't follow.

T01

Logical qubits beat physical

T02

Modality boundaries dissolved

T03

Toolchain didn't follow

Threshold evidenceHardware, modality, and toolchain context

Logical qubits beat physical

Quantinuum H2 reached Microsoft Level 2 Resilient with logical error rates 800× below physical. IBM Kookaburra (4,158 qubits) is on the 2026 roadmap. IonQ committed to 80,000 logical qubits via modular trapped-ion interconnects.

Modality boundaries dissolved

Photonic interconnects between trapped-ion and neutral-atom systems shipped commercially in April 2026 (IonQ, Cisco UQS). Neutral-atom platforms are Spectrum's “2026 big leap.”

Toolchain didn't follow

Qiskit, Cirq, PennyLane and friends remain provider-centric. Cross-modality programs require bespoke glue. Auditability is an afterthought.

Quantum tooling needs engineering context, signed runs, and reproducible diagrams.

qmesh now has a professional visual layer around the compiler story: cross-modality frontends, signed manifests, fault-tolerant promotion, and audit-ready execution paths.

Signed manifests

Cross-modality IR

FT mode

Software developer working with code across a laptop and monitors in a professional workspace — Compiler operations — engineering context for signed quantum runs

Six things qmesh does, that nothing else does together.

Modality-agnostic IR

Fault-tolerant mode

Modality reach

Hybrid DAG scheduler

AI copilot

Provenance & compliance

Pillar definitionsInterfaces, modes, scheduler, AI, and provenance detail

Modality-agnostic IR

A single typed IR (qmesh.ir) for gate, neutral-atom, photonic-CV and pulse programs. Deterministic content-hash. Cross-frontend semantic equivalence — write once, run on any backend the program is compatible with.

Fault-tolerant mode

Surface, repetition, BB qLDPC and cultivation-aware lattice surgery — promotion is a single config flag. PyMatching, sliding-window, BP+OSD and neural decoders are interchangeable. Resource estimates in the Microsoft RE shape, signed end-to-end.

Modality reach

Pasqal Pulser, Strawberry Fields, MrMustard, Bloqade frontends. QutipEmulator, Aer, Stim, OpenPulse backends. First-class ChannelOp lets a single program cross modalities — gate → Rydberg → CV in one signed run.

Hybrid DAG scheduler

Typed DAG nodes (QPUPrimitive, ClassicalTask, MCMRegion, Barrier, Fanout, EntanglementBarrier). Topological executor with thread-pool parallelism. SLURM / PBS connectors. Crash-safe resume via signed parent_manifest_hash lineage.

AI copilot

Intent compiler for common patterns. LLM provider abstraction (Ollama / Anthropic / OpenAI / Mock). Token-level grammar masking with real-time GrammarMaskedProvider. Neural decoder training pipeline (Stim → PyTorch → signed weights). QuanBench evaluation suite.

Provenance & compliance

Every run produces an ed25519-signed manifest. Tamper-evident compliance packs with offline-verifiable hash chains. Cert-chain trust model with TrustStore. Metriq export for public benchmarking. Designed for regulated industries.

04Pipeline

From SDK to signed manifest, in six stages.

Each stage shows the IR primitives, the matching CLI surface, and the active flag at that point in compilation.

Compiler promotion pathEach stage exposes the active primitive and flag before hardware submission.

01
Frontend
Bring your SDK
Active flag · frontend=auto
02
qmesh.ir
Typed, content-hashed
Active flag · ir=qmesh.ir.v1
03
FT mode
One-flag promotion
Active flag · ft=on, code=surface, d=5
04
DAG scheduler
Hybrid orchestration
Active flag · scheduler=dag, executor=slurm
05
Backends
Every modality
Active flag · backend=ibm_torino, shots=4096
06
Signed manifest
Provenance by default
Active flag · manifest=ed25519, ledger=on

Stage contracts and codeIR primitives, SDK surfaces, examples, and active flags

Bring your SDK

Frontend

Programs enter qmesh from the SDK you already use. No rewrite required — Qiskit, Cirq, PennyLane, Pulser, Strawberry Fields, MrMustard and Bloqade all map into the typed IR.

Qiskit · Cirq · PennyLane gate-frontends
Pasqal Pulser (Rydberg / neutral-atom)
Strawberry Fields · MrMustard (photonic-CV)
Bloqade (analog Rydberg)
OpenQASM 3 · OpenPulse direct ingest

from qmesh.frontends import qiskit_to_ir
ir = qiskit_to_ir(qc)

Active flagfrontend=auto

Typed, content-hashed

qmesh.ir

Every program lowers to a single typed intermediate representation with deterministic content-hash. Two semantically equivalent programs produce identical hashes — across frontends, across modalities.

Typed nodes: QPUPrimitive, ClassicalTask, ChannelOp, MCMRegion
Cross-frontend semantic equivalence
Deterministic SHA-256 content-hash
First-class ChannelOp lets gate → Rydberg → CV in one program

ir.hash()
# 'ab1c4f...e8d2'  (deterministic across frontends)

Active flagir=qmesh.ir.v1

One-flag promotion

FT mode

Promote any IR program to fault-tolerant execution with a single config flag. Surface code, repetition code, BB qLDPC, and Gidney-Shutty cultivation are all interchangeable. Decoder choice is also a flag.

Surface · Repetition · BB qLDPC · Cultivation
PyMatching · sliding-window · BP+OSD · neural decoder
Resource estimates in Microsoft RE shape
All FT artefacts signed end-to-end

ir.promote(code="surface", d=5,
           decoder="pymatching")

Active flagft=on, code=surface, d=5

Hybrid orchestration

DAG scheduler

Hybrid quantum-classical DAGs scheduled topologically across local executors, SLURM, and PBS. Crash-safe resume via signed parent_manifest_hash lineage — pick up exactly where you left off.

Typed DAG nodes (QPUPrimitive, ClassicalTask, MCMRegion, Barrier, Fanout, EntanglementBarrier)
Topological executor with thread-pool parallelism
SLURM / PBS connectors
Crash-safe resume via signed lineage

qmesh schedule run.dag \
  --executor slurm \
  --resume-from <manifest_hash>

Active flagscheduler=dag, executor=slurm

Every modality

Backends

Compiled program dispatched to the matching backend. Aer, Stim, QutipEmulator, OpenPulse for simulation; IBM, IonQ, QuEra, Pasqal, Atom, Xanadu, PsiQuantum for hardware — all with the same signed-manifest contract.

Simulation: Aer · Stim · QutipEmulator · OpenPulse
Superconducting: IBM Heron · Google Willow
Trapped-ion: Quantinuum Helios · IonQ
Neutral-atom: QuEra · Pasqal · Atom Computing
Photonic-CV: Xanadu · PsiQuantum

qmesh submit ir.json \
  --backend ibm_torino \
  --shots 4096

Active flagbackend=ibm_torino, shots=4096

Provenance by default

Signed manifest

Every run writes an ed25519-signed manifest into the ledger. Manifests are tamper-evident, offline-verifiable, and chain through parent_manifest_hash so an entire experimental campaign forms a verifiable Merkle-style hash chain.

ed25519 signed manifest per run
Tamper-evident compliance pack
Offline-verifiable hash chain
Cert-chain trust model with TrustStore
Metriq export for public benchmarking

qmesh check ledger/2026-05-10/<hash>.json
# ✓ signature valid, parent verified, chain depth: 47

Active flagmanifest=ed25519, ledger=on

All four modalities. One program. Inspected per backend.

The compatibility matrix below shows which SDK frontend or backend connector is active for each hardware vendor.

9 hardware targets

Gate systems

4 targets

Superconducting + trapped-ion

Neutral atom

3 targets

Pulser + Bloqade routes

Photonic CV

2 targets

SF + MrMustard routes

Portable contract

1 typed IR

Signed manifest per run

Full hardware compatibility matrixNine targets across seven frontend and backend connectors

Hardware	Qiskitgate	Cirqgate	PennyLanegate / hybrid	PulserRydberg	SF / MrMphotonic-CV	Bloqadeanalog Rydberg	OpenQASM 3portable	Notes
IBM HeronSuperconducting (gate)	Frontend & backend	Frontend only	Frontend only	—	—	—	Frontend & backend	Primary QANTIS hardware target
Google WillowSuperconducting (gate)	Frontend only	Frontend & backend	Frontend only	—	—	—	Frontend & backend	Cirq native frontend
Quantinuum HeliosTrapped-ion (gate)	Frontend only	Frontend only	Frontend only	—	—	—	Frontend & backend	Microsoft RE shape supported
IonQTrapped-ion (gate)	Frontend only	Frontend only	Frontend only	—	—	—	Frontend & backend	Modular interconnect roadmap
QuEraNeutral-atom	—	—	—	Frontend & backend	—	Frontend & backend	—	Analog Rydberg + ChannelOp
PasqalNeutral-atom	—	—	—	Frontend & backend	—	—	—	Pulser-native pipeline
Atom ComputingNeutral-atom	—	—	—	Frontend only	—	Frontend only	—	Beta connector
XanaduPhotonic-CV	—	—	—	—	Frontend & backend	—	—	Strawberry Fields native
PsiQuantumPhotonic-CV	—	—	—	—	Frontend only	—	—	MrMustard interop, planned backend

LegendFrontend & backendFrontend onlyBackend onlyPlannedNot supported

A1Field and integration annexSector routes and supported SDK composition

Sector — what qmesh enables

Defense: Cert-chain signed runs, tamper-evident audit packs, classical+quantum DAG with SLURM / PBS.
Aerospace: Quantum navigation (QANTIS) compiled through qmesh; reproducible, manifest-signed flight pipelines.
Industrial: Hybrid optimisation pipelines with HPC connectors; Mitiq ZNE mitigation for noisy-era runs.
Healthcare: Compliance pack with offline-verifiable hash chain; cert-chain trust model satisfies regulatory provenance.
Automotive: Sensor-fusion + quantum-accelerated planning via cross-modality DAGs.

qmesh composes with the SDKs teams already use.

qmesh does not replace Qiskit, Cirq, or PennyLane. It provides a signed cross-modality programme those frontends can compile into.

Qiskit
Cirq
PennyLane
qBraid
OpenQASM 3
Stim
PyMatching
Mitiq
Pasqal Pulser
Strawberry Fields
MrMustard
Bloqade

08Quick start

Five examples ship in the repo.

qmesh / examplesSH

$ pip install -e ".[all]"

# 1 — Hello, quantum
$ python3 examples/hello_bell_crossbackend.py

# 2 — A real algorithm
$ python3 examples/vqe_h2.py                    # E = −1.859 vs FCI −1.857

# 3 — Fault-tolerant memory
$ python3 examples/ft_logical_memory.py         # Λ = 23 across d=3 → d=5

# 4 — Cross-modality, single signed run
$ python3 examples/dag_cross_modality.py        # gate → Rydberg → CV

# 5 — Compliance pack for auditors
$ python3 examples/compliance_export.py         # signed chain, offline-verifiable

# Service mode
$ uvicorn qmesh.service.app:app --port 8788

# CLI (16 commands)
$ qmesh submit circuit.qasm --shots 4096
$ qmesh check ledger/2026-05-02/<hash>.json
$ qmesh compliance-pack ./ledger --since 2026-05-01

Compile the quantum stack

Read the architecture, run the examples, ship a PR.

GitHub ↗Architecture (ARCHITECTURE.md)