QuantumQuill

Rust-native open quantum infrastructure

Make quantum
programs run better

From high-level algorithms to hardware-native instructions, QuantumQuill provides an open, extensible quantum compilation toolchain that connects research ideas to real devices.

Quick start
01

Platform capabilities

One toolchain for the
entire quantum programming lifecycle

Build, optimize, map, and execute circuits through clear, consistent interfaces while retaining precise control over hardware details.

01
Multiple inputs converge into a unified IR and connect to different targets. IR

Unified intermediate representation

A stable translation layer across quantum languages, optimization passes, and hardware backends.

Learn more
02
Two adjacent rotations about the same axis, Rz(α) and Rz(β), combine into Rz(α + β). Rz(α)Rz(β) Rz(α+β)

Intelligent circuit optimization

Reduce circuit depth and execution error with gate fusion, commutation analysis, and topology-aware rewrites.

Learn more
03
Connectivity of six physical qubits, highlighting a pair of adjacent qubits and the connection between them.

Hardware-aware mapping

Choose better routes using chip connectivity, gate fidelity, and calibration data for every task.

Learn more

System architecture / 02

From circuit design to
quantum device control

A Rust-native compiler core connects circuit design, synthesis, optimization, mapping, and pulse generation, while solvers, simulators, and focused modules extend the foundation.

Rust-native High-performance compiler core Hybrid deployment Local, cluster, and cloud Accelerated GPU / FPGA acceleration
QUANTUM EDA SYSTEM MAP
01 / PRODUCT

Product and delivery

A unified interface connects runtime environments of every scale

Product / frontend A unified entry point for engineering workflows

Bring circuit design, compiler configuration, task execution, result comparison, and performance diagnosis into an actionable EDA workflow.

Product / core Rust-native execution foundation

Implemented in Rust, performance-critical computation and search routines support memory safety, concurrency, and cross-platform deployment.

LOCAL Local host / local deployment CLUSTER Distributed / cluster deployment QCaaS Cloud service / managed delivery
02 / COMPILER

Core compiler pipeline

Lower mathematical descriptions into device-executable signals

Compiler pipeline / 01 From unitary matrices to a native gate set

Select synthesis strategies for general matrices, structured circuits, and Pauli strings, producing equivalent circuits for the target gate set.

Compiler pipeline / 02 Adapt to real hardware topology

Map logical qubits to physical hardware across single-chip and heterogeneous distributed environments.

Compiler pipeline / 03 Generate device-control pulses

Lower gate operations into executable pulse sequences and improve fidelity while reducing pulse duration and crosstalk.

03 / CAPABILITIES

Cross-cutting capabilities

Optimization and application-circuit design across the compiler

Cross-cutting / optimization Identify and rewrite equivalent subcircuits

Find optimizable structures and reduce gate count, circuit depth, and hardware error with template matching and local resynthesis.

Cross-cutting / design Generate circuits from application problems

Provide structured templates, generators, and domain-level interfaces for quantum error correction, simulation, and related workloads.

04 / FOUNDATION

Foundational engines

Search, verification, and simulation for higher-level algorithms

Core modules / 02 ArcQML quantum machine-learning framework

Execute parameterized circuits with state simulation, compute gradients of loss functions using automatic differentiation, and update parameters with classical optimizers.

View the ArcQML module
Foundation / solving Formal constraints and exact solving

Encode synthesis, mapping, and equivalence as constraints and use SAT/SMT solvers to obtain provably valid results.

Foundation / simulation Validate circuit behavior and results

Provide state evolution, measurement analysis, and regression validation for circuit design, synthesis, and optimization.

View tensor-network contraction optimization

Application tutorials / 03

Start with a three-matrix chain

ArcTN is a general-purpose Rust tensor-network contraction library for path optimization, slicing, and numerical execution. Quantum-circuit workloads first need a frontend such as Quimb to build a tensor network. The steps below assume you have already constructed a tensor network.

Read the ArcTN quick-start guide
Python / ArcTN 
# 01 · Tensor-network input
# Describe the tensor network as a three-matrix chain and prepare its arrays.

import numpy as np

# Three-matrix chain A @ B @ C; matching labels identify contracted axes
inputs = [("a", "b"), ("b", "c"), ("c", "d")]
output = ("a", "d")  # The result retains axes a and d
size_dict = {"a": 2, "b": 3, "c": 4, "d": 2}

# Array shapes follow label dimensions in inputs order
a = np.arange(6, dtype=np.float64).reshape(2, 3)
b = np.arange(12, dtype=np.float64).reshape(3, 4)
c = np.arange(8, dtype=np.float64).reshape(4, 2)
arrays = [a, b, c]
01 Tensor-network input Example code · Run the steps in order

Learning resources

Find your starting point

View all documentation
GUIDE Quick startInstall QuantumQuill and compile your first circuit DOCS API referenceBrowse modules, compiler stages, and backend interfaces CODE Framework repositoryThe repository is being prepared

Join us / 04

Help shape the future of quantum compilation

Ask questions, improve documentation, contribute code, or connect new quantum hardware to the open toolchain. Every contribution helps turn research into usable tools.

Meet the contributors