60+ algorithms · 4 languages · zero setup

Stop memorizing. Start seeing algorithms.

AlgoViz runs real code in front of you — every comparison, swap and recursive call, with live variables and call stacks. Then the roadmap, problem bank and interview prep make it stick.

Start the roadmap
Open a visualizer

no credit card

quick_sort.js — instrumented trace
step 1/10
algorithmjavascript
1function quickSort(arr, lo, hi) {
2  if (lo >= hi) return;
3  const p = partition(arr, lo, hi);
4  quickSort(arr, lo, p - 1);
5  quickSort(arr, p + 1, hi);
6}
7 
8function partition(arr, lo, hi) {
9  const pivot = arr[hi];
10  let i = lo;
11  for (let j = lo; j < hi; j++) {
12    if (arr[j] < pivot) [arr[i], arr[j]] = [arr[j], arr[i]], i++;
13  }
14  [arr[i], arr[hi]] = [arr[hi], arr[i]];
15  return i;
16}
scopepivot= 55lo= 0hi= 5j= —
array statequickSort(0,5)
38
lo
27
1
43
2
10
3
82
4
55
P

↑ This is the actual product, running live. Every visualizer works exactly like this.

JavaScriptPythonGoC++free sandbox · no API keyJavaScriptPythonGoC++free sandbox · no API key
The whole journey

One platform, first offer

Learn the concept, watch the state, drill the pattern, walk into the interview with it already loaded.

Begin
01 · Learn in order

Guided roadmap

8 stages from Big-O to segment trees. Every topic pairs a concept with the visualizer that proves it.

02 · Watch it run

60+ visualizers

Every core algorithm, animated step by step on your own input.

2
5
8
12
16
23
38
56
72
91
03 · Your code

Trace real code

JS · Python · Go · C++. Genuine instrumentation, not canned animation.

main()
04 · Drill patterns

Problem bank

Blind 75 and topic sheets, tagged by pattern and tracked to completion.

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
05 · Compare

Race algorithms

Two algorithms, one input, synced playback — watch complexity lose live.

06 · Look it up

Cheatsheets

Complexity tables, pattern catalogue and templates in four languages.

n log n
n²
n = 8
07 · Structures

Data structures

Trees, heaps, tries and linked lists drawn as they mutate in memory.

0
0
1
2
head → … → null
Complexity, proven

Big-O is a claim. This is the receipt.

The same 28-element array, run through both sorts, counting every comparison and swap as it happens.

Quick sort

O(n log n)
comparisons
0
swaps
0
vs the winner
—

Bubble sort

O(n²)
comparisons
0
swaps
0
vs the winner
—

same 28-element array · same seed · live counters

Full race arena
How it works

Three moves to mastery

1

Watch it run

Every comparison, swap and stack frame animated. Pause anywhere and inspect the exact state at that line.

Open visualizers
2

Trace your version

Paste your own implementation. The engine instruments it, so your bugs become visible instead of theoretical.

Open workspace
3

Drill the pattern

Take it into the problem bank. Filter by topic, mark problems solved, and watch the ring fill.

Open problem bank
0+
visualizers
0
traced languages
0
curated problems
$0$
to get started
FAQ

Straight answers

The roadmap, all 60+ visualizers, the problem bank, the cheatsheets, AI step explanations and tracing your own code are free — with no run cap for anyone. Pro ($1 for your first 6 months) adds reference solutions and deeper study tools.

JavaScript and Python run with true statement-level instrumentation. Go and C++ are traced with a static parser that reports variables and the call stack at every step.

No. Code executes in a cloud sandbox and your progress lives in your browser. Open the site and press play.

A companion. Understand the algorithm here while the state is visible, then go solve the problem there with the pattern already locked in.

Your first algorithm is ten steps away.

Free forever for the core platform. No credit card, no setup — just press play.