# VizLearn

> Interactive, step-by-step visualizations of algorithms, data structures, AI internals, AI agents, and computer systems, built for developers. Change the input, then step through how the process unfolds: the animation, the highlighted code line, and the execution log move in lockstep.

VizLearn is a debugger for concepts, not an animation gallery. Each of its 175 lessons is a small lab in the browser:

- Step-by-step: play, pause, single-step, or scrub a timeline. Each beat shows one action.
- Inspectable: a hand-drawn canvas, the current line of real code (on lessons that ship code), and an execution log stay in sync.
- Experimental: type your own input, switch modes, and probe edge cases. Default inputs are chosen so the lesson's takeaway is visible without interaction, such as duplicate values in sorting inputs so stability shows.
- Explain doc: every lesson has a standalone written explanation that teaches the topic without the animation. The Markdown files linked below are these docs.
- Quiz: most lessons ask the learner to predict the next step before revealing it.

The site is available in English, Simplified Chinese, and Japanese. The files listed here are English. Each Markdown file links back to its canonical page.

Entry points: [catalog](https://vizlearn.app/), [learning path](https://vizlearn.app/path) (ordered routes from program execution to distributed consensus), [pricing](https://vizlearn.app/pricing).

Free, no account needed:
- Every free lesson, complete — player, quiz, and sandbox
- The Explain doc on every lesson, premium included
- Scrub, step, and replay the trace
- Type your own input on any lesson
- Share links, embeds, and watermarked PNG export
- Progress, bookmarks, and saved inputs kept in this browser

Lifetime, $49 one-time (regular price $79), adds:
- Every premium lesson in this catalog unlocked
- Advanced algorithms, AI, and computer systems
- Future premium lessons added to this catalog
- Video export, without a watermark
- Watermark-free PNG export
- Progress, bookmarks, and saved inputs synced across devices

Lessons marked "premium" below need Lifetime for the interactive player; their Explain doc is free.

## Foundations: Execution Model

- [Execution Model overview](https://vizlearn.app/foundations/execution-model.md): Learn how programs execute line by line, how names bind to objects, and how mutation changes shared state through interactive visualizations.
- [Execution Trace](https://vizlearn.app/foundations/execution-model/execution-trace.md): Follow the program counter, the current statement, and how each step changes state.
- [Variables & Mutation](https://vizlearn.app/foundations/execution-model/variables-mutation.md): Assignment, aliasing, and mutation — see whether a binding moves or a shared object changes.
- [Arrays & Indexing](https://vizlearn.app/foundations/execution-model/arrays-indexing.md): Contiguous storage, indices, traversal, and what going out of bounds really means.
- [Loops & Invariants](https://vizlearn.app/foundations/execution-model/loops-invariants.md): Loop variables, the invariant that holds each pass, and the termination condition.

## Foundations: Abstraction

- [Abstraction overview](https://vizlearn.app/foundations/abstraction.md): Learn core computer science abstractions with step-by-step visualizations of recursion, call stacks, operation counting, Big-O growth, and state machines.
- [Recursion & the Call Stack](https://vizlearn.app/foundations/abstraction/recursion-call-stack.md): Calls pushed and popped, return values, and a recursion unwinding frame by frame.
- [Big-O by Counting Steps](https://vizlearn.app/foundations/abstraction/big-o.md): Build O(1), O(n), O(n²), and O(log n) intuition by counting operations on screen.
- [State Machines](https://vizlearn.app/foundations/abstraction/state-machines.md): States, events, and transitions — the groundwork for TCP, OS, and parsers.

## Algorithm: Data Structures

- [Data Structures overview](https://vizlearn.app/algorithms/data-structures.md): Interactive visualizations of core data structures, including AVL and red-black trees, with each operation animated step by step beside synced code.
- [Array List](https://vizlearn.app/algorithms/data-structures/array-list.md): Contiguous storage with O(1) indexing — append, insert, delete, and the shift cost.
- [Stack](https://vizlearn.app/algorithms/data-structures/stack.md): LIFO — push, pop, peek operations
- [Monotonic Stack](https://vizlearn.app/algorithms/data-structures/monotonic-stack.md): Keep stack values ordered and pop smaller candidates to find each element's next greater value.
- [Queue](https://vizlearn.app/algorithms/data-structures/queue.md): FIFO — enqueue, dequeue operations
- [Linked Lists](https://vizlearn.app/algorithms/data-structures/linked-lists.md): Singly list — node, head, next pointer
- [Doubly Linked List](https://vizlearn.app/algorithms/data-structures/doubly-linked-lists.md): prev + next — O(1) delete, both ways
- [Circular Linked List](https://vizlearn.app/algorithms/data-structures/circular-linked-lists.md): tail.next = head — a ring, no null end
- [Hash Table — Separate Chaining](https://vizlearn.app/algorithms/data-structures/hash-table-chaining.md): Each bucket holds a linked chain of colliding keys
- [Hash Table — Linear Probing](https://vizlearn.app/algorithms/data-structures/hash-table-probing.md): Open addressing: probe forward on collision, tombstones for delete
- [Tree Basics](https://vizlearn.app/algorithms/data-structures/tree-basics.md): Root, child, height, and the three traversal orders — the vocabulary of trees.
- [Binary Search Tree](https://vizlearn.app/algorithms/data-structures/binary-search-tree.md): Ordered tree — insert, search, delete with successor swap
- [AVL Tree](https://vizlearn.app/algorithms/data-structures/avl-tree.md): A BST that rotates whenever an insert leaves a node unbalanced, keeping its height logarithmic. (premium)
- [Red-Black Tree](https://vizlearn.app/algorithms/data-structures/red-black-tree.md): Balance kept by recoloring and rotation — the tree behind most standard libraries. (premium)
- [Heaps](https://vizlearn.app/algorithms/data-structures/heaps.md): Min-heap, max-heap, priority queues
- [Trie](https://vizlearn.app/algorithms/data-structures/trie.md): Prefix tree for fast string lookup (premium)
- [Union-Find](https://vizlearn.app/algorithms/data-structures/union-find.md): Disjoint sets with path compression (premium)
- [Graph Representation](https://vizlearn.app/algorithms/data-structures/graph-representation.md): Adjacency list vs matrix, edges, and degree — how a graph becomes data.

## Algorithm: Sorting Algorithms

- [Sorting Algorithms overview](https://vizlearn.app/algorithms/sorting.md): Watch eight sorting algorithms — bubble, selection, insertion, merge, quick, heap, counting, and radix sort — run step by step, with animations synced to code, complexity, and stability.
- [Bubble Sort](https://vizlearn.app/algorithms/sorting/bubble-sort.md): Simple comparison-based sorting
- [Selection Sort](https://vizlearn.app/algorithms/sorting/selection-sort.md): Find minimum, swap to front
- [Insertion Sort](https://vizlearn.app/algorithms/sorting/insertion-sort.md): Build sorted prefix one element at a time
- [Merge Sort](https://vizlearn.app/algorithms/sorting/merge-sort.md): Stable sort with O(n log n)
- [Quick Sort](https://vizlearn.app/algorithms/sorting/quick-sort.md): Divide & conquer, pivot selection
- [Heap Sort](https://vizlearn.app/algorithms/sorting/heap-sort.md): In-place using binary heap (premium)
- [Counting Sort](https://vizlearn.app/algorithms/sorting/counting-sort.md): Prefix sums turn counts into addresses (premium)
- [Radix Sort](https://vizlearn.app/algorithms/sorting/radix-sort.md): Stable buckets, zero comparisons (premium)

## Algorithm: Search Algorithms

- [Search Algorithms overview](https://vizlearn.app/algorithms/search.md): Watch linear search, binary search, two pointers, sliding window, breadth-first search, depth-first search, tree traversal, connected components, and A* pathfinding run step by step, with animations synced to code — see what each one rules out and the order it visits.
- [Linear Search](https://vizlearn.app/algorithms/search/linear-search.md): Scan front to back until you find it — the baseline, and the worst case.
- [Binary Search](https://vizlearn.app/algorithms/search/binary-search.md): Logarithmic search on sorted data
- [Two Pointers](https://vizlearn.app/algorithms/search/two-pointers.md): Two indices walking a sorted array inward — pair sums and shrinking ranges. (premium)
- [Sliding Window](https://vizlearn.app/algorithms/search/sliding-window.md): Grow and shrink a window over a sequence to answer subarray questions in O(n). (premium)
- [Depth-First Search](https://vizlearn.app/algorithms/search/depth-first-search.md): Graph traversal using stack
- [Breadth-First Search](https://vizlearn.app/algorithms/search/breadth-first-search.md): Graph traversal using queue
- [Tree Traversal](https://vizlearn.app/algorithms/search/tree-traversal.md): Preorder, inorder, and postorder — the same tree, three visiting orders.
- [Connected Components](https://vizlearn.app/algorithms/search/connected-components.md): Label each island of a graph by sweeping unvisited nodes with DFS/BFS. (premium)
- [A* Pathfinding](https://vizlearn.app/algorithms/search/a-star.md): Heuristic-based shortest path (premium)

## Algorithm: String Algorithms

- [String Algorithms overview](https://vizlearn.app/algorithms/strings.md): Watch KMP, Rabin-Karp, and suffix arrays work step by step. Compare prefix borders, rolling hashes, and sorted suffix indices for substring search.
- [KMP String Matching](https://vizlearn.app/algorithms/strings/kmp.md): Reuse prefix-suffix borders after a mismatch to match in O(n + m) without rescanning the text.
- [Rabin-Karp](https://vizlearn.app/algorithms/strings/rabin-karp.md): Find a pattern with a rolling hash, comparing fingerprints before characters. (premium)
- [Suffix Array](https://vizlearn.app/algorithms/strings/suffix-array.md): Every suffix sorted into an array — fast substring queries over one text. (premium)

## Algorithm: Backtracking

- [Backtracking overview](https://vizlearn.app/algorithms/backtracking.md): Watch recursive choices, pruning, and exact rollback in N-Queens, swap-based permutations, and an MRV Sudoku solver.
- [N-Queens](https://vizlearn.app/algorithms/backtracking/n-queens.md): Place N queens with no two attacking — backtrack the moment a column dies.
- [Permutations](https://vizlearn.app/algorithms/backtracking/permutations.md): Build every ordering by choosing, recursing, and undoing each choice.
- [Sudoku Solver](https://vizlearn.app/algorithms/backtracking/sudoku-solver.md): Fill the grid cell by cell, backtracking when a digit breaks a constraint. (premium)

## Algorithm: Dynamic Programming

- [Dynamic Programming overview](https://vizlearn.app/algorithms/dp.md): Learn dynamic programming through overlapping subproblems, bottom-up tables, greedy counterexamples, sequence alignment, minimum edit scripts, traceback, and constrained optimization.
- [Fibonacci & Memoization](https://vizlearn.app/algorithms/dp/fibonacci.md): From naive recursion to bottom-up DP
- [Coin Change](https://vizlearn.app/algorithms/dp/coin-change.md): Greedy vs DP for the fewest coins
- [Longest Common Subsequence](https://vizlearn.app/algorithms/dp/longest-common-subsequence.md): 2D DP table over two strings (premium)
- [Edit Distance](https://vizlearn.app/algorithms/dp/edit-distance.md): Levenshtein recurrence visualized (premium)
- [0/1 Knapsack](https://vizlearn.app/algorithms/dp/knapsack.md): Item selection under capacity constraint (premium)

## Algorithm: Greedy Algorithms

- [Greedy Algorithms overview](https://vizlearn.app/algorithms/greedy.md): Watch greedy algorithms commit to locally best choices step by step — interval scheduling's exchange argument, Jump Game's farthest-reach frontier, Huffman coding's optimal prefix codes, and fractional knapsack's density fill, animated and synced to real code.
- [Interval Scheduling](https://vizlearn.app/algorithms/greedy/interval-scheduling.md): Always pick the earliest finish — the exchange argument shows why it wins
- [Huffman Coding](https://vizlearn.app/algorithms/greedy/huffman-coding.md): Merge the two rarest symbols until one tree encodes them all (premium)
- [Jump Game (LeetCode #55)](https://vizlearn.app/algorithms/greedy/jump-game.md): One sweep tracking the farthest reachable index
- [Fractional Knapsack](https://vizlearn.app/algorithms/greedy/fractional-knapsack.md): When items can be split, packing by value density is optimal (premium)

## Algorithm: Graph Algorithms

- [Graph Algorithms overview](https://vizlearn.app/algorithms/graph.md): Watch graph algorithms work step by step. Build dependency orders with Kahn and DFS, compare Dijkstra and Bellman-Ford shortest paths, then grow Prim and Kruskal minimum spanning trees.
- [Dijkstra](https://vizlearn.app/algorithms/graph/dijkstra.md): Shortest path with priority queue
- [Bellman-Ford](https://vizlearn.app/algorithms/graph/bellman-ford.md): Relax every edge V−1 times — handles negative weights, detects negative cycles (premium)
- [Minimum Spanning Tree](https://vizlearn.app/algorithms/graph/minimum-spanning-tree.md): Prim & Kruskal compared (premium)
- [Topological Sort](https://vizlearn.app/algorithms/graph/topological-sort.md): DAG ordering with DFS and Kahn's algorithm (premium)

## Algorithm: Bit Manipulation

- [Bit Manipulation overview](https://vizlearn.app/algorithms/bit-manipulation.md): Watch bitwise operators, masks, Kernighan bit counting, and power-of-two checks work step by step inside a fixed 8-bit word.
- [Bitwise Basics](https://vizlearn.app/algorithms/bit-manipulation/bitwise-basics.md): AND, OR, XOR, NOT, and shifts — what the bits actually do.
- [Bit Tricks](https://vizlearn.app/algorithms/bit-manipulation/bit-tricks.md): Masks, set/clear/test a bit, count bits, and the classic power-of-two checks. (premium)

## Algorithm: Classic Problems

- [Classic Problems overview](https://vizlearn.app/algorithms/leetcode.md): Interactive classic algorithm problems with step-by-step LeetCode solution traces beside executable Python and JavaScript.
- [Two Sum (LeetCode #1)](https://vizlearn.app/algorithms/leetcode/two-sum.md): Two indices whose values sum to target — one-pass hash map walkthrough
- [LRU Cache (LeetCode #146)](https://vizlearn.app/algorithms/leetcode/lru-cache.md): O(1) get and put — a hash map and a doubly linked list working as one (premium)
- [Trapping Rain Water (LeetCode #42)](https://vizlearn.app/algorithms/leetcode/trapping-rain-water.md): Build both boundary arrays, then collapse them into two running maxima that settle one column per move
- [3Sum (LeetCode #15)](https://vizlearn.app/algorithms/leetcode/three-sum.md): Sort, fix one number, walk two pointers inward — skipping duplicates

## AI: Classical ML

- [Classical ML overview](https://vizlearn.app/ai/classical-ml.md): The arithmetic underneath every model, animated step by step — the dot product that scores an input, the linear classifier that turns K scores into a decision, the k-nearest-neighbors vote that never trains at all, the decision tree that greedily carves the plane into rectangles, the support vector machine that picks the boundary with the widest empty corridor, the least-squares fit that shows what a loss function actually measures, the sigmoid that turns a score into a probability cross-entropy can judge, the k-means loop that provably always stops — somewhere the initial guess chose — the PCA budget where every direction's captured variance and discarded error add to the same fixed total, and the Naive Bayes jury where every word votes without hearing the others.
- [Vectors & Dot Product](https://vizlearn.app/ai/classical-ml/vectors-dot-product.md): Vectors, weights, and the dot product — the weighted sum every model is built on.
- [Linear Classifier](https://vizlearn.app/ai/classical-ml/linear-classifier.md): One dot-product scorer per class: scores, argmax, and the straight borders that carve the plane.
- [Linear Regression](https://vizlearn.app/ai/classical-ml/linear-regression.md): Fit a line to data by minimizing squared error — the simplest learning algorithm.
- [Logistic Regression](https://vizlearn.app/ai/classical-ml/logistic-regression.md): Squash a score through the sigmoid into a probability, then classify.
- [k-Nearest Neighbors](https://vizlearn.app/ai/classical-ml/k-nearest-neighbors.md): Classify by the majority vote of the nearest labeled points — no training step.
- [Decision Tree](https://vizlearn.app/ai/classical-ml/decision-tree.md): Split the data one feature at a time, choosing the split that reduces impurity.
- [Support Vector Machine](https://vizlearn.app/ai/classical-ml/svm.md): The boundary with the widest margin between classes, set by its support vectors.
- [K-Means Clustering](https://vizlearn.app/ai/classical-ml/k-means.md): Group points into k clusters by alternating assignment and centroid updates.
- [Principal Component Analysis](https://vizlearn.app/ai/classical-ml/pca.md): Project data onto the directions of greatest variance to shed dimensions.
- [Naive Bayes](https://vizlearn.app/ai/classical-ml/naive-bayes.md): Classify by multiplying per-feature probabilities — naive, fast, surprisingly strong.

## AI: Evaluation & Generalization

- [Evaluation & Generalization overview](https://vizlearn.app/ai/ml-evaluation.md): Three animated lessons on the only question that decides whether a model ships — nine polynomials whose training error falls monotonically to a perfect zero while held-out error climbs to 899× the best, one dataset whose test accuracy reads 1.00 on one draw and 0.25 on another while its five-fold score never moves, and a confusion matrix where a model that alarms on nobody scores 85% accuracy and one that alarms on everybody scores perfect recall.
- [Overfitting & Validation](https://vizlearn.app/ai/ml-evaluation/overfitting-and-validation.md): Fit polynomials of rising degree and watch train and test error split into a U-curve.
- [Cross-Validation](https://vizlearn.app/ai/ml-evaluation/cross-validation.md): Rotate k folds of held-out data so every point gets scored as unseen.
- [Confusion Matrix](https://vizlearn.app/ai/ml-evaluation/confusion-matrix.md): Precision, recall, and why accuracy lies on imbalanced data.

## AI: Neural Networks

- [Neural Networks overview](https://vizlearn.app/ai/neural-networks.md): Watch a neural network learn, one stage at a time — forward propagation, loss, backpropagation, optimizer dynamics, a live training loop, dropout, and batch normalization — animated from real computed traces.
- [Perceptron](https://vizlearn.app/ai/neural-networks/perceptron.md): Single-layer neural network basics
- [Forward Propagation](https://vizlearn.app/ai/neural-networks/forward-propagation.md): How a neural network turns pixels into a prediction
- [Loss Function](https://vizlearn.app/ai/neural-networks/loss-function.md): How wrong a prediction is — the surface gradient descent walks downhill.
- [Softmax & Cross-Entropy](https://vizlearn.app/ai/neural-networks/softmax-cross-entropy.md): Turn logits into probabilities, then score them against the correct class. (premium)
- [Gradient Descent](https://vizlearn.app/ai/neural-networks/gradient-descent.md): Stepping down the loss surface
- [Backpropagation](https://vizlearn.app/ai/neural-networks/backpropagation.md): Gradient descent and weight updates
- [MNIST Digit Classifier](https://vizlearn.app/ai/neural-networks/mnist-digit-classifier.md): Draw digits or load real MNIST samples and watch a trained MLP classify them live
- [CNN](https://vizlearn.app/ai/neural-networks/cnn.md): Convolution, pooling, feature maps (premium)
- [Training Loop](https://vizlearn.app/ai/neural-networks/training-loop.md): Train a tiny net live in your browser — watch the boundary learn, thrash, underfit and overfit.
- [RNN / LSTM](https://vizlearn.app/ai/neural-networks/rnn.md): Sequential models and hidden state (premium)
- [Vanishing Gradients](https://vizlearn.app/ai/neural-networks/vanishing-gradients.md): Watch one chain-rule product fade through sigmoid layers while an active ReLU path shrinks, survives, or explodes. (premium)
- [Dropout](https://vizlearn.app/ai/neural-networks/dropout.md): Randomly mask hidden units during training and watch the regularization tradeoff. (premium)
- [Batch Normalization](https://vizlearn.app/ai/neural-networks/batch-normalization.md): Standardize each hidden channel, then isolate how the size of its statistics group changes a deep training run. (premium)
- [Optimizers — SGD, Momentum, Adam](https://vizlearn.app/ai/neural-networks/optimizers.md): Race three update rules down the same loss surface. (premium)

## AI: Natural Language Processing

- [Natural Language Processing overview](https://vizlearn.app/ai/nlp.md): Watch text become tokens and vectors, flow through attention and transformer blocks, and turn back into generated text — one inspectable trace at a time.
- [Tokenization](https://vizlearn.app/ai/nlp/tokenization.md): Text preprocessing and encoding
- [BPE Training](https://vizlearn.app/ai/nlp/bpe-training.md): Learn subword merges from a corpus (premium)
- [N-gram Language Models](https://vizlearn.app/ai/nlp/n-gram-language-models.md): Predict the next token by counting — the language model before neural nets. (premium)
- [Word Embeddings](https://vizlearn.app/ai/nlp/word-embeddings.md): Move a real GloVe relationship through 50D space — then audit what else the corpus encoded (premium)
- [Attention Mechanism](https://vizlearn.app/ai/nlp/attention-mechanism.md): Self-attention and transformers
- [Positional Encoding](https://vizlearn.app/ai/nlp/positional-encoding.md): Add sine/cosine position vectors to repeated tokens and compare the inputs with encoding on and off.
- [Transformer Block](https://vizlearn.app/ai/nlp/transformer.md): The residual stream: each layer adds, never replaces (premium)
- [Next-Token Prediction](https://vizlearn.app/ai/nlp/next-token-prediction.md): From logits to the next token — the objective behind every language model.
- [Decoding Strategies](https://vizlearn.app/ai/nlp/decoding-strategies.md): Compare Greedy, Top-k, and Top-p on real GPT-2 logits; change temperature and see which tokens remain eligible.

## AI: Agents

- [Agents overview](https://vizlearn.app/ai/agents.md): Watch how an LLM becomes an agent — tool calling, permission checks, hooks, the reason-act loop, subagents, explicit plans, persistent tasks, context and memory, and retrieval-augmented generation — each animated step by step.
- [Agent Loop](https://vizlearn.app/ai/agents/agent-loop.md): Every agent is one while-loop: call the model, run the tool it asks for, feed the result back, repeat until it stops. The loop never changes — everything else is harness.
- [Tool Calling](https://vizlearn.app/ai/agents/tool-calling.md): The model never runs anything — it returns JSON and stops; your code executes and reports back. One tool call, two round trips.
- [Permission](https://vizlearn.app/ai/agents/permission.md): Before any tool runs, it passes a rule gate: allow runs it, deny blocks it, ask escalates to you. Set boundaries first, then grant freedom. (premium)
- [Hooks](https://vizlearn.app/ai/agents/hooks.md): Attach a check before or after tool execution. Change the event and matcher to see a protected write prevented, reported afterward, or missed entirely. (premium)
- [ReAct Loop](https://vizlearn.app/ai/agents/react-loop.md): Thought → Action → Observation — why checking the world beats reasoning alone, and what written thoughts add to acting alone: a trace you can audit.
- [Plan Before Acting](https://vizlearn.app/ai/agents/todo-write.md): Write a plan with completion conditions, then follow a failed check through repair and recheck. Compare the checklist's status with the actual tool results. (premium)
- [Subagents](https://vizlearn.app/ai/agents/subagent.md): Hand a big task to a subagent with a clean context: it works in isolation and bubbles back only the conclusion, so noise never leaks into the main conversation. (premium)
- [Context & Memory](https://vizlearn.app/ai/agents/context-and-memory.md): Why an agent compacts its context near the limit — what a summary keeps, what it loses, and what a memory file carries into the next session.
- [System Prompt Assembly](https://vizlearn.app/ai/agents/system-prompt.md): Assemble system sections, tool definitions, and context from runtime sources. Compare listed skills with loaded instructions, and available memory with the contents actually sent. (premium)
- [Error Recovery](https://vizlearn.app/ai/agents/error-recovery.md): A failed call isn't the end — it's the start of a retry chain: try again, compact to make room, escalate the token budget, fall back to another model. (premium)
- [RAG: Retrieval-Augmented Generation](https://vizlearn.app/ai/agents/rag.md): How an LLM answers from docs it never trained on — embed, rank by cosine, top-k into the prompt — and why the answer is decided before generation. (premium)
- [Task System](https://vizlearn.app/ai/agents/task-system.md): Big goals break into a dependency graph of small tasks, persisted to disk: each node waits on what blocks it, and finishing one unlocks the next. (premium)
- [Background Tasks](https://vizlearn.app/ai/agents/background-tasks.md): Slow work goes to the background while the agent keeps thinking — a long command runs off to the side, and its completion notification lands at the next turn boundary. (premium)
- [Agent Teams](https://vizlearn.app/ai/agents/agent-teams.md): Teammates keep separate contexts. Follow a contract update through a mailbox, then check whether their API and UI artifacts agree. (premium)
- [MCP Plugin](https://vizlearn.app/ai/agents/mcp-plugin.md): Discover external tools, register their server routes, and follow a call through MCP. Compare an unavailable tool with a failed lookup. (premium)

## AI: Computer Vision

- [Computer Vision overview](https://vizlearn.app/ai/vision.md): Calculate edge responses, compare max and average pooling, and test how an image crop changes classification. Interactive lessons connect local features with image predictions.
- [Edge Detection](https://vizlearn.app/ai/vision/edge-detection.md): Calculate Sobel responses from pixels; test polarity, thresholds, and noise.
- [Pooling & Feature Maps](https://vizlearn.app/ai/vision/pooling-feature-maps.md): Compare max and average pooling, then move a response across a window boundary to see what changes.
- [Image Classification](https://vizlearn.app/ai/vision/image-classification.md): One crop → 1,000 scores → one label; then see why crop policy matters (premium)
- [Object Detection](https://vizlearn.app/ai/vision/object-detection.md): Filter real bounding boxes with score thresholds, IoU, and NMS (premium)

## AI: Generative AI

- [Generative AI overview](https://vizlearn.app/ai/generative.md): Explore learned representations, adversarial training, and repeated denoising. Compare reconstruction error, sample resemblance, and distribution coverage.
- [Autoencoder](https://vizlearn.app/ai/generative/autoencoder.md): Compare learned bottlenecks, pixel reconstruction, and an unfamiliar input. (premium)
- [Diffusion Models](https://vizlearn.app/ai/generative/diffusion-models.md): Compare repeated denoising with a single estimate (premium)
- [GAN](https://vizlearn.app/ai/generative/gan.md): Watch adversarial learning and test sample diversity (premium)

## AI: Reinforcement Learning

- [Reinforcement Learning overview](https://vizlearn.app/ai/reinforcement.md): Watch rewards change a Q table and action probabilities. Explore delayed rewards, greedy choices, and noisy policy updates in two interactive lessons.
- [Q-Learning](https://vizlearn.app/ai/reinforcement/q-learning.md): Watch delayed rewards change earlier choices through Q-table updates.
- [Policy Gradient](https://vizlearn.app/ai/reinforcement/policy-gradient.md): Watch returns change action probabilities with REINFORCE (premium)

## Computer Science: Computer Architecture

- [Computer Architecture overview](https://vizlearn.app/cs/architecture.md): Watch a word hold a number, count, overflow, round, and get added by gates. Binary place value, two's complement, IEEE 754 floats, and logic gates, animated.
- [Binary Numbers](https://vizlearn.app/cs/architecture/binary-numbers.md): Bits, place value, and carry — how a machine counts in base 2.
- [Two's Complement](https://vizlearn.app/cs/architecture/twos-complement.md): How signed integers really work
- [Floating Point (IEEE 754)](https://vizlearn.app/cs/architecture/floating-point.md): Sign, exponent, mantissa visualized
- [Boolean Logic & Gates](https://vizlearn.app/cs/architecture/boolean-logic.md): AND/OR/NOT and digital circuits
- [Instruction Execution](https://vizlearn.app/cs/architecture/instruction-execution.md): Fetch, decode, execute — one instruction's trip through the CPU.
- [CPU Pipeline](https://vizlearn.app/cs/architecture/cpu-pipeline.md): Five stages overlap so an instruction finishes almost every cycle — until a data hazard stalls the pipeline. (premium)
- [Branch Prediction](https://vizlearn.app/cs/architecture/branch-prediction.md): Speculative execution and misprediction cost (premium)
- [Cache Hierarchy](https://vizlearn.app/cs/architecture/cache-hierarchy.md): L1/L2/L3, locality, cache lines (premium)

## Computer Science: Operating Systems

- [Operating Systems overview](https://vizlearn.app/cs/os.md): Watch what an operating system actually does — share one CPU among many processes with FCFS, SJF, round robin and MLFQ, translate every memory address through a page table and TLB, turn a path into bytes through directories and inodes, and lose an update to a race between two threads — animated step by step alongside the code.
- [Process Scheduling](https://vizlearn.app/cs/os/process-scheduling.md): FCFS, SJF, and Round Robin on a Gantt chart
- [Multi-Level Feedback Queue](https://vizlearn.app/cs/os/mlfq-scheduling.md): Round-robin, priority queues, I/O, and aging boost (premium)
- [Virtual Memory](https://vizlearn.app/cs/os/virtual-memory.md): Paging, page table, TLB (premium)
- [Page Replacement](https://vizlearn.app/cs/os/page-replacement.md): FIFO, LRU, Clock, Bélády's anomaly (premium)
- [Threads & Synchronization](https://vizlearn.app/cs/os/threads-and-sync.md): Race conditions, mutex, and deadlock
- [File Systems](https://vizlearn.app/cs/os/file-systems.md): inode, directory entry, link count (premium)

## Computer Science: Computer Networks

- [Computer Networks overview](https://vizlearn.app/cs/networks.md): Watch the stack a packet actually climbs — how OSI names seven jobs and TCP/IP wraps three headers — then the conversations behind every page load: DNS, the TCP open and close, TLS, HTTP/1.1 vs HTTP/2 vs HTTP/3, and the routing protocols that fill a next-hop table, each animated with code synced beat by beat.
- [OSI / TCP-IP Model](https://vizlearn.app/cs/networks/osi-model.md): Layered network architecture walkthrough
- [TCP Handshake](https://vizlearn.app/cs/networks/tcp-handshake.md): Three-way handshake, sequence numbers, retry
- [TCP Connection Teardown](https://vizlearn.app/cs/networks/tcp-teardown.md): Four-way handshake, FIN/ACK, TIME_WAIT (premium)
- [Congestion Control](https://vizlearn.app/cs/networks/congestion-control.md): Textbook Reno: slow start, AIMD, timeout (premium)
- [HTTP / HTTP/2 / HTTP/3](https://vizlearn.app/cs/networks/http-https.md): Request-response, multiplexing, QUIC
- [TLS Handshake](https://vizlearn.app/cs/networks/tls-handshake.md): Certificate, key exchange, encryption (premium)
- [DNS Resolution](https://vizlearn.app/cs/networks/dns-resolution.md): Recursive vs. iterative lookup
- [Routing Protocols](https://vizlearn.app/cs/networks/routing-protocols.md): A stale DV cost loops; a link-state map drops (premium)

## Computer Science: Databases

- [Databases overview](https://vizlearn.app/cs/databases.md): Watch SQL reshape rows, indexes trade page reads, B+ and LSM trees organize storage, and MVCC snapshots select among concurrent row versions.
- [SQL Joins](https://vizlearn.app/cs/databases/sql-joins.md): INNER, LEFT, FULL — watch rows match, miss, and fill with NULL.
- [GROUP BY & Aggregation](https://vizlearn.app/cs/databases/sql-group-by.md): Rows fall into buckets, buckets collapse into aggregates.
- [Window Functions](https://vizlearn.app/cs/databases/sql-window-functions.md): A frame slides over ordered rows — running totals and ranks without collapsing. (premium)
- [B+ Tree](https://vizlearn.app/cs/databases/b-plus-tree.md): Watch leaf copies, internal pushes, and linked-leaf range scans. (premium)
- [LSM Tree](https://vizlearn.app/cs/databases/lsm-tree.md): See fast writes defer sorting and merging while sequence rules keep overlapping versions correct. (premium)
- [MVCC](https://vizlearn.app/cs/databases/mvcc.md): Watch snapshots choose row versions while readers overlap updates and cleanup waits. (premium)
- [Database Indexing](https://vizlearn.app/cs/databases/indexing.md): Watch scans, hash buckets, B+ tree leaves, and covering payloads trade page reads. (premium)

## Computer Science: Distributed Systems

- [Distributed Systems overview](https://vizlearn.app/cs/distributed.md): Watch consistent hashing place keys, two-phase commit coordinate one atomic transaction, and Raft commit a replicated log — three different distributed-systems jobs, animated beat by beat.
- [Raft Consensus](https://vizlearn.app/cs/distributed/raft.md): Leader election and log replication (premium)
- [Two-Phase Commit](https://vizlearn.app/cs/distributed/two-phase-commit.md): Distributed transaction coordination (premium)
- [Consistent Hashing](https://vizlearn.app/cs/distributed/consistent-hashing.md): Hash ring with virtual nodes

## Computer Science: Compilers

- [Compilers overview](https://vizlearn.app/cs/compilers.md): Watch a lexer cut source into tokens, a parser build precedence into an AST, a compiler emit stack bytecode, and a virtual machine run it — including the exact errors at each boundary.
- [Lexer & Parser](https://vizlearn.app/cs/compilers/lexer-parser.md): Tokenization and AST construction
- [AST → Code](https://vizlearn.app/cs/compilers/ast-codegen.md): Tree walker, IR, optimization passes (premium)
- [Virtual Machine](https://vizlearn.app/cs/compilers/virtual-machine.md): Bytecode execution and JIT (premium)

## Computer Science: Git & Version Control

- [Git & Version Control overview](https://vizlearn.app/cs/version-control.md): Watch Git turn files into snapshots, rewrite a branch onto a new base, exchange objects with a remote, pin releases with tags, and undo changes without confusing file content with history.
- [Git's Four Areas](https://vizlearn.app/cs/version-control/git-four-areas.md): Move one change through the working tree, index, local repository, and remote.
- [Commits as Snapshots](https://vizlearn.app/cs/version-control/commit-snapshots.md): A commit records the staged snapshot, its parent, and a new identity.
- [Branches & HEAD](https://vizlearn.app/cs/version-control/branches-head.md): Branches move with new commits; HEAD marks which reference moves next.
- [Fast-Forward Merge](https://vizlearn.app/cs/version-control/fast-forward-merge.md): When history has not diverged, merge advances a branch without creating a commit.
- [Three-Way Merge](https://vizlearn.app/cs/version-control/three-way-merge.md): Combine two diverged histories through their common ancestor and a two-parent commit.
- [Merge Conflicts](https://vizlearn.app/cs/version-control/merge-conflicts.md): Resolve competing edits, stage the result, and finish the interrupted merge.
- [Remote Collaboration](https://vizlearn.app/cs/version-control/remote-collaboration.md): See exactly what fetch, pull, and push change across local and remote repositories.
- [Tags & Releases](https://vizlearn.app/cs/version-control/tags-releases.md): Commits advance branches, not tags; annotated tags add an object, and checkout detaches HEAD.
- [Rebase](https://vizlearn.app/cs/version-control/rebase.md): Replay commits onto a new base and watch every copied commit receive a new ID.
- [Undoing Changes](https://vizlearn.app/cs/version-control/undoing-changes.md): Compare restore, reset, and revert by the repository layer each one changes.

## Capstones: End-to-End Walkthroughs

- [End-to-End Walkthroughs overview](https://vizlearn.app/capstones/projects.md): Interactive capstone lessons connecting browser networking and rendering, handwritten-digit prediction and evaluation, SQL query execution and page caching, and a write's path through Raft replication, commitment, and client response.
- [URL → Rendered Page](https://vizlearn.app/capstones/projects/url-to-page.md): One request end to end: DNS, TCP, TLS, HTTP, and the cache — every layer in motion.
- [SQL Query → Disk Read](https://vizlearn.app/capstones/projects/sql-to-disk.md): From a query to bytes on disk: parser, plan, B+ tree index, and the page cache.
- [Handwritten Digit → Prediction](https://vizlearn.app/capstones/projects/digit-to-prediction.md): Watch a confidence gate route real MNIST predictions—then let held-out truth audit the decision.
- [Message → Distributed Consensus](https://vizlearn.app/capstones/projects/message-to-consensus.md): Follow one write through replication and commitment, then lose its reply: the client can time out after success.

## Blog

- [Two arrows, never one bus](https://vizlearn.app/blog/two-arrows-never-one-bus.md): A lesson player has 'player state': the input, the highlighted line, the log, whether it's playing. The obvious build is one context every surface reads. I used two instead, pointing opposite ways — the learner's input flows in, the animation's position flows out — because a React context re-renders every subscriber on every change, and those two flows move at wildly different speeds. (2026-07-28)
- [Highlight the phase, not the line](https://vizlearn.app/blog/highlight-the-phase-not-the-line.md): The code panel lights up the line the animation is on. Then I added a Python/JavaScript toggle and a naive-vs-optimized switch that both change the code, and the same animation kept highlighting the right line in all four. The trick is that the animation never emits a line number. It emits what's happening, and each code file answers where. (2026-07-08)
- [I drew the algorithm, not an icon](https://vizlearn.app/blog/i-drew-the-algorithm-not-an-icon.md): The easy way to cover a catalog of lessons is a stock icon per card. I drew a tiny diagram for each instead — the lesson squeezed into one monochrome 320×180 frame with a single label. The social card and the poster-size cover then come for free: the same drawing, rendered bigger. (2026-06-24)
- [Your play button shouldn't know what it's playing](https://vizlearn.app/blog/one-play-button-three-engines.md): VizLearn grew three kinds of animation — a recorded sort, an interactive data structure, a live neural net you draw on — and each quietly grew its own play button. Collapsing them into one transport bar meant noticing the few verbs all three engines already had in common. (2026-06-15)
- [Contrast is the cheapest depth](https://vizlearn.app/blog/contrast-is-the-cheapest-depth.md): A single run that works teaches almost nothing you'd actually believe. What teaches is the second run — the same idea with one variable changed, so the property you're trying to show appears in one and vanishes in the other. It turned out to be the cheapest depth I could add to a lesson, and the one I kept reaching for. (2026-06-14)
- [You don't understand it until you can predict it](https://vizlearn.app/blog/predict-the-next-step.md): Watching an animation feels like learning, but recognition isn't recall. So I built a quiz that makes you commit to the next step before it happens — and made it hard to cram, because every run is a fresh random one and every answer is read straight off the trace that drives the animation. (2026-06-13)
- [The animation that lied](https://vizlearn.app/blog/the-animation-that-lied.md): An animation can be correct in every pixel and still teach the wrong thing — by faking a state the code never reaches, or by selling a limit of the canvas as a limit of the algorithm. The worst bugs I've shipped weren't crashes. They were lies a learner had no reason to doubt. (2026-06-08)
- [I told users to rotate their phone](https://vizlearn.app/blog/rotate-your-phone.md): VizLearn's first answer to a phone was an overlay telling you to rotate it. Taking that guard out meant admitting the fixed canvas had already solved more of mobile than I had noticed — shrink the picture, keep the input panel, widen the strokes that break. (2026-06-01)
- [Record the agent, don't script it](https://vizlearn.app/blog/record-the-agent.md): The textbook ReAct diagram is a tidy little fiction. When I ran a real model on the same task, it didn't reason out loud or stumble and recover — so I stopped scripting my AI lessons and started recording them. The lesson changed because the recording refused to match my plan. (2026-05-25)
- [Most of the frame should be quiet](https://vizlearn.app/blog/most-of-the-frame-should-be-quiet.md): Draw every element at full strength and the frame comes out accurate and unreadable — a learner can't tell where to look. The thing I kept coming back to, lesson after lesson, was dull: pick one thing to be loud and let the rest go quiet. (2026-05-11)
- [I deleted the legend](https://vizlearn.app/blog/i-deleted-the-legend.md): Every algorithm visualizer ships a color key — yellow is comparing, red is swapping, green is sorted. I shipped one too, for longer than I'd like to admit, until I stopped naming colors by how they look and named them by what they mean. Then the key explained nothing the picture didn't, so I took it off. (2026-04-25)
- [The default input is the curriculum, not a sample](https://vizlearn.app/blog/default-input-is-the-curriculum.md): Most learners never open the config panel, so the array that loads by default is the only run they ever see. That makes it the lesson — and a tidy default that hides the property you came to teach quietly downgrades the whole thing to a movie. (2026-04-02)
- [It's not too fast](https://vizlearn.app/blog/its-not-too-fast.md): The bug report is usually the same three words — it's too fast — and the fix it asks for is to slow the clock down. But in lesson after lesson, too fast turned out to be a density problem: too much happening in one beat. The cure was duller than any clock knob — split the beat into more beats and leave the seconds alone. (2026-03-23)
- [A fixed canvas is why one component kit works everywhere](https://vizlearn.app/blog/fixed-canvas.md): The reflex in 2026 is a fluid, responsive canvas that fits any screen. I kept doing the opposite: every VizLearn lesson draws on a canvas that is always exactly 1920×1080. It looked backwards at first, then turned into the constraint that let a hand-drawn component move from a sorting lesson to a neural net and still land in the right place. (2026-03-15)
- [AI is a great reverse-engineer. That's the trap.](https://vizlearn.app/blog/ai-reverse-engineering-trap.md): An AI read Motion Canvas's compiled bundle and Excalidraw's renderer for me and handed back the parts that mattered. That was useful enough to keep doing — and comfortable enough to lead me into a month building a tool I should have just adopted. (2026-03-13)
- [I wanted a paintbrush, not a drawing app](https://vizlearn.app/blog/paintbrush-not-a-drawing-app.md): VizLearn's hand-drawn look started life on the Excalidraw npm package — until it became clear I'd adopted a whole drawing app when what I needed was a paintbrush. This is the detour through roughjs and Remotion, the bug that made my rounded rectangles look terrible, and the two Excalidraw functions I kept (and credited). (2026-03-12)
- [I wanted a dependency, not an engine](https://vizlearn.app/blog/dependency-not-an-engine.md): I could make Motion Canvas play, and even seek — I wrote a player that did. The trouble was that 'step 7' isn't a timestamp; it has to drive the animation, the code highlight, the log, and the input at once. Chasing that mismatch down, I rebuilt Motion Canvas in 679 lines of my own — then deleted it for Remotion. (2026-03-11)
- [I wanted a component, not a studio](https://vizlearn.app/blog/component-not-a-studio.md): VizLearn's first three months ran on Motion Canvas, not Remotion. I switched when learner input, scrubbing, and code-sync all needed to live inside the app — and the detour taught me to pay attention to the boundary I was building at, not just the output format. (2026-03-09)
- [I built a debugger, not an animator](https://vizlearn.app/blog/debugger-not-an-animator.md): Most algorithm visualizers play you a movie. VizLearn pins the code, the visual stage, and the log to the same instant — a trace debugger for learning an algorithm, not a clip to watch. This is the architecture I ended up with after chasing that alignment through the implementation. (2026-02-26)
- [I started with binary search](https://vizlearn.app/blog/i-started-with-binary-search.md): Before VizLearn there was AlgoV, and before that, binary search: five lines of code where every hard part is a boundary. Static diagrams could only ever show the author's input. I wanted to type mine. (2026-02-18)

## Optional

- [Full text](https://vizlearn.app/llms-full.txt): every document above in one file
- [Changelog](https://vizlearn.app/changelog): dated release notes