What's new

Every new lesson, feature, and improvement — newest first.

  1. November 1, 2026

    • New lessonMatrix Multiplication — fill each result cell with a row · column dot product, then swap the same two matrices to see how order can change the product's shape.

  2. October 31, 2026

    • New lessonPrefix Sums — answer each range-sum query with two prefix reads and one subtraction, then change an input value to see which later totals need repair.

  3. October 30, 2026

    • ImprovementFinished the animation review that began in September: all 175 lessons were checked for correct results, narration, canvas state, code highlighting, and quiz answers, and the mistakes it found were fixed.
    • ImprovementTwenty more lessons with an Inputs panel now offer Save and Saved inputs, and an outdated or hand-edited share link falls back to the default inputs instead of loading invalid values.
    • ImprovementInteger inputs now reject values like 1.5 and 1e2 instead of quietly running them as 1, and input errors follow the interface language and are announced to screen readers.
    • ImprovementResizing the window no longer resets playback position or speed or exits Quiz, and Look back stays available after an answer is revealed so you can move the card off the canvas.

  4. October 8, 2026

    • FeatureHand-drawn controls and cards are now the default, with a settings page for interface style, language, canvas background, and Log visibility.
    • ImprovementLessons, the learning path, and the library now share a navigation rail, while desktop lessons arrange the canvas, player controls, and Code / Inputs / Log cards on one paper sheet.
    • ImprovementSharing, embedding, PNG export, and video export now live in one Share menu.
    • ImprovementThe lesson sidebar remembers its open state and collapsed categories, and the catalog, sidebar, and learning path show only ready lessons.

  5. October 7, 2026

    • ImprovementTCP Handshake and Big-O now animate state and color changes through each step, with earlier states receding as the current one takes focus.
    • ImprovementFixed clipped grid and dot-paper edges, hand-drawn card borders disappearing in production, and playback sliders missing accessible names.
    • ImprovementFixed Chinese and Japanese Markdown formatting and corrected lesson explanations, category introductions, and card descriptions.

  6. October 5, 2026

    • ImprovementQuiz now pauses after each step's animation settles, question selection no longer depends on input randomization, the log retains consecutive steps with identical labels, and the sidebar reveals the current lesson on navigation.

  7. October 4, 2026

    • ImprovementFeedback now goes to GitHub Issues, where you can report problems, suggest improvements, and follow their progress.

  8. September 24, 2026

    • ImprovementStarted an ongoing review of lesson animations, refining sorting, string, backtracking, and search lessons in batches and continuing through the rest of the catalog.

  9. September 22, 2026

    • New lessonMonotonic Stack — keep unresolved indices in decreasing value order for Next Greater Element; each index enters once and leaves at most once, so the nested `while` stays O(n), and equal values wait for a strictly greater one.

  10. September 21, 2026

    • New lessonMessage → Distributed Consensus — follow one command from client delivery through Raft replication, commitment, and application, then drop the response to show why a client timeout can follow a successful write.
    • New lessonSQL Query → Disk Read — turn a query into a plan, page requests, buffer-pool checks, and returned rows; the same lookup costs three cold reads first and zero additional reads when those pages are cached.

  11. September 20, 2026

    • New lessonAutoencoder — reconstruct held-out digits through two- and eight-coordinate latent codes, then feed the digit-trained decoder a checkerboard to show why a wider code cannot recover an unfamiliar pattern.

  12. September 19, 2026

    • New lessonPolicy Gradient — use REINFORCE to adjust action probabilities from one sampled episode's return, including a correct update that lowers the immediate chance of reaching the goal from 25% to 24.6%.
    • New lessonDiffusion Models — contrast one denoising estimate that averages plausible origins into an empty center with repeated denoising steps that recover samples near all eight data groups.
    • New lessonGAN — train a generator against a discriminator, then separate plausible individual outputs from distribution coverage: fooling the judge is not enough when the generator drops modes.

  13. September 18, 2026

    • New lessonMCP Plugin — route built-in tools to local implementations and external tools through an MCP client, while the plugin server keeps the executable implementation behind the advertised tool contract.
    • New lessonQ-Learning — update one Q-table entry from the observed reward and the best next-state estimate, then revisit earlier states until a delayed reward propagates backward through experience.

  14. September 17, 2026

    • ImprovementVideo export now requires Lifetime; sharing, embedding, and watermarked PNG export remain free.
    • ImprovementVideo export explains the recording steps before starting and shows a cancellable notice outside the player controls.

  15. September 16, 2026

    • New lessonBackground Tasks — launch a command in a detached shell, return its handle immediately, and deliver completion into the agent's context at the next turn boundary rather than interrupting a response in progress.
    • New lessonAgent Teams — coordinate private agent contexts with a shared task board and mailboxes, proving that a completed dependency does not transfer its interface contract until a message reaches the teammate that needs it.

  16. September 15, 2026

    • New lessonPlan Before Acting — keep a checklist of intended work beside the tool results that prove completion, so a failed check remains visible until the plan records its repair and new evidence.
    • New lessonSystem Prompt Assembly — assemble identity, tool guidance, runtime facts, and a skill catalog into system instructions while keeping tool definitions and conversation context separate; a file on disk contributes nothing unless the harness loads it.
    • New lessonError Recovery — classify a failed model call before retrying, then repair the cause by waiting, compacting context, raising the output budget, switching models, or stopping instead of sending the same broken request again.

  17. September 13, 2026

    • New lessonPooling & Feature Maps — replace each local window with its maximum or mean to reduce spatial resolution without mixing channels, then move a response across a window boundary to expose the detail pooling discards.
    • New lessonObject Detection — predict classed bounding boxes, remove weak candidates by score, and suppress likely duplicates by overlap, with separate thresholds controlling missed detections and repeated boxes.

  18. September 12, 2026

    • New lessonPermission — evaluate allow, ask, and deny before a tool runs, with deny taking precedence and an ask path reaching execution only after an affirmative human reply.

  19. September 11, 2026

    • New lessonHooks — match both lifecycle event and tool name before calling a hook; a pre-tool callback can stop a write, while the same check after success can only report what already happened.
    • New lessonDecoding Strategies — compare greedy, Top-k, and Top-p selection on identical model scores, then change temperature to see how concentration shifts without retraining the model.
    • New lessonPositional Encoding — add sine-and-cosine position vectors to token embeddings so two occurrences of the same token enter a transformer with different inputs.

  20. September 10, 2026

    • New lessonImage Classification — run the same Samoyed photograph through three crops and watch the winning label and confidence move from Samoyed at 61.6% to Samoyed at 33.4%, then `chow` at 19.3%.
    • New lessonEdge Detection — compute Sobel responses by comparing brightness across a neighborhood, then vary the threshold to separate strong changes from flat bright regions and noise-made edges.

  21. September 9, 2026

    • New lessonWord Embeddings — move words through a fixed vector space where similar contexts produce nearby directions and recurring relationships appear as offsets, without pretending that geometry is free of corpus bias.

  22. September 8, 2026

    • New lessonBatch Normalization — standardize each hidden feature channel with training-group statistics, then apply learned `γ` and `β`; the fixed six-layer run cuts the epoch-50 activation spike from `64.35` to `9.15`.
    • New lessonHandwritten Digit → Prediction — turn a 28×28 image into ten scores, probabilities, one predicted digit, and a confidence-gated decision, while held-out truth remains the only judge of correctness.
    • New lessonN-gram Language Models — predict the next token from corpus counts over a fixed history, then use smoothing when counts vanish without mistaking a valid probability distribution for new contextual evidence.

  23. September 6, 2026

    • New lessonOptimizers — SGD, Momentum, Adam — race three update rules for the same 20-step budget: SGD wins the round bowl, Momentum the narrow ravine, and Adam the high-noise case under the lesson's fixed reference settings.

  24. September 5, 2026

    • New lessonLSM Tree — make foreground writes durable and fast by buffering the newest versions and merging sorted immutable files later, shifting the cost to reads and background compaction.
    • New lessonDropout — mask a random subset of hidden activations during training so the network cannot depend on one fragile combination, then remove the mask for inference with the matching scale.

  25. September 4, 2026

    • New lessonB+ Tree — route point lookups through internal guide keys to sorted leaf pages, then follow linked leaves for a range scan without returning to the root.
    • New lessonWindow Functions — calculate running totals and ranks over related rows while keeping every source row, unlike `GROUP BY`, which collapses each group to one result.
    • New lessonMVCC — let readers and writers overlap by keeping row versions, then scan newest to oldest for the first version visible to the reader's snapshot.

  26. September 3, 2026

    • New lessonDatabase Indexing — count cold logical page reads across a table scan, hash index, B+ tree, and covering B+ tree: the same point lookup costs 8, 2, 3, and 2, while low selectivity makes the non-covering tree lose 12 to the scan's 8.
    • New lessonVanishing Gradients — multiply one local gain per layer on paired sigmoid and active ReLU paths: at depth 10 and `w = 1`, a unit output gradient reaches the input as `2.785e-7` versus `1`, while `w = 0.5` makes even ReLU fall to `9.766e-4`.
    • New lessonGROUP BY & Aggregation — route every row into the group named by its complete grouping key, then collapse each group to one aggregate row; the same seven rows form `1 → 3 → 6` groups as the key grows, while a `NULL` amount increments `COUNT(*)` but not `COUNT(amount)`.

  27. September 2, 2026

    • New lessonSQL Joins — turn every matching row pair into one result row, then reconcile the same source rows as INNER 3, LEFT 5, and FULL 6; the 3×3 preset exposes the nine-row multiplication.

  28. September 1, 2026

    • New lessonConsistent Hashing — keep key tokens fixed while N4@220 claims only `(140, 220]`, then contrast its 3-of-12 remap with the same hashes moving 10-of-12 under `%3 → %4`.
    • New lessonTwo-Phase Commit — require every participant to vote YES before COMMIT, then expose the prepared locks that remain blocked when the coordinator disappears before delivering its decision.
    • New lessonRaft Consensus — elect a leader and commit a current-term entry at three of five replicas, while a two-server minority can store a conflicting entry but never cross the majority line.

  29. August 30, 2026

    • New lessonRebase — replay feature-only commits oldest-first onto a newer `main`, giving each commit a new ID while the branch ref waits until every patch succeeds.
    • New lessonUndoing Changes — compare `restore`, soft/mixed/hard `reset`, and `revert` by the exact file layer, ref, or commit object each command writes; the hard-reset scenario shows why `ORIG_HEAD` cannot recover working-only bytes.
    • New lessonLexer & Parser — scan `12 + 3 * 4` into a flat token tape, then watch recursive-descent rule boundaries make `*` finish inside the right term before `+` can form the root.
    • ImprovementThe complete Git & Version Control learning path is now free, including Tags & Releases, Rebase, and Undoing Changes.

  30. August 29, 2026

    • New lessonTags & Releases — pin a release name to one commit while `main` keeps moving, then force-move the tag and watch the live name disagree with the recorded source.
    • New lessonMerge Conflicts — delete every conflict marker and Git still refuses to continue until `git add` collapses index stages 1/2/3 into stage 0; stage the markers unchanged and Git accepts them as ordinary bytes.
    • New lessonRemote Collaboration — separate local `main`, cached `origin/main`, and the server's `main`: fetch moves only the tracking ref, pull moves the local branch only on valid ancestry, and push lets the server make the final call.

  31. August 27, 2026

    • New lessonBranches & HEAD — make Git's two-hop reference visible as `HEAD → branch → commit`, then detach HEAD and prove that the next commit moves no branch at all.
    • New lessonFast-Forward Merge — prove ancestry by walking the source tip's parent chain, then move only the current branch ref to an existing commit while the source ref and object count stay unchanged.
    • New lessonThree-Way Merge — find the best common ancestor, merge clean edits into a two-parent commit, then put both branches on the same line and watch Git stop at conflict markers instead.

  32. August 26, 2026

    • New lessonGit's Four Areas — follow one file across the working tree, index, local repository, and remote, with an unstaged edit proving that commit reads the staged snapshot rather than the editor.
    • New lessonCommits as Snapshots — build real Git-format blob, tree, and commit IDs, reuse an unchanged README blob, then change only the parent and watch an identical tree receive a new commit ID.

  33. August 25, 2026

    • New lessonVirtual Machine — a stack VM fetches bytecode one opcode at a time, so 1 + 2 \* 3 is three pushes then MUL then ADD, and emitting ADD first underflows.
    • New lessonAST → Code — codegen walks the tree post-order, children first then the operator, so 1 + 2 _ 3 writes MUL before ADD because _ sits deeper in the tree, not because anyone reordered the text.

  34. August 20, 2026

    • New lessonNext-Token Prediction — ask GPT-2 what follows "The capital of France is" and " Paris" comes fifth, behind " the", with 67.98% of the model's belief on tokens too small to draw: hand it the pen and twelve argmax picks close into a literal loop.
    • New lessonRNN / LSTM — the same sentence read one word at a time by both cells: the RNN answers correctly and still gets its learning signal back at 8.9 × 10⁻⁶, where the LSTM's gated memory line keeps 0.427 — until you hold every forget gate at 0.5 and it vanishes too.
    • New lessonSoftmax & Cross-Entropy — a real handwritten 3 arrives as class 2 at 99.86% confidence; the fused gradient collapses to `p − y` and pushes the true logit 361× harder than MSE through the same saturated softmax.
    • New lessonLoss Function — mean squared error and cross-entropy start from the same confidently wrong sigmoid output, but MSE's extra `p(1 − p)` shrinks the gradient 25× and leaves one run crawling across a plateau.

  35. August 18, 2026

    • New lessonTLS Handshake — both sides derive the same key without ever sending one, then the server signs this connection's transcript to prove it holds the key its certificate names: the on-path attacker forwards a genuine certificate, passes chain, name and dates, and dies on that one signature.

  36. August 17, 2026

    • New lessonDNS Resolution — the root and TLD servers only ever name who to ask next, so one cold lookup costs eight messages and a cached answer costs two: the NXDOMAIN preset still walks the whole hierarchy, because only the zone's own server can say a name does not exist.

  37. August 16, 2026

    • New lessonLinear Regression — squared error drawn as literal area, so the one-pass closed form reads as a line pivoting about (x̄, ȳ) while the squares deflate 25×: then one point falls to y = −6 and the same formula abandons the other eight to shrink its square.

  38. August 15, 2026

    • New lessonLinear Classifier — one weight row per class and argmax on the results, so every region is an intersection of half-planes and therefore convex: the two-islands preset stays wrong no matter how you turn W or slide b.
    • New lessonVectors & Dot Product — w·x is x's shadow on w, so doubling x doubles the score while the angle holds it fixed, and a perpendicular x scores 0 however long it grows: the reason w·x = 0 is a bias-free classifier's decision boundary.

  39. August 14, 2026

    • New lessonTwo's Complement — the top bit is a place value of −128, not a sign flag, so one branchless adder does signed arithmetic: 5 + (−5) drops a carry and is still right, while 127 + 1 drops none and silently reads −128.
    • New lessonBinary Numbers — position k in a fixed row of bits is worth exactly 2^k, which is why `n % 2` reads off the lowest bit and `n // 2` drops it; count past 255 and the carry runs off the end of an eight-position word, leaving 0.

  40. August 13, 2026

    • New lessonJump Game (LeetCode #55) — "up to" jumps keep the reachable set one solid block, so a single number carries the whole search: the default survives its zero while the funnel preset piles every arc onto one and stalls.
    • New lesson3Sum (LeetCode #15) — sort once, fix an anchor, and let two converging pointers find the rest: O(n³) drops to O(n²), with duplicates skipped by one neighbor comparison instead of a hash set.

  41. August 12, 2026

    • New lessonFractional Knapsack — items are density-tall rectangles on a fixed-width shelf, a sliver swap stages the exchange argument, and forbidding the one cut drops the same greedy rule from 240 to 205 — below even the best whole-item packing's 220.
    • New lessonHuffman Coding — merge the two rarest subtrees each round so depth becomes code length: ABRACADABRA compresses to 23 bits against fixed-length's 33, and the tie preset shows Huffman can equal that baseline but never lose to it.

  42. August 11, 2026

    • New lessonBellman-Ford Algorithm — relax every edge V−1 passes with nothing ever locked, so pass 2 repairs the stale estimates pass 1 built, and a final sweep turns "still improving" into a red negative cycle.

  43. August 10, 2026

    • New lessonInterval Scheduling — sort by finish time and keep each compatible interval; an exchange rail rewrites a different optimal schedule into the greedy one without losing a slot.
    • New lessonTrapping Rain Water (LeetCode #42) — prefix maxima expose both boundaries, then two pointers settle the smaller running maximum; a dedicated proof beat shows why unscanned bars cannot invalidate that column.

  44. August 9, 2026

    • New lessonLRU Cache (LeetCode #146) — a hash map finds nodes in expected O(1), a doubly linked list makes every hit MRU, and a split eviction exposes why unlinking the LRU node without deleting its map entry leaves a stale cache.

  45. August 8, 2026

    • New lessonPermutations — reverse every swap to restore the caller's exact array; without that line, the search still visits six leaves but produces only four unique orderings.
    • New lessonSudoku Solver — MRV cuts the same puzzle from 99 placements and 56 backtracks to 46 and 3, while one clue removes the branch entirely.

  46. August 7, 2026

    • New lessonBit Tricks — one-hot masks change one bit, `x & (x - 1)` clears the lowest set bit for popcount, and the zero trap shows why power-of-two checks still need `x > 0`.

  47. August 6, 2026

    • New lessonN-Queens — three constraint keys reject column and diagonal collisions, rollback returns all three, and a search audit sets 26 candidate checks beside 4⁴ raw row assignments.

  48. August 5, 2026

    • New lessonCross-Validation — the same 20 photos score 1.00 or 0.25 under two single holdouts; five folds test every row once and land at 0.800, so the reported result stops depending on one lucky draw.
    • New lessonConfusion Matrix — 40 cases let "alarm on nobody" win 85% accuracy, "alarm on everybody" win recall, and one alarm win precision; the four-cell table is the part none of those ratios can hide.

  49. August 3, 2026

    • New lessonTopological Sort — Kahn deletes zero-indegree sources while DFS writes the order backward on return, and paired cycle runs show why an ordering exists exactly when the graph is acyclic.

  50. August 1, 2026

    • New lessonBitwise Basics — Boolean operators decide each output bit in place while shifts move bits across a fixed 8-bit word; shifting by the full width discards every source bit and leaves zero.

  51. July 31, 2026

    • New lessonPrincipal Component Analysis — one eigenvector captures 95.26% of the variance and cuts reconstruction error 2.8×, then changing centimetres to millimetres raises the score to 99.67% while making the component worse.
    • New lessonOverfitting & Validation — a degree-9 polynomial hits all ten training points and still scores 899× worse on held-out data than degree 3; training error cannot choose capacity because it can only fall as the model grows.

  52. July 29, 2026

    • New lessonMinimum Spanning Tree — Prim grows one tree while Kruskal merges components, and the same bridge graph proves their different edge orders reach the same five-edge MST of weight 19.

  53. July 28, 2026

    • New lessonAVL Tree — rebalance the first broken ancestor without changing key order, then compare the same six inserts against an unrotated BST: height 2 and three probes instead of height 4 and five.

  54. July 27, 2026

    • New lessonNaive Bayes — each word casts an independent likelihood vote, so repeating a correlated word multiplies the same evidence twice and makes confidence rise without adding information.
    • New lessonK-Means Clustering — assign each point to the nearest centroid, move each centroid to the mean, and repeat until inertia stops falling; convergence is guaranteed, but different starting flags still settle in different local minima.

  55. July 26, 2026

    • New lessonRed-Black Tree — insert red, let the uncle's color choose recoloring or at most two rotations, then watch the triangle shortcut leave a red-red edge when its first rotation is skipped.

  56. July 24, 2026

    • New lessonSupport Vector Machine — among infinitely many zero-error lines, the support vector machine takes the widest empty corridor; delete every non-support point and its boundary does not move.
    • New lessonDecision Tree — information gain greedily stacks axis-aligned cuts into rectangles; one extra level gives a lone noise point its own perfect leaf, while a diagonal boundary stays stair-stepped and wrong.

  57. July 23, 2026

    • New lessonEdit Distance — choose the cheapest final edit for every prefix pair, count the recovered +1 script, then replay it; the shift-trap turns six positional mismatches into one delete plus one insert.

  58. July 21, 2026

    • New lessonLongest Common Subsequence — fill one prefix table, then trace back an optimal ordered overlap; the greedy prelude commits the A at a[0] to b[3], burns BDC, and stops at ABA (3) while DP recovers BCBA (4).

  59. July 20, 2026

    • New lessonRouting Protocols — distance vector trusts neighbors' stale numbers and can count toward infinity in a loop, while link state floods the changed map and drops the route after Dijkstra finds no path.
    • New lessonk-Nearest Neighbors — no training step: each query pays to measure every stored point, and the same distances let k = 1 build an island around one mislabeled sample while k = 9 erases a real outpost.

  60. July 17, 2026

    • New lessonGraph Representation — an adjacency list stores only real neighbors while a matrix spends V² cells for one indexed edge check; Dense K5 shows where the list's sparse-space advantage disappears.
    • New lessonSuffix Array — store suffix start indices, double the ranked prefix length each round, then binary-search one fixed text; the all-equal scenario keeps ties alive across every round while the `-1` sentinel still orders shorter suffixes first.

  61. July 16, 2026

    • New lessonTrie — share one prefix path and consume one edge per query character; paired `startsWith("ca")` and `search("ca")` runs prove that a reachable path is not a stored word without its end marker.

  62. July 15, 2026

    • New lessonKMP String Matching — reuse the longest known prefix-suffix border after a mismatch and retry the same text character; the `advance i (bug)` variant shows how one premature increment skips the real match.
    • New lessonRabin-Karp String Matching — roll a fingerprint across each fixed-width window and inspect characters only when hashes agree; the collision scenario proves an equal hash is a candidate, not a match.

  63. July 14, 2026

    • New lessonHTTP / HTTP/2 / HTTP/3 — HTTP/1.1 queues four files, HTTP/2 overlaps them on one TCP byte stream and freezes all four behind one lost packet, while HTTP/3 keeps the loss inside its QUIC stream.
    • New lessonLogistic Regression — sigmoid turns `w·x + b` into a probability, but scaling both `w` and `b` only sharpens confidence; the zero-score boundary stays nailed in place.

  64. July 13, 2026

    • New lessonLoops & Invariants — establish a promise at the loop head, maintain it through the body, and finish the proof at `i = n`; an all-negative counterexample shows why a bad initializer invalidates the result.
    • New lessonArrays & Indexing — an index is a zero-based slot coordinate resolved in O(1); the default run stops safely before length, then proves `values[len(values)]` raises `IndexError` before `print` runs.
    • ImprovementTopic catalogs now hide the Ready / All switch when every listed lesson is already ready.

  65. July 12, 2026

    • New lessonVariables & Mutation — mutation edits a shared object while assignment moves one name's binding; the immutable-int `+=` case proves syntax alone cannot tell which happened.

  66. July 11, 2026

    • New lessonState Machines — the same `push` is rejected while locked and passes while unlocked, because behavior belongs to the `(state, event)` pair rather than the event alone.

  67. July 8, 2026

    • New lessonOSI / TCP-IP Model — OSI names seven jobs, TCP/IP groups them into four, and one Ethernet + IP + TCP request gains three wrappers rather than seven; routers replace the link wrapper without opening the HTTP message.
    • New lessonThreads & Synchronization — `counter += 1` splits into read, add, and write, so six requested increments land at four under the default interleaving; a mutex reaches six, and opposite lock order reaches deadlock.

  68. July 4, 2026

    • New lessonFile Systems — a directory owns the name and an inode owns metadata plus block addresses, so `rm` removes one directory entry while an open file can outlive its last visible path.
    • New lessonPage Replacement — FIFO remembers arrival time, LRU rewrites recency on every access, and Clock settles for one reference bit; the same trace exposes both Bélády's anomaly and the metadata price of a better guess.

  69. July 3, 2026

    • New lessonSubagents — `Task` runs the same agent loop on a fresh `messages[]`, so four noisy searches cost the main context one result card; the same wall makes the child miss a clarification the prompt didn't carry.

  70. July 2, 2026

    • New lessonLinear Search — check each element front to back and stop at the first match, so cost is the target's position and a miss scans all n; the one search that needs no sorted input.

  71. July 1, 2026

    • New lessonTree Traversal — preorder, inorder, and postorder are one depth-first walk; only where `visit(node)` sits reorders the output, and a skewed tree shows the call stack hit depth n.

  72. June 30, 2026

    • New lessonSliding Window — one window grows its right edge and shrinks its left for an O(n) pass over subarrays, until a negative value breaks the greedy shrink.

  73. June 29, 2026

    • New lessonTwo Pointers — walk one index in from each end of a sorted array, dropping the end that can't fit; an unsorted input silently skips a real pair.
    • FeatureA Scenarios row across sorting, search, and data-structure lessons — one-click presets that jump to a boundary case worth seeing (a real collision, a tree collapsing to a chain, a stack overflow).

  74. June 28, 2026

    • New lessonVirtual Memory — one address translation costs about one cycle on a TLB hit, around 100 on a page-table walk, or roughly a million on a major page fault; a TLB miss and a page fault are not the same event.
    • New lessonInstruction Execution — TinyCPU fetches a 16-bit word, increments PC before decode, then lets `JNZ` overwrite it; a loop is just the same address being fetched again, not a structure the CPU understands.

  75. June 27, 2026

    • New lessonRadix Sort — sort integers one digit at a time into stable buckets, never comparing two values; the wide-key case keeps the O(d·n) cost honest.

  76. June 25, 2026

    • New lessonArray List — contiguous storage with O(1) indexing and the shift cost on insert and delete.
    • ImprovementThe predict-the-next-step quiz now runs on Two Sum, across brute-force and hash map.

  77. June 24, 2026

    • New lessonTree Basics — root, leaf, depth, and height, on one set of nodes reshaped into three heights.
    • New lessonUnion-Find — disjoint sets as a forest over `parent[]`, with union-by-rank and path compression.

  78. June 23, 2026

    • New lessonCoin Change — greedy vs DP on one number line, showing where the greedy grab strands itself.

  79. June 22, 2026

    • New lessonCache Hierarchy — row-major and column-major sum the same 2-D array with the same additions, but one consumes each fetched cache line and the other keeps buying a whole line for one word.
    • New lessonBranch Prediction — a two-bit counter needs two surprises to change its prediction, so one loop exit does not cause the re-entry miss that punishes a one-bit predictor.

  80. June 20, 2026

    • New lesson0/1 Knapsack — fill the DP table row by row, then trace back which items were packed.

  81. June 19, 2026

    • New lessonCPU Pipeline — five instructions overlap across IF, ID, EX, MEM, and WB; without forwarding, two read-after-write hazards turn the nine-cycle ideal into thirteen, with every lost cycle visible as a bubble.
    • New lessonFloating Point (IEEE 754) — binary16 stores 0.1 as the nearest rung because its base-2 fraction repeats forever; every exponent step doubles the gap between neighboring values.

  82. June 18, 2026

    • New lessonDoubly Linked List — a `prev` pointer per node: O(1) deletion of a held node, and backward traversal.
    • New lessonCircular Linked List — the tail wraps to the head, so a failed search walks one full lap.

  83. June 17, 2026

    • New lessonThe Agent Loop — the model/tool loop, with the `max_turns` backstop.
    • New lessonA-star Pathfinding — grid search with a Dijkstra comparison and a bad-heuristic failure case.

  84. June 16, 2026

    • New lessonURL → Rendered Page — a capstone following one page load through DNS, TCP, TLS, HTTP, cache, and render.

  85. June 15, 2026

    • New lessonDijkstra
    • FeatureMNIST Digit Classifier and Training Loop gained Play / Pause / Reset and video recording.
    • ImprovementConsistent playback across recorded lessons, interactive data structures, and live neural nets.

  86. June 14, 2026

    • New lessonTransformer Block — the residual stream carried up through attention and an MLP, refined but never replaced.
    • FeatureShare & embed — copy a link that reopens a lesson on your exact input, or embed the live player in your own page.
    • FeatureExport — save the current frame as a PNG, or record the whole walkthrough to video, from the ⋯ menu.
    • FeatureA Contact page — how to embed a lesson, export a clip, or use VizLearn in a class.
    • ImprovementBubble Sort gained boundary presets — best, worst, nearly-sorted, and all-duplicate in one click.

  87. June 13, 2026

    • FeaturePredict-the-next-step quiz — a free taster on Bubble Sort; every attempt rolls a fresh array, so you run the algorithm in your head instead of recalling an answer.
    • FeatureRebuilt Features page — every capability shown as a hand-drawn vignette.
    • ImprovementReAct Loop and Tool-Calling now run on real recorded model traces, not scripts.
    • ImprovementBubble Sort's walkthrough re-cut with a cinematic camera flow.

  88. June 12, 2026

  89. June 11, 2026

    • New lessonTraining Loop
    • New lessonHeap Sort
    • FeatureA living-whiteboard landing hero — type four numbers and watch them bubble-sort in the header.

  90. June 10, 2026

    • New lessonPerceptron
    • New lessonBig-O
    • ImprovementAI lessons retrofitted to the phenomenon standard — a contrast experiment and a failure case in each.

  91. June 9, 2026

    • FeatureToasts, keyboard shortcuts, share links, and smooth view transitions between lessons.

  92. June 8, 2026

  93. June 7, 2026

    • New lessonBoolean Logic & Gates — XOR and AND share the same two input bits to produce a half-adder's sum and carry; replace XOR with OR and three truth-table rows still pass while `1 + 1` fails.
    • New lessonTask System — dependency edges decide what can run next and `tasks.json` saves each completion; after a crash, disk resumes without repaying t1 and t2 while the in-memory plan executes both twice.

  94. June 5, 2026

    • New lessonBreadth-First Search
    • FeatureA Radix luma interface theme, plus a canvas-background switcher.

  95. June 4, 2026

    • New lessonProcess Scheduling — FCFS, SJF, and Round-Robin on one Gantt chart, so you watch a short job wait behind a long one.
    • New lessonMLFQ Scheduling
    • FeatureMulti-language code panel — JavaScript added across sorting, search, DP, and the data-structure lessons.
    • ImprovementBubble Sort and Two Sum gained variant switchers (classic vs optimized, brute-force vs hash map).

  96. June 2, 2026

  97. June 1, 2026

    • FeatureFree-to-start continuity — bookmarks, saved inputs, and progress, synced across devices when you sign in.
    • FeatureA tabbed Library at /library for your saved inputs and progress.
    • ImprovementMobile layout — the player, panels, and canvas stack and scale cleanly on phones.
    • ImprovementRedesigned Terms & Privacy with section navigation.

  98. May 31, 2026

  99. May 29, 2026

  100. May 27, 2026

    • New lessonConnected Components — one DFS colors one island, then the outer sweep skips every vertex already claimed and starts exactly once for each island the first search could not reach.
    • New lessonCounting Sort — counts become final addresses through a prefix sum, and a backward placement walk keeps equal keys in input order; walk forward and the numbers still sort while stability quietly reverses.

  101. May 26, 2026

  102. May 23, 2026

    • New lessonMerge Sort — defaults to an array with duplicate keys, so you see stability hold.
    • New lessonFibonacci — one input, three modes: recursion tree, memo, and table.

  103. May 20, 2026

  104. May 18, 2026

    • New lessonRecursion & the Call Stack — each call leaves a frame holding its locals and unfinished multiplication; `fact(4)` pushes four sticky notes, then returns 1, 2, 6, and 24 as they unwind.
    • New lessonCongestion Control — Reno doubles the window until `ssthresh`, then adds one packet per RTT; a triple-duplicate ACK halves the window, a timeout resets it to 1, and the sender learns the path only by spilling it.

  105. May 17, 2026

    • New lessonHeaps
    • FeatureExplain tab — every lesson ships a written walkthrough beside the animation.
    • FeatureFeedback — send a note or screenshot from inside any lesson.

  106. May 14, 2026

  107. May 11, 2026

    • New lessonTwo Sum — the same array runs brute-force and hash-map side by side.
    • New lessonBinary Search Tree
    • FeatureTerms of Service and Privacy Policy pages.

  108. May 8, 2026

  109. May 4, 2026

    • New lessonLinked List
    • ImprovementSmoother arrows and pointer motion across the data-structure lessons.

  110. May 1, 2026

    • FeatureThe first public landing page — a topic showcase, feature tour, and roadmap teaser.

  111. April 25, 2026

    • New lessonStack
    • New lessonQueue
    • FeatureHome topic browser — every lesson as a hand-drawn card.
    • ImprovementA unified hand-drawn palette (vizPalette) shared across lessons, so the same color means the same thing everywhere.

  112. April 8, 2026

    • FeatureResizable code / visualization / log panels.

  113. March 29, 2026

    • FeatureThe synced code panel — the active line highlights and a step log fills in as each animation plays.

  114. March 17, 2026

    • New lessonSelection Sort
    • FeatureThe whole interface in English, 中文, and 日本語.
    • FeatureGoogle sign-in.

  115. March 14, 2026

    • New lessonBubble Sort — the very first VizLearn lesson.

  116. February 2026

    • FeatureVizLearn started — the first commit.