Why Sort & Visualize exists
Sorting algorithms are one of the most fundamental topics in computer science — and one of the most commonly misunderstood. It is entirely possible to read pseudocode for Quick Sort a dozen times, pass a test on it, and still have no mental picture of what the algorithm actually does to the data.
Sort & Visualize exists to close that gap. Watching Merge Sort split a list and recombine it, or seeing Quick Sort partition around a pivot, turns a page of notation into something you can picture afterwards from memory. The written guides then fill in the parts an animation cannot show: why the complexity is what it is, and when each algorithm is actually the right choice.
The goal is simple: make sorting algorithms approachable, memorable, and even enjoyable to explore.
What this site stands for
Hi, I'm Aman Jaiman
I'm a software engineer, currently working at an early-stage startup that is still in stealth — so there is not much I can say about what we are building. Before that I spent around a year and a half as a front-end engineer, which is where most of my instincts about interfaces and animation come from.
I am genuinely passionate about software development, and Sort & Visualize is what that looks like outside of work. Front-end engineering is largely the craft of making complicated state legible to a person looking at a screen — which turns out to be exactly the problem with teaching sorting algorithms. That overlap is the whole reason this site exists.
You can reach me at amanjaiman890@gmail.com, or find my code on GitHub.
One person, not a company
Sort & Visualize is an independent personal project. I write the code, build the visualisations and write every article on the site. There is no company behind it, no editorial team, and no other contributors. When you email the site, I am the person who reads it.
I am not a professor and I do not claim any formal teaching credential. What I do have is the experience of learning this material the hard way — from static textbook diagrams that never quite explained what was happening — and a lot of time spent building and re-building these animations until they were genuinely clear. That is the perspective the site is written from, and it is the only authority I claim for it. Where I state a complexity or a language implementation detail, it is because I checked it against a primary source, not because I am asking you to take my word for it.
How the content is written and checked
Every article and every complexity table on this site is written by me, from scratch, for this site. Nothing is scraped, spun or reposted from elsewhere. I do not attribute articles to invented authors, I do not claim expert review that has not happened, and I do not pad articles to hit a word count.
Complexity figures, stability claims and "which language uses which algorithm" statements are checked against primary sources — language specifications, standard-library source code and the original papers — rather than against other blog posts. Where implementations differ between versions or vendors, the article says so instead of pretending there is one answer.
Every article carries a visible "Updated" date, and that date changes only when the content genuinely changes. If you find a mistake, please tell me — corrections are welcome, I fix them promptly, and I would much rather be corrected than be quietly wrong.
The visualiser is a teaching aid, not a benchmarking tool. Animation speed is deliberately slowed so you can follow it, so on-screen timing tells you nothing about real-world performance. Use the comparison and swap counters for that instead — those are exact.
How it's built
The site is statically generated, so every page is plain HTML by the time it reaches your browser. The visualiser itself is dependency-free vanilla JavaScript running entirely on your device — no data is sent anywhere when you run a sort.
- Astro for static page generation — every page ships as plain HTML
- Pure vanilla JavaScript for the visualiser — zero runtime dependencies
- Web Audio API for optional real-time audio feedback
- Tailwind CSS with CSS custom properties for consistent theming
- requestAnimationFrame-driven animation loop for smooth 60fps playback
- Space Mono & Syne typefaces via Google Fonts
What's covered
The visualiser animates 10 foundational sorting algorithms, from introductory to advanced:
- Bubble Sort — the classic teaching algorithm
- Selection Sort — minimal write operations
- Insertion Sort — excellent for nearly-sorted data
- Merge Sort — guaranteed O(n log n), stable
- Quick Sort — fastest in practice for random data
- Heap Sort — O(1) extra space with an O(n log n) guarantee
- Shell Sort — generalised insertion with gap sequences
- Counting Sort — linear time for bounded integers
- Radix Sort — digit-by-digit linear sorting
- Tim Sort — the hybrid used in Python, Java and Swift
The documentation covers each one in reference form, and the articles go deeper on complexity, comparisons and language implementations.