See algorithms think.
Read the C++ line-by-line.
Step through 60+ classic algorithms in real-time. Every animation is paired with the matching C++ STL implementation — and the currently-executing line lights up as you watch.
Algorithm DNA
Tap any card for the key idea behind each algorithm family.
Big-O Playground
Scroll on the chart to zoom · hover for exact values.
Explore by category
Ten sections, dozens of algorithms — every one with a synced C++ panel.
Live Sort Race
5 algorithms, same array — watch them race step-by-step.
A* Pathfinding — Live 3D
Watch A* explore the grid, then trace the optimal path.
What you get
Designed to make algorithms click — not just watch them move.
Step-by-step playback
Play, pause, step forward or back. Adjust speed at any time to slow down the tricky parts.
Live C++ STL code
Each visualization is paired with clean, well-commented C++ using STL you can read, copy, or download.
Synced line highlighting
As the visualization runs, the matching line in the C++ source lights up so the algorithm makes sense.
Custom inputs
Type your own arrays, draw obstacles on pathfinding grids, and pick from sample graphs.
Complexity badges
Time and space complexity are shown next to every algorithm so trade-offs are obvious.
Fully responsive
Looks and feels great on phone, tablet, laptop, monitor — code panel adapts to your screen.
Algorithm Spotlight
Auto-rotating — one classic algorithm at a time.
Dijkstra
Shortest path on positively-weighted graphs · GPS, routers
How it works
Four steps from curious to confident.
Pick a category
Choose Sorting, Searching, Graphs, DP and more from the sidebar.
Pick an algorithm
Each category ships with multiple classic algorithms to compare side-by-side.
Press play
Watch it run. Step backwards, adjust speed, or jump frame-by-frame.
Read the code
The C++ panel highlights the line that is currently executing.
Complexity at a glance
How the algorithms stack up.
| Algorithm | Best | Average | Worst | Space |
|---|---|---|---|---|
| Bubble Sort | O(n) | O(n²) | O(n²) | O(1) |
| Quick Sort | O(n log n) | O(n log n) | O(n²) | O(log n) |
| Merge Sort | O(n log n) | O(n log n) | O(n log n) | O(n) |
| Heap Sort | O(n log n) | O(n log n) | O(n log n) | O(1) |
| Binary Search | O(1) | O(log n) | O(log n) | O(1) |
| BFS / DFS | O(V+E) | O(V+E) | O(V+E) | O(V) |
| Dijkstra | O(E log V) | O(E log V) | O(E log V) | O(V) |
| Bellman-Ford | O(VE) | O(VE) | O(VE) | O(V) |
| Floyd-Warshall | O(V³) | O(V³) | O(V³) | O(V²) |
Everything covered
A peek at the algorithms waiting for you.
Pseudocode in motion
Watch Quick Sort step through its own code.
function quickSort(a, lo, hi):◀ Entry pointif lo >= hi: returnpivot = a[hi]i = lo - 1for j = lo to hi - 1:if a[j] <= pivot: swap(a[++i], a[j])swap(a[i+1], a[hi])quickSort(a, lo, i); quickSort(a, i+2, hi)
Built with
Modern tooling for a snappy experience.
A short history
The minds behind the algorithms you're learning.
Did you know?
Six surprising facts about the algorithms you use every day.
Binary search beats linear search by 1,000,000×
On a sorted list of 1B items, linear search takes ~1B steps. Binary search takes ~30. That's the power of O(log n).
Strategy algorithms, animated
Six animated strategy algorithms — each with synced Python code and an explanation.
Play the Prisoner's Dilemma
Pick a choice for each prisoner and watch the payoff. Years in prison — lower is better.
Strategy showdown
A round-robin Iterated Prisoner's Dilemma — the simple, forgiving Tit-for-Tat tends to come out on top.
Ready to see your first algorithm?
Bubble sort is a great place to start. Then graduate to graphs and DP when you're hooked.