I've always found algorithms easier to understand once I can see them move. Pseudocode and textbook diagrams are fine, but for a lot of things — how a sort actually rearranges elements, why Dijkstra picks the path it does — a static picture only gets me so far. I usually end up tracing through it by hand on paper.

So I made a small thing to do that tracing for me: bigoh.dev. It's free, open, and meant for learning. Sharing it here in case it's useful to anyone else who thinks the same way.

What it does

You pick an algorithm or data structure, edit the input, and press play. It runs step by step on a canvas. Below the animation there's a short description of what's happening at the current step, and the pseudocode with the active line highlighted. You can step forward and back, or scrub a timeline to jump around. That's basically it.

A few of the visualizations are interactive in a way that helps: on graphs you click to add nodes and edges, on grids you click to toggle walls, and on the geometry plane you click to drop points. Then you watch the algorithm run on the thing you just drew.

What's covered

There are around 67 visualizations right now, grouped roughly like this:

• Sorting — bubble, quick, merge, heap, counting, radix, and the usual rest.
• Searching — binary, jump, interpolation.
• Data structures — stack, queue, deque, linked list, hash table, BST, heap.
• Trees & graphs — traversals, BFS, DFS, Dijkstra, Bellman-Ford, MST (Prim, Kruskal, Borůvka), topological sort, connected components, cycle detection, bipartite check, Floyd-Warshall.
• Pathfinding & mazes — BFS, A*, greedy best-first, Dijkstra on weighted terrain, bidirectional search, plus maze generation (recursive backtracker, Prim, Wilson).
• Dynamic programming — edit distance, LCS, coin change, subset sum, knapsack (0/1 and unbounded), partition, Kadane, LIS, Fibonacci.
• And I try to expand the list

One example

The pathfinding ones are where seeing it move helped me most. Run plain BFS on a grid and it spreads out evenly in all directions, like a flood — it has no idea where the goal is. Switch to A* on the same grid and the explored area visibly leans toward the target, because it's using a heuristic to guess which direction is worth checking first. Watching the two side by side made the difference click for me in a way that "A* is informed search" never did.

Dijkstra on weighted terrain is similar: you can watch it deliberately detour around the expensive squares instead of just taking the straight line, and suddenly the cost function isn't abstract anymore.

On the tech

For the developers here: it's built with Vue 3, with the visualizations drawn on canvas using Konva. Each algorithm produces a list of steps up front, and the player just renders whichever step you're on — which is what makes stepping back and scrubbing work. The pages are statically prerendered so they load quickly and are reasonably friendly to search engines.

That's it

It's a hobby project and still growing, so there are rough edges and gaps. If you try it and something is confusing, broken, or just missing an algorithm you wanted to see, I'd genuinely like to hear about it — suggestions for what to add next are very welcome.

Here it is: bigoh.dev. Thanks for reading.