Amplitude: a quantum course you can move with your hands

I have read a lot of quantum mechanics explainers.

Most of them fail in one of two ways.

The first kind is all metaphor. Electrons are "in two places at once," particles "talk to each other across space," a cat is "both alive and dead." It feels profound and teaches you almost nothing you can use.

The second kind is the opposite: a wall of equations, dense and correct, with nothing to touch and no reason the symbols mean what they mean.

I wanted a third thing.

A course where the math is real, and you can move it.

That experiment is called Amplitude, and it is live now: Open the course → quantum.vayuai.ai

What it actually is

Amplitude is an interactive course in quantum mechanics, built for someone who starts at zero and leaves with intuition.

Six chapters. You do not read them so much as operate them.

You spin a single qubit on a live Bloch sphere and watch its amplitudes and probabilities update in real time. You dial the phase inside an interferometer and watch a photon land somewhere different. You build a two-qubit state and push a correlation past the limit that every classical theory obeys.

The reader is not a spectator. The reader is turning the knobs.

But the part I care about most is not the knobs. It is what sits underneath them.

The engine is the whole point

Underneath every screen in Amplitude is a genuine state-vector simulator running in your browser.

It holds the actual quantum state as a complex vector. It applies real gate matrices to that vector. It computes real measurement probabilities from the amplitudes.

It is not a scripted animation that plays a pre-baked outcome. Nothing is faked. Every dot, every bar, every needle on the Bloch sphere is driven by the real linear algebra happening one layer down.

That distinction is the entire thesis of the project.

A pretty animation is the end of a workflow. A real simulator is the beginning of understanding.

I do not think a teaching tool needs to pretend. When you drag the phase slider and the interference pattern shifts, it shifts because the amplitudes actually changed and actually re-added, not because I drew the next frame of a cartoon. Credibility comes from running the real math and showing it.

Here is the loop, the same on every page:

The reader never sees the matrices unless they want to. But the matrices are always what is running.

Chapter by chapter, what you do

The course is built so that each idea is something you operate before it is something you read.

Superposition. You start with one qubit. There is a live Bloch sphere, and you can spin the state anywhere on it. As you rotate, the amplitudes update and the measurement probabilities update with them. You watch a state that is genuinely a superposition of zero and one (|0> and |1> in code), and you watch what it means to measure it. The point lands on its own: superposition is not "in both places," it is a specific vector with specific weights.

Interference. This is a Mach-Zehnder interferometer you can dial. A photon enters, the paths split, and a phase control decides where it comes out. Turn the phase and the photon moves from one detector to the other. The lesson is the one most metaphors miss entirely: it is the amplitudes that add, not the probabilities. Two paths that each have a real chance of firing a detector can, when their amplitudes are out of step, cancel to zero. You see the cancellation happen as you turn the dial.

Entanglement. Here you build a two-qubit state and go after Bell's inequality. You set up the correlation and push it, and you watch it climb past the ceiling that any classical strategy is stuck under, all the way up to the Tsirelson bound, the exact quantum limit. No hidden-variable theory, no clever classical trick, can reach that number. You are not told this. You drive the correlation up to the wall and see where the wall is.

Circuit Lab. The course ends in a sandbox. You place gates on qubits, run the circuit on the very same state-vector simulator that powered every earlier chapter, and measure the outcomes. Everything you learned by feel now has a place to be assembled and tested.

That is the arc:

There are six chapters in total. The simulator is the constant under all of them.

The depth dial: you choose the altitude

The hardest problem in a course like this is not the physics. It is the audience.

A curious beginner and a physics graduate need the same ideas explained at completely different altitudes. Pitch it low and you bore one. Pitch it high and you lose the other.

So I gave the reader the controls there too.

Amplitude has a depth dial. It rewrites every explanation along a spectrum, from plain language at one end to research-level rigor at the other. The same page, the same diagram, the same live simulator, but the words around them move to meet you.

Turn it down and "superposition" is described in ordinary sentences. Turn it up and the same passage speaks in the formalism, with the structure a physicist would expect.

The reader chooses the altitude. I am not guessing at one level for everyone and getting it wrong for most of them.

The tutor is a guide, not an oracle

There is also an AI tutor in the course. It answers questions, and it answers them at the reader's chosen level: a beginner's question gets a beginner's answer, a formal question gets a formal one.

But I want to be precise about its role, because this is where a lot of AI education tools quietly lie.

The tutor is a guide on the side. It is not the source of truth.

The source of truth is the simulator. The simulator is running real linear algebra and cannot be talked out of the right answer. The tutor helps you ask better questions and interpret what you are seeing, but if the tutor and the simulator ever disagreed, the simulator would be right. I built the product so that the thing you can trust is the math you can touch, not the language model describing it.

That ordering matters to me. The engine is load-bearing. The tutor is a helpful voice next to it.

The honest scope

I want to be clear about what Amplitude is not, because the honesty is the point.

This is pure-state, small-qubit quantum mechanics, for learning.

It is not a noisy-hardware emulator. It does not model a real device with its real imperfections.

It is not a path to running anything on an actual QPU. Nothing here compiles down to real hardware.

It does not cover decoherence or error correction in any depth. Those are enormous, important subjects, and they are out of frame here on purpose.

The states are clean. The qubit counts are small. The scale is deliberately the scale you can feel in your hands and reason about in your head.

That is the trade I chose. I would rather build correct intuition on real math at a scale you can grasp than offer a sprawling, half-true simulation you cannot follow. The goal is not to impress. The goal is for the ideas to actually land, and to land on something true.

The stack

The build is intentionally lean.

Vite and React for the app shell and the interactive controls.

The state-vector engine as the core: complex amplitudes, real gate matrices, real measurement probabilities, all in the browser.

Three.js for the Bloch sphere and the 3D visuals, so that spinning the state is a real object in space, not a flat illustration of one.

The whole thing wears the same warm-paper light theme as the rest of what I build, with Fraunces for display type and Inter for the body. A quantum course does not have to look like a terminal from 1995.

What I learned building it

A few things stayed with me.

A real engine changes how it feels to learn. When the interference is computed and not drawn, the moment you cancel two amplitudes to zero hits differently. You are not watching a claim. You are watching a consequence.

The audience problem is solvable by handing it to the reader. I spent a long time trying to pick the right level of explanation. The depth dial was the moment I stopped picking and let the reader pick. That was the right call.

Be loud about the source of truth. Putting an AI tutor next to a simulator is only safe if you are explicit about which one to trust. The simulator runs the physics. The tutor talks about it. Keeping that order honest is most of what keeps the tool trustworthy.

Where this goes next

The foundation is a real simulator, and a real simulator is a thing you can keep building on.

More chapters fit naturally on the same engine. The depth dial can reach further down toward the formalism for the readers who want it. The Circuit Lab can hold more gates and more elaborate constructions without changing what is underneath.

And the honest boundaries stay drawn. This stays a learning instrument for pure-state, small-qubit quantum mechanics. If it ever grows toward noise or hardware, I will say so plainly and build that part for real, the same way the rest of it is real.

For now, it does the one thing I wanted no explainer I could find would do.

It lets you move the math with your hands, and trust that the math moving back is true.

Intuition you can trust is built on mechanisms you can touch, not metaphors you have to take on faith.

Open Amplitude live →