From-scratch mini-apps, free to download.

Walk through what you want to remember.

WebGL memory palace with a pure, framework-free SM-2 spaced-repetition scheduler kept apart from the scene - 8 tests pin the interval ladder, ease floor, and timezone-safe due dates.

Light, traced by hand.

A CPU ray tracer with Vec3 algebra, ray-sphere intersection, Phong shading, hard shadows, recursive mirror reflections, and 2× supersampling AA. 13 tests on the core intersection and shading math.

See exactly what changed.

An LCS dynamic program + a forward backtrack into an equal/add/del edit script - the algorithm behind git diff, from scratch. 7 tests incl. the reconstruction invariant.

Spot the bait before you bite.

Emails are typed data, not HTML: any element can carry a severity-rated flag, so the difficulty curve and the hover-to-teach UI both fall out of one model.

Formulas that flow.

A pure formula language (tokenize → Pratt parse → evaluate; refs, ranges, SUM/AVG/MIN/MAX) plus a Sheet that resolves recursively - dependency-ordered recalc + cycle detection for free. 11 tests, no DOM.

Settle up with the fewest moves.

Net everyone to a single balance in integer cents, then greedily match creditors to debtors - at most n−1 transfers. 10 tested invariants keep the books exact.

It sees your move coming.

From-scratch minimax with alpha-beta pruning and centre-biased move ordering, with a live “positions searched” counter. 13 tests, including that alpha-beta returns the identical move to plain minimax while visiting far fewer nodes.

Your words. Yours alone.

Web Crypto E2E: passphrase → PBKDF2 → non-extractable AES-256-GCM; storage holds only ciphertext, and 'a wrong passphrase can't decrypt' is a tested invariant.

Numbers without a ceiling.

Sign-magnitude big integers over base-10⁷ limbs: schoolbook add/multiply, long division, fast exponentiation, factorial, and fast-doubling Fibonacci. 14 tests using native BigInt as the oracle across hundreds of random operations.

A regex engine that won't backtrack.

A Thompson-construction regex engine: parse → NFA → set-of-states simulation, with bounded quantifiers. 16 tests, including that the “evil” pattern (a|aa)*c matches 60 a's in well under a millisecond.

A fake API in seconds.

Pure Node, zero deps: seeded generator + in-memory store + a pure router (tested without sockets). Collections support filter/search/sort/paginate (X-Total-Count); latency/error simulation built in.

Revenue, divided fairly. Automatically.

A trustless pull-payment splitter (native + ERC-20) with 25 Foundry tests incl. fuzz; the frontend visualises the split as a live flow diagram.

Simple rules, complex life.

Conway's Game of Life (B3/S23, toroidal) plus the 256 elementary 1-D rules as a space-time diagram. 12 tests against the canon - Rule 90 = left XOR right, the glider's period and travel.

Cron, in plain English.

A from-scratch cron parser turns each field into a value set; matching honours cron's surprising day-of-month/day-of-week OR rule; 20 unit tests.

Release notes that read like a human wrote them.

Pure, tested Conventional-Commits parser → grouper → Markdown (9 tests, zero deps); an optional --narrate layer rewrites with Claude and falls back to an offline summary with no key.

People like you liked these.

Item-item CF, the approach Amazon scaled: cosine/Pearson similarity over a ratings matrix, then a k-nearest similarity-weighted prediction. No training - just similarity and a weighted mean. 13 tests, including the full “fan of Inception → Interstellar” scenario and an honest cold-start.

Source to stack.

A full pipeline - tokenizer → recursive-descent parser → single-pass bytecode compiler (slot resolution, constant interning, back-patched jumps) → 22-opcode stack VM. 18 tests, including agreement with an independent tree-walking interpreter.

Wrap the points in their tightest shape.

Andrew's monotone-chain hull, shoelace area, point-in-polygon, and segment intersection - all from the cross product. 13 tests, including a property-based fuzz that the hull is convex, encloses every point, and is minimal.

Nine by nine, solved by logic.

A pure Sudoku engine: constraint propagation (naked/hidden singles) + minimum-remaining-values backtracking, solution counting for uniqueness, hole-digging generation, and explained hints. 14 tests.

Music that writes itself.

Pure, tested music engine (Bjorklund Euclidean rhythms + seeded melodic walk + scales; 6 tests) feeding a from-scratch Web Audio synth via a lookahead scheduler. Never repeats.

A fingerprint for any data.

A from-scratch SHA-256 (padding, message schedule, 64 compression rounds) with an avalanche heatmap and a proof-of-work miner. 9 tests, cross-checked byte-for-byte against Node's crypto across all padding boundaries.

The same message, far fewer bits.

A complete Huffman pipeline (frequencies → tree → canonical codes → encode/decode) plus Shannon entropy, all pure. 13 tests, including the prefix-free property and the average-code-length ∈ [H, H+1) Shannon bound.

Sorted, with express lanes.

A skip list with coin-flip tower heights giving O(log n) search/insert/delete without rotations, plus range queries. 11 tests, including a 600-operation fuzz against a reference set.

Stay balanced, no matter what you add.

A textbook B-tree (split-on-insert, borrow/merge-on-delete) with a live invariant validator. 12 tests, including a 1000-operation fuzz cross-checked against a reference set with every invariant verified after each step.

Edit together, even offline.

Per-field LWW registers with Lamport (ts, site) clocks make merge commutative/associative/idempotent - the convergence laws are the tests (9). BroadcastChannel transport + an offline toggle.

Make sense of the slashes.

A hand-rolled regex lexer powers the explainer; ReDoS detection and native $-expansion replace mode round it out - all client-side, dependency-free.

Miss a beat, not the rhythm.

Streak state is derived from two stored statuses by a pure, unit-tested engine; daily habits get the repair mechanic, weekly habits a frequency-aware streak.

Learns a voice, then speaks in it.

A pure Markov text generator: tokenize → tally each n-gram's continuations → sample forward, weighted, from sentence-aware seeds. 13 tests, centred on the invariant that the generator never emits a transition it didn't see in training.

Find the shortest way.

A pure pathfinding core (BFS, Dijkstra, A*, greedy best-first) over a weighted 4-connected grid with a binary min-heap, returning both the path and the frontier visit order. 12 tests, including that A* with an admissible heuristic matches Dijkstra's optimal cost.

Resize an image by what matters.

From-scratch seam carving: a gradient-energy map + a min-seam dynamic program + pixel removal, all pure number-grid math (7 tests). Side-by-side content-aware vs naive scale.

A little language you can read.

Lexer → Pratt parser → tree-walking interpreter with closures + recursion, zero-dep. Now with arrays, while loops, assignment, and higher-order builtins (map/filter/reduce). run(src)→{output,result,error} makes the pipeline testable; 18 tests drive real programs.

Watch it learn.

A multilayer perceptron with backpropagation (tanh/ReLU, Xavier/He init, full-batch gradient descent), training live on XOR and concentric circles. 11 tests, centred on a finite-difference gradient check.

Find your breath.

A pure phaseAt(pattern, elapsed) engine (phase/countdown/cycle/orb-scale, skips zero-length holds; 6 tests) drives one animated orb; a hand-written manifest + cache-first service worker make it installable and fully offline.

Who matters in a network, and why.

A pure PageRank engine: the random-surfer step (teleport + dangling-mass redistribution) iterated to its fixed point, with nodes sized by rank and convergence you can scrub. 13 tests on the two defining invariants - ranks sum to 1, and they satisfy the PageRank equation.

Threads, cloth, and gravity - live.

Verlet integration (velocity = current − previous position) + distance-constraint relaxation; cloth emerges from one tiny rule applied to a grid of sticks. 6 tests on the pure physics.

Probably yes. Definitely no.

A from-scratch Bloom filter: k hashes by double hashing over a packed bit array, optimal m/k from a target error rate, and false-positive + cardinality estimators. 12 tests led by the two defining properties - no false negatives, and an empirical false-positive rate that tracks theory.

Worlds from noise.

Gradient (Perlin) noise with a quintic fade, summed over fractal octaves (fBm) into terrain coloured by height. 7 tests, including that noise is exactly zero at every integer lattice point.

The For-You feed, from the inside.

A pure feed ranker: affinity × interest × engagement, scaled by an exponential recency decay, then a greedy diversity re-rank with an author-repeat penalty. Flip ranked vs chronological and watch posts rise and sink. 12 tests on the scoring, interleaving, and explanations.

Check your passwords without exposing them.

Local entropy + reuse analysis plus the HIBP k-anonymity pattern: SHA-1 split into prefix/suffix, the suffix matched on-device. 19 tested assertions.

Every signal is a sum of sines.

A radix-2 Cooley-Tukey FFT (and inverse) with a Hann window, driving paired time- and frequency-domain views. 14 tests using the transform's own identities - Parseval energy conservation, exact inverse round-trip.

Paid when the work is done.

A guarded state machine (Created→Funded→Completed + Disputed + deadline reclaim) with access control and CEI - 18 Foundry tests incl. fuzz cover the full lifecycle. Demo-mode tracker frontend.

Know how well you actually know.

Pure, tested calibration math: Brier score + confidence-binned reliability diagram + an over/under-confidence read. Boundary cases pinned by 8 unit tests.

Everything, one keystroke away.

The latency-critical fuzzy + frecency engine is a pure Rust crate with 19 tests, isolated from the Tauri shell so \u201cis it fast?\u201d is answerable without a window.

Argue better. Lose gracefully.

Three independent model calls - a streaming opponent, a structured fallacy analyzer, and an impartial judge - keep each concern single-purpose and trustworthy.

Find the groups that were always there.

Lloyd's algorithm with k-means++ seeding, inertia, and best-of-N restarts, animated to convergence. 13 tests anchored on the monotonic-inertia guarantee and >95% recovery of well-separated blobs.

Watch a program run, one instruction at a time.

Two-pass assembler (labels → indices) + a ~20-opcode stack machine where execution is a pure step(program, state) - so the debugger just renders state. 8 tests run real programs (factorial loop, max via jumps).