A bottom-up tour of how computers actually work.
Most explanations of computer architecture stop at the abstraction you happen to need. This series goes the other direction — start from the physics of a single transistor and build up, one interactive simulator at a time, until we've assembled a working CPU. The goal is that by the end you can answer 'what is actually happening when my code runs?' from first principles, without hand-waving.
From XOR to a working ALU
Half adders, full adders, ripple-carry vs. carry-lookahead, and an interactive 4-bit ALU you can run programs through.
State-holding circuits, explained visually
How gates with feedback become memory. SR latches, D latches, edge-triggered flip-flops, and a small interactive register file.
Synchronous logic and the heartbeat of a CPU
Why everything in a CPU happens on clock edges, what setup and hold times mean, and an interactive pipeline visualization.
Putting it all together
Combine arithmetic, memory, and sequencing into a runnable 4-bit CPU. Type a tiny program; watch the registers and bus update cycle-by-cycle.
Why your CPU lies about memory
Why memory is slow, what locality is, and an interactive cache simulator that shows hit/miss patterns for different access strategies.
Making the CPU faster (and harder to reason about)
Instruction pipelines, data hazards, branch prediction. An interactive pipeline diagram with stalls and forwarding visualized.
Cores, threads, and the cost of sharing
How multi-core changes the rules. Cache coherence protocols, memory ordering, and an interactive multi-core memory simulator.
From bare metal to processes
Virtual memory, interrupts, system calls, and the boundary between hardware and the kernel.
When the CPU isn't enough
How GPU architecture differs from CPUs, why ML workloads found their natural home there, and where things are heading.