Play room
A real quantum computer.And you, at the controls.
We're learning quantum programming in public, one experiment at a time. Nothing to buy here: build a circuit, hear it, measure it — and see what a quantum processor actually does.
We don't wait for a technology to be useful to understand it.
We put it in our hands. We play with it.
That's how the studio learned computer vision, virtual reality and generative AI: years before any client asked, by building things that weren't good for anything yet. This page is the next one. It sells nothing, it learns — and it lets you touch.
What we do here
An open lab. Not a showroom.
Quantum computers exist, you can send them programs from any browser, and almost nobody has ever tried. We have. Here's what you'll find on this page — and what you won't.
- 01
Experiments, not products
Every experiment on this page is a small quantum program you can manipulate. None of them solves a business problem. That's deliberate: we learn first and find the use afterward — if there is one.
- 02
A simulator in your browser
What you hear and see live is computed by your own computer, which simulates three qubits perfectly. That's what makes the page instant. A real quantum processor queues requests for minutes.
- 03
A real IBM processor, alongside
The same circuit can be sent to an IBM quantum computer, cooled to fifteen thousandths of a degree above absolute zero. It comes back with a job ID and a slightly dirty result. That's the result we'll place side by side with the ideal version.
- 04
What we learn, we say
What works, what doesn't, what surprised us. The page evolves as the studio understands — and the next experiments will come from the questions you ask us.
What's quantum here, and what isn't
A quantum computer doesn't compute "everything at once". It makes probabilities interfere, and you measure a single answer at the end, drawn according to those probabilities. With three qubits, your browser simulates that effortlessly — nothing on this page is impossible for a classical computer. What the real processor adds is physical reality: noise, errors, the queue. What the page adds is letting you see and hear it.
What you hear
A probabilityis something you can listen to.
How it works
Three ideas are enough to play.
The instrument will show you the rest better than any text.
- 01
The qubit
An ordinary bit is 0 or 1. A qubit holds both at once, with a weight for each. Three qubits therefore hold all eight combinations, from 000 to 111, each with its own probability.
- 02
The gates
A gate changes those weights. Some open a qubit onto both values, some flip it, some tie two qubits together. Two gates can cancel each other out: that's interference, and it's the whole secret.
- 03
The measurement
At the end, you look. The system picks a single one of the eight combinations, at random, according to the weights. Measure a thousand times, count, and the shape that appears is the circuit's answer.
Experiment 01
Sound circuit
Three qubits, eight states, eight notes. Place gates on the wires, and the music tells you what the circuit is doing to the probabilities — before you even measure.
How to play
- 01
Place gates
Pick a gate, click a cell on a wire. The state columns move immediately: that's the probability of each combination.
- 02
Hear the chord
Each state has a note. Its volume is its probability. An empty circuit plays a single note; one H gate makes two; three H, a cluster of eight.
- 03
Measure
Thirty-two measurements in a row. Each time, the circuit picks a state at random according to the probabilities: its digits light up, its note rings. The digits that stay dark will never come up.
000
Ready. Measure to read the qubits.
- Ideal
- Simulator, in your browser
- Real
- IBM processor — loading measurements
What you hear by default is the ideal version, computed by your browser. On a real processor, the same circuit comes back with slight noise: states that should stay silent sometimes light up. Load an example and hear the real thing — or simulate it with the slider.
The real hardware
Fifteen thousandths of a degreeabove absolute zero.
Experiment 02
The column
Twenty thousand measurements made on a real quantum processor, in the order they occurred. You're at the foot of the column; the machine's time rises above you.
- Processor
- —
- Job
- —
- Date
- —
- Measurements
- —
- States
- —
- 01
The disk
The 128 possible states of seven qubits sit on a circle: two states that differ by a single bit are neighbours, and the more 1s a state holds, the farther it is from the centre.
- 02
The time
Each measurement is a point, at the height of its rank. The thread joins them in order. It glows where the machine keeps returning to the same states, and fades in the escapes.
- 03
The noise
The pale filaments toward improbable states are the hardware getting it wrong. A simulator doesn't produce them. Two identical jobs give two different columns: that's the signature of this machine, on this day.
What's quantum here
The processor draws nothing. It provides the data — the sequence of measurements, with the noise as it actually happened. The rendering is classical: it's the developing of a negative. As in photography, light makes the image, the camera captures it, and someone reveals it. The label under the artwork is verifiable: the job exists at IBM, on that date, on that machine.
The same column exists as a large-format print, seen from the inside, with its certificate on the back. And it will become an installation: a window into the column, where every hour a new layer of measurements stacks above the last.
Experiment 03
The rigged coin
A coin in a box, heads up. Three moves: the machine, you, the machine. If the coin ends up heads, it wins. Against anyone else, it's a coin toss. Against it, go ahead and try.
- 01
The machine plays
The box closes. It flips the coin, or doesn't. You see nothing.
- 02
You play
Still blind: flip the coin, or leave it. That's your only move.
- 03
The machine plays again, the box opens
Heads, it wins. Tails, you win. Ten rounds.
Machine
0
You
0
Ten rounds. See if you can win one.
- Ideal
- The quantum machine wins 100% of rounds
- Real
- Real processor result coming — until then, the machine plays the ideal version.
The trick
The machine doesn't flip the coin. It stands it on its edge — an equal superposition of heads and tails, something a real coin can't do. Flipping a coin that's already on its edge changes nothing: it stays on its edge. Then the machine lays it back down exactly the way it stood it up. Heads.
Your move never mattered. That's the demonstration: a player with access to a state between 0 and 1 beats any coin-toss strategy, every time. This game was described by David Meyer in 1999, and it's one of the simplest examples of something a quantum computer does that yours can't.
And the rare rounds you win against it? That's not you. That's the real processor fumbling its landing — hardware noise, measured at IBM. The rate shown under the game is its own, not ours.
Experiment 04
The canvas
The same twenty thousand measurements as the column, read as paint: sixty-four measurements make one splash — the first picks the colour, the rest pick the place and sculpt the gesture. None of the randomness here comes from your computer. All of it comes from the machine.
- Processor
- —
- Job
- —
- Date
- —
- Measurements
- —
- Same negative as the column
- 01
The colour
Each state has its own colour, and the hues are scattered so that two nearby states never look alike. Dominant states come back again and again: their colours rule the canvas, everywhere, interwoven.
- 02
The place
A splash lands anywhere: its position comes from the bits of the group's other measurements, not from a fixed layout. That's why the colours mingle instead of lining up — the canvas is a portrait of the job's proportions.
- 03
The gesture
The more improbable a state, the bigger its mark. The large isolated splashes, with their streaks and drips, are the machine's mistakes — hardware noise is the most dramatic gesture on the canvas.
Why it's always different
This isn't an image generator. The rule is fixed and deterministic, and the same negative twice would give the same canvas twice, pixel for pixel — that's what makes it printable. What changes is the data: every run on the processor yields a sequence of measurements nobody can predict or reproduce, not even the machine itself. The canvas you're looking at belongs to that one job. The next will be another.
Experiment 05
The question game
Two isolated players, one question each, no communication. The best any team can do: win three rounds out of four — proven since 1964. Then two entangled qubits play, and the ceiling breaks.
- 01
Two players, isolated
A and B agree on a strategy, then can no longer talk. The referee asks each a random question: 0 or 1.
- 02
The rule
Each answers 0 or 1. The team wins if the answers match — except when both questions are 1: then they must differ.
- 03
The ceiling
No strategy agreed in advance wins more than 75% of rounds. It's not about being clever: it's a theorem. Try.
Act 1 — your turn
You're player A. Your partner plays the best classical strategy: he always answers 0. Twelve rounds — see how high you climb.
Act 2 — the quantum team
Play your twelve rounds first — breaking the ceiling means nothing until you've hit it yourself.
The game's circuits haven't run on the processor yet — until then, the team plays the ideal rate (85.4%), and this line says so.
Why it's the strongest one
The 75% ceiling isn't a computational limit, it's a limit of the classical world: John Bell proved it in 1964. Any theory where the answers are decided in advance — however secretly, however cleverly — is stuck under that line.
The experiments that verified the violation, with photons and then atoms, earned the 2022 Nobel Prize in physics. What you just watched over a thousand rounds is the same violation, measured on a commercial processor reachable from a browser.
And the quantum team's score doesn't reach the theoretical 85.4%: hardware noise costs it a little. What remains above 75% is exactly the part of the world that isn't classical.
Experiment 06
The teleporter
Sculpt a quantum state — a needle between 0 and 1. Then teleport it: it's destroyed here and rebuilt over there, on another qubit, without ever crossing the space in between. On the real chip.
- 01
Sculpt
The needle is your state: straight up is 0; straight down is 1; anywhere in between, a superposition tilted exactly where you put it.
- 02
Teleport
The protocol destroys your state on the departure qubit — a measurement erases it — and rebuilds it on a qubit at the far end, thanks to an entangled pair and two classical bits that do make the trip.
- 03
Verify
We compare what arrived with what you sculpted. The fidelity shown is measured on the processor: the share of your state that survived the journey.
Hereq0
The relayq1
Over thereq2
Nine angles were run on the processor; the needle snaps to the nearest one, and the fidelity shown is the one measured for it.
The teleporter's circuits haven't run on the processor yet — until then, the fidelity shown is the ideal one, and this line says so.
What travelled, and what didn't
What was teleported is a STATE — the angle you sculpted — not matter. The arrival qubit already existed; it received the complete description of yours, which was destroyed in the operation. This is Bennett and colleagues' 1993 protocol, executed here across a few millimetres of chip — and already demonstrated between Earth and a satellite.
And nothing travelled faster than light: without the two classical bits you watched slide along the wire, the arrival state is unreadable. Quantum teleportation doesn't transmit information instantly — it transmits a state perfectly, which is something else, and already dizzying enough.
Fidelity never reaches 100% on the real machine: every gate in the protocol costs a little noise. That missing percentage is the real, measured price of moving a quantum state today.
Up next
Two ideas you won't see anywhere else.
In the order we plan to build them. If one speaks to you more than the other, tell us: it changes the order.
- 07Coming
The heartbeat
Listen to a qubit's memory fade out.
A qubit prepared at 1 falls back to 0 in two hundred millionths of a second — that's its memory span, measurable point by point on the real machine. We stretch that fading into sound: a beat that weakens, measured that very morning, different every day. Coherence time, the fundamental limit behind everything on this page, becomes something you listen to.
- 08Coming
The twins
Two machines, same circuit — tell them apart by their noise.
The same circuit, the same day, on two IBM processors. Two columns side by side, almost identical — almost. Then the game: we show you one, and you say which of the two machines produced it. Every processor has a fingerprint, like a hand, and you'll learn to read it.
What's next
The next experimentmight be yours.
What's next
Have an idea for an experiment?
A question that keeps nagging, a game you'd like to see, something you don't believe is possible: write to us. The best experiments on this page will come from there.
Creative Drops — immersive experiences, interactive systems, and a play room for learning in public. Montreal, Quebec.