From Lab Bench to Laptop: How Quantum Machines and NVIDIA are Transforming Quantum Development

For most of quantum computing’s history, working with a real quantum processor has meant working like a hardware engineer, not a software developer. To run even a modest hybrid quantum-classical experiment, you needed to understand pulse-level control, timing constraints down to the nanosecond, and the specific electronics sitting between your code and the qubits. That barrier hasn’t just slowed individual projects; it’s kept quantum computing largely in the hands of a small community of specialists, at a moment when the field needs many more builders.

In September 2026, Quantum Machines closed a meaningful piece of that gap with NVIDIA accelerated computing. At IEEE Quantum Week in Toronto, QM demonstrated the first end-to-end NVIDIA CUDA-Q program run across live qubits and a Pulse Processing Unit (PPU) classical processor, using NVIDIA NVQLink to connect the two with low latency and high throughput. In practice, that means a program written once, in a high-level language, ran seamlessly across a quantum processor, GPUs, and CPUs, with the full round trip between them completing in about a millionth of a second.

Why the Low-Level Barrier Existed in Quantum Computing

Quantum processors don’t execute code the way classical chips do. Every operation on a qubit corresponds to a precisely timed microwave or voltage pulse, and getting useful results out of a quantum system means controlling and reading out those pulses with extreme timing precision, often while making real-time decisions based on measurement outcomes mid-experiment. Historically, that meant writing control sequences by hand, tailored to a specific piece of hardware, using tools accessible mainly to physicists and control engineers.

That’s a fundamentally different skill set than the one most software developers, data scientists, or applied researchers bring to the table. It’s a bit like asking every web developer to also be fluent in semiconductor physics before they could ship an app.

NVIDIA CUDA-Q is  the open platform for quantum-GPU supercomputing – a way of writing a single set of instructions for a hybrid application that can execute on classical and quantum hardware as appropriate. Rather than hand-coding the translation between a high-level algorithm and the low-level pulse sequences a specific QPU needs, developers can write in familiar languages such as Python, C++, or QM’s own QUA and let CUDA-Q and QM’s control stack handle the routing underneath. Quantum operations are sent to the QPU, classical computation is handed to GPUs and CPUs, and each part of the workload lands on the right processor automatically.

That’s the part of this announcement most relevant to anyone who isn’t already deep in quantum hardware: the specialized expertise doesn’t disappear, but it moves. It shifts from “everyone who wants to build something has to have it” to “it’s built into the platform once, and developers can build on top of it.”

Why NVQLink’s Low Latency Is the Real Enabler

None of this works, though, without a fast enough connection between the quantum and classical sides. NVQLink is the interconnect that makes it possible – a microsecond-latency link between a quantum controller and GPU compute, enabled by QM’s own hardware and physical layer over OPNIC, which couples the OPX1000 to CPU/GPU servers. The Toronto demonstration completed its full exchange in around a millionth of a second, fast enough that classical processors can receive measurement data, make a decision, and send that decision back to the quantum control system before the next operation needs to happen.

That timing matters more than it might first appear. Many of the most promising near-term and future quantum applications, such as variational algorithms, real-time calibration, and especially quantum error correction, depend on this kind of tight feedback loop. Error correction, in particular, requires continuously measuring qubits, detecting errors, and correcting them, all within the physical coherence time of the qubits themselves. Without a low-latency bridge to classical compute, that loop simply can’t run fast enough to be useful at scale.

QM’s CTO Yonatan Cohen has drawn a comparison to the early history of GPUs themselves: purpose-built, specialist tools, initially confined to research labs and niche applications, that eventually became a standard part of mainstream computing infrastructure. Whether or not quantum computing follows exactly the same timeline, the direction of travel is the same one: from something only a handful of experts can operate, toward something applications and mainstream developers can simply call on.

What This Means for the Future of Quantum Computing

This demonstration is a proof point, not a finished product, and there’s a lot of engineering ahead before workloads like large-scale quantum error correction are running routinely on infrastructure like this. But it’s an important step forward, as QM and NVIDIA have been building toward tighter, faster QPU-GPU integration for a while, and last week’s result is the latest, not the last, milestone in that direction.

For developers watching the space, the practical takeaway is this: the on-ramp into quantum computing just got a little less steep.