memQ has released an open-source compiler that converts monolithic quantum circuits into network-aware execution graphs and models entanglement costs across heterogeneous QPUs
On 24 September 2026, memQ announced the public release of its open-source Distributed Quantum Compiler, or memQ DQC. The Chicago University spinout describes the framework as software that translates a standard quantum circuit into a distributed program and produces a time-ordered execution plan that accounts for both computational and network resources. The tool is available on GitHub, alongside documentation and technical materials.
memQ has released an open-source compiler designed to turn separate quantum processors into a coordinated network rather than treating each QPU as an isolated machine.
The software takes standard monolithic circuits and converts them into OpenQASM execution graphs that account for communication between QPUs connected by optical quantum channels. Independent industry coverage describes the release as an open-source toolchain intended for researchers, developers and system integrators rather than as a marketing demonstration alone.
That translation is the central engineering task. A circuit written for one processor does not automatically specify where its qubits should reside across several machines or how remote operations should be performed. memQ DQC models those dependencies and can insert state teleportation operations for moving qubit states as well as gate teleportation primitives based on Cat-Entangler and Cat-Disentangler protocols.
The release is software rather than a deployed quantum network. It does not demonstrate a new QPU, establish a production link or show that distributed quantum computing has achieved practical advantage. As of 25 September 2026, the available reporting describes a compiler, simulator and documentation release, not industrial deployment or a hardware demonstration. Its stated purpose is to let developers, system integrators and researchers test the consequences of networked execution before committing to a particular hardware layout.
The toolchain includes an interactive Quantum Network Constructor that represents both the links between QPUs and the physical qubit arrangements inside them. Users can model chain, ring, hub, grid and all-to-all network topologies while specifying heterogeneous processor capacities and link fidelities through a custom JSON format. This modality-agnostic scope is intended to cover networks assembled from different qubit types and vendors, although it does not by itself demonstrate interoperability among those technologies.
That distinction matters because communication costs depend on more than the number of available qubits. A remote gate may require entanglement generation and additional operations, while a restricted intra-QPU layout can force more movement even before traffic reaches the network. The compiler therefore offers multiple partitioning strategies including a dynamic interaction method adapted from Kernighan-Lin and a hypergraph partitioner integrated with KaHyPar. Their stated objective is to reduce EPR-pair consumption and improve the grouping and reuse of gate packets.
For context, the same hardware-topology problem appears in an earlier hardware study on surface-code behavior, where connectivity is part of the processor's error and control environment. In memQ's case the issue extends across processor boundaries: the compiler must decide not only which gates belong together but also when scarce inter-QPU entanglement can be used.
The underlying systems question is familiar from quantum-information research reported across institutions such as MIT and CERN: performance depends on the interaction between physical hardware, control software and communication architecture, not on qubit count alone. In this context, a compiler is an instrument for exposing system-level trade-offs rather than a substitute for a functioning quantum network.
memQ DQC uses discrete-event scheduling to produce time-resolved execution plans. Its simulations include Poisson-distributed entanglement-generation events, link arbitration policies such as FIFO, shortest-duration and critical-path scheduling, and physical parameters including gate durations, decoherence times and link entanglement-generation rates.
This is more informative than a circuit diagram alone. A network may contain enough nominal qubits to host a partitioned algorithm yet still take longer if links generate entangled pairs slowly or if several remote operations compete for the same channel. The scheduler produces timestamped Gantt charts, while the verifier compares the resulting output distribution with a statevector calculation. Such separation between simulated resource accounting and experimental validation is also important when interpreting claims in the broader quantum literature, including work published in Nature.
The accompanying technical preprint reports a concrete sensitivity to those assumptions. In an 18-qubit quantum Fourier transform circuit, changing the assumed intra-QPU connectivity from all-to-all to nearest-neighbor increased EPR-pair consumption by more than 10 times. A contention-aware link scheduler reduced the overall execution makespan by about 18 percent in the reported study.
Those figures describe compiler simulations and co-design analysis rather than measurements from a running multi-vendor quantum network. They show how strongly a partitioning or scheduling decision can affect resource estimates, but they do not establish that the same savings will appear on a particular optical link or processor fleet. The results should therefore be read as modeled sensitivities, not universal performance guarantees.
The open release arrives alongside U.S. federal technology directives including Executive Order 14413 issued in June 2026. The order instructs government agencies to establish operational frameworks for quantum networking and distributed quantum-computing architectures, while memQ's software supplies a way to represent and evaluate such architectures.
Open access may be useful precisely because distributed quantum computing has no single hardware model. Superconducting, trapped-ion, neutral-atom and photonic systems can impose different timing, connectivity and interface constraints, yet the available release materials do not report a hardware demonstration across those modalities. The framework is described as modality-agnostic, but that label refers to the software architecture and modeling scope rather than proof that every QPU technology can interoperate in practice.
The remaining barriers are physical as much as computational. Optical links must generate usable entanglement at a workable rate, processors must preserve coherence while waiting for remote operations, and schedulers must handle contention without allowing communication overhead to dominate the computation. The compiler can expose those trade-offs; it cannot remove photon loss, decoherence, calibration drift or hardware incompatibility.
That makes memQ DQC a useful infrastructure release rather than evidence that distributed quantum computing is already a practical service. Its strongest contribution is diagnostic: by forcing topology, link behavior and timing into the execution model, it gives researchers a clearer way to measure the price of connecting QPUs. In an industry that often treats qubit count as the main marker of scale, this work points to the harder metric-how reliably a network can move quantum information and complete a circuit under real constraints.
A physical qubit is an individual controllable quantum system, while a logical qubit encodes information across multiple physical components to manage errors; memQ DQC addresses the placement and communication of physical quantum operations but does not claim to create logical qubits or provide fault-tolerant computation. State teleportation transfers quantum information using shared entanglement and classical communication, not matter and not faster-than-light messages. The reported 10-times-plus increase in EPR-pair use and approximately 18 percent scheduling reduction therefore belong to a modeled execution workflow, not to a universal performance guarantee. That distinction is why the open-source compiler matters: it turns network ambition into testable resource accounting without confusing a software model with a working quantum internet.
