All 663 animated visualizations, grouped by topic. Prefer a plain list? See the text index.
Algorithms & Data Structures
Basics 6
Recursion 5
Indexing 31
Linear, Binary and Interpolation Search
Binary Search Trees
AVL Trees
Red-Black Trees
AVL vs Red-Black Tree
Splay Trees
Skip List
Open Hash Tables
Closed Hash Tables
Closed Hash Tables, using buckets
Separate Chaining vs Linear Probing, side by side
Bloom Filter
HyperLogLog
LRU Cache
Cache Eviction: LRU vs LFU vs FIFO vs CLOCK vs OPT
Trie
Radix Tree
Trie vs Hash Map
Ternary Search Tree
B Trees
B+ Trees
B-Tree vs B+Tree
Quadtree vs Geohash: Restaurants Near Me
KD-Tree vs R-Tree: Spatial Indexing
Fenwick Tree / Binary Indexed Tree
Segment Tree
Reservoir Sampling
Count-Min Sketch
Segment Tree vs Fenwick Tree, side by side
Cuckoo Hashing
Treap
Sorting 10
Heap-like Data Structures 7
Graph Algorithms 28
Breadth-First Search
Depth-First Search
BFS vs DFS
Connected Components
Strongly Connected Components
Kosaraju vs Tarjan
Euler Path and Circuit
Dijkstra's Shortest Path
Bellman-Ford Shortest Path
A* Search
Dijkstra vs A*
Dijkstra vs Bellman-Ford
Floyd-Warshall vs Johnson
Floyd-Warshall
Prim's Minimum Cost Spanning Tree
Kruskal Minimum Cost Spanning Tree Algorithm
Prim vs Kruskal
Topological Sort
Topological Sort
Graph Coloring
Maximum Flow
Grid Pathfinding
Grid Pathfinding Side by Side
Grid Replanning: A* from Scratch vs D* Lite
Any-Angle Path Planning: A* vs Theta*
Maze Generation Side by Side
Lowest Common Ancestor: Binary Lifting
Bipartite Matching and the Hungarian Algorithm
Dynamic Programming 10
String & Greedy Algorithms 9
Geometric Algorithms 11
2D Rotation and Scale Matrices
2D Rotation and Translation Matrices
2D Changing Coordinate Systems
3D Rotation and Scale Matrices
3D Changing Coordinate Systems
Fourier Series and the FFT
Convex Hull: Graham Scan vs Gift Wrapping
Bézier Curves
JPEG Compression: DCT and Quantization
Rasterization: Edge Functions and the Z-Buffer
Ray Tracing vs Rasterization
Mathematics
Number Theory 13
Number Bases and Two's Complement
Euclidean Algorithm
Sieve of Eratosthenes
The Ulam Spiral: Primes on Diagonals
Modular Exponentiation and Toy RSA
The Times-Table Circle: i → k·i mod N
The Sunflower Spiral: Vogel's Model and the Golden Angle
Extended Euclid, Modular Inverse and Toy RSA
Prime Factorization
Chinese Remainder Theorem
The Collatz Conjecture: 3n + 1 Hailstones and the Collatz Seaweed
Hamming Code
Reed-Solomon Erasure Coding
Algebra & Functions 23
Function Transformations
Quadratic Equations
What a, b and c Do to a Parabola
Polynomial Division
Cubic Functions: What a, b, c, d Do
Types of Asymptotes
Rational Functions: What a, b, c, e, f Do
Exponentials and Logarithms
Exponential Graphs: What a, b, h, k Do
Damped Oscillation: What A, γ, ω, φ Do
The Heart Curve: a Sine Wave Filling a Heart
A Wave in Any Envelope: h
Driven Oscillator: Resonance, Phase Lag and Q
Spring Oscillator: What m, k, A, ω, f, T Do
Simple Pendulum: What L, g, m, θ₀ and T, f, ω Do
Elastic and Inelastic Collisions: What m₁, m₂, v₁, v₂, e Do
Collisions in 2-D: What m₁, m₂, v₁, b, e Do
Ballistic Pendulum: What m, M, v, L Do
Projectile Motion: What v₀, θ, g and h Do
A Block on a Ramp: What θ, m, μs, μk Do
Orbital Motion: Circles, Ellipses, Escape and Kepler's Laws
RC Circuit: Charging and Discharging a Capacitor
Lens Ray Diagrams: Where the Image Forms
Trigonometry & Geometry 28
The Pythagorean Theorem
Proofs Without Words
Circle Theorems
Triangle Centres
Euler's Formula V − E + F = 2
The Unit Circle: sin, cos, tan
Sine Waves: What a, b, c, d Do
Cosine Waves: What a, b, c, d Do
Wave Interference: Two Coherent Sources
Standing Waves on a String: What n, L, T, μ Do
Transverse and Longitudinal Waves: a Rope, Sound and Water
Group Velocity and Phase Velocity: Beats, Wave Packets, Dispersion
The Doppler Effect: Why a Passing Siren Changes Pitch
Tangent Graphs: What a, b, c, d Do
Polar Coordinates
The Rose Curve r = cos kθ: Petals as k Goes from 0 to 10
The Lemniscate of Bernoulli
The Maurer Rose: Straight Lines Across a Rose
Lissajous Figures: Two Sine Waves Drive One Pen
Harmonograph: a Pen Driven by Damped Pendulums
Spirograph: Hypotrochoids and Epitrochoids
The Butterfly Curve: Six Laps of a Polar Pen
The Superformula: Gielis Shapes from Four Numbers
Ellipse: What a, b, h, k Do
Parabola: Focus, Directrix and What p, h, k Do
Hyperbola: What h, k, a, b Do
Conic Sections: What A, B, C, D, E, F Do
Conics by Eccentricity: r = ep/
Quadric Surfaces 18
Quadric Surfaces
Ellipsoid
Hyperboloid of One Sheet
Hyperboloid of Two Sheets
Elliptic Paraboloid
Hyperbolic Paraboloid
Elliptic Cone
Elliptic Cylinder
Hyperbolic Cylinder
Plane Equation
Surfaces of Revolution
Quadric Classification
Surfaces by Degree: Planes, Quadrics, Cubics, Quartics
Monkey Saddle
Cubic Surface x³ + y³ + z² = 1
Cayley's Nodal Cubic
Quartic Surface x⁴ + y⁴ − z⁴ = 1
Kummer Surface
Linear Algebra & Complex Numbers 27
2D Vectors and the Dot Product
Determinant: how a 2×2 matrix scales area
Gaussian Elimination
Eigenvectors & Eigenvalues
Complex Numbers
Matrix Multiplication
Linear Transformations
Rotation Matrix
Reflection Matrix
Scaling Matrix
Shear Matrix
Projection Matrix
Squeeze Mapping
Composing Transforms
Affine Transforms: Translation as a 3×3 Matrix
Inverse Matrix
Diagonalization: A = P D P⁻¹
Column Space and Null Space
Gram–Schmidt and QR
3D Rotation Matrix
3D Reflection Matrix
Projection Matrix in 3D
3D Shear Matrix
Quaternions
Perspective Projection: the Pinhole Camera
Least Squares as Projection
SVD and PCA in 2D
Calculus 30
Limits & Continuity
Derivative as a Limit
Local Linearity: Zoom In
Derivative Rules as Pictures
f, f′, f″: Reading Derivative Graphs
Critical & Singular Points
Mean Value Theorem
Accumulation: Rate → Amount
Riemann Sums
Numerical Integration: Riemann vs Trapezoid vs Simpson
Geometric Series
Taylor Series
Fourier Series, Harmonic by Harmonic
Fourier Epicycles: Drawing a Shape with Spinning Circles
The Weierstrass Function: Continuous Everywhere, Differentiable Nowhere
Newton's Method
Root Finding: Bisection vs Newton vs Secant
The Chain Rule
Fundamental Theorem of Calculus
Integration by Parts and Substitution
Volumes by Slicing
Improper Integrals
Six Types of Integrals
Euler's Method
Runge–Kutta vs Euler
The Logistic Map: from a Fixed Point to Chaos
The Lorenz Attractor: Deterministic Chaos
The Double Pendulum: Normal Modes and Chaos
The Laplace Transform
Level Curves and Contour Maps
Fractals 5
Physics & Circuits 11
RLC Circuits: Charging, Ringing and Resonance
Ohm's Law and Kirchhoff's Laws: Solving a Resistor Network
Diodes and Rectifiers: AC In, DC Out
The Ideal Op-Amp: Two Rules, Four Circuits
Electromagnetic Waves: E, B, c and Polarization
A Dipole Antenna: How Radio Waves Are Sent and Received
Polarizers and Malus's Law: Linear, Circular and Unpolarized Light
Refraction: Why Light Bends, Snell's Law and Total Internal Reflection
Diffraction: Single Slit, Double Slit and Gratings
Faraday's Law: Electromagnetic Induction and Lenz's Law
The Transistor as a Switch: MOSFET, BJT, CMOS NOT and NAND
Probability & Statistics 13
Bayes' Theorem
Pascal's Triangle
Permutations vs Combinations
Central Limit Theorem
Monte Carlo Estimation of π
Normal Distribution, z-Scores and Confidence Intervals
Mean vs Median vs Mode
Markov Chains and Random Walks
Binomial vs Poisson
Hypothesis Testing with a Coin
Confidence Intervals
The Birthday Paradox
The Monty Hall Problem
Logic, Sets & Counting 6
Systems
Databases & Storage 29
B+ Tree as a Database Index
Clustered vs Secondary Index, side by side
LSM Tree vs B+ Tree
Row Store vs Column Store
Snowflake vs UUIDv4 vs UUIDv7
How MySQL Runs a Query
How MySQL Executes JOIN, GROUP BY and ORDER BY
How PostgreSQL Runs a Query
How PostgreSQL Executes JOIN, GROUP BY and ORDER BY
How a SELECT Runs: WHERE, GROUP BY, HAVING, ORDER BY
How a Query Planner Picks a Plan
Nested Loop vs Hash Join vs Merge Join
Database Connection Pool
Connection Pool Settings in Action
The N+1 Query Problem
How MongoDB Runs a Command
MongoDB Sharding: mongos, Chunks and the Balancer
MongoDB Replica Set Elections and Rollback
MongoDB Read Concern and Causal Consistency
MongoDB Multi-Document Transactions
MongoDB Aggregation Pipeline, Stage by Stage
MongoDB Indexes: Compound, ESR, Multikey, Covered
MVCC and Isolation Levels
Optimistic vs Pessimistic Locking
Two-Phase Locking and Deadlock Detection
Write-Ahead Logging and ARIES Crash Recovery
SQLite Internals
Database Normalization: 1NF, 2NF and 3NF
Inverted Index: From Documents to Posting Lists
PostgreSQL Internals 15
PostgreSQL Process Architecture
PostgreSQL Shared Buffers and the Clock Sweep
Inside a PostgreSQL Heap Page
How PostgreSQL Stores Big Values
PostgreSQL Free Space Map and Visibility Map
PostgreSQL pg_xact
PostgreSQL XID Wraparound and Freezing
The PostgreSQL Lock Manager
Serializable Snapshot Isolation in PostgreSQL
PostgreSQL WAL Internals
PostgreSQL Checkpoints
PostgreSQL Logical Decoding and Logical Replication
PostgreSQL Index Types
PostgreSQL Bitmap Index Scan and Bitmap Heap Scan
PostgreSQL Parallel Query
MySQL / InnoDB Internals 15
The InnoDB Buffer Pool: Midpoint LRU and Flushing
Inside an InnoDB Index Page
The InnoDB Change Buffer
InnoDB Adaptive Hash Index
InnoDB Doublewrite Buffer and Torn Pages
InnoDB Undo Logs, Read Views and Purge
InnoDB Isolation: Snapshot Reads vs Current Reads
InnoDB Record, Gap and Next-Key Locks
MySQL Metadata Locks and Online DDL
InnoDB Redo Log Internals
MySQL Binlog Group Commit
InnoDB Crash Recovery
MySQL Replication Internals
MySQL Group Replication and InnoDB Cluster
MySQL Index Access Paths and EXPLAIN
Distributed Systems 61
Primary–Replica Replication: Sync vs Async, Lag and Failover
Consistency Patterns: Weak, Eventual, Causal, Strong
The CAP Theorem: CP vs AP Side by Side
How Raft Elects a Leader and Replicates a Log
Raft vs Multi-Paxos, Side by Side
etcd: the Store Behind Kubernetes
Paxos: How Three Acceptors Agree on One Value
Lamport Clocks and Vector Clocks
Leader Election: Bully vs Ring
Byzantine Fault Tolerance: PBFT
Gossip and SWIM: How a Cluster Knows Who Is Alive
Chandy–Lamport Distributed Snapshot
Quorum Reads and Writes
Leader-based vs Leaderless Replication
CRDTs: Conflict-Free Replicated Data Types
Merkle Trees for Anti-Entropy Repair
Partitioning vs Sharding
Consistent Hashing
Range vs Hash Partitioning
MapReduce: Word Count, Shuffle and Failures
Saga vs Two-Phase Commit
Two-Phase Commit
Saga: Orchestration vs Choreography
Transactional Outbox and Inbox
Delivery Semantics: At-most-once vs At-least-once vs Exactly-once
Event Sourcing and CQRS
Change Data Capture: Log Tailing from the WAL to Kafka
How Kafka Moves a Message
Push vs Pull Messaging: RabbitMQ vs Kafka
Kafka Consumer Groups: Rebalancing, Duplicates and Exactly-Once
Kafka Log Segments: How a Partition Is Stored on Disk
Kafka Replication: Fetching, the ISR, Leader Epochs and Truncation
Kafka Log Compaction
Kafka KRaft: the Controller Quorum and the Metadata Log
Kafka Zero Copy
How Redis Sentinel Fails Over a Master
How Redis Cluster Shards and Fails Over
How Redis's Keyspace Dict Rehashes
How a Redis Sorted Set Is Stored
How Redis Stores Small and Large Values
How Redis Forgets Keys: Expiry and Eviction
How Redis Saves Data: RDB Snapshots and the AOF
How Redis Replicas Sync: PSYNC and the Backlog
Redis Streams and Consumer Groups
Redis Transactions and Scripts
Distributed Locks and Fencing Tokens
Cache Strategies Side by Side
Circuit Breaker and Bulkhead
Monolith vs Microservices
Distributed Tracing with OpenTelemetry
Rate Limiting: Token Bucket vs Leaky Bucket
Backpressure: When the Producer Is Faster than the Consumer
Latency vs Throughput
Kubernetes Cluster Architecture
The Life of a Kubernetes Pod
How Kubernetes Talks to containerd and Docker
Kubernetes Container Lifecycle Hooks
How the Kubernetes Control Plane and Nodes Talk
Bitcoin Merkle Trees and SPV Proofs
Object Storage: How an S3-style Store Keeps a File
Proof of Work: Mining a Chain of Blocks
Software Design 14
SOLID Principles
Hexagonal Architecture: Ports and Adapters
The Observer Pattern vs Publish–Subscribe
Virtual DOM Diffing: How React Reconciles
Strategy and Factory Method Patterns
Inheritance vs Composition
Decorator, Proxy and Adapter: Wrappers That Share One Interface
The Command Pattern: Undo and Redo
The State Pattern
Git Three-Way Merge
Git Packfiles
Git Merge vs Rebase
Git Branches and HEAD: Pointers to Commits
Git Objects: Blobs, Trees and Commits
Networking 38
Internet Protocol Layers
Cyclic Redundancy Check
How ARP Finds a MAC Address
How a Router Forwards a Packet
Hub vs Switch vs Router
Anycast and BGP: One Address, Many Sites
How NAT Shares One Public Address
IPv4 vs IPv6
How Docker Networking Works on One Host
How a VPN Works: a WireGuard Tunnel
Forward Proxy vs Reverse Proxy, Side by Side
How a Device Gets an IP Address
The Life of an HTTP Request in Kubernetes
Kubernetes Service Types
How a DNS Name Is Resolved
NTP: How a Clock Sets Itself From Four Timestamps
How a CDN and Route 53 Work
How an API Gateway Handles a Request
TCP vs UDP
ARQ: Stop-and-Wait vs Go-Back-N vs Selective Repeat
How TCP Congestion Control Works
How an HTTP Connection Is Established
A TCP Socket in Linux
The Linux Listen Backlog
Unix Socket vs TCP on Loopback
TCP Three-Way Handshake and the Listen Queues
How an HTTPS Connection Is Established
TLS Certificate Chain and Revocation
HTTP/1.1 vs HTTP/2 vs HTTP/3
The QUIC Handshake vs TCP + TLS 1.3
WebSocket vs SSE vs Long Polling
How a gRPC Call Travels over HTTP/2
REST vs GraphQL vs gRPC
How HTTP Caching Works: Browser Cache, CDN and Origin
TCP Flow Control: the Receive Window
How Traceroute Works
VLANs: One Switch, Several Networks
Wi-Fi CSMA/CA
Web & Security 22
How Browser Cookies Work
CORS and the Preflight Request
CSRF and SameSite Cookies
XSS and Content-Security-Policy
How OAuth 2.0 Works
JWT vs Session Cookies
HttpOnly Cookie vs localStorage
How a Digital Signature Works
How Diffie-Hellman Key Exchange Works
Salt vs Pepper: Storing Passwords
Symmetric vs Asymmetric Encryption
Encryption vs Hashing
Inside AES-128 and SHA-256
OWASP A02:2025 Security Misconfiguration
OWASP A04:2025 Cryptographic Failures
OWASP A06:2025 Insecure Design
OWASP A07:2025 Authentication Failures
OWASP A08:2025 Software or Data Integrity Failures
How Kerberos Works
Mutual TLS: Both Sides Show a Certificate
Password Hashing: Fast vs Slow Hashes
Server-Side Request Forgery
Servers & Event Loops 16
How Tomcat handles an HTTP request
How nginx Handles an HTTP Request
nginx Proxy Request: Memory, System Calls and Kernel
Scale Up vs Scale Out: vertical vs horizontal scaling
Canary, Blue/Green and Rolling Deployments
A/B Testing
Linux epoll
How a request is handled in Tomcat and Linux epoll
io_uring vs epoll
Blocking vs Non-blocking vs Async I/O
Reactor vs Proactor
The Node.js Event Loop
How the Browser Runs JavaScript: the Event Loop
Server-side vs Client-side Rendering
Node.js Under the Hood: libuv and Where the Work Runs
How Redis Serves Many Connections with One Thread
Operating Systems 43
How Linux Boots
systemd Units: Dependencies, Restart and Socket Activation
How a C Program Is Compiled, Linked, Loaded and Started
Little-Endian vs Big-Endian
Static vs Dynamic Linking, side by side
How a C/C++ Program Is Compiled and Run: What C++ Adds
How Linux Loads a Program
A Linux System Call, Step by Step
How Linux Delivers a Signal
How strace and gdb Work
TTY, PTY and Job Control: What Ctrl-C Really Does
What a Container Really Is
seccomp and eBPF: Programs Inside the Kernel
How a Dockerfile Becomes Image Layers
Linux Context Switch
Process vs Thread, side by side
The Interrupt-Driven I/O Cycle
Kinds of Interrupts in Linux
CPU Scheduling
Linux Load Average, Explained
Preemptive vs Cooperative scheduling
Real-Time Scheduling and Priority Inversion
Disk Scheduling
Banker's Algorithm
Linux Virtual Memory
The TLB and the x86-64 Page Walk
Copy-on-Write fork
A Linux Process from fork
How the Shell Runs ls | grep foo
Paging and Page Replacement
Paging vs Segmentation
Direct Memory Access: How a NIC Moves Packets
How Linux Receives a Packet
How a File System Survives a Crash
The Page Cache: read vs mmap
How a Hard Disk Reads and Writes Data
How an SSD Reads and Writes Data
The Linux Block Layer: How a Write Reaches the Disk
What open
Linux Permissions: uid, rwx, setuid and Capabilities
The Buddy Allocator
Linux Out of Memory: Reclaim, kswapd and the OOM Killer
Stack vs Heap in C
Concurrency 21
Concurrency vs Parallelism
Bounded Buffer / Producer–Consumer
Monitor & Condition Variables
Readers–Writers Problem
Dining Philosophers
Test-and-Set Spinlock
Compare-and-Swap
Spinlock
Mutex with a Futex
Mutex vs Spinlock, side by side
How a Mutex Works: the Futex
Readers–Writer Lock
Read-Copy-Update
Semaphore
Semaphore vs Condition Variable
The Go Scheduler
OS Threads vs Goroutines
Inside a Goroutine
Coroutines: Stackful vs Stackless
Thread Pool: Java ThreadPoolExecutor
The Python GIL
Computer Architecture 31
Levels of Abstraction in a Computer
Sequential Logic: Latches, Flip-Flops, Registers and Counters
A Latch and a Flip-Flop Built from Transistors
Timing Analysis: Setup, Hold, Clock Skew and Synchronizers
Finite State Machines: Moore, Mealy, Encodings and Factoring
Logic Gates: NOT, Buffer, AND, OR, NAND, NOR, XOR, XNOR
Combinational Logic: Gates, Adders, Muxes and the ALU
Multilevel Logic, Bubble Pushing, and the Values X and Z
From Verilog to Hardware: What Synthesis Builds
Arithmetic Circuits: Fast Adders, Comparators, Shifters, Multiplier
Number Systems: Two's Complement, Fixed Point and IEEE 754 Floating Point
Memory Arrays: DRAM, SRAM, ROM, Register Files, PLAs and FPGAs
From C to MIPS Machine Code: Branches, Instruction Formats and Addressing Modes
Translating and Starting a MIPS Program
MIPS Procedure Calls: jal, jr $ra, the Stack and Saved Registers
Building the Single-Cycle MIPS Datapath
The Single-Cycle MIPS Processor
How a Program Runs on the MIPS Datapath
Exceptions in the MIPS Processor
The MIPS Pipeline: Hazards and Forwarding
Branch Prediction on the MIPS Pipeline
Single-Cycle vs Multicycle vs Pipelined MIPS: a Performance Race
Superscalar and Out-of-Order Execution with Register Renaming
Parallel Hardware: SIMD, Multithreading and Multicore
How a CPU Cache Finds, Misses and Replaces
One Load Through the Memory Hierarchy
DRAM Timing: Why Reading Memory in Order Is Fast
MESI Cache Coherence and False Sharing
Virtual Memory in Hardware: Page Table, TLB, Protection and Replacement
Embedded I/O: Memory-Mapped I/O, GPIO, UART, SPI, Timers and Interrupts
Register Allocation by Graph Coloring
Java & the JVM 20
Compiler vs Interpreter
How a Java Program Is Compiled and Run
How a Java Application Starts
HotSpot JIT Tiers
How V8 Runs JavaScript
Java Garbage Collectors: Parallel GC, G1, ZGC
Tracing GC vs Reference Counting
Stack vs Heap in Java
How Java's HashMap Works
How Java's TreeMap Works
How Java's ConcurrentHashMap Works
From a Java Thread to a CPU Core
Java ForkJoinPool and Work Stealing
Spring Core: IoC Container, Bean Lifecycle, Scopes, AOP Proxies
Inside a Tiny Compiler
Go's Garbage Collector
How Java Loads a Class
Java Memory Model: happens-before, volatile, synchronized
Python Garbage Collection: Reference Counting and the Cycle Collector
Java Virtual Threads vs Platform Threads
Machine Learning 44
Gradient Descent
SGD vs Momentum vs Adam
Linear & Logistic Regression
L1 vs L2 Regularization
Perceptron Learning Rule
K-Nearest Neighbors
K-Means Clustering
Supervised vs Unsupervised vs Reinforcement Learning
DBSCAN Density Clustering
PCA vs t-SNE
Decision Tree Learning
Random Forest vs Gradient Boosting
Naive Bayes Spam Filter
Precision vs Recall
Neural Network Forward Pass
Neural Network: Recognizing Digits
Backpropagation
Backpropagation Intuition
Draw a Digit: Neural Network Math
Draw a Digit: Template Matching
Softmax & Cross-Entropy
Train a Tiny Network on Your Points
Convolution in a CNN
CNN vs Transformer: Receptive Field vs Self-Attention
Recurrent Networks: RNN, LSTM and GRU
Self-Attention
Byte-Pair Encoding
How a Large Language Model Works
Decoding Strategies: Greedy vs Beam Search vs Top-p
LoRA and Quantization
How an AI Agent Works
Retrieval-Augmented Generation
HNSW Vector Search
MCP: the Model Context Protocol
BM25 vs Vector Search vs Hybrid
Diffusion Model
Dropout & Batch Normalization
The KV Cache
Logistic Regression
Mixture of Experts
RLHF vs DPO
Speculative Decoding: Draft Model and One-Pass Verification
Support Vector Machine
Word2Vec
