The Lab is for exploring: learning how something works by running it — walk-throughs built around live simulations, code you can edit and run in your browser, small sketches, and the same program in many languages. Tools are for getting a job done; the Lab is for poking at ideas and seeing what happens.
Guided experiments: a question, live tools and code to try, and what the results show.
Exploration ·
How things work · part 1
Start with one transistor switching an LED, wire switches into gates, gates into an adder, feedback into memory, and memory plus a clock into a tiny CPU — then watch a real 6502 run a program you can read byte by byte.
Circuit simulatorDigital logic simulator6502 assemblerAtari 8-bit computer: emulator, BASIC, assembler and debugger
Exploration ·
How things work · part 2
From magnets and coils to a quadcopter in the air: how a brushless motor is wound, how an ESC switches it in six steps, how it finds the rotor without sensors, what field-oriented control does better, and what happens when you bolt four of them to a frame — with the simulators running alongside.
Brushless motors — inside and how they are drivenRC power setup — motor, prop and batteryFPV quad: build, rates, CLI diff and blackboxPID loop simulator
Exploration ·
How things work · part 3
Pull the plug on a database halfway through a write and it comes back with every committed transaction and none of the half-finished ones. How? Follow a write through the log, the buffer pool and the disk, compare B+trees with LSM-trees, watch compaction, and then see the other half of the promise — what concurrent transactions are allowed to see — with real PostgreSQL and SQLite running between the paragraphs.
Postgres playgroundStorage engines: LSM-tree vs B-tree, simulatedSQLite internalsIsolation lab
Exploration ·
How things work · part 4
Follow a parcel of air through a jet engine — squeezed, burned, expanded, thrown out of the back — with the cycle worked out live at every step, then see why airliner fans keep growing and why a car's turbocharger is a little gas turbine.
Jet engines and gas turbinesThermochemistryTurbocharger matching
Exploration ·
How things work · part 5
A red and white ball bouncing across a purple grid sold a computer. Take it apart with live tools — the copper and the beam, colour cycling, sprites and blitter objects, the cookie-cut blit, the fight for chip RAM, and Paula's boom — and see how a 7 MHz machine made it look effortless.
Shader playgroundCopper and blitter playgroundAmiga sprites and BOBsAmiga blitter labAmiga DMA slot timingPaula audio, MOD tracker and player
Exploration ·
How things work · part 6
Follow a query from the box you type it into to the ten blue links: how text becomes terms, how an inverted index stores and compresses them, how BM25 scores a match, how we know a ranking is any good, and how the whole thing is split across thousands of machines — with the tools running live between the paragraphs.
Analyzer and inverted-index playgroundPostings labRelevance and scoring explainerRanking metrics workbenchElasticsearch, simulatedSystem design interviews
Exploration ·
How things work · part 7
A jar of flour and water raises a loaf with no packet of yeast. Follow it from the microbes in the starter, through temperature, time, water and gluten, to the oven — with the sourdough, bread and artisan-bread tools open beside the text.
Sourdough starter and levain plannerBread and baker's percentagesArtisan bread
Pages of code to edit and run, by language.
Playground
Edit the code and run it in your browser — a quick demonstration of the site's playgrounds.
JavaScript · Python · HTML
Playground
BQN, a modern APL, in your browser — whole-array primitives, folds and scans, tables, and tacit trains like (+´÷≠) for the mean.
BQN
Playground
Real Clang, compiled to WebAssembly, building and running C and C++ programs entirely inside your browser.
C · C++
Playground
Clojure in your browser through Scittle — immutable data, lazy sequences, transducers, threading macros, atoms, and multimethods.
Clojure
Playground
Two famous esoteric languages to run in your browser — Brainfuck's eight commands on a byte tape, and Befunge's program counter wandering a 2-D grid.
Brainfuck · Befunge
Playground
A small Forth that runs in your browser — the data stack, defining new words, loops, and memory, in the language that fits in 8 KB.
Forth
Playground
Modern Fortran compiled in your browser by LFortran — whole-array arithmetic, matrix intrinsics, modules and derived types, and a numerical kernel solving the heat equation.
Fortran
Playground
Edit Kotlin here and JetBrains' Kotlin Playground compiles and runs it — data classes, null safety, sealed types with when, extension functions, sequences, and coroutines.
Kotlin
Playground
Lua 5.4 running as WebAssembly — coroutines, metatables, and string patterns you can edit and run.
Lua
Playground
The OCaml 5 toplevel in your browser — type inference, pattern matching, variants, records, and modules with functors.
OCaml
Playground
Perl 5 running as WebAssembly in your browser — regular expressions, hashes, text munging, and the context rules that make Perl Perl.
Perl
Playground
PHP 8.4 running as WebAssembly in your browser — its do-everything arrays, the string library, match, enums, readonly classes, and generators.
PHP
Playground
Logic programming with SWI-Prolog compiled to WebAssembly, and Lisp-family functional programming with Scheme — both live in the page.
Prolog · Scheme
Playground
Real R running in your browser through webR — vectors, data frames, a linear model with its summary, simulation, and base-graphics plots.
R
Playground
Classic line-numbered BASIC, the way the 8-bit machines did it — PRINT, INPUT, GOTO, GOSUB, and a lunar lander to fly.
BASIC
Playground
CRuby 3.4 with its standard library, running as WebAssembly — blocks, Enumerable, pattern matching, and Data classes.
Ruby
Playground
Edit Rust and Go here; they are compiled and run by the official Rust and Go playgrounds, with the output shown in the page.
Rust · Go
Playground
Two real database engines compiled to WebAssembly — SQLite for everyday SQL and DuckDB for analytics on your own CSV and Parquet files.
SQLite · DuckDB
Small visual experiments: shaders, generative drawings, canvas toys.
Playground
A WebAudio toy that improvises a melody with a random walk over a pentatonic scale, plus a drone and an echo — silent until you press Play.
HTML
Playground
Four decaying pendulums steer a pen; frequencies near simple ratios draw the spirograph-like curves Victorian harmonographs were famous for.
p5.js
Playground
A whole 3-D scene — a blobby shape on a checkered floor, soft shadows, an orbiting camera — drawn by one fragment shader with no triangles at all.
GLSL
Playground
Craig Reynolds' flocking model — three local rules per bird, and a flock emerges; the mouse is a predator.
p5.js
Playground
Thousands of particles drifting through a Perlin-noise vector field, leaving trails that pile up into silk.
p5.js
Playground
A few rewriting rules and a turtle grow a meadow of plants that are never quite the same twice.
p5.js
Playground
Conway's Game of Life where live cells are coloured by age and dead ones leave a fading ghost, so you can see where the action has been.
p5.js
Playground
The Gray–Scott model — two imaginary chemicals that spread and react — grows coral, fingerprints and dividing cells from a few drops.
HTML
Same program, many languages — one task written side by side, each runnable.
Playground
A recursive-descent JSON parser and pretty-printer, written from scratch in thirteen languages — how each one represents "a value that could be anything", reports errors, and handles strings, escapes and Unicode.
JavaScript · Python · Ruby · Lua · PHP · Perl · Clojure · C · Rust · Go · Kotlin · OCaml · Prolog
Playground
The smallest interesting program, written the way each language would write it — from JavaScript and Rust to SQL, Prolog, BQN, Forth and a Befunge maze. Every block runs and prints the same twenty lines.
JavaScript · Python · C · Rust · Go · Kotlin · Ruby · Lua · PHP · OCaml · Clojure · Scheme · Prolog · SQLite · R · BQN · Forth · BASIC · Befunge
Playground
The same five-body gravity simulation in fifteen languages, each timing itself — a hands-on look at how much the runtime matters when the program is all floating-point arithmetic in a tight loop.
C · C++ · Fortran · JavaScript · OCaml · Clojure · Python · Ruby · Lua · PHP · Perl · R · Rust · Go · Kotlin
Playground
Nested loops and floating-point arithmetic in eighteen languages — plain loops, complex numbers, whole-array versions in R and BQN, and a recursive query in SQL — all drawing the same 66 × 23 picture, character for character.
JavaScript · C · Rust · Go · Kotlin · Lua · Ruby · PHP · Perl · Python · C++ · Fortran · R · BQN · OCaml · Clojure · SQLite · BASIC
Playground
Count the words in a paragraph and list the ten most common — split, count, sort — in fifteen languages, from one-line pipelines in Ruby and Clojure to a hand-rolled hash table in C and a recursive string split in SQL.
JavaScript · Python · Ruby · Clojure · Kotlin · R · Perl · PHP · Lua · OCaml · C · Rust · Go · SQLite · DuckDB
Open-ended tools that live under Tools but are made for experimenting.