Quantum Systems: Quantum Networking for the Classical Engineer (Part II)

This WWT Research Note breaks down quantum technologies and draws intuitive parallels with traditional engineering approaches. While the previous Research Note in this series laid the foundation of quantum computing, this one will explore some of the more speculative elements of quantum networking.

What is quantum networking?

Let's begin with a definition. 

quan·tum net·work·ing \ ˈkwän-təm ˈnet-ˌwər-kiŋ  

noun

1 : The technological framework and protocols enabling the transfer of quantum states, such as qubits or entanglement, between distinct physical nodes. Unlike classical networking which transmits binary bits via electrical or optical pulses, quantum networking facilitates the exchange of subatomic information without direct measurement.

2 : A distributed architecture used to interconnect multi-QPU systems, allowing logical qubits to span multiple physical chips for scalable computation.

3 : The infrastructure supporting advanced applications, including Quantum Key Distribution (QKD), entanglement-assisted sensing, and distributed quantum compute clusters.

What is real and not real?

Before diving into the details, it's important to understand what exists in the market today, what's under development and what's purely theoretical.

As of early 2026, the landscape of quantum networking has transitioned from laboratory curiosity to strategic infrastructure, though it remains far from a "quantum internet" for consumers (be they individual or institutional).

The quantum technology can be categorized into three general maturity tiers:

Quantum networking

For the classically-trained engineer, the term "networking" is synonymous with the movement of packets across a switched fabric. However, as we move from the foundations of quantum compute into the realm of the quantum internet, we must shift our mental model from electron-based switching to photon-based entanglement.

While many of the components of quantum networking are very young, still just a gleam in some researcher's eye, the entire technology stack is essentially "UltraEthernet for qubits" — a scheduled, all-analog optical fabric where the "data" is not a stream of bits running through a switch, but rather quantum states using photonics and teleportation.

Future large-scale QPU fabrics will look like generative AI clusters with the following components:

How does data actually move?

With all that said, actually moving data in a quantum network is a function of teleportation, repeaters and a centralized control plane. 

Quantum teleportation

Quantum teleportation is analogous to remote direct memory access (RDMA) — i.e., it is ultra low-latency, zero-copy and hardware accelerated. Whether they are photonic or microwave based, the primary/current methods for transmitting quantum information rely the mechanisms outlined in Table 4 below:

Quantum repeaters

A quantum repeater is a critical component in the development of quantum communication networks. Its primary purpose is to enable the transmission of qubits over long distances, overcoming the limitations of photon loss and the degradation of quantum states (decoherence) in fiber optic cables.

The nature of quantum mechanics works against us here, as the inherent instability of an entangled state (including the fact that you can't even look at it without making it collapse into a single state) make the traditional approach impossible. Unlike classical repeaters, which simply measure, amplify and re-transmit a signal, a quantum repeater cannot use this method because of a fundamental law of quantum mechanics called the no-cloning theorem. This theorem states that an unknown quantum state cannot be copied perfectly. Moreover, measuring the quantum state would destroy the fragile information.

Key components of a quantum repeater

A functional quantum repeater will require several complex, state-of-the-art quantum devices: 

• Quantum memories: These devices temporarily store the quantum states (qubits) until the entanglement swapping operation is successful and the link is established. The storage time must be long enough to wait for the successful establishment of the adjacent links.
• Entanglement sources: Devices that generate pairs of entangled photons with high efficiency.
• Bell-State Measurement (BSM) apparatus: The core component at the repeater node that performs the joint measurement to extend entanglement through entanglement swapping.
• Classical communication channels: Used to relay the classical outcome of the BSM back to the end-nodes, which is necessary to perform local operations that finalize the extended entanglement.

The practical upshot is that you will leverage classical communication techniques (i.e., "normal routing and switching") to pass quantum states between endpoints.

Once that quantum state has been established between endpoints, data can pass directly between the two without involving the intervening classical channels.

Conceptually, this is similar to the classic networking question, "How do two endpoints on different networks establish a link-layer connection?", in that the source endpoint forwards the request to the switch/router, which does a lookup for known/unknown MAC addresses, swaps source/destination information along the way, then finally delivers the connection request to the other endpoint.  Once that information is established, the two endpoints communicate "directly" without intervening lookups. 

How quantum repeaters will work

The quantum repeater process can be summarized through the concept of of "divide and conquer:"

1. Segmentation: The long transmission path is broken down into shorter, more manageable segments where the risk of loss is acceptable (e.g., 100 km segments).
2. Local entanglement: Entangled pairs of photons are generated. One photon from each pair is sent toward a central repeater node, and the other is stored in a quantum memory at the transmitting or receiving end-node.
3. Entanglement swapping: At the repeater node, a Bell State Measurement (BSM) is performed on the incoming photons from the two adjacent segments. This measurement "swaps" the entanglement, effectively creating a single, longer entangled link between the quantum memories at the far ends of the two segments.
4. Repeat and extend: By chaining these segments together via successive entanglement swapping operations, a secure, end-to-end entangled link can be established between two distant parties without ever having to send a single quantum particle directly across the entire distance. This entanglement can then be used for tasks like quantum key distribution (QKD) or quantum teleportation to send qubits.

Quantum network control plane

Bringing it all together is the Quantum Network Control Plane (QNCP), also sometimes known as a Quantum Aware Network Orchestrator. It is purely theoretical at this point, but descriptive of a vital component as quantum systems evolve from solitary systems to integrated clusters.

The QNCP is responsible for managing distributed entanglement across multiple, geographically separated quantum nodes. While the host stacks manage the state of the QPU, the QNCP manages the state of the entire quantum network by coordinating resources like quantum memories and quantum channels, often integrating the classical control plane (using concepts like Quantum SDN) to achieve flexible and programmable management across the hybrid classical-quantum infrastructure.

Quantum as code

The architectural concepts of entanglement swapping and teleportation are implemented through specific circuit primitives in modern quantum frameworks.

In the evolving landscape of quantum networking, NVIDIA CUDA-Q™ and Qiskit represent the two primary software philosophies for managing distributed quantum resources. While both frameworks allow you to define quantum logic, they approach the "network" from different architectural perspectives.

NVIDIA CUDA vs Qiskit

NVIDIA CUDA-Q: The performance fabric approach

NVIDIA CUDA-Q (formerly C++ QM) treats the quantum network as a Scheduled Fabric, where the QPU acts as a specialized accelerator similar to a GPU:

• Network role: CUDA-Q is built for hybrid, low-latency orchestration. It is the preferred tool for simulating the Quantum Network Control Plane (QNCP) because it allows for real-time classical feedback.
• Key advantage: In networking terms, CUDA-Q excels at "Fast Path" operations. It can handle the mid-circuit measurements required for quantum teleportation and entanglement swapping using standard C++ control flow, making it ideal for simulating how a router might process a Hybrid Quantum Dataframe.

Qiskit: The circuit-design approach

IBM's Qiskit is the most widely used framework for research and circuit-level development. It views the network through the lens of logical connectivity:

• Network role: Qiskit is primarily used to design the "payload" of the quantum network. It allows engineers to map complex algorithms onto physical hardware topologies, accounting for noise and decoherence.
• Key advantage: Qiskit provides extensive libraries for Quantum Information Science (QIS), making it the industry standard for developing the protocols that will run over the network, such as Quantum Key Distribution (QKD) or entanglement-assisted sensing.

Ultimately, a mature Quantum OS will likely utilize both Qiskit for the high-level application logic and NVIDIA CUDA-Q for the underlying network orchestration and hardware-accelerated execution.

For consistency and simplicity, snippets in this section will leverage one language (CUDA-Q).

Code: Implementing entanglement (the link layer)

Before swapping or teleporting, you must establish a "Bell pair" (the quantum equivalent of a link-layer connection).

h(qubits[0]);         // Superposition 
x.ctrl(qubits[0], qubits[1]); // CNOT: Create the entangled link 

Code: Quantum teleportation (the zero-copy move)

This process recreates a state at a distant location by consuming an entangled pair and sending classical bits over a side channel.

Logic: You entangle the qubit you want to move with one-half of a pre-established Bell pair, measure them and then send those two classical bits to the destination to "fix" the state.

#include <cudaq.h> 
struct quantum_teleportation { 
    void operator()() { 
        // Allocate 3 qubits: 
        // q[0] = Message (The state to be moved) 
        // q[1] = Bell Qubit A (Alice's half of the link) 
        // q[2] = Bell Qubit B (Bob's half of the link) 
        auto qubits = cudaq::make_vector(3); 
        auto& msg_qubit = qubits[0]; 
        auto& bell_qubit_A = qubits[1]; 
        auto& bell_qubit_B = qubits[2]; 
  
        // --- PRE-ESTABLISH BELL PAIR (The Entangled Link) --- 
        h(bell_qubit_A); 
        x.ctrl(bell_qubit_A, bell_qubit_B); 
  
        // --- BELL MEASUREMENT --- 
        // Entangle the message with Alice's half of the link 
        x.ctrl(msg_qubit, bell_qubit_A); 
        h(msg_qubit); 
         
        // Measure both to extract classical bits c0 and c1 
        auto c0 = mz(msg_qubit); 
        auto c1 = mz(bell_qubit_A); 
  
        // --- REMOTE RECONSTRUCTION --- 
        // Apply the "fix" to Bob's qubit based on measurements 
        // c1 corresponds to the X-gate correction 
        if (c1) { 
            x(bell_qubit_B); 
        } 
        // c0 corresponds to the Z-gate correction 
        if (c0) { 
            z(bell_qubit_B); 
        } 
    } 
}; 

Technical breakdown for the classical engineer

• Conditional logic: In Qiskit, you use .c_if(). In NVIDIA CUDA-Q, you use a standard C++ if statement. This is possible because CUDA-Q kernels are designed to handle "mid-circuit measurement" and real-time classical feedback, which is exactly how the Classical Side Channel operates in a real network.
• Zero-copy mechanism: As noted earlier, this is the ultimate "zero-copy" move. The physical msg_qubit is never sent; instead, the Entanglement Swapping and Bell State Measurement ensure the state is reconstructed on the remote hardware.
• Memory management: The cudaq::make_vector(3) call acts as your memory allocation for the local and remote ports of the quantum fabric.

Entanglement swapping (the repeater logic)

This is essentially "teleporting" the entanglement itself to extend the network range:

• The "swap" call: In higher-level orchestrators, this is often abstracted as a Bell-State Measurement (BSM) at a repeater node.
• API analogy: While Qiskit and NVIDIA CUDA-Q currently focus on single-QPU circuits, upcoming Multi-QPU OS stacks will likely expose these as "network" or "fabric" calls.

Code: Hello World

Below is a conceptual "Hello World" script for quantum teleportation using NVIDIA CUDA-Q. This script simulates the process of moving a specific quantum state from one virtual node to another by consuming an entangled "link."

In this scenario, we use the NVQ++ compiler environment. The code defines a kernel that establishes the link, performs the Bell-State Measurement, and reconstructs the state at the destination.

CUDA-Q: Quantum Teleportation "Hello World" 
C++ 
#include <cudaq.h> 
#include <iostream> 
 
// The 'teleport' kernel simulates the transfer of a state from qubit 0 to qubit 2 
struct teleport { 
    void operator()() { 
        // Allocate 3 qubits:  
        // q[0] = the message (the data we want to move) 
        // q[1] & q[2] = the entangled link (the "fabric") 
        auto qubits = cudaq::make_vector(3); 
        auto& msg = qubits[0]; 
        auto& link_A = qubits[1]; 
        auto& link_B = qubits[2]; 
 
        // 1. PREPARE THE MESSAGE (State to be moved) 
        // Let's put the message in a specific state (e.g., state '1') 
        x(msg);  
 
        // 2. ESTABLISH THE ENTANGLED LINK (Layer 2) 
        h(link_A); 
        x.ctrl(link_A, link_B); 
 
        // 3. BELL STATE MEASUREMENT (The "Swap" Logic) 
        x.ctrl(msg, link_A); 
        h(msg); 
        auto m0 = mz(msg); 
        auto m1 = mz(link_A); 
 
        // 4. REMOTE RECONSTRUCTION (The Classical Side-Channel) 
        // Based on measurement results, apply corrections to the destination 
        if (m1) x(link_B); 
        if (m0) z(link_B); 
 
        // 5. VALIDATION 
        // If successful, link_B should now be in state '1' 
        auto result = mz(link_B); 
    } 
}; 
 
int main() { 
    auto counts = cudaq::sample(teleport{}); 
    counts.dump(); 
    return 0; 
}

How this maps to the network stack:

Code: Quantum repeater entanglement swapping

To transition from simple teleportation to a quantum repeater model, we introduce a middle node (the Repeater). Instead of just moving a message, the repeater's job is to perform a Bell-State Measurement (BSM) on two independent entangled links to "stitch" them together.

This script simulates three virtual locations: Alice (Node 1), the Repeater (Node 2) and Bob (Node 3). 

C++ 
#include <cudaq.h> 
#include <iostream> 
 
// The 'repeater_swap' kernel establishes two short links and swaps them into one long link 
struct repeater_swap { 
    void operator()() { 
        // Allocate 4 qubits:  
        // q[0]-q[1]: Link Alpha (Alice to Repeater) 
        // q[2]-q[3]: Link Beta (Repeater to Bob) 
        auto qubits = cudaq::make_vector(4); 
         
        // 1. ESTABLISH LOCAL ENTANGLEMENT (Segmentation) 
        // Create Link Alpha 
        h(qubits[0]); 
        x.ctrl(qubits[0], qubits[1]); 
         
        // Create Link Beta 
        h(qubits[2]); 
        x.ctrl(qubits[2], qubits[3]); 
 
        // 2. ENTANGLEMENT SWAPPING (At the Repeater Node) 
        // The Repeater holds qubits q[1] and q[2].  
        // By performing a BSM on them, q[0] and q[3] become entangled. 
        x.ctrl(qubits[1], qubits[2]); 
        h(qubits[1]); 
         
        // Measure the intermediate qubits (The "Swap" triggers here) 
        auto m1 = mz(qubits[1]); 
        auto m2 = mz(qubits[2]); 
 
        // 3. REMOTE RECONSTRUCTION (Classical Side-Channel) 
        // Bob (q[3]) applies corrections based on the Repeater's BSM results 
        if (m2) x(qubits[3]); 
        if (m1) z(qubits[3]); 
 
        // 4. VERIFICATION 
        // q[0] (Alice) and q[3] (Bob) are now directly entangled  
        // even though they never shared a physical photon. 
        auto alice_bob_link = mz(qubits[3]); 
    } 
}; 
 
int main() { 
    auto results = cudaq::sample(repeater_swap{}); 
    results.dump(); 
    return 0; 
}

"Quantum OS" perspective

On the bright side, very little of this will be required with a mature Quantum OS ("QuOS" - see next article). Rather than manually managing these gates, you would likely call a service like: 

quantum_fabric.request_link(destination="Bob", distance=200, fidelity=0.98) 

The OS would then handle the segmentation, swapping and error correction (syndrome measurements) in the background, much like a modern OS handles virtual memory paging.

Future outlook

Table 11 outlines where we expect progress to happen in quantum network in the near and long-term future:

Summary

The move toward a mature quantum network is effectively an exercise in leveraging classical control to orchestrate quantum correlations. While the "data plane" of this new network utilizes teleportation and entanglement swapping to bypass the limitations of the no-cloning theorem, it relies heavily on classical side channels for synchronization and Bell-State Measurement results. 

Ultimately, this is a hybrid reality for the engineer. We will continue to use "normal" routing and switching to establish the initial entangled links between endpoints. Once established, however, these endpoints can communicate directly through a distributed, lossless fabric that behaves more like a unified, modular system than a collection of separate nodes.

As quantum repeaters and high-fidelity memories move from the lab to the data center, this fabric will become the backbone of the quantum economy, enabling a level of secure, high-performance computing that classical architectures simply cannot match.