Under the Hood
Loading visualizer…
DNSresolving host
TCPconnecting
TLShandshake
HTTPrequesting
Initializing Sorting Algorithms...
Sorting
Trees
Graphs
Preparing interactive visualizations...
Under the Hood
Loading visualizer…
CS Internals — visualized. From DNS lookups to CPU caches, from Python bytecode to virtual memory. See exactly what happens at every layer of the stack.
How source code becomes execution
Source → Tokens → AST → Bytecode → CPython VM → Memory Model → GIL. Every layer visualized step by step.
Source → BytecodeInterpreterPreprocessor → Compiler → Assembler → Linker → Loader → CPU. See why compiled code runs 50× faster than Python.
Source → MachineCompilerPyObject internals, reference counting, the small int cache, closures, and LEGB name resolution — all animated.
Heap + StackReference CountReference counting, cyclic GC, mark-and-sweep, and generational collection. How memory gets reclaimed automatically.
O(n) scanMark & SweepThreads, async, and parallelism
The event loop as a spinning wheel. Task queues, microtask vs macrotask, how await suspends a coroutine without blocking the thread.
O(1) per taskEvent LoopThread creation, time slicing, race conditions, mutex locks, and deadlock — each animated with the classic counter and dining philosophers examples.
O(1) ctx switchShared MemoryVirtual address spaces, the process control block, fork() semantics, and why threads share heap but not stack.
fork: O(1) CoWOS SchedulingNetworks, protocols, and browsers
DNS resolution → TCP handshake → TLS handshake → HTTP request → server pipeline → HTTP response → browser rendering. All 8 acts animated.
~300ms coldFull StackCertificate chains, Diffie-Hellman key exchange, the paint-mixing analogy, and why TLS 1.3 needs only 1 round trip.
1 RTT (TLS 1.3)Asymmetric → SymmetricHTTP verbs, status codes, request/response cycle, JSON serialization, authentication headers, and REST constraints visualized.
O(1) requestRequest/ResponseMemory layout, dispatch, and patterns
How classes and instances live in memory. Python __dict__, __class__ pointer, method lookup chain, and metaclasses.
O(1) lookupObject ModelC3 linearization step by step. Why MRO exists (diamond problem), how super() walks the chain, and what multiple inheritance really does.
O(n) MROC3 LinearizationC++ vtables in memory. How virtual function calls follow the vptr → vtable → function pointer chain. Non-virtual vs virtual call cost.
O(1) + 1 derefvtable"Is-a" vs "has-a". Fragile base class problem animated. Why swapping a component is impossible with deep inheritance but trivial with composition.
design tradeoffHAS-A > IS-AOS, CPU, databases, and version control
Virtual address space layout, page tables, TLB, page faults, and why every process thinks it has 4GB of RAM.
O(1) TLB hitMMU + Page TableL1/L2/L3 cache lines, spatial locality, cache misses vs hits, and why column-major array access kills performance.
L1: ~4 cyclesCache HierarchySQL → Parser → Planner → Optimizer → Executor. Index scan vs full scan animated. Why the query planner chooses what it chooses.
O(log n) indexCost-Based Opt.Blob, tree, and commit objects. SHA-1 content addressing. Branches as sticky notes on commits. Merge vs rebase as DAG transformations.
O(1) branchDAG + Content HashSenior engineers get asked what happens when you search a URL, how Python's GIL works, or what a race condition looks like. These visualizers build the mental models interviewers expect.
Understanding DNS caching explains why a config change takes time to propagate. Knowing Python's reference counting explains why circular references can leak memory. Internals prevent mysterious bugs.
Knowing about CPU cache lines makes you write cache-friendly array traversals. Understanding the event loop makes async code obvious. Seeing a vtable makes polymorphism intuitive.