Let's talk!

Product

Plaquette

Design automation software for fault tolerant quantum computing.

What is Plaquette

Plaquette is a powerful and flexible fault-tolerant quantum computing (FTQC) simulation software suite, available as a Python package. Plaquette enables addressing the impact of arbitrary hardware imperfections on fault-tolerance architectures involving hundreds or thousands of qubits.

Plaquette covers the full workflow from code definition to noise modeling, circuit generation, simulation, decoding, and analysis, end to end, as one integrated package rather than a collection of separate tools you’d need to assemble yourself.

Diagram of the Plaquette workflow: a QEC code and noiseless circuit combine with an error model to produce a noisy circuit, which feeds into logical performance analysis showing threshold plots across error types.

To date, it supports circuit-based (CBQC), measurement-based (MBQC), and fusion-based (FBQC) quantum computing, and includes hardware-specific noise models for major qubit platforms. New codes, circuits, hardware models, and decoders are added regularly.

Who uses Plaquette and why

Plaquette is built to work across all hardware platforms and code families. A few illustrations:

  • A hardware team simulates qubits leaking out of the computational subspace during gate pulses, tests whether adding leakage reduction units restores fault-tolerance performance, and gets a number before committing to hardware changes.
  • A research team building a new qLDPC code uses the custom code API to define their construction, then uses the near-Clifford sampler to characterize performance under coherent errors that Pauli-only simulators can’t capture.
  • A company preparing a fault-tolerance roadmap runs qubit overhead calculations across surface and qLDPC code families to put defensible numbers behind architectural decisions.

If you’re building or simulating fault tolerant quantum computers, Plaquette almost certainly fits your use case. But if you’re not sure, get in touch and we can confirm.

What you can do with Plaquette

Define your problem

Plaquette includes built-in implementations of the most common QEC codes: planar and rotated surface codes (including XZZX variants), repetition code, color code, Steane code, Shor code, Bacon-Shor code, subsystem surface code, and qLDPC codes (hypergraph product, bivariate bicycle, generalized bicycle). New codes that are published in the literature are added regularly. For anything not yet implemented, you can define a custom stabilizer code with full control over its structure: logical operators, stabilizers, gate schedules, and measurement circuits.

Circuits are auto-generated from code definitions for standard use cases. Plaquette comes with methods to generate good circuits from these code definitions. You can also bring your own circuits, which matters when you’re modeling a specific pulse sequence or a non-standard syndrome extraction protocol.

Diagram showing Plaquette automatically generating a QEC noiseless circuit from a QEC code definition, illustrated with a surface code and a color code as inputs and a gate-level circuit as output.

Noise modeling covers arbitrary hardware imperfections including single-qubit Pauli errors, gate-level noise, leakage to higher energy levels, and environment-dependent errors. Defining a custom error model is straightforward: bring whatever noise characterization you already have (e.g. measured gate fidelities, Kraus operators, process matrices, or Pauli error rates) and Plaquette handles the rest, without having to express your noise as depolarizing noise first, or write separate model definitions for each sampler.

Two examples of noisy QEC circuits: idling errors shown as error operators appearing between gates at a specific tick, and two-qubit gate errors shown as error operators on both qubits immediately following a two-qubit gate.

Simulate and decode

The sampler and decoder are choices you make together depending on what you’re trying to learn and how much compute you want to spend.

Four samplers are available:

  • Stim — exact simulation for Clifford/Pauli error models, very fast, built on Google’s Stim. The right default for threshold plots under Pauli noise.
  • XPauli — extends Clifford-style simulation to systems with leakage and multi-level (qudit) dynamics. Also addresses ancillary motional modes or valley degrees of freedom impacting qubits. Moderate speed.
  • Near-Clifford — handles coherent errors such as over-rotations as well as other non-Clifford operations like T gates exactly, at higher computational cost. Plaquette has three near-Clifford options: proprietary nc_general for arbitrary channels, proprietary nc_unitary for coherent unitary errors, and tsim for circuits with a small number of supported non-Clifford single-qubit gates.
  • Full-state — full state vector or density matrix simulation, with CPU and NVIDIA GPU backends. Slow for larger systems; useful for exact small-scale analysis or validating other samplers.

More simulators are added regularly.

Chart titled 'Selecting a Simulator' mapping Plaquette's four samplers against the errors they support and their speed-accuracy tradeoff. Stim handles bit flips, erasures, and readout errors at the highest speed. XPauli adds leakage, heating, state-dependent, and correlated errors. Near-Clifford adds overrotation and T-state simulations. Full-state CPU and GPU handle all error types at the highest accuracy.

Eight decoders are available: PyMatching, FusionBlossom, Chromobius, ConcatMWPM, BPOSD, BPLSD, Relay, and Tesseract, with more added regularly. You can run the same simulation with different decoders without restructuring anything. You can also run with mismatched noise models (one model for simulation, a different one for decoding) which is useful for studying the impact of imperfect characterization.

Get to results

Once your code and error model are defined, running a threshold sweep is a single function call. Plaquette handles error insertion, sampling, decoding, and logical error rate calculation automatically. Simulations are parallelized across available CPU cores by default, requiring no configuration for parameter sweeps over code sizes and error rates.

Results save to file and can be reloaded and replotted without rerunning simulations. Threshold plots are produced via matplotlib and drop directly into existing notebooks and reports. Code visualization uses an interactive backend with options for gate schedule display and plaquette highlighting.

Two Plaquette output charts: a threshold plot showing logical error rate vs hardware imperfection across code sizes 3, 5, and 7 with the threshold marked at approximately 0.06, and a bar chart showing fault tolerance thresholds for bit flip, dephasing, leakage, and erasure error types.

Get started

If you’re building or scaling quantum hardware, get in touch to discuss licensing or book a demo.

Not ready yet? Join our practitioners mailing list to be notified when we release new features or publish technical content.

To see how Plaquette fits into a hardware design workflow, check out How Plaquette Works In Practice.

Frequently Asked Questions

Who is Plaquette for?

Plaquette is built for quantum hardware teams working on logical circuit demonstrations and on fault-tolerance architectures. This includes not only fault-tolerance theorists but also hardware engineers who are looking to simulate, analyze, and optimize fault-tolerance designs.

What makes Plaquette different from Stim?

Stim is a fast simulator for Clifford circuits, designed as an assembly language. By analogy, Plaquette is a user-friendly IDE offering libraries of error correction codes, error models, several decoders, and multiple backends, including Stim. Plaquette includes over 5 additional backends that accurately model imperfections that Clifford simulators miss, such as leakage, failed fusions and coherent errors.

When should I consider using Plaquette instead of combining open source packages?

Plaquette is built for hardware efforts like demonstrating logical qubits and devising fault-tolerance architectures. You should use Plaquette if you're looking to:

  • Quickly simulate and optimize fault-tolerant designs without the costs of maintaining custom-built software.
  • Accurately model various hardware imperfections—such as leakage and overrotation—that Clifford simulators miss.
  • Access extensive libraries of quantum error-correction codes, decoders, and error models tailored for your hardware platforms.
  • Free your team to focus on core innovation instead of software development.
Which hardware platforms does Plaquette support?

Plaquette is designed to work with any of the major quantum hardware platforms. We enable matter-based qubit simulations via circuit-based quantum computing (CBQC) and photonics-based qubit simulations via measurement- or fusion-based approaches (MBQC, FBQC). Thanks to this framework, Plaquette supports all of the major hardware platforms including superconducting qubits, neutral atoms, trapped ions, and photonic systems.

Which hardware imperfections can Plaquette's simulators handle?

Plaquette can simulate a wide range of hardware imperfections, including those most critical for various hardware platforms, such as (in no particular order):

  • Photonic systems: e.g., fusion failures, imperfections in single-photon sources and detectors.
  • Superconducting qubits: including transmons and bosonic qubits (e.g., two-qubit gate imperfections, leakage).
  • Neutral atoms: e.g., errors from measurements, scattering, leakage, over- and under-rotation.
  • Trapped ions: e.g., errors from over- and under-rotation, heating of motional modes.
  • Spin qubits: e.g., charge noise, fabrication defects.
How can I specify error models in Plaquette?

You can mix-and-match built-in or user-defined error models. Plaquette's simulator backends support specifying realistic hardware imperfections through Kraus operators or propagators acting on the computational subspace of the qubits and, optionally, higher energy levels. Alternatively, you can define error models via a Hamiltonian describing gate operations and Lindblad operators describing error processes. This framework allows analysing the effects of leakage, photon loss, shuttling errors, intermediate state scattering, over- and under-rotation, and other significant noise models. All Plaquette simulators support these error models with varying accuracy and performance.

Which quantum error-correction codes does Plaquette support?

Plaquette provides an extensive library of quantum error-correction codes, including:

  • Surface codes: such as the planar surface code, rotated planar surface code, toric code, and subsystem surface code.
  • LDPC codes: including Hypergraph Product (HGP) codes, Bivariate Bicycle (BB) codes, Generalized Bicycle (GB) codes, and Lifted Product (LP) codes.
  • Other fundamental codes: such as the Bacon-Shor code, Steane code, Five-qubit code, and Repetition codes.
  • Photonic codes: including foliated versions of any of the above codes for measurement-based quantum computing (MBQC), and specific fusion networks such as Four-star fusion networks (open and periodic boundaries) and Six-ring fusion networks (open and periodic boundaries) for fusion-based quantum computing (FBQC).

Additionally, you can also define custom codes by specifying stabilizer generators and logical operators, allowing you to use Plaquette's circuit generation, simulation, and decoding capabilities to design your own fault-tolerant architectures. We continuously add new codes as they emerge in research literature.

Is Plaquette available for local installation?

Yes! Plaquette is provided as downloadable on-premises software that can be installed directly on your local devices, such as laptops or private cloud infrastructure.

Do I need to share my proprietary data or device designs with QC Design?

No. Plaquette is offered as an on-premises installation on your laptops or private cloud, allowing you to run sensitive simulations internally and maintain full confidentiality of your designs. There is no need to share any proprietary IP, including error-correction codes, decoders, error models, or compilation methods.

What kind of support is available?

As a Plaquette subscriber, you receive support from our dedicated team, composed of leading global experts in fault tolerant quantum computing. Our customers consistently praise our team for responsiveness.

Does Plaquette require advanced expertise in fault tolerance to use?

No advanced expertise is required to get started. Customers frequently find Plaquette's extensive documentation to be an approachable way to quickly reach the cutting edge of quantum fault tolerance—more accessible than primary research literature and more practical than review articles.

I have more questions—how can I contact you?

We'd love to chat! You can reach out to us using our contact form.