memQ DQC Open-Sources Distributed Quantum Compilation Across Heterogeneous QPUs

By AiCybr Editorial · Published September 24, 2026

memQ publicly released DQC, its open-source distributed quantum compiler, on September 24, 2026. The Python framework accepts a conventional quantum circuit plus a user-defined network topology, partitions the workload across quantum processing units (QPUs), routes operations that cross processor boundaries and produces a time-resolved distributed execution schedule.

The framework is modality-agnostic: a modeled network can contain processors with different qubit counts, local connectivity and hardware characteristics. Users can describe gate and coherence times as well as inter-processor quantum links, allowing the compiler and scheduler to account for both compute and networking resources when mapping a circuit.

For researchers evaluating distributed quantum architectures, the practical value is control over the full compilation pipeline. Partitioning, routing, scheduling and visualization are modular components, and memQ provides a graphical Quantum Network Constructor for defining processors, local qubit connectivity and quantum links. The current Python package requires Python 3.11 or newer, is classified as beta, and uses the Apache-2.0 license.

What DQC does

A distributed quantum computer has an additional mapping problem beyond compiling a circuit for one processor: some logical operations must span QPUs connected by quantum links. DQC models that topology explicitly.

The workflow begins with two inputs:

1. a quantum circuit; and
2. a network description containing the available processors and their connections.

The compiler then assigns circuit qubits and operations to processors. When an operation involves qubits located on different processors, the framework inserts the remote operations required by the distributed representation. memQ's documentation also describes support for modeling qubit movement between processors through state teleportation.

After compilation, the scheduler places local and network operations into time steps while preserving circuit dependencies. This makes network resources part of the scheduling problem instead of treating the QPUs as isolated devices.

Hardware and network parameters are explicit

DQC's network model is intended for architecture exploration as well as compilation. Users can vary processor size, local qubit connectivity, gate durations, coherence times and the links between processors.

That matters because two distributed systems with the same aggregate qubit count can behave differently when their processor topology and interconnect resources differ. A circuit partition that minimizes remote operations on one topology may be a poor mapping on another.

The graphical Quantum Network Constructor provides a visual route for building these configurations. Researchers can change processor and link layouts without rewriting the source circuit, then compare how the compiler maps the same workload onto different network designs.

Modular compilation pipeline

The public package is structured so researchers can replace individual stages of the workflow. Its package documentation describes partitioning, routing, scheduling and visualization as swappable components.

That design is useful for compiler research because a new partitioning or scheduling method can be evaluated inside the same surrounding pipeline. The package also exposes verification helpers that compare the original and distributed programs through simulation-based checks.

The published quick-start interface centers on a Compiler object. The package includes reference circuits and network descriptions, while lower-level APIs expose the partitioner, distributed-circuit builder and verification functions for experiments that need more control.

Current package requirements

The current public package metadata establishes several deployment boundaries:

The beta classification is material for reproducible research environments: the project documentation warns that the public API can change before a 1.0 release. Pinning an exact package version and recording the network/circuit inputs is therefore appropriate when an experiment needs to be reproduced later.

From the March roadmap to the public framework

memQ first described an Extensible Distributed Quantum Compiler roadmap in March 2026, including work built around NVIDIA CUDA-Q and a broader distributed-quantum software stack. The September public DQC release provides an inspectable Python framework for the core problem of mapping and scheduling circuits over distributed QPU networks.

The current DQC material focuses on the compiler's own circuit, topology, routing and scheduling abstractions. Researchers evaluating a particular physical quantum network still need to supply hardware assumptions that match the system they intend to study.

What researchers can evaluate

The release is most useful as an experimental framework for questions such as:

• how processor topology changes circuit partitioning;
• how local qubit connectivity affects placement;
• where remote operations appear after partitioning;
• how network constraints affect scheduling;
• how alternative partitioning or routing strategies compare; and
• how a distributed design changes as processor sizes or links are varied.

Those are architecture and compiler questions. Performance conclusions still depend on the hardware and network parameters supplied to the model, so results should be reported together with those assumptions.

Deployment and reproducibility guidance

For a first evaluation, use the package's reference circuit and network assets to verify the installation and compilation flow before introducing a custom topology. Then keep the circuit, network description, package version and relevant compiler settings together with experiment outputs.

For comparative studies, change one architecture or compiler dimension at a time and preserve the generated distributed circuit and schedule. This creates a traceable link between the input topology and the resulting mapping instead of reducing the experiment to a single aggregate metric.

The framework's verification helpers are also useful as a regression check when swapping pipeline components. Verification establishes consistency between the modeled programs under the tool's checking path; hardware-level fidelity remains dependent on the physical assumptions encoded in the network model.

Bottom line

memQ DQC gives distributed-quantum researchers a public framework for treating QPU topology and quantum links as first-class compilation inputs. Its strongest contribution is the combination of configurable network models, circuit partitioning, remote-operation handling, scheduling and modular compiler stages in one open-source Python package.

The project is currently best suited to research, benchmarking and architecture exploration. Its beta status and configurable hardware model make version pinning and explicit experiment assumptions important for reproducible results.

Sources

• memQ — DQC technical introduction: https://memq.tech/introducing-memq-dqc-an-open-source-framework-for-distributed-quantum-computing/
• memQ DQC package on PyPI: https://pypi.org/project/memq-dqc/
• memQ — March 2026 distributed quantum compiler roadmap: https://memq.tech/memq_qc_software_stack/
• The Quantum Insider — September 24 release coverage: https://thequantuminsider.com/2026/09/24/memq-open-source-distributed-quantum-compiler/