IEEE Quantum Week 2026 · QCE26 Tutorial

Practical Distributed Quantum Computing

Programming distributed applications with NetQMPI over the CUNQA emulator — from monolithic circuits to multi-QPU networks.

Friday, September 18, 2026 10:00–11:30 & 13:00–14:30 Metro Toronto Convention Centre
20% Beginner 50% Intermediate 30% Advanced
01 — Introduction

Why distributed quantum computing?

As quantum hardware matures, the physical limits of a single Quantum Processing Unit (QPU) — qubit count, coherence time, cross-talk, cooling, wiring — make monolithic scaling increasingly difficult. Distributed Quantum Computing (DQC) connects multiple QPUs through quantum networks to form one larger computational cluster.

Programming model

NetQMPI

An MPI-inspired, backend-agnostic Python library for Distributed Quantum Computing. Following a Single-Program, Multiple-Data (SPMD) model, one script runs across N quantum nodes, coordinated through quantum-aware primitives — qsend, qrecv and quantum collectives — so entanglement, teleportation and classical messaging never need manual orchestration.

netqmpi -n 2 app.py --cunqa --shots 1024
NetQIR/netqmpi
HPC emulator

CUNQA

A Distributed Quantum Computing emulator built for HPC infrastructure. CUNQA provisions virtual QPUs (vQPUs) directly through the job scheduler (Slurm), letting you raise a multi-QPU network on a real supercomputer and model its noise and latency — the engine NetQMPI programs run on in this tutorial.

qraise -n 4 -t 01:00:00 --co-located
CESGA-Quantum-Spain/cunqa

By the end of this tutorial, you will be able to

  • Explain the bottlenecks of monolithic QPUs and the case for DQC.
  • Write distributed quantum circuits using NetQMPI's syntax and concepts.
  • Deploy, execute and profile a distributed algorithm on the CUNQA emulator.

Who this tutorial is for

Quantum software engineers, HPC researchers transitioning to quantum architectures, computer science graduate students, and computational scientists looking to future-proof their skills for the multi-QPU era.

02 — Prerequisites

What you should bring

Bring the background below — everything else arrives pre-installed. NetQMPI, CUNQA, Slurm and Jupyter all live inside a single Docker image that turns your laptop into a small HPC cluster.

  • Core quantum conceptsComfort with qubits, gates, measurement and entanglement.
  • Python or C/C++General familiarity with either language is enough to follow every exercise.
  • Classical MPI conceptsHelpful for recognizing the communicator/rank model — but not required.

Environment setup guide

One Docker image, four commands. It ships NetQMPI, the CUNQA emulator, Slurm and Jupyter already wired together, so the cluster you work on during the tutorial runs on your own laptop — no remote accounts, no VPN, nothing to compile.

✓ Ready — pull it before you travel Open the setup guide
03 — Environment Setup

Your laptop is the cluster

Every exercise runs inside a single Docker image that ships NetQMPI, the CUNQA emulator and a working Slurm installation, wired together as a miniature HPC cluster on your own machine. No supercomputer account, no VPN, no dependency hunting — install Docker, pull the image, run it. And if Docker refuses to cooperate with your laptop, Plan B puts the same image in the cloud.

NetQMPI The MPI-inspired library you will program with — qsend, qrecv and friends.
CUNQA The emulator that raises virtual QPUs and models the links between them.
Slurm 24.11 A real job scheduler in single-node mode: qraise provisions vQPUs just like on Qmio.
Jupyter + Python Qiskit, mpi4py and the tutorial notebooks, served to your browser on port 8888.
  1. 1

    Install Docker

    This is the only thing you install on your own system. Pick your operating system below — the whole process takes about ten minutes, most of it downloading.

    1. Docker Desktop is not required here: the Docker Engine daemon is enough, and the official script below picks the right packages for Ubuntu, Debian, Fedora, CentOS and friends.
    2. Adding yourself to the docker group lets you drop sudo. Log out and back in — or run newgrp docker — for it to take effect.
    3. The hello-world container is the standard smoke test: if it prints its greeting, the daemon is running and you are done.
    bash · any distribution
    # 1 — install the Docker Engine
    curl -fsSL https://get.docker.com | sudo sh
    
    # 2 — use Docker without sudo (log out and back in afterwards)
    sudo usermod -aG docker "$USER"
    
    # 3 — check the installation
    docker run --rm hello-world
    If your distribution ships an old docker.io package, prefer the script above — the tutorial image needs Docker 20.10 or newer.
    1. Docker on Windows runs on top of WSL 2. Open PowerShell as Administrator, run wsl --install and reboot. Windows 10 21H2+ or Windows 11 required, with virtualization enabled in the BIOS.
    2. Download Docker Desktop for Windows from docker.com and run the installer, keeping “Use WSL 2 instead of Hyper-V” ticked.
    3. Launch Docker Desktop and wait until the whale icon in the system tray reports Engine running. Leave it open: every docker command needs it.
    4. Open PowerShell (a normal one this time) and run the smoke test below.
    PowerShell · Windows 10 / 11
    # 1 — enable WSL 2 (Administrator PowerShell), then reboot
    wsl --install
    
    # 2 — after installing Docker Desktop, check the installation
    docker run --rm hello-world
    Run every command of this guide from PowerShell or from a WSL terminal — not from the old cmd.exe, which quotes arguments differently.
    1. Download Docker Desktop for Mac from docker.com, choosing the Apple silicon build on M1–M4 machines or the Intel chip build otherwise. uname -m tells you which you have: arm64 or x86_64.
    2. Open the .dmg, drag Docker into Applications, launch it and accept the privileged-helper prompt. Homebrew users can do the same with one command (below).
    3. Apple silicon only: in Settings → General, enable “Use Rosetta for x86_64/amd64 emulation”. The tutorial image is an amd64 build, and Rosetta is what makes it run at a sensible speed.
    4. Open Terminal and run the smoke test below.
    zsh · macOS
    # optional — install Docker Desktop with Homebrew instead of the .dmg
    brew install --cask docker
    
    # which build do you need? arm64 = Apple silicon, x86_64 = Intel
    uname -m
    
    # check the installation
    docker run --rm hello-world
    On Apple silicon, add --platform linux/amd64 to the pull and run commands in the next steps. CUNQA is compiled for x86-64, so it runs under emulation here — and if it will not start at all, take Plan B instead.
  2. 2

    Pull the tutorial image

    The image is published on Docker Hub, already built for you — nothing is compiled on your machine.

    View the image on Docker Hub jvazquezperez/cunqa_netqmpi:latest
    terminal · Linux, macOS or PowerShell
    docker pull jvazquezperez/cunqa_netqmpi:latest
    Pull it before you travel. The image is a ~430 MB download: do it at home or at the hotel, not on the conference Wi-Fi at 10:00 alongside everyone else.
  3. 3

    Start your local cluster

    One command boots munge, slurmctld, slurmd and a Jupyter server inside the container, and drops you into a shell on the head node of your very own cluster.

    terminal · start the container
    docker run --rm -it -p 8888:8888 --name qce26 jvazquezperez/cunqa_netqmpi:latest
    Do not drop -p 8888:8888. The Jupyter server runs inside the container and listens on port 8888 there. Publishing that port is what connects it to port 8888 on your own machine; without it the container starts fine, but http://localhost:8888 stays dead and there is no way into the notebooks from your browser.

    Two variants worth knowing:

    terminal · optional variants
    # keep your notebooks on the host after the container exits
    docker run --rm -it -p 8888:8888 -v "$PWD/work:/home/tutorial/work" jvazquezperez/cunqa_netqmpi:latest
    
    # Apple silicon (M1–M4): run the amd64 image under Rosetta
    docker run --rm -it --platform linux/amd64 -p 8888:8888 jvazquezperez/cunqa_netqmpi:latest
  4. 4

    Open the notebooks and check the cluster

    On startup the container prints the address of its Jupyter server. Open it in your browser — the token is cunqa — and the tutorial notebooks are waiting for you.

    http://localhost:8888/?token=cunqa
    01-foundations.ipynbExercise 0
    02-mpi-basics.ipynbExercises 1–3
    03-netqmpi-basics.ipynbExercises 4–5

    A last sanity check, from the container shell — or from a Jupyter terminal, or from docker exec -it qce26 bash:

    container shell · your cluster, one node
    $ sinfo
    PARTITION AVAIL  TIMELIMIT  NODES  STATE NODELIST
    debug*       up   infinite      1   idle 7c41ab93f2e5
    
    $ srun -N1 hostname
    7c41ab93f2e5
    A partition called debug in state idle means Slurm is alive and CUNQA can raise vQPUs on it with qraise. That is Exercise 0 done — you are ready for the tutorial.
Plan B — when Docker will not cooperate

Docker not working? Let us make this easy.

CUNQA is compiled for x86-64. On an ARM laptop, on a machine where Docker Desktop never gets past the installer, or behind a corporate policy that blocks virtualization, the image may simply refuse to run — and there is nothing you can do about it from your side on the day of the tutorial.

So run it on someone else's x86-64 machine instead. Railway deploys the very same published image, hands you an HTTPS address, and the tutorial opens in your browser. About five minutes, no terminal, nothing installed on your laptop.

Open railway.com same image · jvazquezperez/cunqa_netqmpi:latest
  1. A

    Create a Railway account

    Go to railway.com and sign up — GitHub is the quickest route. New accounts get a one-time $5 trial credit, valid for 30 days and with no card required, which is far more than a two-session tutorial consumes.

    railway.com / login
    The old railway.app address redirects to railway.com — the dashboard is the same, only the domain changed. Deployed services still get a *.up.railway.app URL.
  2. B

    Deploy the Docker image

    From the dashboard, hit New Project — or New inside an existing project, or Ctrl/⌘ + K for the command palette — and choose Docker Image. Paste the image name, tag included, and deploy. Nothing is built: Railway pulls the very same image from Docker Hub that the Docker path uses, on its own fast network.

    railway.com / new
    Deploy from… GitHub Repo Docker Imagepick this Template Database
    Image path jvazquezperez/cunqa_netqmpi:latest Deploy
    Copy the image path exactly — jvazquezperez/cunqa_netqmpi:latest. Watch the Deploy Logs tab: when the lines [entrypoint] munge OK and [entrypoint] Jupyter: http://localhost:8888/… scroll past, your cluster is up.
  3. C

    Publish port 8888 as a public URL

    The container is running, but nothing reaches it yet. Open the service, go to Settings → Networking → Public Networking and click Generate Domain. When it asks for the port, answer 8888 — the port the Jupyter server listens on inside the container, exactly the same number that -p 8888:8888 publishes on the Docker path.

    cunqa-netqmpi / settings / networking
    Public Networking
    Target port 8888 Generate Domain
    cunqa-netqmpi-production.up.railway.app :8888
    8888 is the only port the container listens on, so Railway usually detects it and fills the field in for you. If the page later shows “Application failed to respond”, the target port is the first thing to check — and adding a service variable PORT = 8888 settles it for good.
    That URL is public. Anyone who has it — and the token — can run code in your container. The image ships with the default token cunqa, which is fine on your laptop and careless on the open internet. In Variables, add JUPYTER_TOKEN with a secret of your own and use that one in the URL below.
  4. D

    Open the notebooks

    Take the domain Railway just generated and add the token to it. That is the whole setup — the notebooks, Slurm and CUNQA are already there, running on an x86-64 machine that is not yours.

    https://cunqa-netqmpi-production.up.railway.app/?token=cunqa
    01-foundations.ipynbExercise 0
    02-mpi-basics.ipynbExercises 1–3
    03-netqmpi-basics.ipynbExercises 4–5

    There is no docker exec here, so run the Exercise 0 check from a Jupyter terminal — New → Terminal in the file browser:

    jupyter terminal · your cluster in the cloud
    $ sinfo
    PARTITION AVAIL  TIMELIMIT  NODES  STATE NODELIST
    debug*       up   infinite      1   idle 3f9a1c02b7de
    
    $ srun -N1 hostname
    3f9a1c02b7de
    It costs credits while it runsThe trial grant covers the tutorial comfortably, but the meter runs for as long as the service is up. Delete the project when the session is over — Settings → Danger → Delete.
    2 vCPU and 1 GB of RAMThat is the per-service ceiling on the free trial. Plenty for the exercises as written; if qraise dies on memory, raise fewer vQPUs or drop a couple of qubits.
    The filesystem is ephemeralA redeploy or a restart wipes everything you wrote. Download the notebooks you want to keep — File → Download — or attach a Railway Volume mounted at /home/tutorial/work.
04 — Agenda

Tutorial agenda

Two 90-minute sessions on Friday, September 18, 2026, split by a 90-minute lunch break — six exercises take you from a first distributed Bell pair to a distributed Quantum Fourier Transform.

Session 1 — Foundations 10:00 – 11:30
10:00
10:30

Foundations of Distributed Computing

  • Anatomy of a distributed system.
  • Structure of a High-Peformance Computing (HPC) cluster.
  • How to divide computational tasks across multiple nodes.
  • Exercise 0Environment setup.
10:30
11:00

Programming Model: MPI Basics

  • Single Program Multiple Data (SPMD) programming model.
  • Exercise 1"Hello world" with MPI.
  • Point to point directives for communication between processes.
  • Exercise 2Distributed vector addition.
  • Collective operations.
  • Exercise 3Dot product with a reduction.
11:00
11:30

Programming Model: NetQMPI Basics

  • Quantum Distributed Directives, mapping classical MPI operations to quantum states.
  • Exercise 4Creating a Distributed Bell State between two NetQMPI ranks.
  • Managing non-local operations and distributed gates.
  • Exercise 5Executing a Non-Local CNOT gate across two different QPUs.
Break · 11:30 – 13:00
Session 2 — Backend & Advanced Algorithms 13:00 – 14:30
13:00
13:45

CUNQA foundations

  • What is CUNQA and why to use it.
  • Exercise 6Communicating two vQPUs.
  • Exercise 7Comparing CUNQA programming model with NetQMPI.
13:45
14:15

Advanced Distributed Algorithms

  • Exercise 8Building a distributed Quantum Fourier Transform (QFT) across 3 QPUs.
  • Exercise 9 (optional)Building a distributed Quantum Phase Estimation (QPE) across 3 QPUs.
14:15
14:30

Q&A and Wrap-up

  • Open discussion, troubleshooting and pointers for going further.
05 — Code Examples

What the code actually looks like

Real, runnable snippets from the two open-source libraries — the same shape of code you'll write during the hands-on exercises.

examples/netqmpi/send_recv.py
from netqmpi.sdk.environment import Environment

def main(env: Environment = None):
    comm = env.comm
    rank = comm.rank

    next_rank = comm.get_next_rank(rank)
    previous_rank = comm.get_prev_rank(rank)

    with comm:  # everything inside runs on the selected backend
        if rank == 0:
            circuit = env.create_circuit(num_qubits=1, num_clbits=1)
            circuit.h(0)                          # prepare |+>
            comm.qsend(circuit, [0], next_rank)   # teleport the qubit
        else:
            circuit = env.create_circuit(num_qubits=1, num_clbits=1)
            comm.qrecv(circuit, [0], previous_rank)
            circuit.measure(0, 0)

    results = comm.results
    if rank != 0:
        print(f"measure: {results}")
The programmer only calls comm.qsend() / comm.qrecv() — entanglement generation, teleportation and classical corrections are handled by whichever backend adapter you select. This exact file runs unchanged on the CUNQA backend used in this tutorial.
$ netqmpi -n 2 send_recv.py --cunqa --shots 1024 View on GitHub →
quickstart.py
# Raising 4 virtual QPUs (vQPUs) for this job
from cunqa.qpu import qraise, get_QPUs, run
from cunqa.circuit import CunqaCircuit
from cunqa.qjob import gather

family = qraise(4, "01:00:00", simulator="Aer", co_located=True)
qpus = get_QPUs(co_located=True)

# A 2-qubit Bell circuit, sent to every vQPU
qc = CunqaCircuit(num_qubits=2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

qjobs = run([qc] * 4, qpus, shots=1000)
results = gather(qjobs)

for r in results:
    print(f"Counts: {r.counts}")  # e.g. {'00': 512, '11': 488}
qraise provisions vQPUs straight from the Slurm job scheduler; get_QPUs hands you live handles to run circuits on. This is the emulation layer NetQMPI targets with its --cunqa backend flag.
$ python3 quickstart.py && qdrop --all View on GitHub →
06 — Who We Are

Two institutions, one quantum-HPC roadmap

This tutorial is delivered jointly by researchers from CiTIUS (Universidade de Santiago de Compostela) and CESGA, the Galicia Supercomputing Center.

CiTIUS logo

CiTIUS — the Centro Singular de Investigación en Tecnoloxías Intelixentes — is the Universidade de Santiago de Compostela's (USC) research center for intelligent technologies, spanning computer vision, trustworthy AI, high-performance computing, robotics and quantum computing. Founded in 1495, USC is one of the oldest universities in the Spanish-speaking world and CiTIUS's host institution.

Visit CiTIUS
CESGA logo

CESGA — the Galicia Supercomputing Center — has been at the service of scientific advancement since 1993, as a node of the Spanish Supercomputing Network (RES). Through the Quantum Spain initiative, CESGA operates the 32-qubit Qmio quantum computer and develops CUNQA within its HPC infrastructure.

Visit CESGA
Jorge Vázquez-Pérez
Lead Presenter

Jorge Vázquez-Pérez

CESGA

Predoctoral researcher at the intersection of HPC and quantum computing, and lead developer of the CUNQA emulator. Experienced in leading technical workshops on advanced computing architectures.

F. Javier Cardama
Lead Presenter

F. Javier Cardama

CiTIUS · USC

Postdoctoral researcher specializing in distributed quantum computing and heterogeneous architectures. Creator and lead author of NetQMPI, translating the classical MPI paradigm into the quantum realm.

Tomás F. Pena

Tomás F. Pena

CiTIUS · USC

Full Professor at USC and senior CiTIUS researcher with decades of experience in HPC, parallel programming and computer architecture, and director of numerous national and European research projects.

Andrés Gómez

Andrés Gómez

CESGA

Senior researcher and Aplications & Projects manager at CESGA. He leads the integration of quantum technologies into classical supercomputing environments through key projects such as Qmio (32 qubits) and Quantum Spain.

07 — Acknowledgements

Funding & support

NetQMPI and CUNQA are the outcome of publicly funded research. This tutorial acknowledges the programmes and grants that made them possible.

Quantum Spain España Digital 2026
Ministerio para la Transformación Digital y de la Función Pública Plan de Recuperación, Transformación y Resiliencia Financiado por la Unión Europea – NextGenerationEU Red Española de Supercomputación

Quantum Spain

CUNQA has been developed with the financial support of Quantum Spain — Spain's Quantum Computing Ecosystem for AI — financed by the Ministerio para la Transformación Digital y de la Función Pública through the Quantum ENIA project, within the Recovery, Transformation and Resilience Plan – NextGenerationEU, under the Digital Spain 2026 Agenda.

About Quantum Spain
Gobierno de España, Ministerio de Ciencia, Innovación y Universidades, Cofinanciado por la Unión Europea, and Agencia Estatal de Investigación logos

DeepQuantum

Further supported by the DeepQuantum project, contributing new knowledge, algorithms and tools to High Performance Quantum Computing.

MICIU / AEI / 10.13039/501100011033 / FEDER, UE

About DeepQuantum
Funded by the European Union Xunta de Galicia
  • This work has been supported by the "Ministerio de Ciencia, Innovación y Universidades del Gobierno de España" through the European Union NextGenerationEU recovery plan PRTR-C17.I1.
  • This project is funded by the "European Union" through the EuroHPC programme under grant agreement 101194491, and by the "Ministerio de Ciencia, Innovación y Universidades del Gobierno de España" (MICIU) and the "Agencia Estatal de Investigación" (AEI, 10.13039/501100011033), under the projects PCI2025-163133, PCI2025-163180, and PCI2025-163229.
  • Financial support from the "Ministerio de Economía, Comercio y Empresa del Gobierno de España" under the grants PID2019-104834GB-I00, PID2022-141623NB-I00, and PID2022-137061OB-C22.
  • Financial support provided to CiTIUS (Research Centre on Intelligent Technologies) through the Galician Research Center accreditation 2019-2027 (grant ED431G-2023/04), funded by the "Consellería de Cultura, Educación e Ordenación Universitaria". This research was co-funded by the "European Union" (European Regional Development Fund – ERDF).
  • The authors acknowledge the financial support from the "Consellería de Educación, Cultura y Ordenación Universitaria da Xunta de Galicia" through the predoctoral grant ED481A-2022/241 and IN606A-2025/012.
08 — Further Reading

Recommended bibliography

The peer-reviewed and preprint work behind NetQMPI and CUNQA, for attendees who want to go deeper than the hands-on exercises.

Review of Distributed Quantum Computing: From Single QPU to High Performance Quantum Computing

D. Barral, F.J. Cardama, G. Díaz, D. Faílde, I.F. Llovo, M. Mussa Juane, J. Vázquez-Pérez, J. Villasuso, C. Piñeiro, N. Costas, J.C. Pichel, T.F. Pena, A. Gómez

Computer Science Review, Vol. 57, 2025, Art. 100747 10.1016/J.COSREV.2025.100747

NetQMPI: An MPI-Inspired Library for Programming Distributed Quantum Applications over Quantum Networks Using NetQASM SDK

F.J. Cardama, J. Vázquez-Pérez,T.F. Pena, A. Gómez

IEEE Access, 2026 10.1109/ACCESS.2026.3723566

CUNQA: A Distributed Quantum Computing Emulator for HPC

J. Vázquez-Pérez, D. Expósito-Patiño, M. Losada, Á. Carballido, A. Gómez, T.F. Pena

arXiv preprint, 2025 arXiv:2511.05209

Communication-Efficient Distributed Inverse Quantum Fourier Transform

F. Javier Cardama, J. Vázquez-Pérez, T.F. Pena and A. Gómez

arXiv preprint, 2026 arXiv:2605.10710