If you have read some of our earlier episodes (check here), you already know that building a quantum computer is hard. Qubits are fragile, errors creep in, and keeping a calculation alive takes considerable effort.

Today, we look at a surprising challenge: ordinary computers could hold back the growth of quantum computing. But why would a quantum computer need an ordinary computer in the first place?

Let’s see why.

One important reason is our old friend: quantum error correction (read here).

The basic idea of error correction is to spread quantum information across several qubits, adding redundancy so that we can recover it if something goes wrong.

Note: This does not mean making independent copies of an unknown quantum state. Instead, we encode the information into the collective state of several qubits.

The process looks roughly like this:

That fourth step is where the normal computer becomes essential. But first, let’s make the process concrete with an example.

Suppose we represent 0 as 000, and 1 as 111. If one bit flips, the other two still let us recover the original value.

For this example, we will consider only an error that swaps 0 and 1, called a bit flip. This simple code can correct one such error; protecting against other quantum errors requires more.

Imagine we start with the state 0 , so we encode it to 000, and the third qubit flips:

000 → 001

We need to find out if the error occurred without directly measuring all the three qubits.

(Why not simply measure all three qubits and read their values? That is for another episode.)

So we ask two more careful questions:

These checks reveal whether the qubits agree without revealing whether the encoded information is 0 or 1. Quantum gates transfer each comparison result to an extra helper qubit, which we then measure. This is how we learn about an error without reading out the protected information itself.

Let’s write 0 for “same” and 1 for “different.” Keeping the two checks in the order above gives this table:

Assuming at most one bit flip.

In our example, 001, the first two qubits are the same, while the last two are different. The checks therefore give us 01.

Now we have to answer a question: which qubit should we flip to correct the error?

Assuming only one qubit flipped, our table gives the answer: the third qubit. Flipping it back restores 000.

This is where an ordinary computer comes in. It receives the check results, looks up the table, and decides which qubit to flip. Interpreting the check results and choosing a correction is called decoding. The software or hardware that does this job is called a decoder. The ordinary computer then sends the correction instruction to the quantum computer.

But what if more than one qubit flipped?

Starting from 000, two different things could happen:

Both give the same check results: 01. So the ordinary computer receives exactly the same clues, even though the errors need different corrections.

So which happened: one qubit flipped, or two? If errors are rare and happen independently, a single flip is more likely. The decoder therefore assumes the third qubit flipped and tells the quantum computer to flip it back.

But if the first two qubits actually flipped, that correction would be wrong. The same check results can point to different errors, so the decoder sometimes has to make an educated guess.

In our simple example, the decoder chooses between two possible errors. With more qubits, the same check results could fit 50 different error patterns, or many more. Working out which is most likely error pattern and choosing a correction takes time.

But error correction does not happen just once at the end. We repeatedly check the qubits while the computation runs. So while the decoder is still interpreting one set of results, the next set can arrive. If it cannot keep up, unfinished work starts to pile up.

On superconducting hardware, these rounds can happen roughly every microsecond—a millionth of a second. That can mean around a million rounds of checks per second, with many checks happening in each round.

The difficulty is not that ordinary computers cannot perform fast logic. They can. The difficulty is completing the whole decoding task quickly enough, repeatedly, as the amount of information grows.

Two things make this harder.

First, the puzzle grows. More qubits mean more checks and more possible error patterns. A simple table lookup is often no longer practical. Instead, the decoder must use an algorithm to work out which errors most likely caused the check results. That calculation takes time.

Second, the work never stops arriving. While the decoder processes one batch, the quantum hardware produces the next. If processing consistently falls behind, a backlog builds up.

So how do we make the decoding fast enough to keep up with all these error checks?

Yes and one approach uses devices called FPGAs, short for field-programmable gate arrays.

The name sounds complicated, but the useful idea is simple: an FPGA is a chip whose digital circuitry can be configured for a particular task. Engineers can arrange it to perform parts of the decoding process simultaneously and pass incoming results through dedicated processing stages.

Your laptop is designed to handle countless different tasks while the FPGA can be programmed specifically to decode error-check results quickly.

This is already being tested in practice. For example, Riverlane describes an FPGA implementation of its decoder that processes a decoding round in under a microsecond for the configurations it reports. That does not solve decoding at every scale, but it shows why specialised electronics are part of the effort.

FPGAs are one option, we can also speed up decoding by improving the algorithm so it needs fewer calculations to choose a correction.

After all this talk about specialised electronics, here comes a surprising twist: sometimes, a normal processor may be enough.

On September 22, IonQ announced a decoding system tested on simulated quantum computations involving up to 408 logical qubits. The decoding ran on a single commercial processor—the Apple M4 Max found in a MacBook Pro.

How could it keep up? The study assumed error-checking rounds lasting 1–5 milliseconds for its trapped-ion architecture. That gives the classical processor much more breathing room than the roughly microsecond rounds we discussed for superconducting hardware.

The researchers split the work between two decoders. One kept track of errors throughout the calculation. The other handled urgent measurement results, those the quantum computer needed before it could continue.

For clarity, IonQ did not create 408 logical qubits on a real quantum computer. Instead, they used an ordinary classical computer to simulate the error-check results from a system with up to 408 logical qubits, then tested how quickly their decoder could process those results. But it shows a promising possibility: with the right algorithms and architecture, ordinary processors could handle substantial decoding workloads.

So building a useful quantum computer also means building the classical machinery that supports it. The qubits produce clues about what went wrong. Something has to interpret those clues, round after round, in time for the calculation to continue.

Some of the work that makes quantum computing possible happens entirely in ordinary zeros and ones.

The question, then, is not simply “How fast is the decoder?” It is “Can it keep up with the quantum computer it serves?”

A few useful bonus links