The Lab.

Every dot remembers its home. Each frame its target becomes home plus a pull toward the cursor, capped at min(42, 3000/d) — an inverse-distance field. A damped spring integrator chases that target, which is why the field overshoots and wobbles back instead of snapping.

Each word is rasterised to an offscreen canvas, then alpha-sampled every 3px into a target list. Every particle is assigned a target with a prime-number stride (i × 7919 mod n) so neighbours scatter instead of clustering, then eases 7.5% of the remaining distance per frame.

Semi-implicit Euler with impulse collision response: overlapping seals are separated along the contact normal, then the relative velocity along that normal is reflected with restitution 0.82. Your throw velocity comes from a five-point pointer history sampled at release.

There is no trick. Your keystrokes land in a style tag and the browser's CSSOM re-cascades in real time. The demo card is just markup — which is the point: this is how every custom build works underneath.

The legendary donut.c, reimplemented. Points on a torus (two angles), rotated by two rotation matrices, perspective-projected with 1/z, z-buffered per character cell, and lit by the surface normal — luminance indexes into the ramp .,-~:;=!*#$@.

Three accumulators per boid, computed over every neighbour within 70px: separation (inverse-square push), alignment (velocity matching) and cohesion (pull to the local centroid). Your cursor injects a fourth force — flee — and speed is clamped to 60–170 px/s so panic still looks graceful.

Recursive midpoint displacement: split the segment, shove the midpoint sideways by ±disp, halve disp, recurse. A 16% branch chance spawns forks with doubled offset. Each bolt is stroked twice — a fat red glow underneath and a thin hot core on top — then fades out in under half a second.

Rockets decelerate under gravity until apex, then burst into 70–130 sparks with random heading and speed. Sparks feel real because of three cheats: per-spark drag (0.985), gravity, and drawing onto a canvas that is faded instead of cleared — which is where the trails come from.

A value-noise field turned into wind: the angle at any point is noise(x, y, t) × 4π. Sixteen hundred particles are advected through it at 70px/s, each drawing a 1px segment from where it was to where it is. The canvas fades 5.5% per frame, so the rivers linger.

The classic constellation, hand-rolled: every pair of nodes is tested each frame (O(n²), 3 570 pairs, still trivial for a modern CPU) and edges fade in with proximity. Edges to your cursor get the brand treatment.

One object per column: a head position and a fall speed. The head glyph is drawn bright, one behind it in red — and that's it. The iconic trails aren't stored anywhere; they're the ghost of previous frames left behind by a 13% translucent fade.

Textbook wave interference: the height at any point is the sum over every stone of sin(0.11d − 7·age) attenuated by e^(−0.006d − 0.9·age). Sampled on a 15px grid; |height| maps to dot size and brightness, and crests above 0.55 turn red.

Metaballs without marching squares: blobs are drawn as soft radial gradients at quarter resolution, then composited through blur(14px) contrast(24). The blur merges their fields; the contrast thresholds the result into clean liquid edges. Two CSS filters doing the work of an isosurface algorithm.

Verlet integration: each point stores only position and previous position — velocity is implied by their difference, which makes cloth stable almost for free. Three constraint iterations per frame pull neighbours back to rest spacing. The wind is noise-scaled force, and your cursor transfers its velocity on contact.

The same verlet trick as the flag, but run through fourteen constraint iterations — more iterations equals stiffer rope. The grabbed node is pinned to your pointer during the solve, and both anchors stay locked, so tension propagates realistically along the chain.

The full double-pendulum equations of motion — the 2 − cos(2Δ) denominator form — integrated with three substeps per frame for stability. The five pendulums start 0.002 radians apart. Watching their trails split is watching sensitive dependence on initial conditions, live.

Newtonian gravity toward the sun: a = GM/d², semi-implicit Euler. Thrown planets get a tangential velocity of √(GM/d) times a random 0.75–1.1 — exactly circular-orbit speed, fuzzed. Under it: stable orbits, ellipses and the occasional dramatic escape.

Conway's B3/S23 on a toroidal Uint8Array, double-buffered, stepped every fourth frame. An age array colours newborn cells red, fading toward paper as they survive. If population drops below 1.5% the grid quietly reseeds — extinction is off-brand.

Two classic algorithms chained: a stack-based recursive backtracker knocks down walls to carve a perfect maze, then breadth-first search records every cell's distance from the entrance. The flood you watch is the BFS visit order replayed six cells per frame; the path walks backwards down the distance gradient.

The quicksort runs once, instantly, on a hidden copy — recording every swap into a log. What you watch is the log replayed four swaps per frame on the visible array. Visualising algorithms is mostly time travel.

Stars live in a unit cube with a shrinking z. Screen position is (star − steering) / z × focal — as z approaches zero the division flings positions outward, which is the entire hyperspace effect. Each streak is a line from the previous frame's projection to this one's.

The head is a damped spring chasing your cursor. Every segment behind it is solved with one-pass inverse kinematics: place yourself at a fixed distance along the direction to your predecessor. Tapered radii and two eyes on the velocity vector do the character design.

Each filing eases its angle toward atan2(dy, dx) + 90° — the tangent of a circle around your cursor, which is roughly what iron does around a pole. The easing uses shortest-path angle wrapping so filings never spin the long way round.

Seventeen rows, drawn top to bottom. Each is a value-noise line whose amplitude is shaped by a gaussian envelope (big in the middle, flat at the edges). Filling below every line with the background colour before stroking it paints the occlusion — fake 3D for the price of a fill call.

A harmonograph: x(t) and y(t) are each sums of two damped sine waves with random frequencies and phases. Seventy points are appended per frame with no clearing, so the pen literally draws. When the decay envelope dies below 4%, it picks new parameters and starts again.

Pure reflection physics — velocity components flip independently at the walls. A corner hit is both axes clamping in the same frame, and the maths makes that genuinely rare, which is why the counter matters. The tint cycles on every wall hit, as tradition demands.

The ball gains 6% speed per return and deflects by where it strikes the paddle (vy += offset × 6), so placement is strategy. The AI chases the ball with a capped speed plus a sine wobble — deliberately imperfect. If it never lost, you'd stop playing.

One triangle oscillator per press, shaped by a gain envelope — an exponential ramp up in 12 milliseconds and out over 650. No samples, no files: the browser synthesises every note. The scale is pentatonic, so wrong notes are mathematically impossible.

Your pointer draws circles with globalCompositeOperation destination-out, which erases alpha instead of painting. Every 0.8 seconds a strided getImageData pass counts how much is gone; past 45% the panel concedes and fades itself out.

A dictionary of commands, one input and an HTML printer. That's the whole shell. The sudo response is hand-written because the alternative was you not trying it, and we both know that was never going to happen.

Stars sit at random radii with angular velocity proportional to 1/√r — inner stars lap outer ones and the density waves your brain reads as arms emerge on their own.

Each flake falls with noise-driven sway. The floor is a height-map array: when a flake lands, its column grows — which is why drifts form under where the wind funnels them.

Drops are drawn as motion streaks (a line along their velocity). On impact each spawns three or four short-lived splash particles with upward velocity — that detail is 90% of the realism.

Bubbles rise with a phase-offset sine sway. Touching one replaces it with an expanding, fading ring — the pop is one arc with a growing radius and a dying alpha.

Each bee accelerates toward the cursor but keeps its momentum, so it orbits and overshoots instead of arriving — steering behaviour with deliberately bad brakes.

Particles stream left to right; near the cursor their velocity gains a perpendicular component scaled by 1/d — the same maths as air around a wing, give or take a physics degree.

While the pointer is down it emits 12 sparks per frame with random velocity, gravity and a lifetime. The trail is the usual translucent-fade trick — nothing is stored, everything is memory.

Each drag stamp is a soft radial gradient composited with 'lighter', so overlapping strokes sum into brightness. The canvas is never cleared and is exempt from the memory reclaimer.

Every grain checks down, then down-left or down-right, one cell per tick. That three-line rule is the entire physics of sand — slope angles and avalanches are emergent.

On white turn right, on black turn left, flip the cell, move forward. After ~10 000 steps of apparent chaos every Langton's ant builds a diagonal highway — an unproven-in-general, universally observed mystery.

Each ball is a pendulum solved with angular acceleration −g/L·sin θ. Collisions between neighbours swap angular velocities — which for equal masses is exactly what elastic collision maths collapses to.

The trampoline is a pinned verlet string. When a ball penetrates it, the nearest points get pushed down (stretching the string) and the ball gets the string's displacement back as upward velocity next frame.

The ball is a driven pendulum; crates are boxes that take an impulse when the ball's swept circle crosses them, with torque from the hit offset. They respawn after a decent interval of rubble.

Each domino rotates around its base corner once triggered. When its top edge sweeps into the next one's space, that one starts tipping too — the delay between falls is just geometry.

The water surface is summed sines. Submerged depth drives an upward force proportional to displacement (Archimedes), drag slows everything, and the bobbing frequency falls out for free.

Every pair feels a force ±k/d² along their separation vector, sign by charge product. Clicking negates all charges, which instantly turns clusters into explosions — physics' best party trick.

Each gear is drawn parametrically (teeth as radial bumps). Angular velocity chains through the mesh: ω₂ = −ω₁ × T₁/T₂ — the minus is why adjacent gears counter-rotate.

Fifteen verlet points with hard distance constraints (eight solver iterations) make the links rigid. Mass is fake — heaviness comes entirely from damping and gravity tuning.

Skin nodes connect to neighbours with springs; an internal pressure force pushes outward along each node's normal, scaled by how compressed the area is versus rest. Springs pull in, pressure pushes out — the argument is the wobble.

Pure kinematics: the crank pin moves on a circle and the piston position solves the rod-length triangle. One line of trig every engine textbook opens with.

Both search the same maze in parallel strides. BFS explores in distance order and guarantees the shortest path; greedy chases the goal by straight-line distance and sometimes pays for its optimism. The scoreboard keeps receipts.

Random points land in a square; the fraction inside the inscribed circle approaches π/4. Accuracy grows with √n, which is why the third decimal takes forever — a very honest algorithm.

The grid strikes multiples of each prime in turn — the animated version of the fastest simple way humanity has to find primes. Red sweeps are composites dying; the pale survivors are the primes.

Each square's side is the sum of the previous two; each contributes a quarter arc. The arcs approximate a golden spiral because consecutive Fibonacci ratios converge on φ.

For every pixel, iterate z = z² + c until it escapes or the budget runs out; the escape speed picks the colour. Clicking re-centres and shrinks the window by 3× — computed fresh, because storing images would be cheating.

Same iteration as the Mandelbrot but c is a constant shared by all pixels — and here c orbits slowly, dragging the whole set through its family of shapes. Rendered at low resolution and upscaled, because art forgives pixels.

Your stroke is resampled and pushed through a discrete Fourier transform, decomposing it into rotating vectors sorted by amplitude. Summed tip-to-tail they retrace your drawing — proof that any squiggle is secretly a sum of circles.

Numbers spiral outward from centre; primes get a dot. The diagonal streaks correspond to prime-rich quadratics like n²+n+41 — observed since 1963, still without a complete explanation.

A cubic Bézier point is nested linear interpolation: lerp the four controls pairwise, then those results, then once more. The animated scaffolding shows all three layers meeting at the curve point.

Each coarse cell asks which drifting seed is closest and takes its colour; boundaries are where two seeds tie. Computed brute-force per frame because n is small and honesty is cheap.

Each worm's heading eases toward the value-noise angle at its position — same field as the Currents exhibit, but the trail persists, so you watch the field's topology get slowly discovered.

Chemical A feeds in, B eats A and B decays, both diffuse at different rates. Iterated on a coarse grid several times per frame, those rules alone paint every animal you've ever seen — Turing patterns, live.

Random starters have their full hailstone path traced as a polyline (height = value, log scale). The Collatz conjecture — that every path reaches 1 — has been checked past 2⁶⁸ and proven never.

Hours, minutes and seconds are drawn as bit columns — each dot is one bit of the current time. The blink you see every second is the least significant bit doing its job.

Each letter shifts N places around the alphabet, wrapping at Z — encryption a schoolchild can break and an emperor trusted. The slider is the entire key space, which is precisely the problem.

The phrase is drawn letter by letter, each with y = sin(t·speed + index·gap)·amp. Coherent motion from independent parts — the entire concept of a wave in one line.

Each glyph is measured, positioned, then — on click — handed velocity, spin and gravity, bouncing on the floor until it settles into rubble. A second click restores the sentence, because kaizen.

Each ring places its characters around a circle with per-character rotation, then the whole ring turns — outer clockwise, middle counter, inner slow. The renderer is save/rotate/translate/fillText, forty times.

Three line templates draw from word banks whose entries carry syllable counts, so every poem scans 5-7-5. Meaning is the reader's job — same as all poetry.

Value noise sampled on a character grid indexes into a density ramp from space to @. It's the Donut's lighting trick applied to weather — proof that any scalar field can be typeset.

The ball reflects off axis-aligned boxes; which axis flips depends on the shallowest overlap. Paddle hits add english proportional to strike offset — the entire skill ceiling of the genre in one line.

Before each move the snake BFS-searches from head to food, treating its own body as walls. Optimal until the board fills and its body becomes the maze — machine hubris, visualised.

Mines are placed only after your first click, excluding it — that's the classic mercy rule. Zero-cells flood-fill their neighbours recursively, which is why one click can crack half the board.

Each round appends a random pad and replays the whole sequence with synthesised tones (one oscillator per note). Your job is echoing it back; the loop's job is outlasting you. It will.

Seals rise from random holes on a shrinking timer, hittable only while up. Score-chasing is pure human-benchmark: the spawn window tightens 4% per hit until your mouse hand files a complaint.

Gravity pulls, clicks set a fixed upward velocity, pipe gaps scroll past at constant speed. The genre's cruelty is that both your inputs and the physics are perfectly deterministic — every death is yours.

A random 1–3s wait arms the trigger; clicking early resets it with appropriate shame. The measurement is one subtraction — performance.now() at colour-flip versus at click.

Every keystroke diffs your input against the target — greens, reds and a WPM computed as (correct chars / 5) per elapsed minute, the standard nobody agreed on but everyone uses.

A tiny state machine: at most two cards face-up; a match locks them, a miss flips both back after 700ms of public embarrassment. The flip is scaleX through zero — cardboard 3D.

Minimax recursively scores every reachable position — win +10, loss −10, depth-adjusted so it prefers quick wins and slow losses. Noughts and crosses has 5 478 positions; the machine holds all of them at once.

The vertices are rotated by X and Y matrices, then projected by dividing by depth. Drag velocity becomes angular velocity with momentum — the throw is the feature.

Points are distributed by the golden-angle spiral (the only way to spread points evenly on a sphere without a committee), rotated in 3D and alpha-faded by depth.

Rings shrink toward a vanishing point that eases toward your cursor; when one collapses it respawns at the far end. Fifteen circles pretending to be infinity, successfully.

Layer one is static lines; layer two is the same grating rotated by a slowly oscillating angle. The bands are spatial beat frequencies — the same maths as two guitar strings slightly out of tune.

The cloud rotates through a small oscillating angle. Motion parallax — near points moving more than far ones — is enough for your visual system to reconstruct depth. Stereo vision, single eye edition.

Horizontal lines are spaced by perspective (y ∝ 1/row) and scroll by recycling; vertical lines converge on the vanishing point. The sun is a gradient circle with gaps — the whole genre in 40 lines.

Every stroke point is stamped eight times: rotated into each 45° sector, alternating mirrored. The symmetry group does the artistry; you just have to move.

Each frame is the previous scaled by a constant ratio; all of them grow together and the largest is culled as it passes the viewport. An infinite zoom needs only six rectangles and a modulo.

The text is drawn, then covered in darkness except a radial gradient hole at your cursor (destination-out). Information architecture reduced to a flashlight — surprisingly tense.

Each layer offsets by cursor distance × its depth factor (0.02 to 0.14). Nearer layers move more — the monocular depth cue every scrolling site borrowed and few credit.

Each branch spawns two children — shorter, tilted apart by a per-tree angle. Ten levels deep is 2 047 branches, swaying by noise sampled per depth so the canopy moves more than the trunk. Genetics is one random seed.

Walkers jitter randomly; contact with the frozen cluster freezes them too. Branches emerge because tips catch walkers before gaps do — growth mathematics with zero blueprint, maximum coral.

Random candidate points grow radius until touching any existing circle or the walls. Rejection plus growth fills space with the classic packing texture — the algorithm behind a thousand data-viz posters.

Every tile holds two quarter-arcs in one of two orientations; edges always meet, so any random grid connects into mazes. A few tiles flip per second and locally rewire the entire labyrinth.

When k is an odd integer you get k petals, even integers give 2k, fractions bloom into overlapping laces. Here k drifts continuously so the rose never stops re-deciding what species it is.

Gielis' superformula generalises the circle with six knobs; small changes in m and the exponents jump between petals, polygons and organisms. The outline you're watching is one equation surfing its own parameter space.

Each point feeds through x' = sin(a·y) − cos(b·x), y' = sin(c·x) − cos(d·y) and lands somewhere new on the same ghostly shape — chaotic orbits with additive glow, thousands per frame.

Three building layers scroll at different speeds; windows are a random bitmask per building, lit amber with a small flicker chance. Every click reseeds the skyline generator — instant metropolis.

A handful of bright stars get connected by a greedy nearest-neighbour walk (the same way ancient astronomers freelanced), then a two-part name grammar christens it. Astrology, procedurally honest.

One hundred K-seals with confetti physics, a counting ticker and the entire page's thesis in one sentence. The code is the same playroom gravity you met 97 exhibits ago — by now, an old friend.