How quantum computers work

1The coin

A coin that always lands heads?

Start with two coins. One is an ordinary coin. The other is a quantum coin. I’ll explain what that means soon. For now, treat it as a coin with one odd habit.

Flip each one once and look. Both land heads or tails at random, half the time each. You can’t tell them apart. Next, flip each coin twice in a row, without looking in between, and then look. The ordinary coin is still random, of course. What about the quantum coin?

Now try it:

Flip once Flip twice Flip, look, flip

Start on headsStart on tails

Do it 100 times

Pick a button. Each press flips both coins the same way.

Flipped twice, the quantum coin lands heads every time. Start it on tails and it lands tails every time. The second flip undoes the first.

Now press Flip, look, flip. The only change is a peek in the middle. That peek is enough to make the quantum coin random again.

A coin that undoes itself unless you look isn’t a party trick. It’s what a single particle of light does, and you’ll see the real experiment in chapter 4. It’s also the whole difference between a quantum computer and a normal one, packed into one toy. To see why, start with the normal one.

2Bits

What does a normal computer do?

Your phone is made of billions of tiny switches. Each one is off or on, which we write as 0 or 1. One switch holds one bit. Everything on your phone, this page, your photos, your messages, is stored as long rows of bits.

At any moment, each switch is either off or on, so the whole machine is in exactly one arrangement. Three switches have 8 possible arrangements, from 000 to 111. Four have 16. Each extra switch doubles the count. A program is a rule for getting from one arrangement to the next, step after step, billions of times a second.

Now give the computer some coins to flip. Programs really do this, to shuffle a playlist or to simulate the weather. Now you can’t say for sure which arrangement it will end up in. You can only give each one a chance.

Here are three switches. Tap them to set an arrangement. Then press With coins: before the next step, each switch flips its own coin, and changes if the coin says so.

With coins Run it Run it 100 times

The machine is in one arrangement: 000. Tap a switch to change it.

With coins, the gold squares show each arrangement’s chance. That’s 8 numbers to keep track of, for only 3 switches. For 50 switches it would be about a million billion numbers. But press Run it and look: the machine still lands in one arrangement. The list of chances is only our bookkeeping. The computer is never in more than one arrangement at a time.

Chances follow one simple rule. If there are two ways to reach the same arrangement, you add their chances. A chance can’t be less than zero, so every extra way of reaching an answer makes it more likely, never less. Flip an ordinary coin twice and there are two ways to end on heads, heads then heads or tails then heads. Each has a chance of a quarter. Add them, and you get a half. Random, as you’d expect.

In a normal computer, even one that flips coins, chances only ever add up.

Hold on to that. The quantum coin breaks it.

3Minus signs

What if chances could cancel?

Here’s the quantum coin’s secret. It doesn’t carry chances. It carries amplitudes.

An amplitude is like a chance that’s allowed to be negative. The rules for using them are the rules for chances, with one change at the end:

1. Follow each path through the flips, and multiply the amplitudes along it.
2. Add up the amplitudes of all the paths that end the same way.
3. Square the total. That’s the chance you’ll see that ending.

Squaring is why a negative amplitude still gives a sensible chance: minus a half, squared, is a quarter. In the pictures from here on, an amplitude is an arrow, pointing up for plus and down for minus. Its chance is the area of the gold square built on it.

One flip of the quantum coin, starting from heads, gives heads an amplitude of 0.71 and tails an amplitude of 0.71. Squared, each is a half, which is why one flip looks like an ordinary coin. Starting from tails, it’s the same except for one minus sign: heads gets 0.71 and tails gets minus 0.71. (The number 0.71 is 1 divided by the square root of 2, picked so that its square is exactly a half.)

Now flip twice, and follow all four paths:

Start on headsStart on tails

Look after the first flip

Two paths end on heads, each with an amplitude of plus a half. They add to 1, and 1 squared is 1: heads every time. Two paths end on tails, one with plus a half and one with minus a half. They cancel to zero. Tails never happens, even though each path to it, on its own, looked perfectly possible.

Now press Look after the first flip. You know which way the coin went in the middle, so the paths no longer meet: whatever you saw, only one of them is still possible. With nothing to cancel, you’re back to adding chances, a quarter plus a quarter. Random.

If you’ve read the guide to noise-cancelling headphones, this will feel familiar. There, a sound and its upside-down copy added up to silence. Here, two ways of getting an answer add up to nothing.

That’s the one new rule. In the quantum world, ways of getting an answer can cancel.

It sounds like an accounting trick. Is it real?

4Light

Is the quantum coin real?

Light comes in tiny packets called photons. Special light sources can send them out one at a time, and a sensitive detector clicks once for each photon that hits it.

A half-silvered mirror lets half of the light through and reflects the other half. Send one photon at it, and the photon doesn’t split. One detector or the other clicks, never both, at random, half the time each. That’s the coin’s first flip.

Now catch both beams with ordinary mirrors and bring them back together at a second half-silvered mirror, with a detector on each side of it. Before you send a photon through, a guess.

Send a photon Send 100 Second mirror

Extra glass on top

none

Reset

Tap a beam to put your hand in it.

With both mirrors in place, every photon lands on the same detector. The second mirror is the coin’s second flip: the two ways of reaching the other detector cancel. Take the second mirror out, and it’s a coin again.

Next, block the top beam, as if you put your hand in it. One more guess first.

Half the photons now hit your hand. The ones that get past land at random again. Blocking a path changes where the photons that never touched your hand end up. The maths only works if each photon has an amplitude on both paths, and the two meet at the second mirror. Block one path and there’s nothing left to cancel.

The glass slider makes the top path a tiny bit longer, by a fraction of the light’s wavelength. That shifts the timing of its amplitude, and the photons slide over from one detector to the other. Half a wavelength sends every photon to the other side.

This was done carefully, one photon at a time, in 1986, by Philippe Grangier, Gérard Roger and Alain Aspect in France. First they showed that a photon really does go one way or the other at a half-silvered mirror, never both. Then they showed the same photons cancelling in an interferometer like this one. The same cancelling has been seen with electrons, atoms, and even whole molecules of 60 carbon atoms.

One simplification: in a real setup, which detector gets all the light depends on the exact lengths of the two paths. Here they’re set equal.

The quantum coin is real. Every photon carries one.

So let’s build a computer out of it.

5Qubits

What is a qubit?

A qubit is anything with two states that follows the amplitude rule. The two states are called 0 and 1, as with a bit. The two paths of a photon make a qubit. So do two energy levels of an atom, or the two lowest energy states of a tiny superconducting circuit on a chip, which is what the gold fridge is for.

A qubit doesn’t hold a 0 or a 1. It holds two amplitudes, one for 0 and one for 1. You’ll often read that a qubit is 0 and 1 at the same time. That’s a loose way of saying it has an amplitude for each. When you look, you only ever see one.

Here’s a neat way to draw it. Take an arrow of length 1 and let it point anywhere around a circle. Its shadow on the 0 line is the amplitude for 0. Its shadow on the 1 line is the amplitude for 1. The squares on the two shadows are the two chances, and together they always have the same area as the square on the arrow, which is 1. That’s Pythagoras, and it’s why the chances always add up to 1.

Drag the arrow around, then try the buttons:

X Z H Look Look at 100 copies Back to 0

The arrow points at 0: amplitude 1 for 0, nothing for 1.

Every step a quantum computer can take on one qubit turns or mirrors this arrow. These steps are called gates. X mirrors the arrow across the diagonal, swapping 0 and 1. It’s the quantum version of flipping a switch. Z mirrors it across the 0 line, which flips the sign of the 1 shadow. You can’t see that change at all, until something cancels.

H, named after the mathematician Jacques Hadamard, mirrors the arrow across a line at 22.5 degrees. This is the quantum coin’s flip. Start at 0 and press H: the arrow lands at 45 degrees, with two equal squares, half and half. Press H again and it mirrors straight back to 0. A mirror used twice is no mirror at all. That’s chapter 1’s coin, in one picture.

Press Look and the arrow snaps to 0 or 1, at random, with the chances the squares showed. After that it stays where it landed. Looking doesn’t gently read the arrow. It replaces it.

Physicists write the arrow as a|0⟩ + b|1⟩, where a and b are the two amplitudes. I’ve also left something out: real amplitudes are complex numbers, which lets the arrow turn in a direction off this page as well. That’s why textbooks draw a sphere, not a circle. The circle is enough for every idea in this guide. In fact, a quantum computer that only ever uses plus and minus can do everything a full one can, given one extra qubit.

A qubit is an arrow. Gates turn it. Looking snaps it.

If the arrow can point anywhere, why not use its exact angle to store a huge number?

6Looking

Why not just read the arrow?

An arrow’s angle can be any number, like 31.41592653 degrees. Keep writing digits and one qubit could hold a whole book. Except you can’t read it.

Looking gives you one bit, 0 or 1, and wipes out the arrow. You can’t make copies first and look at each copy, either. That was proven impossible in 1982: no machine can copy a qubit it doesn’t already know. So the only way to learn an angle is to have someone make many qubits in the same way, and look at each one once.

Here’s a qubit whose arrow I’ve hidden somewhere between 0 and 90 degrees. Look at some fresh copies, then drag your guess and press Reveal:

Look at 1 Look at 10 Look at 100 Reveal New arrow

No looks yet. Each look uses up one copy.

Ten looks give you a rough idea. A hundred get you within a few degrees. Precision comes slowly: to halve your error you need four times as many looks, and each look uses up a whole qubit.

There’s a hard limit behind this. In 1973 Alexander Holevo proved that n qubits can give you at most n bits of answers, no more than n ordinary switches. That’s why a quantum computer runs the same program thousands of times. It’s also why its programs must be arranged so the answer comes out clearly in the bits you see.

A qubit holds a lot, but shows very little: one bit per look.

So one qubit on its own isn’t much use. Things change when there are two.

7Two qubits

What happens when qubits team up?

Two bits have four arrangements: 00, 01, 10 and 11. So two qubits have four amplitudes, one for each arrangement. Gates can now act on a pair. The most useful one is called CNOT, short for controlled-NOT. It flips the second qubit, but only in the arrangements where the first qubit is 1.

Flip the first qubit with H, then use CNOT. The flip gives 00 and 10 an amplitude of 0.71 each. CNOT turns the 10 into 11. So the pair ends up with 0.71 on 00, 0.71 on 11, and nothing on 01 or 10.

StartAfter HAfter CNOT

Look at the pair Do it 100 times

Look at either qubit on its own and it’s a fair coin. But the two always agree: 00 or 11, never 01 or 10. Neither qubit has an arrow of its own any more. There’s only one arrow, for the pair. This is called entanglement.

You could carry one of the qubits to the other side of the world, carefully, and the two would still agree. Does that let one send a message to the other, faster than light? No. Whatever you do to your qubit, your friend’s looks still come out like a fair coin. The agreement only shows up when the two of you compare notes, by phone or by post, at ordinary speeds.

So here’s a fair doubt. Put the same card into two envelopes and post them to two cities. Open one, and you know what’s in the other. Maybe the qubits simply agreed on their answers when they were made, and carry them along like cards in envelopes.

In 1964, a physicist named John Bell found a way to test that.

8The no-talking game

Could the pair be carrying hidden answers?

Bell’s test is easiest to see as a game. Two players, Alice and Bob, sit in separate rooms and can’t talk. A referee hands each of them a card, red or blue, picked at random. Each must answer 0 or 1.

They win the round if their answers match, with one exception: if both of them got blue, they win only if their answers differ. They can agree on a plan beforehand, but once the cards arrive, each one only knows their own card.

Each player can follow one of four rules: always say 0, always say 1, say 0 for red and 1 for blue, or the opposite. Pick a rule for each, and play.

Alice’s rule

Bob’s rule

Play 1,000 rounds Show all 16 plans Use qubits

Pick a rule for each player, then play.

No plan wins more than 3 rounds in 4. Look at all 16: the best ones lose exactly one of the four card pairs, every time it comes up. Dice don’t help either. Dice only pick one of the 16 plans at random, and none of those beat 75%.

Now give Alice and Bob one qubit each from an entangled pair, and press Use qubits. Their plan: before looking at your qubit, turn it by an angle that depends on your card. Alice turns hers by 0 degrees for red and 45 for blue. Bob turns his by 22.5 for red and minus 22.5 for blue. Their answers then agree more often the closer their two angles are. With these angles, they win about 85% of rounds. Drag Bob’s arrows to try other angles.

No plan can win 85%. So the qubits can’t be carrying answers written down in advance, like cards in envelopes. The best a shared pair can do is 85.4%, the cosine of 22.5 degrees, squared.

This has been tested for real, with the two sides as much as 1.3 kilometres apart. The cards were picked so fast that no signal, even one moving at the speed of light, could pass between them in time. The main loopholes were closed together in 2015, in experiments in Delft, Vienna and Boulder. The 2022 Nobel Prize in Physics went to Alain Aspect, John Clauser and Anton Zeilinger for this line of work.

For a quantum computer, entanglement is how qubits come to share one arrow, and it needs it everywhere. A row of qubits that never get entangled can be copied easily by a normal computer.

Entangled qubits aren’t carrying answers like cards in envelopes.

9Doubling

How much does a quantum computer keep track of?

Two qubits need four amplitudes. Three need eight. Every qubit you add doubles the list. For n qubits, it’s 2 multiplied by itself n times. Slide to add qubits:

Qubits

3

Amplitudes

8

To write them down

128 bytes

That’s about

a short text message

At 30 qubits, the list fills the memory of a good laptop. At 50, it’s about 18 petabytes. In late 2025, a team at Jülich in Germany squeezed that list into about 2 petabytes and simulated 50 qubits in full on JUPITER, Europe’s first exascale supercomputer. That’s the record. At 266 qubits, the list has more entries than there are atoms in the observable universe.

This is the number people usually point to when they explain quantum computers. Be careful with it, for two reasons. First, remember the computer with coins in chapter 2. Fifty coin-flipping switches also need a list of about a million billion chances. A long list on its own isn’t new. What’s new is that amplitudes can cancel. Second, remember chapter 6. However long the list, looking at n qubits gives you n bits.

The list doubles with every qubit, but it’s locked. You only ever see one entry.

To get anything useful out, you have to make the list cancel in just the right way. That’s what a quantum algorithm is.

10All at once

Does it try every answer at once?

Here’s the claim you’ll see most often: a quantum computer tries every possible answer at the same time. There’s something true in it. Flip each of 4 qubits once, and the register has an equal amplitude on all 16 arrangements. Run a program on that, and the program runs on all 16 at once.

Say one of the 16 is the answer you want, like the code to a lock. Before you look, a guess.

Look Look 100 times

One of these 16 is the right code. Press Look.

One in 16. Looking at an even mix gives you an arrangement at random, so this is no better than guessing. The computer did try every answer, and then handed you one at random.

The real trick is the one from the coin. Add more steps, arranged so that the amplitudes of the wrong answers cancel each other out and the amplitude of the right one builds up. Then look. That only works when a problem has a structure that the steps can use, and finding steps that cancel in just the right way is hard. That’s why good quantum algorithms are rare, and why most everyday problems wouldn’t run any faster on a quantum computer.

Here are the two most famous ones. The first finds a needle in a haystack.

11Search

How do you find a needle with cancelling?

Say a lock has a million possible codes, and the only way to test a code is to try it. A normal computer has to try them one by one. On average it needs half a million tries.

In 1996 Lov Grover found a quantum way. Start with an even mix of all the codes. Then repeat two steps:

1. Flip the right code’s sign. A quantum version of the lock can do this without saying which code it is. It just turns that one arrow upside down.
2. Mirror every amplitude around the average. The wrong codes, a little above the average, dip a little below it. The right code, far below the average, jumps far above it.

Each round moves a little amplitude off all the wrong codes and onto the right one. Here are 64 codes. Before you start pressing, a guess.

1. Flip its sign 2. Mirror around average Do a round

416641,024

Look Start over

With 64 codes, six rounds take the right code’s chance above 99%. Keep going and it falls again. The circle shows why. The two mirrors together make a turn. It’s the arrow from chapter 5, with one direction meaning “the right code” and the other meaning “any wrong code”. Each round turns the arrow by the same small angle toward the right code. Turn too far and you go past it.

For a million codes, the best number of rounds is 785, against about 500,000 tries for a normal computer. That’s a big gain, but it’s only the square root. In 1997, four researchers proved that no quantum computer can do better on a problem with no structure to use. So a quantum computer can’t crack every password in an instant by brute force. And each round on real hardware is slow, and has to be protected from errors. For a long time, a square-root gain may not beat a fast normal computer at all.

Search gets a square-root speedup. Useful, but no miracle.

The second famous algorithm is a much bigger deal. It could break the locks that protect the internet.

12Factoring

How would it break the locks on the internet?

When your browser connects to a website, the two have to agree on a secret key while anyone could be listening. For decades this has relied on maths problems that are easy one way and hard the other way. Multiplying two big prime numbers takes a computer a moment. Splitting the answer back into its two primes is so slow, with every known method, that nobody has come close for the sizes in use. The biggest number of this kind ever split was 250 digits long, in 2020, after about 2,700 years of computer time. Today’s keys are 617 digits long.

In 1994, Peter Shor showed that a quantum computer could split such numbers quickly. His method has three steps, and only the middle one needs qubits:

1. Turn splitting into a rhythm. Pick a number a. Work out a, a × a, a × a × a, and so on, keeping only the remainder after dividing by N, the number you want to split. The remainders repeat, with some rhythm r. Once you know r, a few lines of school maths give you the two factors.
2. Find the rhythm by cancelling. For a 617-digit number, the rhythm is far too long to step through. A quantum computer puts a register into an even mix of every step at once and works out all the remainders together. Then it uses a step called the quantum Fourier transform, the quantum cousin of the maths that splits a sound into its pitches. Amplitude piles up on the values that fit the rhythm and cancels everywhere else.
3. Look, and work back. A little arithmetic on the number you see gives you r.

Try it with a small number. This page works out the qubits exactly:

Split Pick another a

1. The rhythm2. Even mix3. Fourier step4. Look

Next step

For 15, the quantum part needs 8 qubits to count with, plus 4 to hold the remainders. Real keys need far more, and the estimates keep falling. In May 2025, Craig Gidney at Google estimated that under a million qubits could split a 617-digit key in under a week. That assumes each step goes wrong only once in a thousand times. In March 2026, Google estimated that the 256-bit elliptic-curve keys that most websites and Bitcoin use today would take fewer than 500,000 qubits and a few minutes. The same month, researchers at Oratomic and Caltech argued that 10,000 to 26,000 atoms might be enough, running for days. Those are estimates for machines nobody has built.

The machines that do exist are far from this. On real hardware, Shor’s algorithm has only split tiny numbers like 15 and 21, and those runs took shortcuts that relied on already knowing the answer.

So why does it matter now? Because anyone can record encrypted messages today and decrypt them once a big enough machine exists. It’s called harvest now, decrypt later. So the internet is changing its locks already. In 2024 NIST, the US standards body, published new methods built on maths problems that no known quantum algorithm can crack. Chrome, Firefox and Safari now use one of them by default, mixed with the old method so that an attacker would have to break both. By April 2026, over 65% of the traffic from people reaching Cloudflare was protected this way. Google and Cloudflare plan to finish the switch by 2029.

Shor’s algorithm turns splitting a number into finding a rhythm, and cancelling is very good at finding rhythms.

13Keeping qubits

Why is a qubit so hard to keep?

Go back to the half-silvered mirrors. Blocking a path spoiled the cancelling. So does anything else that disturbs one path and not the other. A stray particle of light, a jiggling atom or a little heat can bump into a qubit. That can leave a trace of which path was taken, or nudge one path by a random amount. Either way, the paths stop cancelling cleanly. Nobody has to look. Physicists call this decoherence.

Here are the mirrors again, with jitter: each photon’s top path gets lengthened by a different random amount. Slide it up:

Jitter

none

Send 100

With no jitter, every photon reaches the same detector. With a lot, it’s back to a coin. A quantum computer is a huge stack of cancellations like this, so it has to be shielded from almost everything. Yet you still have to be able to steer every qubit precisely. That’s the whole engineering problem.

Google’s and IBM’s qubits are tiny circuits of superconducting metal on a chip. Their 0 and 1 differ by about the energy of a 5 gigahertz microwave. At room temperature, heat would kick them back and forth all the time. A 5 gigahertz step is worth about 0.24 degrees above absolute zero. At 0.01 degrees, 24 times colder, the heat around a qubit is far too weak to kick it. That’s what the fridge is for. Even so, the qubits on Google’s Willow chip hold their state for only about 100 microseconds. Each step takes tens of billionths of a second, so there’s time for a few thousand steps before a qubit fades.

Other teams use atoms. Trapped ions are single charged atoms, held in a vacuum by electric fields and steered with lasers. They are slower, but very accurate: Quantinuum’s Helios machine gets a two-qubit step right 99.92% of the time. Neutral atoms are held in place by tightly focused laser beams, called tweezers. In 2025, a team at Caltech held 6,100 of them in one grid. Still other teams build qubits from photons.

The best machines get a two-qubit step wrong about once in a thousand tries. That sounds good until you count. Splitting a 617-digit key takes billions of steps. At one slip in a thousand, even a program of a thousand steps fails about two times in three:

Slips

1 in 1,000

Steps

1,000

Qubits are easy to disturb, and every disturbance spoils the cancelling.

So errors have to be fixed as they happen. But how do you fix something you aren’t allowed to look at?

14Fixing errors

How do you fix errors you can’t look at?

Normal computers fix errors by copying. Store each bit three times, and if one copy flips, the other two outvote it. If each copy flips one time in a hundred, the vote is wrong only about three times in ten thousand.

Neither trick works on qubits. You can’t copy a qubit you don’t know, and you can’t look to see which copy flipped, because looking wipes out the arrow.

In 1995, Peter Shor, the same Shor, found a way around both. In its simplest form, you spread one qubit’s amplitudes across several qubits, using entanglement, so that 0 becomes 000 and 1 becomes 111. Then, instead of looking at the qubits, check only whether neighbours agree. Those checks show where an error happened, but say nothing about the value being stored, so they don’t disturb it.

Below, five qubits store one hidden value. Add an error, then use the checks to find the qubit that flipped. Tap it to flip it back:

Add an error Fix it for me Show the values

All four checks are quiet. Nothing has gone wrong yet.

The checks never tell you whether the stored value is 0 or 1. They only show where neighbours disagree, and that’s enough to find the odd one out. On a real chip, extra measuring qubits sit between the data qubits and run these checks over and over, about a million times a second.

Qubits also suffer a second kind of error, a sign flip, which leaves 0 and 1 alone but spoils the cancelling. The surface code catches both kinds, using a grid of data qubits with measuring qubits in between.

Here’s the catch. More qubits means more places for errors to happen. Spreading a value wider only helps if each qubit is good enough to begin with, below a level called the threshold. Below it, every step up in size makes the protected value far safer. One last guess before you slide.

Each qubit flips

10%

For this simple code the threshold is 50%. The surface code has to catch both kinds of error, with checks that can go wrong too, so its threshold is much lower, at about 1%.

In December 2024, Google’s Willow chip showed this working. Google grew the grid of data qubits from 3 by 3 to 5 by 5 to 7 by 7. At each step, the protected qubit’s error rate fell by a factor of 2.14, down to 0.143% per round of checks. It also lasted 2.4 times longer than the best single qubit on the chip. It was the first clear sign that the plan works.

A protected qubit made this way is called a logical qubit. Willow’s best one took 101 physical qubits. IBM plans a machine with about 200 logical qubits by 2029, using codes that need fewer physical qubits for each. Google’s 2026 estimate for breaking a 256-bit elliptic-curve key needs about 1,200 logical qubits.

Errors can be fixed without looking, as long as each qubit is good enough to start with.

15What for

What will quantum computers be good for?

A big, error-corrected quantum computer won’t be a faster laptop. It will be more like a telescope: a special instrument, attached to normal computers, for a few kinds of problems. Here’s an honest list.

• YesSimulating molecules and materials

  This was the first idea for a quantum computer. In 1981 Richard Feynman pointed out that nature follows the amplitude rule. So the natural way to simulate it is with a machine that does too. In his words: “Nature isn’t classical, dammit.” A famous target is FeMoco, the heart of the enzyme that bacteria use to turn nitrogen from the air into ammonia. Factories do the same job for fertiliser with great heat and pressure. A 2021 estimate put it at about 4 million physical qubits running for about four days, and later work has cut that. This is likely to be the first real use.

• YesBreaking today’s public-key locks

  As in chapter 12. The fix is already rolling out, and you are probably using it right now.

• ModestSearch and optimisation

  A square-root speedup at best for searching by brute force, and it may not pay off on early machines. Some quantum methods might help with particular scheduling or design problems, but none is proven to.

• UnprovenMachine learning and AI

  Many quantum speedups have been proposed. Several of the most exciting were later matched by normal computers, starting with one found in 2018 by Ewin Tang, then an 18-year-old student. And just loading large amounts of data into qubits is slow.

• NoEveryday computing

  Email, games, video, websites: none of it needs amplitudes that cancel, and a quantum computer would run it far slower than your phone.

Quantum computers have already beaten normal ones at a few tasks designed to show it. In 2019, Google’s Sycamore chip finished a random sampling task in 200 seconds that Google estimated would take a supercomputer 10,000 years. Better methods on normal computers later cut that down a lot. In 2025, Google ran a calculation it calls Quantum Echoes about 13,000 times faster than the best known method on a supercomputer, with an answer that can be checked. Results that someone would pay for are still ahead.

Here’s how far the machines that exist are from the jobs above:

Each step up the scale is ten times more qubits. The estimates assume qubits that slip about once in a thousand steps, and machines built for the job.

When will the gap close? Nobody knows. IBM aims for its first machine with about 200 logical qubits in 2029. Google and Cloudflare plan to finish protecting their systems by 2029, and the US government plans to retire the old locks by 2035. Those dates are precautions, not predictions.