Every interactive lab we've built, organized by track. Machine Learning, Data Structures & Algorithms, and Deep Learning — learned by doing, not by reading.
Regression, classification, clustering, and evaluation — all interactive.
Fit a line to data by hand and compare it to the least-squares solution.
Explore how increasing polynomial degree changes the fit — and the risk of overfitting.
See how logistic regression draws decision boundaries for classification.
A beginner-friendly walkthrough of how gradient descent finds the optimum.
Roll down a loss surface and see how learning rate changes the path to the minimum.
Build and prune a decision tree while watching splits happen live.
A refined decision tree simulator with deeper visualization of splits and impurity.
Classify points live by adjusting k and watching decision boundaries shift.
An enhanced KNN sandbox with distance metrics and boundary visualization.
Watch SVM find the optimal separating hyperplane and margin.
Watch clusters form step-by-step as centroids converge on real data points.
Discover density-based clustering and how it finds clusters of arbitrary shape.
An upgraded density-based clustering sandbox with tunable epsilon and min-points.
Reduce dimensions visually and see which directions carry the most variance.
See how predictions map to actual outcomes and how metrics are derived.
Tune a classification threshold and watch precision and recall trade off live.
Compare two key evaluation curves and understand when to use each.
Explore how k-fold splits protect models from overfitting to a single dataset.
Visualize the tradeoff between underfitting and overfitting as complexity changes.
Add noise to data and watch how models react — and where they break.
Build intuition for probability distributions through interactive experiments.
A game-like sandbox for core statistics: mean, variance, and distributions.
Build intuition for vectors, dot products, and broadcasting through play.
Sorting, searching, graphs, and core data structures — visualized step by step.
A live recursion tree for the Master Theorem.
Brute force vs sliding window, counted side by side.
A balance-scale take on the Two Sum problem.
Range sums as water pouring through buckets.
Maximum subarray sum as a bursting bag.
Four shrinking tripwire boundaries trace the spiral.
A raw hex-address RAM simulation.
Reverse a linked list one rewired pointer at a time.
Cycle detection via slow and fast pointers.
Merge two sorted lists in O(1) space.
An LRU Cache as a theme-park ride queue.
Doubly linked list insert and delete, click by click.
Fold a linked list in half to check for a palindrome.
Clone a linked list that has random pointers.
Recursion as blocks stacking and collapsing.
Valid Parentheses as a Tetris-style falling stack.
Next Greater Element via a monotonic stack.
Sliding Window Maximum via a monotonic deque.
A literal ring layout for a circular queue.
N-Queens with live laser threat lines.
Rat in a Maze, backtracking one dead end at a time.
Watch a decision tree grow every permutation live.
One robot walks all three DFS tree traversal orders.
Balls fall through a funnel to build a BST.
All four AVL rotation cases, live.
A configurable-degree B-Tree with real search.
Two colored liquids climb and mix at the LCA.
BFS tree serialization with null markers.
A spreading puddle races a bolt of lightning.
Shortest paths as an expanding water wavefront.
Minimum Spanning Tree via Kruskal and union-find.
Binary Search as a shrinking block of wood.
A standalone Union-Find with union-by-size.
Shortest paths that also catch negative cycles.
Click anywhere to trigger a 4-directional BFS fill.
Search a rotated array on a spinning circular dial.
Split into blocks, then zipper them back sorted.
The pivot becomes a wall; elements fly over it.
A red ripple races a cyan scan-and-leap beam.
Naive vs memoized recursion trees, side by side.
Merge (stable) vs Quick (unstable) on tagged duplicates.
Throw values into bins, then pour them back sorted.
Lift, slide, and drop disks with a live recursive narration.
Two-pointer walkers find where two lists intersect.
Min/Max Heapify via bottom-up sift-down.
Chaining vs Linear vs Quadratic probing, compared live.
Topological sort — and catching a cycle in the act.
0/1 Knapsack as a DP grid, with item backtrace.
Longest Common Subsequence, traced back to the actual string.
Levenshtein edit distance, one grid cell at a time.
A branching recursion tree counts every way to make change.
Watch bubble sort compare and swap its way to a sorted array, step by step.
Watch selection sort repeatedly find the minimum and build a sorted array.
See how insertion sort builds a sorted array one element at a time.
Watch merge sort divide, conquer, and merge its way to a sorted array.
Watch quicksort partition and recurse its way to a sorted array.
Watch a binary heap build and unwind itself into a sorted array.
See how counting sort achieves linear-time sorting for bounded integer ranges.
See how radix sort sorts numbers digit by digit without comparisons.
Step through binary search and see exactly how the search space shrinks.
Compare breadth-first and depth-first traversal side-by-side on the same graph.
Visualize shortest-path discovery across a weighted graph, node by node.
Watch the A* algorithm search a grid for the shortest path using heuristics.
Insert, delete, and traverse nodes to build intuition for pointer-based structures.
Push and pop elements to build intuition for LIFO structures.
Enqueue and dequeue elements to build intuition for FIFO structures.
Explore hashing, collisions, and resolution strategies interactively.
Race algorithms head-to-head and see how input order changes performance.
Tensors, autograd, layers, activations, optimizers, RNN/LSTM, loss functions, and generative models — all interactive.
0D to ND tensors, visually.
How mismatched shapes stretch to match.
Reshaping data without moving it.
Picking exactly the elements you need.
Adding and removing size-1 dimensions.
torch.matmul, row by column.
Moving tensors between devices.
The add_() trailing underscore, explained.
How PyTorch builds the graph as you compute.
Data flowing through a network, live.
backward() and gradient flow.
Why gradients pile up without zero_grad().
Turning autograd tracking on and off.
Why inference skips gradient tracking.
Cutting a tensor loose from its graph.
nn.Linear as weights and a bias, animated.
nn.Conv2d sliding across an image.
nn.MaxPool2d, keeping only the loudest pixel.
nn.Flatten turning a grid into a line.
Randomly silencing neurons during training.
nn.BatchNorm2d stabilizing activations.
nn.LayerNorm, normalizing per example.
nn.Embedding turning words into vectors.
nn.RNNCell, one step of a recurrent net.
Forget, input, and output gates in action.
clip_grad_norm_, stopping exploding gradients.
nn.ReLU — the simplest activation, live.
A small negative slope instead of a hard zero.
nn.GELU, the smooth modern activation.
Two optimizers racing the same landscape.
torch.sum dim=0 vs dim=1, made concrete.
The RuntimeError every CNN builder hits once.
Catching overfitting before it gets worse.
Squared error as literal geometric squares.
A bowl near zero, straight lines far away.
SGD, Momentum, RMSprop, and Adam head to head.
Squeezing an image down to a single point.
Why RNNs forget the start of a long sequence.
When a Generator gives up and repeats itself.
What a convolution kernel actually detects.
Memory riding an undisturbed highway.
From a rigid dot to a probability cloud.