Hüseyin Pekkan

A toy rocket game. Holding the burn button fires the engine: an autopilot climbs and turns the rocket sideways, and once its orbit clears the atmosphere the engine throttles down. Let go in orbit; hold too long and the rocket escapes. In orbit, the separate button drops the booster and it falls back: steer it with the tilt buttons or arrow keys, and press the button once to light its landing burn, neither too early nor too late, to land it upright on the land pad. With the booster gone, the rocket can deploy a satellite, which stays in orbit across flights until Reset, and turn to face forward or backward and burn to raise or lower its orbit; lowered into the atmosphere, it re-enters and lands the same way, on a drone ship. The autopilot, on at first, flies the separation and both landings for you; its button turns it off. The status and fuel are shown at the top.

A gravity slingshot game with eight levels. Aim the probe with the up and down buttons, then launch it. The planets' gravity bends its path, and the goal is to fly into the target; later levels add a moon, a black hole, asteroids and a wormhole. The status shows the level, shots and hits.

A lunar landing game with two pilots. As You, hold the burn button to fire the engine and use the rotate buttons to cancel sideways drift, then touch down on the pad slowly and upright. As PID, an autopilot flies the same landing with a PID controller; the Kp, Ki and Kd sliders change its gains live, so it can land smoothly, wobble or crash. The status shows the pilot, altitude, fuel and speed.

A Mars rover driving game with a signal delay. Drive with the forward, reverse and turn buttons or the arrow keys, or tap the map to send a route; every command reaches the rover only after the delay, which you can set to Earth, Moon or Mars. Reach the three science targets and stop on each to take a sample, without hitting boulders or getting stuck in sand; reverse to back out of deep sand. The Ghost button shows where the rover will be once your commands arrive. The status shows the delay, samples and battery.

A simulated orbital rendezvous. Your capsule and a space station orbit Earth; you see them from the station, with Earth below. Fire small burns forward, backward, up or down with a limited fuel budget, and dock by arriving within a few metres at a walking pace. Orbital mechanics is counterintuitive: a burn toward the station raises your orbit and makes you fall behind. A dotted line predicts your path and marks the closest approach. The status shows the range, the closing speed and the fuel left as change in velocity.

A simulated interplanetary launch game. The planets move on circular orbits, starting from their mean positions for today's date. Choose Mars, Venus or Jupiter, set the kick your probe gets on top of Earth's own speed around the Sun, forward or backward, and launch when the planets line up. A dotted path previews the transfer orbit and a faint ghost marks where the target will be when you get there. The status shows the date, the angle between Earth and the target, and the kick.

A simulated planetary-defence game. An asteroid will hit Earth unless you push it aside. Choose a kinetic impactor like NASA's DART, a heavier impactor, or a gravity tractor that tugs it gently for years, and launch while there is time: a push of millimetres per second, given years ahead, moves the arrival point by thousands of kilometres. A target view shows Earth and where the asteroid will cross. The status shows the time to impact, the predicted miss distance and the Torino hazard rating.

A simulated reentry game. A space capsule meets the top of the atmosphere at 122 km, from low orbit, from the Moon or, for a comet-dust capsule, at 12.8 km/s. Choose the entry angle: too shallow and it skips off the atmosphere or stays too long in the heat; too steep and the deceleration crushes the crew. During the descent, roll the capsule to point its lift up or down, as Apollo did: up eases the g-load and flies farther, down dives sooner. A guidance display predicts the splashdown; land near the recovery ship. The status shows the altitude, the speed and the g-load.

A simulated solar-sailing game. A sail near Earth's orbit is pushed by sunlight alone: the push is always away from the Sun, strongest face-on, and fades with distance from the Sun. Tilt the sail to push along your path and spiral outward, or against it to spiral inward; the push along your path is greatest at a tilt of about 35 degrees. Missions: grow your orbit to the size of Mars's, shrink it to the size of Venus's, and, with a lighter sail, dive close to the Sun and face it at the bottom to escape the Solar System, without coming closer than 0.1 AU. The status shows your distance from the Sun, the size of your orbit and the days sailed.

A first-person starship among the real stars near the Sun, from the HYG star catalogue. Hold Burn for a steady push along the nose, set from 0.1 to 3 g, and Brake to push against your motion until you stop; there is no friction, so you coast until you do. A flight computer shows your speed, the time aboard and at home, the distance and arrival time to the target, the distance you would need to stop, with a Brake now cue, and the fuel an ideal photon rocket would have burned. In free flight, tapping a named star makes it the target. The window shows where the stars are, streaming past as you fly; the Einstein view shows what your eyes would really see near light speed: the stars crowd toward your direction of motion, turn blue ahead and red behind. Time aboard runs slower than at home. A lime ring marks where you are really going, a pink one where you came from, and the Sun is labelled. Missions: change course from Sirius to Vega; fly to Alpha Centauri and stop there, then find the Sun as a new star in Cassiopeia; reach 99 percent of light speed in the Einstein view and look back; and fly until the Big Dipper no longer looks like one; then free flight. Newton, a plush duck in a corner of the cabin, is a zero-g indicator: he floats while you coast and is pressed back when you burn. The status shows your speed as a fraction of light speed, the time aboard and the time at home.

A simulated black hole, drawn the way the black hole in the film Interstellar was: by following light through curved space. A thin disk of hot gas circles it; the far side of the disk appears bent over the top of the hole and under it, and a thin ring of light hugs its shadow. Behind it are the real stars and the Milky Way, bent around the hole. Look from any side, from above, below or edge-on, and from near or far. A ship hovers seven Schwarzschild radii out, above the hole; throw a rubber duck, a probe, an astronaut or a teapot from it, choosing the aim and speed. Thrown things fall in, orbit, or fly away; seen from outside, anything falling in slows down, reddens and fades at the edge of the shadow, and its own clock runs slower and slower. The Doppler button shows the disk as it would really look, bright and blue on the side coming toward you and dim and red on the other, which the film left out. A corner map shows the flight plan of the next throw, the hole, the ring where light can orbit and the last stable orbit. Missions: look from above or below; switch Doppler on; drop the duck in; put the probe in orbit for three laps; and dive the astronaut inside the last stable orbit and back out; then free play. The status shows your distance from the hole, the last thing thrown and how fast its clock runs.

A live globe showing where the International Space Station is now, from the public wheretheiss.at API, refreshed every five seconds while the globe is on screen. It shows the station's position, altitude and speed, its ground track 45 minutes back and ahead, and the day and night sides of Earth, with how long until the station's next sunrise or sunset when the track ahead reaches it, derived from Earth's shadow. If the API does not answer, it says so and shows the age of the last position. Guess where next is a game on the live data: you point to where the station will be in 10 minutes, half a lap, one lap and two laps from now, by clicking or tapping the globe or by turning it with the arrow keys and pressing X on the crosshair, and the API's own position for that moment is the answer, with the distance you missed by and up to three stars a round.

An orbit painting toy. Throw satellites around a planet by dragging, or by tapping a start point and then a direction; each follows a real orbit under gravity and leaves a fading trail. Patterns switch between plain ellipses, a spirograph seen from the turning planet, and rosettes around a slightly squashed planet. Ring of six adds six evenly spaced satellites, Random adds one, and Clear removes them all. Satellites that collide break into debris.

A radio telescope game. Point the dish at the sky and tune from 10 megahertz to 10 gigahertz to find real kinds of radio sources: the Sun, Jupiter, the hydrogen line of the Milky Way, a pulsar, the cosmic microwave background, Voyager 1, radio galaxies and a few surprises. The status shows the frequency, the signal-to-noise ratio and how many sources you have found; the hint button gives clues. Once you have used it, the arrow keys move the dish and the square bracket keys fine-tune.

A simulated space-weather game. The Sun throws out clouds of plasma; a spacecraft between the Sun and Earth measures each one as it passes. When its magnetic field points south, it couples to Earth's and an aurora follows. Issue an alert at the right moment, then photograph the aurora at its best. The status shows the storm level Kp, the field direction Bz and your photos.

A simulated night of stargazing during a meteor shower. Photograph shooting stars as they appear; their trails all point back to one spot, the radiant, which tells you which shower it is. Satellites, planes and other lights are decoys. The status shows the meteors caught, the shower and the time left.

A simulated eclipse-chasing game. The Moon's shadow will cross a map along a narrow path; pick where to stand, then watch. The closer to the centre line, the longer the total eclipse, unless a cloud drifts over at the wrong moment. The status shows your spot, the totality you saw and the cloud cover.

A simulated light-pollution game. A town's lights wash out the night sky. With a limited budget, shield lights so they point down, change them to warm bulbs, or switch them off; some neighbours switch theirs back on. The darker the sky gets on the Bortle scale, the more stars appear, until the Milky Way returns. At the star party the guests' telescopes show more the darker the sky, and every wow counts. The status shows the Bortle class, your budget and the stars visible.

A rainbow and halo simulator built from ray optics. In Rain, the Sun is behind you and rain in front: the picture is computed by sending sunlight through spherical raindrops, with one internal reflection making the main bow at about 42 degrees around the point opposite the Sun and two making the fainter outer bow at about 51 degrees, its colours reversed, with Alexander's dark band between them. Smaller drops blur the colours until fog makes a white bow. In Ice, the view looks toward the Sun and a ray tracer sends light through hexagonal ice crystals: tumbling crystals make the 22-degree halo, flat plates make sun dogs and the circumzenithal arc, columns make tangent arcs. Controls: the Sun's height, the drop size or crystal shape, angle guides, and a diagram of one drop or crystal with the light path. Clicking the sky reads the angle from the antisolar point or the Sun. The missions: the tallest rainbow, the height where it disappears, finding the dark band, making a fogbow, and the Sun height where sun dogs vanish. The status shows the Sun's height and the bow's angle or the sun dogs' distance.

A simulator of the planets' wandering. The top of the picture is a strip of the real night sky along the ecliptic, with the bright stars from the HYG catalogue, and Mars, Jupiter or Saturn with the trail of the last 240 days; where the planet moved backwards (westward), the trail is pink. The bottom is the solar system seen from above, with the line of sight from Earth to the planet, or, in Ptolemy's model, Earth in the middle with the planet on an epicycle riding a deferent, with an equant. Positions come from NASA JPL's orbital elements, valid from 1800 to 2050. Controls: play and pause time, step 10 days, change speed, jump to today, drag the date, choose the planet, choose the model, and in Ptolemy's model set the epicycle's size and switch the equant. The missions: catch Mars going backwards, find the moment of opposition, watch Jupiter and Saturn loop, fit Ptolemy's epicycle to Mars, and find the closest opposition before 2050. The status shows the date, whether the planet moves eastward or backwards, and its distance.

A simulator of the air's effect on starlight. By eye: five lights low in the sky, four twinkling stars and one steady planet; a planet's disc averages the flicker away. Through a telescope: a Fourier-optics simulation, in which a drifting pattern of Kolmogorov turbulence distorts the light across the mirror and the star's image breaks into speckles that boil, blurring to the seeing disc in a long exposure. Controls: the telescope's size, the seeing (the air's coherence length r0), the target (a star, a double star 0.3 arcseconds apart, or a faint target), long exposure, lucky imaging (capture 200 frames and keep the sharpest), and adaptive optics with a 6, 12 or 24 actuator-wide deformable mirror and a laser guide star. Maps show the air's wavefront and what is left after the mirror; the status shows the Strehl ratio, how close the image is to perfect. The missions: find the planet by eye, see the seeing disc on a 2-metre telescope, split a double star with lucky imaging, reach a Strehl ratio of 0.5 with adaptive optics, and correct a faint target with a laser guide star.

A star-hopping game on the real sky: every star brighter than magnitude 6 from the HYG catalogue, north up and east to the left. Move the telescope by dragging, clicking or tapping a spot to centre it, or the arrow buttons; look with the naked eye (70 degrees), the finder (6 degrees, with crosshairs) or the eyepiece (0.4 degrees, about 100 times). Star patterns and a dashed hop line can be shown. The missions: find Polaris from the Big Dipper's pointers; hop from Alpheratz through Mirach, mu and nu Andromedae to the Andromeda Galaxy; find the Ring Nebula between Sheliak and Sulafat in Lyra; find the Hercules Cluster a third of the way from eta to zeta Herculis; and look at Albireo, the gold and blue double at the foot of the Northern Cross. The status shows the view and where the telescope points.

A planet-hunting game with simulated light curves. Each star's brightness is recorded for 90 days; a planet crossing the star makes small, regular dips. Slide the trial period to fold the light curve: at the right period the dips line up and the signal strength rises. Then decide: a planet, an eclipsing binary star, or nothing. The status shows the star number, the signal strength and how many planets you have found.

A blink comparator game, the method that found Pluto in 1930. Two simulated photographic plates of the same star field, taken days apart, are shown in turn; whatever moved between them, an asteroid, a comet or a dwarf planet, jumps back and forth. Find it and select it. Variable stars, faint stars and plate flaws are decoys. The status shows which plate is showing, the level and the time taken.

A gravitational-wave game with simulated detector data. Hidden in the noise is the chirp of two black holes or neutron stars spiralling together. Set the two masses with the sliders or on the mass plane; the game compares your template waveform with the data and shows the signal-to-noise ratio. At 8 or more it counts as a detection and shows what merged, and a bank of templates shows that masses with the same chirp mass score almost alike. The neutron-star event is squeezed in time to fit. The sound button plays the end of the chirp three octaves up. Once you have used it, the left and right arrow keys change the first mass, down and up the second, and N starts a new event. The status shows the signal-to-noise ratio, the chirp mass and how many events you have found.

A galaxy classification game in the style of Galaxy Zoo, with simulated galaxy images. Sort each image as a spiral, an elliptical, a merger, or a star or artifact, as many as you can in 30 seconds. A small classifier, trained in your browser on generated galaxies, classifies the same images; the status shows your score, its score and the time left.

A spectroscopy detective game with simulated spectra. Each case shows the light of a star or a galaxy spread into a rainbow, crossed by dark lines where atoms absorb and, in galaxies, bright lines where gas glows. Toggle a suspect, hydrogen, helium, sodium, calcium, iron or titanium oxide, to lay that element's laboratory lines under it; lines that match are joined. For a star, name its class from hottest to coolest, O, B, A, F, G, K or M, from which lines are strong and where its light peaks; a wrong guess tells you whether to go hotter or cooler. For a galaxy, all its lines are shifted by its motion: set the velocity until the laboratory lines line up, and the galaxy joins a chart of velocity against distance whose slope is Hubble's law. The status shows the case number, how many of the visible lines your suspects explain, and how many cases you have closed.

A star-making game with a simulated nebula. Gather gas into a protostar by holding the Gather button or pressing on the cloud, shed some with jets, then ignite it. The game plays the star's whole life on fast-forward: how long it shines depends on its mass, since heavy stars burn out in a few million years and small ones last trillions, and it ends as a white dwarf, a neutron star or a black hole, or as a brown dwarf or a planet if there was too little gas. A chart of brightness against temperature traces its life. Seven orders ask for particular stars. The status shows the mass gathered, how long the star will live, and how many orders you have filled.

A gravitational-lensing game with a simulated deep field. A massive galaxy in front bends the light of everything behind it; the picture is ray-traced for every pixel. Move the lens and set its mass to make two images of a quasar, an Einstein ring, and a four-image Einstein cross with the help of shear, to magnify a galaxy too faint to see, and to find where the mass of a galaxy cluster really is: with its galaxies, not its hot gas, and far more of it than the stars and gas explain. The caustics button shows where a source makes one, two or four images. The status shows how many images the mission's source makes, how much it is magnified, and how many missions you have done.

A simulated radio pulsar search. Mission one shows Jocelyn Bell's 1967 chart recording: find three pulses of the first pulsar. Then a survey's filterbank shows signal strength by frequency and time; a pulsar's pulses arrive later at lower frequencies, delayed by the electrons between the stars, so they sweep across the plot. Slide the dispersion measure, DM, until the sweep stands straight and the pulses add up in the summed series below. Fold the series at the pulsar's period, by hand or with an FFT search, to bring out pulsars too faint to see one pulse at a time. Tell a real pulsar from signals made on Earth, which arrive at all frequencies at once, and find the DM of a fast radio burst from another galaxy. The status shows the DM, the signal-to-noise ratio of the summed series and of the folded profile.

A simulated Event Horizon Telescope. A world map shows twelve real radio dishes, the eight of the 2017 campaign and four that joined later or are proposed; switch them on to link them into one Earth-sized telescope observing at 1.3 millimetres. Each pair of dishes measures one Fourier component of the sky, plotted as a blue point; letting Earth turn all night adds arcs of points. The image panel shows what the measurements make: the dirty image, or the CLEAN image, which removes the blur of the array's gaps, compared with a model of M87*'s ring. Missions: two dishes far apart; the 2017 array all night; CLEAN to a match of 0.90; add the one dish that helps most; and the best image from only five dishes. The status shows the number of dishes, how well the image matches the model sky and the number of measurements.

A simulated cosmic distance ladder, the chain of methods that measures the universe. Rung one: two photos six months apart show the nearby star δ Cephei shifting against distant stars; its parallax gives its distance, 273 parsecs. Rung two: measuring Cepheid variable stars in the Small Magellanic Cloud shows that the longer their period, the brighter they are, Henrietta Leavitt's law, anchored by δ Cephei. Rung three: sliding the distance until the law fits Andromeda's Cepheids puts it 2.5 million light-years away. Rung four: a supernova in a galaxy of known distance calibrates type Ia supernovae, and far galaxies' supernovae against their speeds give the Hubble constant. Rung five: the farthest supernovae are fainter than a universe of matter alone predicts, showing that the expansion is speeding up. The status shows the rung and its current measurement.

A simulated double-slit experiment with electrons. Electrons are fired one at a time at a wall with two slits; each lands on a screen as a single dot. As dots pile up they form stripes of many and few hits, an interference pattern, and a chart beside the screen counts them. The wave view shows the electron's wave spreading from both slits and adding up or cancelling. Close one slit and the stripes disappear. Turn on the Peek lamp, which can tell which slit each electron went through, and the stripes fade: at full strength they vanish, and at partial strength the which-way knowledge and the stripe contrast trade off. The slit gap and the electrons' energy set the spacing of the stripes. Missions: build the pattern; close a slit; peek; keep half the stripes; squeeze the stripes; then free play. The status shows the number of hits, the stripe contrast and how much the lamp knows about the path.

A simulated electron meeting a wall of energy, solved with the Schrödinger equation. The electron is a small wave packet drawn on its energy line. Classically, an electron with less energy than the wall must bounce back; here part of the wave fades through the wall and comes out the other side, and the meters count how much got through and how much came back. Set the electron's energy and the wall's height and width; a height below zero makes a dip, which also reflects slow electrons. Two walls make a gap where only certain energies fit, marked as levels and listed; at those energies the electron passes both walls far more easily than one. Missions: tunnel through a wall; get a third through; bounce off a dip; find a resonance between two walls; and watch a trapped electron leak out with a half-life; then free play. The status shows how much went through and back, and the energy.

A simulated interaction-free measurement, Elitzur and Vaidman's bomb tester. Single photons enter an interferometer: a half-mirror sends each one both ways at once, along an upper and a lower path, and a second half-mirror brings the halves together. With both paths open the halves cancel at detector D and add at detector C, so only C clicks. Put a hand or a live bomb in the lower path and D starts to click a quarter of the time, while half the photons are caught by whatever blocks the path: a live bomb goes off, in confetti. A click at D proves the bomb is live although the photon never touched it. A dud lets light through, so D never clicks. Sort a crate of mystery bombs, then use the Zeno tester, which loops the photon many times so that a live bomb almost never goes off. The status shows the bombs certified live, the bombs that went off, and the clicks at each detector.

A simulated Bell test, the CHSH game. Two twins, Alice and Bob, sit in rooms far apart. Each round each gets a random question, 0 or 1, and answers 0 or 1 without talking. They win if their answers match, except when both got question 1, when they must differ. With notes agreed in advance the best possible is 75% of rounds. With entangled photons, each twin answers by whether her photon passes a polarizer at the angle she chose for her question, and the right angles win about 85% of rounds, more than any notes could: this is Bell's theorem. Yet each twin alone sees random answers, so no message can be sent this way. The scoreboard shows the rounds won, the rate played and expected, and the 75% and 85.4% limits.

A simulated quantum computer with up to three qubits. Each qubit starts at 0. Place gates on its wire: H makes an even superposition, X flips 0 and 1, Z and S change the phase, and CNOT flips one qubit when another is 1. One qubit is drawn as an arrow on a sphere, pointing up for 0 and down for 1; several are drawn as bars, one per outcome, with the chance of each and its phase. Run measures 100 copies and counts the outcomes. Missions: make a fair coin; use interference to get 1 every time; entangle two qubits; tell a constant oracle from a balanced one with one query, as in Deutsch's algorithm; and find a hidden item among four with one query, as in Grover's search; then free play with three qubits. The status shows the number of qubits and gates and how many outcomes the last run gave.

A simulated drone light show with Crazyflie-style quadcopters. Type a word, pick a heart or a honeycomb, or draw a shape, and the drones fly into formation. Smart paths gives each drone a straight path so that no two collide; Naive assigns them in order, and the paths cross. The status shows the number of drones, the closest distance between any two, and the number of near collisions.

A honeybee waggle dance game. A bee dances on the comb: the angle of its waggle run from straight up gives the direction of the flowers relative to the sun, and the length of the waggle gives the distance, about one kilometer per second in this hive. Set your guess on the field map, or with the arrow keys (left and right turn it, up and down change the distance), then press Enter to fly out and see how close you got.

A simulated game in a honeybee queen's court. You steer a small robot bee around the comb: feed the queen when she is hungry and lure her toward empty cells, where she lays eggs, without crowding her. A solid, compact brood pattern scores best. The status shows the eggs laid, how the queen is doing and the time left. Keys: the arrow keys move the robot, F offers food, L toggles the lure, Enter starts a shift.

A simulated honeybee swarm choosing a new home. Scouts visit candidate nest sites and dance for them, more strongly for better sites; when enough scouts gather at one site, the swarm flies there. You can inspect a site to learn its quality, and head-butt scouts dancing for a worse site, the stop signal real bees use. The status shows the scouts dancing, the leading site and how close it is to a quorum.

A simulated pollination route race. Pick the order in which to visit the flowers, starting and ending at the nest: a flower's letter adds it, Backspace undoes, Enter races. A simulated bumblebee practises while you plan and improves its route over its trips, as real bumblebees do, and a drone flies the shortest route computed exactly. The status shows the length of your route, the bee's and the drone's.

A simulated arcade game with a tiny solar-powered robot bee. Each flap lifts it and uses charge, which only sunlight refills; clouds cast shade. Fly between the plant stems and collect pollen. The status shows the pollen collected, the charge left and your best score.

A simulated drone-racing game with a quadrotor seen from the side. Fly through each gate's gap in order and land on the far pad, against the time of an autopilot that flies the same course. Raw mode gives you the two motors directly, which is nearly impossible, as real drones rely on flight controllers adjusting the motors hundreds of times a second. Angle mode keeps the drone balanced while you tilt it left or right and climb or sink. Auto mode flies to wherever you tap. Mars mode has 38% of Earth's gravity and very thin air. Later courses add gusty wind. The status shows the gates passed, your time and the autopilot's.

A simulated flocking game. A flock of drones follows three rules, as in Craig Reynolds' boids: keep apart from neighbours, match their heading, and stay close to them, each drone watching its seven nearest neighbours. A beacon leads the flock through five levels: an open field, a winding canyon, a forest of pillars, a storm, and all three in a row. You set how strongly each rule counts, with the triangle or the presets Balanced, Stream, Spread and Huddle, and see how many drones make it home and how the others were lost: hitting rock, bumping each other in mid-air, or blown away. The status shows the drones home, the drones lost and the level.

A small neural network that trains in the browser. Add lime and pink points, or pick a dataset such as XOR, a circle, two spirals or two moons, and the network learns to separate them; the background shows its decision, lime on one side and pink on the other. Change the number of hidden layers and neurons to see what a network can and cannot learn. The status shows the training epoch, loss and accuracy.

A golf game about training neural networks. Each hole is a real test function from optimization, drawn as a landscape with the flag at its lowest point. Choose an optimizer (plain gradient descent, noisy stochastic gradient descent, momentum or Adam) and a learning rate, then swing: the ball takes 25 real gradient steps. Too large a learning rate makes it diverge; too small barely moves it. The status shows the hole, your strokes and the loss where the ball lies.

A reinforcement-learning game. A robot on a grid learns by Q-learning, in your browser, from the rewards you place: treats worth one point that come back, lava that costs five and ends the run, walls, and a cost for every step. The flag is worth ten. Train it, then watch what it learned; it often finds loopholes in the rewards. The status shows the level, the episodes trained and the average return.

An overfitting game. A polynomial of the degree you choose is fitted by least squares to noisy training points drawn from a hidden curve, and judged on held-out points it never saw. Low degrees miss the shape; high degrees chase the noise. The status shows the degree and the error on held-out and training points; a chart fills in the error for each degree you try.

Noughts and crosses against MENACE, a learning machine that Donald Michie built in 1961 from matchboxes and coloured beads. Each position has a box; MENACE plays X by drawing a bead at random, so moves with more beads are likelier. After each game, a win adds beads to the moves it played, a draw adds one, and a loss takes one away. The board shows the beads for the current position. Train it a thousand games at a time against sparring partners (a strong player who sometimes slips, a novice, and a trickster who sets up forks), or start over with fresh matchboxes. The status shows the games played, MENACE's wins, draws and losses, and the boxes it has used.

An adversarial-attack game with made-up pictures and a real classifier. A logistic-regression model trains in your browser to tell 24 by 24 pixel panda faces from gibbon faces. Then you try to fool it: flip pixels until it calls a panda a gibbon, using as few as you can (par is the fewest that could work), or slide the noise control to add the fast gradient sign method's nudge to every pixel. The X-ray shows which flips matter most, and a picture of the model's weights shows what it looks for. Harden retrains it on its own attacks. Once you have used it, the arrow keys move a cursor over the picture and Enter flips a pixel. The status shows what the model says, how many pixels you have flipped, and the par.

A game about explaining a black-box classifier. A small neural network, trained in your browser on drawn photos, tells wolves from dogs and gets all its test photos right, but every wolf it learned from stood on snow and every dog on grass. You choose the animal and the background of a photo and see its answer; Explain shows an occlusion map, where hiding each patch of the photo changes the answer; Training photos shows its training set. Five missions: make it call a dog a wolf, find what it looks at, see why, retrain it with photos that break the pattern until a fair test passes 90%, and check whether it now looks at the animal or only at its coat colour. The status shows its score on its own test photos, on the fair test, and how many photos it learned from.

A race against a small language model, after Claude Shannon's 1951 guessing game. The model learned which letters follow which, and the 10,000 commonest words, from 334 English Wikipedia articles, and a little from this page's own text, with the test lines taken out. You guess a hidden line letter by letter, spaces included, with a clue, using the keyboard or the on-screen keys; the model guesses in order of probability, and whoever needs fewer guesses wins the letter. With hints on, the model's guess for the rest of the word is drawn in blue and its favourite letters light up after a miss; three misses show the letter. At the end you see the score, guesses and bits per letter, and what the model would have written alone. Write makes the model generate text; temperature sets how adventurous it is. The status shows letters won by you and by the model, and the model's bits per letter.

A slot-machine showdown with a learning algorithm. Each machine pays a coin at its own secret rate. You get 40 pulls (30 in the last round), with the number keys, the machine buttons or a tap; then the algorithm plays the same machines with the same luck: each machine's luck is dealt from a deck drawn before the round, so the fifth pull of a machine draws the same card for both of you. The algorithm keeps a belief about each machine's rate and pulls the machine with the highest finite-horizon Gittins index: its best guess plus a bonus for what more pulls could teach it, a bonus that shrinks as the pulls run out. Under each machine you see your record and, during its turn, its belief and score. At the end the secret rates are revealed, with both scores and what always pulling the best machine would have won. The four rounds: five machines; one machine going cold while another heats up, where the algorithm lets old evidence fade; five machines only 5 points apart; and ten machines with 30 pulls. The status shows your coins, the algorithm's coins and the pulls you have left.

A Hopfield network, a memory made of 144 neurons on a 12 by 12 grid, learning in your browser. Store pictures, a heart, a smile, a bee, a robot, a letter, random noise or your own drawing: each is written into the connections between neurons by Hebb's rule. Scramble a picture by flipping a share of its pixels and press Recall: one neuron at a time, the network rolls downhill in energy until it settles, usually back into the stored picture it was closest to. The negative of every memory is stable too, and storing too many pictures, past about 20, makes recall fail. Thumbnails show the stored memories and how close the grid is to each; a chart shows the energy falling at every step. The status shows the number of memories, the closest overlap and the energy.

Rock, paper, scissors against a machine that learns your habits, in your browser. Before each round it predicts your move with six simple models: your favourite move, what you play after each move, after your last two moves, after winning or losing, in answer to its last move, and whether you step up, down or repeat. Like the 1999 competition winner Iocaine Powder, it also plays each prediction second- and third-guessed, scores all eighteen strategies on every round and plays the one doing best, or a random move when none is. The picture shows both moves, the result and the model that gave the machine its tip; below, the score, the last 40 rounds and a bar for each model. The missions: play 20 rounds, play only rock, play a rock-paper-scissors cycle, keep its wins under 40% over 30 rounds, and let the Random button play 30 rounds. Free play adds Peek, which shows the machine's next move. The status shows your wins, the machine's wins and its win rate.

A genetic algorithm evolving walking creatures, in your browser. Evolve one generation at a time, or 10, 50 or 100 at once. Each creature is three to six masses joined by springy muscles that pulse on its own clock, with feet that grip or slide. Its score is how far it moves in a 10-second (or 1-second) test. Each generation, the slower half of the 24 dies and every survivor has one child with random changes, at the mutation rate you set. The picture replays the whole generation, with the best creature drawn bright and the rest as ghosts, a dashed line where the best will finish, a strip of the 24 coloured by the founder they descend from, and a chart of the best and median score per generation. With Body set to Two legs, every creature instead has the same two-legged body, with motors at the hips, knees and ankles, and evolution tunes its brain: a small neural network, shared by both legs, that turns 11 senses (a clock, its lean and spin, its speed, which feet touch the ground, its hip and knee angles) into hip, knee and ankle commands, drawn live at the top right. A two-legged test ends when it falls. The missions: evolve 10 generations; switch mutation off and on again; reward a 1-second race and see what wins; evolve on the Moon; evolve until one founder's family has replaced all the others; and evolve a two-legged walker that covers 8 metres without falling. The status shows the generation, the record and the number of founding families left.

A kitchen for image filters. You set the nine weights of a 3×3 convolution kernel, drawn as spoons of honey (positive) and chili (negative), and a number to divide by; the kernel runs for real on a drawn photo of a beehive, a harbour or a robot, and your result is shown beside the photo, split at a seam with the dish you were asked for. Six missions: cook a box blur and see why weights summing to 1 keep the brightness; find vertical edges with the Sobel kernel, whose weights sum to 0; sharpen; stack two kernels into one 5×5 kernel; let gradient descent learn a secret recipe, where too much heat makes it diverge; and train a tiny convolutional network whose eight filters turn into edge finders and colour blobs on their own. Free play adds new orders and a recipe book. Keys: arrows pick a weight, plus and minus change it, brackets change the divisor, N normalises, T turns the kernel, C clears it, K stacks, L learns, H heat, F network, O new order, B recipe book, P plate, M next mission. The status shows the state, how well your dish matches the order, the sum of the weights, and dishes served.

A game about stitching two camera pictures of a marina into one, as panorama software does. Camera B sees part of what camera A sees, from another place; both pictures are rendered in your browser from a drawn marina through two simulated pinhole cameras. You drag four pins on picture B, and the game solves the homography, the 3×3 matrix that maps B onto A, through them, warps B pixel by pixel and blends it over A. Models with 2, 4, 6 or 8 numbers: shift, turn and zoom, affine, perspective. The error is the mean distance, in camera pixels, between where your matrix and the true one put B's pixels. Five missions: a shifted camera, a turned and lower one, a tilted one that needs perspective, automatic corner matching with wrong pairs that RANSAC must vote out, and a sailboat whose mast never lines up because it stands out of the water plane. Free play adds new cameras and a cheap lens whose distortion no homography can remove. The status shows the error, the number of degrees of freedom and RANSAC's inliers.

A bee-counting game. A simulated camera frame shows honeybees on a comb. You mark each bee with a point, the way annotators label training images for point-counting networks such as P2PNet, and a classical blob detector, a difference of Gaussians with non-maximum suppression, counts the same pixels in your browser. Check matches both sets of points one-to-one to the true bees and reports hits, misses, false alarms, precision, recall and F1. Five missions: count a sparse frame exactly; beat the detector on a crowded frame where touching bees merge into one blob; mark only the workers when two drones and a wasp are on the frame; tune the detector's threshold until its count is exactly right, and see whether its points are; and estimate a whole frame by counting sample squares and multiplying by sixteen. Then free play with new frames. The status shows your point count, the detector's, and the true number of bees once revealed.

A camera simulator that films spinning things: a drone propeller, a desk fan or a stagecoach wheel. Every pixel is computed from the physics. With a rolling shutter the sensor reads its rows one after another, top to bottom, so fast blades come out bent like bananas; the left picture replays one frame in slow motion, with the read line moving down. The right picture is the video at the chosen frame rate: when the blades move a whole number of gaps between frames the propeller seems to stand still, and just short of that it seems to turn backwards, the wagon-wheel effect. A dial counts the blade gaps turned between two frames and shows the nearest match the video sees. Controls: speed (dragging sideways on the picture or the arrow keys fine-tune it), number of blades, readout time, frame rate, exposure, and later a global shutter that reads every row at once. Six missions: bend the blades, sharpen them, freeze the propeller, make it turn backwards, find the road speed where a stagecoach's wheels stand still at 24 frames a second, and see that a global shutter straightens the blades but does not stop the video lying. The status shows the true speed, the speed the video shows, and the bend.

A tracking game: you against a real multi-object tracker. Simulated bees that look exactly alike fly between flowers under a leafy branch, a simulated detector boxes them 30 times a second with jitter, misses and false alarms, and SORT, a Kalman filter per bee plus the Hungarian method for pairing boxes, gives each an ID. Go rings one bee; when the ring fades the boxes hide, you follow that bee with your eyes, and when the picture freezes you tap it. Then you see where it really went and whether the tracker's ID stayed on it. Six missions: a crossing; a pass under the leaves, where SORT's default memory of one missed frame loses it; raising Max age so the Kalman prediction carries the box through; a crowd where the tracker swaps IDs; tuning Max age, the IoU gate and process noise to halve the ID switches on a fixed test; and paint dots, a colour cue like DeepSORT's appearance features. The status shows rounds where you kept your bee, rounds where the tracker kept it, and the tracker's ID switches in the current scene.

Depth from two eyes. Two simulated pinhole cameras a baseline apart photograph a ray-traced street, a garden wall, a picket fence or a random-dot pattern. Sliding the right camera's picture over the left one until a thing stops looking double gives its disparity d in pixels, and its depth is Z = f times B over d. A real block-matching algorithm then compares small windows of the two pictures at every shift and keeps the best per pixel, giving a depth map, with a left-right check that blanks pixels the two directions disagree on. Six missions: measure a car; measure a far taxi, where a wider baseline is needed because depth error grows with the square of distance; find a strip only one eye can see; fix a blank white wall with a dot projector; widen the matching window so a repeating fence lands at its true depth; and find a shape hidden in random dots that exists only in depth. Free play adds every scene, a cross-eyed view, swapped eyes and wiggle stereo. Keys: arrows left and right shift, up and down baseline, M match, V view, L LR check, P projector, brackets the window size, N next mission, X cross-eyed, S swap eyes, W wiggle, G red-cyan glasses. The status shows the shift, the depth it means, and the baseline.

A Hough transform you can play with. Every edge pixel votes for every straight line that could pass through it: in a map of angle θ against distance ρ, one point's votes form a sinusoid, and where many sinusoids cross, a line is elected and drawn on the picture. Start in a bubble-chamber photo, where you tap bubbles on a particle track until three of them agree on a line. Then a simulated dashcam: an edge detector finds the paint, and you set how strong an edge must be to vote (Edges) and how many votes a line needs to win (Votes) until only the two lane lines are found, then again with pole shadows and a dashed line. Circles need a third number, the radius: on a table of euro coins each edge pixel votes for every centre one radius away, and you scrub the radius until the votes collapse onto a coin, then count the money. The twist is a snowstorm whose flakes bury the lanes in votes, until each pixel aims its votes along its own edge. The status shows the number of voting pixels, the shapes elected and the strongest vote.

A camera simulator: what happens between a camera's sensor and its JPEG. A scene is lit wavelength by wavelength and photographed onto a 240 by 160 pixel sensor with a Bayer colour filter, so each pixel records only red, green or blue, with real photon shot noise and read noise. You develop the raw picture stage by stage: demosaicing (nearest, bilinear or edge-aware), white balance (a colour temperature, gray world, white patch, or a grey you pick), a tone curve, and a real JPEG encoder whose file size and PSNR are measured. Five missions: expose a dim party so the moving dancer is sharp and the noise low; find the demosaicing method that leaves no false colour on a striped shirt; make a white van white under orange sodium street lamps; make the smallest JPEG that still scores 34 dB; and the dress of 2015, white and gold or blue and black depending only on white balance. The status shows the shutter time, the ISO and the JPEG's size.

A film camera simulator. A full-frame camera films an actor standing in a long corridor whose end window looks out on a night city and the moon; the picture is computed with a real pinhole projection and the thin-lens equation, and anything away from the focus distance blurs by its circle of confusion, with out-of-focus lights spreading into bokeh discs. A plan view shows the camera, its field of view and the zone that is in focus. Controls: zoom (focal length 14 to 300 millimetres), dolly (the camera's distance), later focus, aperture, follow focus, an Action button that rolls the dolly back on its own, and a lock that keeps her size. Six missions: frame her head to toe with a wide and a long lens and see the background swell; do Hitchcock's Vertigo shot, zooming as the dolly pulls back so she keeps her size within 5 percent while the window doubles; frame her face at 24 and at 85 millimetres and compare the noses; blur the city into large bokeh discs with her sharp; get everything sharp with the hyperfocal distance; and find the peephole of an Ames room, where two twins of the same height look twice as different. The status shows the focal length, the camera distance, the f-number and her height in the frame.

A game about seam carving, the content-aware resizing of Avidan and Shamir (2007), running for real on four drawn pictures: a beach with a lighthouse, a city at dusk with a balloon, a portrait in front of a hedge, and a castle. Narrowing the picture removes seams one at a time: a seam is a connected path of one pixel per row, the cheapest by an energy that is high at edges, found by dynamic programming. Widening copies the seams carving would take first. You can paint pixels to protect or to remove; Vanish carves out what you marked, then widens the picture back. Views show the picture, its energy, the dynamic-programming cost table, and a comparison with plain scaling and cropping. Six missions: narrow the beach to 70% and see what survives; find the cheapest seam in the cost table; make the balloon vanish; see a face squeezed and protect it; compare gradient energy with forward energy on the castle; and shrink both ways, where dynamic programming over every intermediate size chooses the order of rows and columns. Keys, once used: left and right arrows for width, up and down for height, P protect, R remove, V vanish, 1 to 4 views, G and F energy, D DP order, S scene, X reset, N next mission. The status shows the state, the width, the number of seams and the last seam's energy.

A path-planning race on a grid map you can edit. Two robot mice race to the same cheese, each with its own planner, and the planners really run in your browser: Dijkstra's algorithm, A*, weighted A*, greedy best-first search, and the sampling planners RRT and RRT*. Each map shows what its planner explored, the expanded cells or the random tree, and the path it found; the mouse runs its path once its plan is ready. Above each map are the cells expanded or samples drawn, the path length in cells and the computing time measured in your browser. Draw and erase walls, move the mouse and the cheese, set the weight of weighted A*, and in free play pick any two racers and maps. Missions: make A* search less than Dijkstra for an equally short path; build a cup that traps greedy into a long detour; trade path length for speed with weighted A*; squeeze a corridor until RRT struggles; watch RRT* shorten RRT's path; and lock the cheese in, so that Dijkstra proves there is no path while RRT can only give up. The status shows whether the race is running, which mouse reached the cheese first, and the number of walls.

An inverted pendulum on a cart, simulated with its full equations of motion. First you balance the pole yourself by pushing the cart left and right with 10 newtons, or by dragging it: the pole tips over fast, and a longer pole tips more slowly. Then an LQR controller takes over: the model is linearised at the top, the Riccati equation is solved in your browser, and the cart's force is minus the gain K times the state. Six missions: balance by hand for 5 seconds, survive three kicks under LQR, move the cart's target and see it first step the wrong way, compare a gentle and an aggressive setting of R, the price of force, swing the pole up from hanging with an energy rule, and balance two stacked poles. The picture shows the cart, the pole and its lean, the motor force, the gains K and charts of the tilt, force and cart position. The status shows who balances, the tilt and the force.

A robot localization game with a simulated robot vacuum in a small flat. The robot has the floor plan but does not know where it is; Monte Carlo localization, a particle filter, runs in your browser: each of up to 5,000 guesses of its position and heading is moved by the wheel odometry with noise, weighed by how well a simulated lidar scan fits the map from there, and redrawn in proportion to its weight, so the guesses gather where the robot really is. Drive with the arrow buttons or keys, or tap the map to send the robot there. The panel shows the robot's own scan and what its best guess would see. Five missions: localize from scratch; switch the lidar off and watch the guesses spread on odometry alone; start in one of two identical bedrooms and see two clouds of guesses until the hall breaks the tie; try 50 particles or fewer, which often settles on the wrong place; and kidnap the robot to another room, then switch on Rescue, which adds random guesses when the scans stop fitting, so it recovers. A cat that is not on the map sleeps in the living room. The status shows how spread out the guesses are, how far the best guess is from the true position, and how many clouds of guesses there are.

A simulated ball-and-beam rig, the classic control lab. A steel ball rolls on an 80 centimetre beam that a servo tilts up to 15 degrees either way; rolling without slipping, it speeds up at five sevenths of g times the sine of the tilt. A noisy, slightly late sensor measures where it is. First you tilt the beam yourself with the slider and try to park the ball in the middle; then a PID controller does it 50 times a second, with sliders for its proportional, integral and derivative gains. A chart plots the ball's position, the target and the beam angle over the last seconds, with the overshoot, settling time, steady error and beam jitter measured live. Six missions: park the ball by hand; settle it with Kp and Kd; reach a new target with little overshoot; calm a noisy sensor with a derivative filter; keep control of a hollow ping-pong ball after a kick; and remove an offset with Ki, then hold the ball, let go, and tame the integral windup with anti-windup. The status shows who is tilting the beam, the ball's position and the beam angle.

An inverse-kinematics game with a three-joint robot arm and a gripper, simulated in your browser. You place a crosshair and the arm works out its joint angles with one of five real solvers: the Jacobian transpose, the pseudo-inverse, damped least squares with a damping you set, cyclic coordinate descent and FABRIK. Each joint has an angle range and a top speed, so the arm moves at its own pace while a dashed outline shows the pose the solver asks for. A faint cloud marks every point the gripper can reach, an ellipse at the gripper shows which ways it can move fast, and a panel plots the error at every iteration with the joint angles and speeds. Six missions: touch three beacons; put the target out of reach and watch the ellipse flatten at the singularity; see the pseudo-inverse go wild there and damped least squares calm it; keep the gripper on a weld while a crane's swinging crate passes, using the spare joint to duck the elbow; put two cups of tea on a tray with the wrist pointing down; and race all five solvers to the same point. The status shows the solver, the gripper's distance from the crosshair and the arm's manipulability.

A parallel parking game seen from above, with a car that moves like a real one: the kinematic bicycle model, a 33 degree steering limit, steering that turns at a limited rate, forward and reverse gears and a speed limit. Hold the forward and reverse buttons to drive and the steering buttons to turn the wheel; parking sensors beep faster as a bumper nears another car. Park between two cars, straight and close to the kerb, without touching anything. Autopark runs a real hybrid A star planner over positions and headings, drawn as it searches, then drives the path it found. Shortest draws the Reeds and Shepp path, the shortest way into the space for a car alone, and shows whether it would hit a car. Five missions: park by hand, let the planner park, find a start where the shortest path is clear, park in a gap shorter than the smallest one you can reverse into in one sweep, and park nose-first with the reverse gear broken. The status shows the gear, the speed, the number of gear changes and the distance from the kerb.

A SLAM game: a simulated robot maps a building it has never seen, with a lidar and wheel odometry that slowly drifts. Drive it with the arrow buttons or keys, or tap the map to give it a route. Every 40 cm it adds a pose and its scan to a pose graph; when a scan looks like an old one, a scan matcher checks it and a loop closure is added, and Gauss–Newton re-solves the whole graph, so the doubled, drifting walls snap together. The panel shows the poses and loop closures, the solver's steps, the map's error against the real walls with odometry alone and with SLAM, and the position error over the drive. Truth draws the real walls; Odometry shows the map from wheel counts alone; Fast drives faster, with more wheel slip; New run starts again. Five missions: close a loop, compare with the truth, close one in a hurry, get fooled by two identical rooms, and fix that with a robust solver. The status shows the loop closures, the map error and the number of poses.

A robotic warehouse seen from above, where drive-under robots carry shelf pods to pickers at six stations and back, and every robot moves one cell a second. Three path planners really run in your browser on a grid of cells and seconds: Solo A*, where each robot plans its own shortest path and ignores the others, so they crash; Reserve, where robots take turns booking the cells they will use in the coming seconds in a shared table, windowed cooperative A* on the floor and prioritized planning in the aisle puzzles; and Conflict-Based Search, which grows a tree of rules until no two plans clash and finds the best joint plan for a few robots. The panel shows orders packed per minute, distance travelled, time spent waiting, crashes, the constraint tree, and a chart of throughput against the number of robots, measured over seven simulated minutes in the background. Missions: watch independent plans crash; run a minute crash-free with reservations; solve an aisle with one empty slot where reservations fail in every order but CBS succeeds; raise the robot count until throughput falls; and find where one-way aisles beat two-way ones. You can break a robot down by clicking or tapping it. The status shows the planner, orders per minute and crashes.

A one-legged hopping robot, simulated with real dynamics: a body on a springy telescoping leg with a hip motor, a foot that sticks to the ground by friction or slides when pushed too hard. First you hop it by hand, timing a push of the leg at the bottom of each landing and swinging the foot ahead of or behind the body. Then Marc Raibert's three-part controller takes over part by part: Height pushes at the bottom of each stance to set the hop height, Speed places the foot at the neutral point plus a correction to set the forward speed, and Level uses the hip in stance to keep the body level. Six missions: six hops by hand, eight steady hops in place, run at 1.2 metres per second, stop on a flag, cross a gap and a step with Look-ahead choosing each hop's height, and stop on ice, where a foot placed more than 5.7 degrees off vertical slides. The picture shows the robot, the neutral point, where the foot will land, the touchdown angle and the friction cone, the controller's numbers, and charts of hip height and speed. The status shows who is in control, the hops in a row and the speed.

A robot grasping game in a side view, simulated in your browser with rigid-body contact physics: gravity, and Coulomb friction at every contact, where friction can be at most the coefficient μ times the normal force. You place a parallel gripper on an object, set how hard its fingers squeeze, grip, lift and shake; the object comes along, slides out, tips or squirts away, depending on whether the contact forces can balance its weight and the hand's acceleration. Each contact's friction cone and force are drawn, and the grasp's quality is computed from them: whether it has force closure, and the Ferrari–Canny measure ε, with the grasp's wrenches drawn in three dimensions. Five missions: lift a parcel; lift a wet bar of soap; lift and shake an egg gently enough not to crack it; lift a mug of coffee by its rim without spilling; and shake a flared flower pot, which two fingers can't hold through a shake but three can. The status shows the squeeze, ε and how much of the available friction the worst contact uses.

A band-math game on a simulated Sentinel-2 image of a made-up alpine valley with a lake, a river, fields, forest, a town, a burn scar, snow and clouds. Every pixel has reflectances in seven bands, from blue to shortwave infrared. You choose two bands A and B and a threshold; pixels where (A − B)/(A + B) is at least the threshold form a mask, scored against the true land cover by intersection over union, with hits, false alarms and misses drawn in colour. A chart shows any pixel's spectrum against the signatures of each land cover; the map can show the mask, the index, colour composites or the true labels. Six missions: find vegetation, water, snow but not clouds, the burn scar, an algal bloom that needs two rules joined by AND, and the town, where a search through every band pair shows the limit of band math. The status shows the score, the index and the threshold.

A city-cooling game with a simulated district of flats, a supermarket, offices, a school, a care home, a park and a river, 320 by 200 metres, on a clear July day. A surface energy balance runs for every 10-metre cell: sunlight absorbed according to each surface's reflectivity, shade from buildings and trees, heat radiated to the sky, heat stored in asphalt and concrete and given back at night, evaporation from lawns, trees and water, waste heat from traffic and air conditioning, and a light westerly wind that carries warm or cool air downwind. You spend points on trees, white roofs, green roofs, lawns and ponds by choosing a tool and tapping the map. Views show the city, the surface temperature a thermal satellite would see, the air temperature with the wind, and the change since the start; a time slider or Play day moves through the 24 hours, and a chart shows the city's mean surface temperature over the day against the countryside. People shows the residents, schoolchildren and care-home residents outdoors, coloured by the temperature they feel, which counts sun and shade as well as the air. Five missions: cool the supermarket block below 55 degrees; lower the city's mean by 0.4 degrees with ten trees; lower what people feel by 2 degrees; cool the school block both at 2 in the afternoon and at 3 at night; and, in a heatwave after every roof is painted white, bring the school and care home back to a normal day's felt temperature. The status shows the time, the city's mean surface temperature and the points left.

A simulated street in cross-section, about seismic risk. Six lots stand on rock, stiff soil and a soft-clay basin. You choose each building's floors, whether it is old or modern, and a retrofit: shear walls, dampers or base isolators. Shake runs a synthetic earthquake made with the stochastic method; each soil column filters the rock shaking through its own resonance, about four times its depth over its shear-wave speed, and each building, a yielding shear frame of about 0.1 seconds per storey, sways in response. Its peak roof drift decides its damage, from none through slight, moderate and extensive to collapse, by FEMA's HAZUS thresholds. A chart shows how hard each ground shook buildings of each period. Five missions: see the soft clay amplify shaking; tune a building to the clay's period and see resonance; keep an old hospital undamaged with a retrofit; halve a street's expected loss over 20 quakes with three retrofits; and show a tall building on rock can do better than a short one on clay. The status shows the magnitude, whether the street is shaking, the chosen building's peak drift and the street's loss.

A simulated river valley seen from above, about flood defence. The ground is a height map 3 kilometres by 1.8 with a river, a town with a hospital and a school, a village just upstream of it, fields, meadows and forested hills. Rain falls on every cell; land cover decides how much soaks in, by the curve-number method, and the rest flows over the ground and down the river by a shallow-water model, cell to cell, driven by the slope of the water surface and slowed by friction. You spend a budget on levees along the river, retention ponds dug in the fields, new forest, and permeable paving in town, then run a 10-year or a 100-year storm. A chart shows the flow through the town over three hours against the untouched valley, and the map shows the water and, afterwards, how deep it got; the panel says whether the hospital, the school, the houses and the village upstream stayed dry. Radar shows the valley as a radar satellite would see it through the clouds. Five missions: keep the hospital dry; wall in the town and see what happens to the village upstream; give the river room upstream instead; undo the damage of a housing estate on the hills; and map the flood from orbit. The status shows the storm clock, the flow through the town and the budget left.

A wildfire game on a made-up valley seen from above, 4.8 by 3.6 kilometres in cells of 50 metres, with a village, a river, a lake, fields, shrubland and pines on a ridge with a lookout. The fire spreads by Rothermel's fire-spread model: faster in dry fuel, with the wind and uphill, so it grows into an egg shape with a fast head, slower flanks and a slow back. Intense shrub and crown fires throw embers that start spot fires ahead. You have tools: a firebreak, which two dozers clear along a line you set by its two ends; a water drop, which wets the fuel for a while and puts out what it hits; and a backburn, a line that crews light so it burns back toward the fire and leaves no fuel for it. Three satellite views: true colour with smoke, a thermal view that sees through smoke and marks satellite fire pixels of 375 metres, and a burn-severity map from the change in the normalised burn ratio. Six missions: stop a grass fire before the village; bet which of two fires burns more, one at the foot of a slope or one at its top; find a fire's head under smoke and drop water on it; prepare for a forecast wind change that turns the fire's long flank into its head; stop a shrub fire with a backburn from a track; and, with no crews, burn the shrubland in spring so that an August fire finds too little fuel. The status shows the time, the burnt area and the houses still standing.

A game about span and bases, with a bee that can only fly to linear combinations of the vectors you drag: a·v₁ + b·v₂ in the plane, a·v₁ + b·v₂ + c·v₃ in space. The picture shows the vectors, the skewed grid of their combinations, the span, and the matrix A of the vectors with Ax, the determinant, rank, nullity and null space, all computed live, and a small panel of the coefficients x with the null space. Five missions: land the bee on three flowers; make the two vectors dependent and watch the span collapse to a line; move the basis until the bee's fixed coordinates (2, 1) land on a flower, a change of basis, with glasses that show the world in the bee's grid; in space, put the third vector into the plane of the other two, so rank 2 plus nullity 1 makes 3; and solve Ax = b with b off the plane, getting as close as possible, which is least squares. The status shows the space, the rank and the determinant.

A game about matrices as machines that move the plane. A little robot, a grid and the unit square live in the plane; the columns of a 2×2 matrix A are where the basis vectors î and ĵ land, and you drag their tips (or select one with 1, 2 or 3 and move it with the arrow keys) while every point follows. The determinant is shown as the signed area of the image of the unit square, with a turning arrow that runs backwards when the map mirrors; at determinant 0 the plane collapses onto a line and the null space, everything sent to 0, is drawn dashed. Play animates the plane from the identity to A, Identity goes back, Inverse undoes A and then shows A inverse alone, and the moves rotate, shear, flip, stretch or project the plane. Six missions: build a shear with determinant 1, a reflection with determinant −1, flatten the plane (determinant 0), undo a mystery matrix by building its inverse, reach a target pose with rotate, shear and flip in the right order, and in 3D flatten a cube, whose signed volume is the determinant, into a sheet. Under the matrix, each map is named (rotation, mirror, shear, projection, scaling and more) with the property of its matrix that gives it away; free play adds 3D and asks you to collect all five kinds. The status shows the matrix size, the determinant, the rank and what kind of map it is.

A game about eigenvalues and eigenvectors of a 2 by 2 matrix A, computed exactly in your browser. A probe vector v sweeps round the unit circle and the picture shows Av; where Av lands on v's own line, v is an eigenvector and the stretch is its eigenvalue, negative when Av points the other way. Dragging the tips of A's two columns changes the matrix. Beside the picture: the turn from v to Av for every direction, which is zero exactly at eigenvectors, and the characteristic polynomial det(A − λI), whose roots are the eigenvalues. The Eigenbasis view animates A = P D P inverse: into eigen coordinates, a pure stretch, and back. The Repeat view applies A again and again: power iteration turns any start towards the dominant eigenvector, while complex eigenvalues make it spiral; with a Markov chain between a lab and a café it shows sixty people settling into the steady state, the eigenvector for eigenvalue 1. Six missions: catch both eigenvectors, find a matrix with none, give a defective shear a second eigenvector, diagonalize, make the matrix symmetric so its eigenvectors meet at right angles on the axes of the ellipse it makes from the circle, and win a race to the steady state. The status shows the view, the eigenvalues and the probe's angle.

A game about the singular value decomposition, A = U Σ V transpose, computed in your browser by one-sided Jacobi rotations. Sculpt: a 2 by 2 matrix is built from a turn, a stretch along the axes by σ₁ and σ₂, and another turn; you drag the stretched axes σ₁u₁ and σ₂u₂ of the ellipse that A makes from the unit circle, and the input direction v₁, and Play animates the three steps on the circle and a bee. A probe v shows |Av|, largest at v₁ and smallest at v₂, the eigenvectors of A transpose A. Solve: two nearly parallel lines, the rows of Ax = b; shaking b by 1% sends x far along the lines, up to the condition number σ₁/σ₂ times more, and the pseudo-inverse with σ₂ cut keeps x steady. Picture: a 96 by 96 grey picture is rebuilt from k rank-1 layers σᵢuᵢvᵢ transpose, with the energy kept and the storage used; tapping a pixel makes a rank-1 guess from its row and column, and Refine improves it by least squares until it equals the best rank-1 layer. Cloud: 60 points and a line you turn about their mean; the spread along it is largest on the principal axis, v₁ of the centred data's SVD. Six missions: build a given matrix, find where a shear stretches most and least, tame a nearly singular system, compress the picture to 99% energy, refine a rank-1 guess, and fit the principal axis. The status shows the view, the singular values or the rank k, and the condition number or the energy kept.

A game about orthogonality, projections and least squares, computed live in your browser. Shadow: slide a point p along the line through a vector a until the error e from p to b meets the line at a right angle, so a·e = 0 and p is the projection of b, (a·b over a·a) times a; a chart shows the squared error against p's position, smallest exactly there. Fit: drag a line through points by hand while every miss is drawn as a square whose area is the squared error, then let springs pull a rod to the exact least-squares line, where the normal equations hold; one dragged outlier swings the squared-error fit while the absolute-error fit hardly moves; a simulated ball's flight is fitted by a parabola to measure gravity. R³: with three points the data b is a point in space, every line is a point Ax on the plane of A's columns, and the best line is where b minus Ax is perpendicular to that plane, the projection P b with P = A (AᵀA)⁻¹ Aᵀ. QR: Gram–Schmidt turns three skewed vectors into an orthonormal basis step by step, A = QR; then a nearly flat matrix shows the normal equations losing every digit while QR keeps them. Seven missions; the status shows the view, the error and one key number.

A game about forecasting rain for the next 90 minutes from weather radar, called nowcasting. A simulated radar, 128 kilometres across, shows rain bands and thunderstorms in decibels of reflectivity (dBZ) as they drift with the wind, grow and die, with a new scan every five minutes. Events around a small town, such as a wedding, a football match or laundry on the line, happen at set times; you call each one rain or dry, then run the clock and the truth arrives scan by scan. Three forecasters help or compete: persistence, which says the rain stays where it is; Motion, which matches blocks of the last scans to measure how the rain moves and carries it forward; and a small neural network trained in your browser on the last three hours, which learns how rain grows and fades along its path. Each is scored over the whole map with the critical success index, hits over hits plus misses plus false alarms, at every lead time. Five missions: beat persistence, use the motion, beat Motion when storms grow and die, train the network and see it blur, and spot a storm being born that no extrapolation can see, using the satellite's view of the clouds. The status shows the clock, the rain over the town and how many of your calls were right.

A geolocation game against an AI. Each round shows a simulated satellite tile of a famous landscape: centre-pivot fields, fishbone forest clearing, bulb fields, star dunes, salt ponds, thermokarst lakes, rice terraces, a river delta, an open-pit mine or an ice fjord. You place a pin on a world map where you think it is, then the AI answers: a softmax regression trained in your browser on generated tiles, from 29 numbers it measures on a 48 by 48 pixel view (colours, edge directions, texture and circles). Its answer is a probability for each of the 11 places it knows, drawn on the map as heat; its pin goes on the likeliest. Whoever is closer by great-circle distance wins the round. AI's eyes shows its pixel view, the circles it found, its measurements and which of them pushed its bet. Six missions: play a round; look through its eyes; see it split its bet between centre pivots in Kansas and in Saudi Arabia; fool it with snow, since it only studied spring and summer; teach it autumn and winter and see it fixed; and beat it on a place it never studied by reading the shape. The status shows rounds won by you and by the AI, and the round number.

A game about training a classifier to find emperor penguin colonies from space by their guano stains, as researchers did with Landsat images in 2009. A simulated Landsat image of an Antarctic coast, 30 m pixels in five bands, shows sea ice, icebergs and their shadows, open water, rock, a cloud and its shadow, a research station and five colonies. Each step marks a spot to label as guano, ice, rock, shadow, water or cloud; a tap labels a patch of similar pixels, and a k-nearest-neighbour classifier, trained in the browser on the two bands you choose, names every pixel. A plot of those two bands shows every pixel, your examples and the decision. Connected guano pixels become detections, scored as colonies found and false alarms. Five missions: find colonies with two examples, clear the false alarms in water and shadow, catch a pale colony, beat brown rock with shortwave infrared, and, zoomed to 30 cm pixels, estimate the number of birds from penguin area calibrated on ground counts instead of counting blobs. Show me does the current step.

A lesson in eight steps on symmetric matrices, quadratic forms and positive definiteness, computed live in your browser for the matrix A with rows a, b and b, c, set by three sliders. Each step shows the function f(x) = x transpose A x as a shaded 3-D surface that turns when dragged, as contour lines on a map, and the numbers beside them. Step 1: the four shapes, bowl, valley, saddle and dome. Step 2: the spectral theorem A = Q Lambda Q transpose: the perpendicular eigenvectors are the axes of the contour ellipses, and the contour f = 1 has half-axes one over the square root of each eigenvalue; Turn rotates the axes until the cross term vanishes. Step 3: five tests that agree for a symmetric matrix: positive eigenvalues, positive pivots, positive leading minors, x transpose A x positive for every nonzero x, and a Cholesky factor. Step 4: semidefinite and indefinite matrices, and a trap where the leading minors are not enough. Step 5: the Hessian at the critical points of Himmelblau's function, found by Newton's method from where you tap, decides minimum, saddle or maximum. Step 6: A as the inverse covariance of a Gaussian, with simulated samples drawn through the Cholesky factor; about 39.3 percent fall inside the ellipse f = 1. Step 7: gradient descent zigzags on a long, thin bowl; the condition number, the largest over the smallest eigenvalue, sets how many steps it needs. Step 8, Try it: turn the bowl into a saddle with the smallest move of one slider, then make descent finish in three steps or fewer. The status shows the step, the kind of matrix and one key number.

A lesson in eight steps on elimination and the four fundamental subspaces of a matrix, after Gilbert Strang's big picture, with one editable matrix A and right side b, all computed exactly with fractions. Step 1 shows Ax = b two ways: in the row picture each equation is a plane in x-space and a solution lies on all of them; in the column picture b is built from the columns of A. Step 2 runs elimination one row operation at a time, each an elimination matrix, and builds L and U so that A = LU, while the planes turn but keep their common points. Step 3 finds the pivots, the rank, the free columns and the reduced row echelon form R. Step 4 shows the column space C(A), where every Ax lands, and the null space N(A), the x with Ax = 0, built from special solutions. Step 5 shows that the null space is perpendicular to the row space and the left null space to the column space, and splits x into its row-space and null-space parts. Step 6 is Strang's diagram of the four subspaces with dimensions r, n − r, r and m − r. Step 7 gives the complete solution x = particular solution plus null space, and when Ax = b has no, one or infinitely many solutions. Step 8, Try it, asks for a nonzero vector in the null space, a b with no solution, and one changed entry that makes every b have exactly one solution, and explains each answer. The shape of A can be 3 by 3, 2 by 3 or 3 by 2. The status shows the step, the rank, the shape and how many solutions Ax = b has.

A simulated game about quantum key distribution with the BB84 protocol, where you play Eve the eavesdropper. Alice sends Bob single photons, each carrying a random bit in a random basis, plus or cross, as a polarization. You tap the fibre: you measure some of the photons with your polarizer and send Bob fresh ones with your results. Measuring in the wrong basis gives a random result and changes the photon. Bob measures in random bases; Alice and Bob announce their bases in public, keep the bits where the bases matched, compare a sample of them, and give up if more than 11% disagree; otherwise they hash the key shorter. Five missions: learn that the wrong basis is a coin flip; intercept everything and get caught at about 25% errors; tap only some photons and see that the hashing wipes out what you learned; beat a dim laser source over 50 km of fibre by splitting its multi-photon pulses, blocking single photons and using your own better line, and read Alice's message; and get caught by decoy pulses. The status shows the error rate in their test, the final key length, and how much of the key Eve can read.

A simulated Stern–Gerlach bench. Silver atoms leave an oven one at a time and fly through up to four magnets, each turned to an angle around the beam. Each magnet splits the beam in two, up and down along its own axis: an atom comes out up with a chance that depends on the angle between its spin and the magnet, cos² of half that angle. Every magnet but the last passes one beam on and catches the other in a cup; the last one's two beams land on a plate, drawn end-on, where the dots pile up into two spots. A panel shows the spin entering the picked magnet as an arrow on a circle, with the chances of up and down. A loop splits the beam and joins it again; with both arms open it measures nothing. Missions: see two spots instead of a smear; check that up atoms stay up; bring back blocked down atoms with a sideways magnet; tilt a magnet so one atom in four lands down; get atoms through two crossed magnets by adding a third; open a loop's arms so nothing is measured; and find the hidden angle of a secret beam from your own measured shares; then free play. A Hint button gives the next step, one level at a time. The status shows the atoms fired, the up and down counts on the plate, and the expected share of up.

A lesson in eight steps on change of basis and diagonalization, every number computed live from 2 by 2 matrices. Step 1: one vector and two grids; its coordinates c in a basis b1, b2 satisfy x = P c, where the columns of P are b1 and b2, so c = P inverse x. Step 2: the map A in another basis has the matrix B = P inverse A P, played as translate in, act, translate out; column j of B is A bj written in the basis. Step 3: dragging the basis changes every entry of B, while its trace, determinant and eigenvalues stay those of A: similar matrices. Step 4: with A's eigenvectors as the basis, B is the diagonal matrix D of eigenvalues 2 and 0.5, A = P D P inverse, and A only stretches along them. Step 5: powers A to the k equal P D to the k P inverse, so A to the k times x turns onto the dominant eigenvector. Step 6: Fibonacci numbers from the eigenvalues phi and psi of the matrix 1 1, 1 0: Binet's formula. Step 7: a shear and a spiral that no real basis makes diagonal. Step 8, try it: drag a basis in which a new matrix M becomes diagonal; the lesson checks it and explains why. The status shows the step and its key numbers.

A simulated lab bench for growing quantum dots: crystals of cadmium selenide a few nanometres across whose glow under ultraviolet light depends only on their size. Inject precursors into a hot flask and a burst of tiny seeds grows; the heat buttons stop, slow or speed the growth, Add precursor feeds the flask more material, and Sample pulls the flask's contents into a vial. Beside the flask, one dot is drawn as a box for its electron and hole, with their energy levels and standing waves; the photon they give off when they recombine has the energy of the bulk band gap, plus the confinement energy, minus their attraction, from Brus's formula, and its wavelength is shown. A spectrum shows the flask's glow, its peak and its width, which grows when the dots' sizes spread. A tick on the flask says when the peak is in the mission's target band, and the Sample button lights up; a sample that misses says by how much, and Rewind restores the flask to before the band, keeping the vials. Six missions: sample a green, then a red; five colours from one batch; a red that is also sharp, by feeding the flask before the dots ripen; a blue, which needs the tiniest dots; and a display whose pixels mix your three best vials, scored by how much of the sRGB colour range it covers. The status shows the flask's peak wavelength, the width of its glow and the dots' mean diameter.

A lesson in eight steps on what activation functions do inside a small neural network that trains in the browser, every number measured from the runs. Step 1: with no activation, stacked layers collapse into one matrix, W2 times W1, so the boundary is a straight line that cannot separate a circle. Step 2: one ReLU or tanh between the layers bends the boundary; ReLU cuts the plane into flat pieces, and a tapped point is followed through the network. Step 3: fitting a curve, a ReLU network is a polyline whose kinks can be counted, a tanh network is smooth. Step 4: in a deep, narrow network the error signal fades layer by layer for sigmoid, whose derivative is at most one quarter, and initialisation by Xavier or He keeps tanh and ReLU healthy. Step 5: a race of sigmoid, tanh, ReLU and Leaky ReLU from the same start on two spirals, with live loss curves. Step 6: a hot start with a large learning rate kills ReLU units, which never come back, while Leaky ReLU units keep learning. Step 7: the course's advice tested on five seeds. Step 8, try it: pick an activation and learning rate that solve the spirals within 400 epochs with no dead units; the lesson checks the run and says why. The status shows the step and its key numbers.

A lesson in eight steps on activation functions, every number computed live from the formulas. One figure stays throughout: the function f of z on top, its derivative f prime below, a point z you move, its tangent, and the zones where the slope is under 10% of its peak (saturated) or exactly 0 (off). Step 1: a neuron computes z = w transpose x + b and outputs a = f(z); pick linear, step, sigmoid or ReLU and nudge z to see that f prime is how fast a changes. Step 2: the sigmoid 1 over 1 + e to the minus z squashes everything into 0 to 1; its derivative sigma times 1 minus sigma peaks at 0.25. Step 3: tanh is zero-centred with slope 1 minus tanh squared, up to 1, and a morph shows tanh z = 2 sigma(2z) minus 1. Step 4: both saturate, and because sigmoid outputs are all positive, a neuron fed by them updates both weights with the same sign and zig-zags, shown by gradient descent in two small weight-space pictures. Step 5: ReLU, max(0, z), with derivative 1 for z above 0, and Nair and Hinton's sum of shifted sigmoids built term by term into log(1 + e to the z). Step 6: one ReLU neuron on 21 inputs; a gradient step with a large learning rate pushes every z below 0, the gradient becomes exactly 0 and the unit is dead. Step 7: leaky ReLU, PReLU, maxout with draggable lines, softplus, Swish and ELU, each with its parameter, and a compare view that overlays any of them, ending with the course's advice. Step 8, try it: find where the sigmoid's gradient falls below 1% of its peak, then drag maxout's two lines into a leaky ReLU; the lesson checks each and explains why. The status shows the step and its key numbers.

A lesson in eight steps on cross-entropy, every number computed live. One example runs through it: a camera that labels insects as bee, wasp or fly. Step 1, entropy: drag three bars for the probabilities p of the labels; each label's ideal code is log base 2 of 1 over p bits long, Huffman's whole-bit code is shown, and Send codes 24 randomly drawn labels; the average is the entropy H(p). Step 2, cross-entropy: the code is built for a guess q instead, so the average cost is H(p, q), never below H(p). Step 3: the extra bits are the Kullback-Leibler divergence, cross-entropy minus entropy, drawn as one bar per label; it is never negative, zero only when q equals p, and Swap shows it is not symmetric. Step 4: a classifier's three scores for a bee picture go through softmax, e to the score over the sum, into probabilities, and the loss is minus the natural log of the bee's probability. Step 5: the gradient of the loss with respect to each score is p minus y, derived by the chain rule and checked by finite differences, and Step takes a gradient step. Step 6: with two classes softmax becomes the sigmoid of the score gap and the loss becomes the logistic loss. Step 7: a temperature sharpens softmax toward the arg max or flattens it, and adding 1000 to the scores shows the naive formula overflowing to NaN while subtracting the largest score first still works. Step 8, try it: get the loss under 0.1 with the bee's score capped at 0, then set scores whose gradient is minus 0.4, plus 0.2, plus 0.2; the lesson checks each and explains why. The status shows the step and its key numbers.

A lesson in eight steps on loss functions, every number computed live from the formulas shown, on one example: a classifier that tells bees, wasps and flies apart. Step 1: one photo's three class scores as bars you drag; the multiclass hinge loss, the sum over wrong classes of max(0, s_j minus s_bee plus a margin delta), is exactly zero once every wrong score is delta below the bee's, while cross-entropy, minus the log of the softmax probability, is never zero; Learn runs gradient descent on the scores, and the hinge stops while cross-entropy keeps pushing. Step 2: one label with softmax, against many labels with a sigmoid and binary cross-entropy per class; tap the labels. Step 3: the 0-1 loss counts the mistakes of a line separating bees from the rest on 24 synthetic toy points; it is flat almost everywhere, so its gradient is zero and gradient descent cannot move, while the hinge loss's gradient can. Step 4: regression with absolute and squared error; dragging one outlier pulls the squared-error fit, the mean, but hardly the absolute-error fit, the median. Step 5: a structured answer, eight frames tagged, where the Hamming distance counts wrong frames and the 0-1 loss only says wrong. Step 6: slices of a real linear classifier's loss along one or two random directions in weight space, as a curve or a map. Step 7: hinge, logistic and square losses drawn against the margin t = y f(x) all lie on or above the 0-1 step, and the course's summary. Step 8, try it: make the hinge loss zero while cross-entropy stays above 0.5, then make the squared-error line slope downhill by moving one point; the lesson checks each and says why. The status shows the step and its key numbers.

A lesson in eight steps on convexity, every number computed live from the formulas. Step 1: an optimisation problem minimises f0 of x subject to constraints; a set is convex when the segment between any two of its points stays inside, shown with an ellipse, a polygon of half-planes and a crescent, and a map of least squares, linear programs, convex and general nonlinear problems. Step 2: a function is convex when every chord lies on or above its graph; drag two points and the point between them on x squared, e to the x, absolute value or a wiggly function and read the gap. Step 3: a differentiable convex function lies above each of its tangents, so a flat tangent marks the global minimum. Step 4: a twice differentiable function is convex exactly when its second derivative is never negative; in several dimensions the Hessian must be positive semidefinite. Examples: x to the fourth, x log x, log of 1 plus e to the x, and the sigmoid, which is not convex. Step 5: balls released anywhere roll downhill by gradient descent; on x squared they all reach the same minimum, on the wiggly function they end in different valleys. Step 6: non-negative weighted sums, pointwise maxima and affine changes of variable keep convexity; negative weights, minima and non-affine insides can break it. Step 7: in deep learning Wx and ReLU are convex, but the loss of a small ReLU network over its two weights is not: two perfect minima that are copies of each other under swapping the hidden units, valleys where a unit is dead, and a plateau. Step 8, try it: find a chord that passes below the wiggly function, then the smallest weight decay that makes it convex; the lesson checks each and says why. The status shows the step and its key numbers.

A lesson in eight steps on what makes a loss surface hard and how momentum helps, every number computed live. Step 1, local minima: 140 small ReLU networks of 1 to 32 hidden units learn the same curve from 20 random starts each; small networks stop at many different, often poor, losses, while large ones all end low, as Choromanska and colleagues argued in 2015. Step 2, saddles and plateaus: the loss of a two-weight linear network, one half of (1 minus w1 times w2) squared, drawn as a surface you can turn; gradient descent rolls in along the ridge, stalls at the saddle point, then escapes, and a Newton step is drawn toward the saddle. Step 3, valleys: in a long narrow valley with curvatures 0.02 and 1, gradient descent must keep the learning rate below 2 and zigzags across while creeping along the floor. Step 4, cliffs and exploding gradients: the loss of a one-neuron recurrent network from Pascanu and colleagues, 2013; on the wall the gradient explodes and one step throws the weights off the map, and gradient clipping with a threshold tau prevents it. Step 5, momentum: v becomes mu v minus eta times the gradient, then theta adds v, shown with velocity and gradient arrows beside plain gradient descent. Step 6, the heavy ball with friction: mu is one minus the friction; a slider shows too little momentum crawling and too much overshooting, with the steps to settle against mu. Step 7, Nesterov momentum: the gradient taken at the look-ahead point, in two equivalent forms that trace the same path, and how it matches classical momentum when the learning rate is small. Step 8, try it: choose mu and eta so momentum settles at the bottom within 40 steps without climbing above the rim; the lesson checks each try and says why. The status shows the step and its key numbers.

A lesson in eight steps on learning rates and adaptive optimizers, every number computed live. The demo run is a small network with one input, 16 tanh units and one output, fitting 64 noisy points by stochastic gradient descent, four points a step. Step 1: a dial sets the learning rate; too small crawls, a middle rate learns fast, and too large makes the loss blow up; a dashed line shows the edge two over lambda, from the steepest curvature of the loss. Step 2: on a bowl where one weight's gradient is 100 times the other's, a single rate must stay below 0.02 and the other weight crawls, while one rate per weight finishes in one step. Step 3: schedules drawn above the loss they give: step, exponential and one over t decays, cyclic, cosine with restarts, and a warm-up. Step 4: batch size and learning rate: the same rate, the square-root rule and the linear rule with and without warm-up. Step 5: Adagrad, RMSprop and RMSprop with Nesterov momentum on the bowl, with each weight's own rate plotted. Step 6: Adam, its bias correction, and Reddi's trap where Adam converges to the wrong end while ADOPT, from NeurIPS 2024, does not. Step 7: every optimizer tuned on the demo run, and the slides' sum-up checked against the numbers. Step 8, try it: pick a schedule, warm-up and peak rate that reach loss 0.02 in fewer epochs than the best constant rate; the lesson checks the run and says why.

A lesson in eight steps on descent methods, every one run live on one small problem: a line y = w x + b fitted by least squares to 240 generated points, whose loss over the weights w and b is drawn as contour ellipses. Step 1: full-batch gradient descent, mini-batch descent with 16 points and stochastic gradient descent with one point run an epoch each from the same start; the per-batch gradients are drawn as arrows, and in one epoch the full batch takes 1 step, the mini-batch 15 and SGD 240. Step 2: batch size; the spread of the batch gradients shrinks like one over the square root of B, the steps per epoch fall as 240 over B, and the papers of Keskar and colleagues and of Takase and colleagues on generalisation and stability are summarised. Step 3: Newton's method in one dimension fits a parabola using the first and second derivatives and jumps to its bottom, x minus f prime over f double prime, which is Newton's root finder applied to f prime; a toggle shows the root finder on f instead. Step 4: Newton's method with the Hessian lands on the minimum of the quadratic loss in one step, with no learning rate, but the Hessian has n squared entries. Step 5: Rprop uses only the sign of each partial derivative and a step size per parameter that grows by 1.2 or halves; rescaling the loss changes gradient descent but not Rprop. Step 6: steepest descent with exact line search, where each new gradient is perpendicular to the last step, so the path zigzags. Step 7: conjugate gradient picks A-orthogonal directions and reaches the minimum in 2 steps, against 25 for steepest descent; a stretch of the plane turns the ellipses into circles and the conjugate directions into perpendicular ones. Step 8, try it: start Newton where it ends on the local maximum, then aim a direction from the first point so that one line search lands next to the minimum, with a live readout of how many degrees it is off and buttons that turn it by 1 degree; after a miss each task shows a hint, and the lesson checks each and explains why. The status shows the step and its key numbers.