Subscribe
Share
Share
Embed
The daily quantum computing briefing you don't need a physics degree to follow. Every day, Quickly Quantum cuts through the hype to bring you the breakthroughs, funding rounds, policy moves, and research that actually matter, with plain-English analysis a smart non-physicist can follow. Hosted by Brian Lampert. AI-voiced, human-built, always skeptical of press releases. Nothing on this show is financial advice.
Also from Brian Lampert: Concrete Compute and Space Stakes.
How far short are today's quantum computers of actually doing useful science? A new benchmark just put a number on it, and it's not a small one — one hundred thousand times. That's our main story today: a cross-vendor benchmark called QUOPS, tested live on machines from Quantinuum, Google, and IBM, giving the field its first honest, apples-to-apples ruler for progress. Before that, in the headlines: NVIDIA throws open its fault-tolerant software platform, IonQ racks up peer-reviewed wins at a major conference, and a five-hundred-million-dollar Canadian chip fab gets pitched to the government. Welcome back to Quickly Quantum, your daily brief on the quantum frontier. It's Tuesday, September 15th, 2026. Let's get into it.
Let's start with the platform quietly becoming the plumbing under almost every quantum hardware maker's fault-tolerant plans. NVIDIA expanded its open-source CUDA-Q platform with a new piece called CUDA-Q Logical — an orchestration layer, think of it as the software glue, for designing fault-tolerant quantum applications across totally different hardware types. Fermilab says using it cut their fault-tolerant design evaluation time from about five months down to three weeks, and that's the kind of number you don't see every day in this field. Now, here's the part that made me raise an eyebrow: this is the same announcement that packaged the QUOPS benchmark we're spending our main story on today, and on the same day, IQM and Infleqtion announced their own CUDA-Q Logical integrations, while Anyon Computing and Quandela announced integrations with a separate NVIDIA architecture called NVQLink, which couples quantum hardware directly to GPUs rather than routing through CUDA-Q Logical. Even split across two different NVIDIA products, that's not independent adoption — it's one coordinated NVIDIA rollout, and it's worth being honest about that. Felix Thomsen, an executive at IcebergQuantum, posted on X as @flexithomsen that his team, working with Diraq and NVIDIA, demonstrated that Pinnacle's logical performance advantage is achievable on Diraq's hardware, carrying that hardware mapping through to end-to-end compilation using NVIDIA CUDA-Q. NVIDIA's own newsroom account, @nvidianewsroom, confirmed the QUOPS integration on X as well. So does deep reliance on one company's software layer create new vendor lock-in for the whole industry? That's a fair question to sit with as more of these integrations roll in.
Sticking with the same conference floor, IonQ had a genuinely strong week at IEEE Quantum Week 2026, the field's flagship academic gathering. The company presented nine peer-reviewed papers spanning quantum machine learning, computational fluid dynamics, protein folding, and error mitigation, all run on IonQ hardware paired with NVIDIA software. Four of those papers won Best Paper Awards, and those four specifically covered protein folding, large-scale linear algebra workflows, quantum fine-tuning of foundational AI models, and AI-assisted distributed quantum optimization. Now, we've talked about IonQ before mostly in the context of its Bitcoin-security estimates moving the stock; this is a different IonQ story, the peer-reviewed research side getting real academic recognition in one week, which is rarer for a hardware vendor than you might think. On X, the official IonQ account, @IonQ_Inc, called the work one that merges quantum's origin story in the lab with quantum's roadmap. Worth keeping the scale honest, though — a conference best-paper award is a meaningful bar, but it's an academic one; the commercial translation is still early-stage collaboration work, not something deployed in production yet.
From research papers to poured concrete, or at least the proposal for it. Photonic Inc. unveiled what it's calling Project VANGUARD, and The Quantum Insider reports it's a proposed multi-tenant semiconductor manufacturing facility in Canada, with an estimated cost of up to five hundred million Canadian dollars — about three hundred fifty-nine million U.S. dollars. The Quantum Insider also reports the facility was selected for the Canada Investment Summit Prospectus, a curated list of investment opportunities pitched to global institutional investors, presented in Toronto as part of a summit hosted by Prime Minister Mark Carney. The plan is to anchor Photonic's silicon spin-qubit production while also serving AI, aerospace, and defense customers. Photonic CEO Don Mattrick framed it as a play for what he called, quote, "economic and technological sovereignty." Now, here's the caveat that matters: this is a proposal selected for a government prospectus, not a funded, shovel-in-the-ground facility. Financing and site details are still to be worked out, so treat that half-billion-dollar figure as an estimate, not a receipt.
One more quick one, and it's from the sensing side of quantum rather than computing. MITRE, working with Quantum Brilliance, NVIDIA, and SandboxAQ — Quantum Computing Report reports — published a GPU-accelerated digital-twin framework designed to automate error attribution for quantum sensors, detailed in a new arXiv preprint. Tested on nitrogen-vacancy diamond ensembles, the framework found that a specific noise mechanism called T-two-star spin dephasing accounts for about eighty-nine percent of the sensitivity error budget, while separate mechanisms limit accuracy and drift. They also validated it on a cesium magnetometer array built for biomagnetic heart imaging. Now, the point worth pulling out is that optimizing a sensor for raw sensitivity alone doesn't guarantee it's accurate in the field, and this tool is meant to catch that gap before you build the hardware. It's preprint-stage research, single-source in our reporting so far, not a validated clinical product — but it's another sign, if you're keeping score, that NVIDIA's GPU-acceleration stack is spreading well beyond computing into quantum sensing too.
Now let's get to the number that's going to be sitting in the back of your mind the rest of this episode: one hundred thousand. That's our main story's thesis — call it the honest-ruler problem: quantum computing finally has a real benchmark for how far it has to go, and the answer is farther than most public roadmaps admit. For years, the industry has measured progress in numbers that sound impressive but don't tell you much on their own — qubit count, gate fidelity, the accuracy of a single quantum logic operation. The problem is a machine can have a lot of qubits and still be useless if its error rates are high, or have blazing-fast gates and still choke on a real calculation because its qubits aren't well connected to each other. None of those specs tell you what the whole machine can actually finish. That's what a new benchmark called QUOPS — the Quantum Universal Operations Performance System — is trying to fix. It was built by Sandia National Laboratories, with contributions from Quantinuum and NVIDIA, and posted as a paper on the preprint server arXiv; it hasn't been peer-reviewed yet. Here's the idea: instead of asking about one gate or one qubit, throw randomized circuits of different widths, meaning qubit count, and depths, meaning how many steps in a row, at the machine, and see which ones it can actually run above a set accuracy threshold. That maps out a whole region of what the computer can do, which QUOPS boils down to two numbers. The first, called Q, is the size of the largest circuit the machine can successfully run. The second, Omega, is how many effective quantum operations it completes per second at that point. Together they tell you both how big a problem the machine can tackle and how fast it gets there. And the researchers didn't just simulate this — they ran it directly on three leading commercial machines: Quantinuum's Helios, Google's Willow, and IBM's Boston processor, plus a small fault-tolerant test on Quantinuum's Helios-1 system using up to eight logical qubits, which are error-corrected qubits built by combining many noisy physical ones. The results exposed a real trade-off. Quantinuum's Helios, a trapped-ion machine, handled larger circuits. Google's Willow and IBM's Boston, both superconducting processors, ran their operations faster. Neither company wins outright — they're strong in different directions, and QUOPS is the first tool that shows that trade-off in the same units. And then the headline finding: current systems sit about five orders of magnitude — that's the one hundred thousand-fold gap — below the computational capability the study estimates is needed for the scientific problems the researchers examined. The paper argues that finding actually supports the case for fault-tolerant computing generally, since noise is still the thing limiting how large and long a calculation these machines can run reliably before errors pile up.
So how is the field reacting to being handed its own report card? Quantinuum, one of the co-developers, posted on X through its official account, @quantinuumqc, calling out exactly why the old metrics fell short: quote, "Metrics like qubit count and gate fidelity have been essential for quantum computing, but as the industry moves toward fault-tolerant, application-scale systems, they no longer tell the whole story." NVIDIA's own newsroom account, @nvidianewsroom, framed QUOPS as a way of, quote, "measuring progress toward utility-scale fault-tolerant quantum computing available in CUDA-Q" — which folds this new benchmark directly into NVIDIA's own software platform. And an industry analyst account, @qtumanalysis, laid out the two core numbers for its followers — Q for the largest computation a machine can complete, Omega for the effective operations per second — describing QUOPS, in their words, as the field's new universal benchmark. It also strengthens the case that NVIDIA's CUDA-Q Logical, which we opened with, is becoming the reference software stack under both the fault-tolerant tooling and the benchmark used to judge it — worth remembering when you notice NVIDIA's name attached to basically every part of this story. Here's what actually excites me about this: it's a thirty-author, cross-vendor collaboration that ran on real hardware from three competing companies, not a simulation and not a single vendor's cherry-picked demo. But — and this is where I want to slow down — the skeptics have a real point buried in the fine print. That one hundred thousand-fold figure is scoped specifically to, quote, "the scientific workloads examined" in the paper. It's not a claim that every quantum application is one hundred thousand times away from usefulness; some narrower problems could need far less of a jump, and we don't actually know because the paper didn't test all of them. And QUOPS itself is brand new, tested on exactly three vendors, with zero independent replication yet outside the team that built it. So the ruler is honest, but it's also unproven as a ruler — nobody's checked whether a fourth lab gets the same numbers running the same test. Now, this connects to something we've flagged with two of these companies before. With IBM, the open question on this show has been whether its quantum bet is actually paying off commercially, or whether the company just needs it to be the answer. A brand-new benchmark that quantifies exactly how far IBM's Boston processor is from useful science doesn't resolve that — if anything, it hands IBM's critics a bigger, more citable number to point at. And with Quantinuum, the read here has been that the company tends to re-announce incremental progress, the way it has with its anyon milestones. QUOPS is different in kind, since it's a joint benchmark rather than a company press release, but it's still Quantinuum's own hardware coming out ahead on the Q side of the ledger, in a benchmark Quantinuum helped design. That's normal for a cross-vendor benchmark — vendors typically help design the tests that measure them — but it's a detail worth holding onto when you read the headline. And practically, what happens next is straightforward to watch for: does a fourth lab, someone with no hand in building QUOPS, run this benchmark on their own hardware and get numbers that hold up? That's the test that turns an honest ruler into a trusted one. So where does that leave us? I think QUOPS is the most useful thing to happen to quantum benchmarking in a while, precisely because it replaces vibes with a number you can argue about. But the honest version of that number comes with three asterisks: it's scoped to specific workloads, it's untested outside its own creators, and it was co-designed by two of the three companies it just measured. Buyers and policymakers recalibrating their timelines around a five-orders-of-magnitude gap should recalibrate around those asterisks too. Time for the Hype Check. I'm putting this one at a 7. The methodology is real, the collaboration is credible even with peer review pending, and running it live on three competing machines instead of simulating it is genuinely rare in this field. It loses points because the killer number — one hundred thousand-fold — is doing a lot of work for a benchmark that's exactly one paper old, tested by exactly the people who built it.
Now, if today's episode gave you a number to actually use next time someone tells you quantum computers are about to change everything, follow Quickly Quantum wherever you're listening, so tomorrow's episode is just there waiting for you. This has been Quickly Quantum, an AI-voiced podcast, created and built by a real human using today's cutting-edge technology. Nothing you heard on this show is financial advice. I'm Brian Lampert, and I'll catch you all tomorrow — take care!
I also host Concrete Compute: a daily briefing on the AI buildout. The datacenters, the megawatts, and who actually pays for them. Find it wherever you get your podcasts.