CPU Pipeline Architecture
Follow instructions through a five-stage pipeline, distinguish latency from throughput, and connect issue width to out-of-order execution.
Related
6 min read · intermediate
Systems & Architecture
CPU pipelines, memory hierarchies, the Linux kernel, filesystems, and networking.
- SYS
- 49 concepts
CPU execution
Follow instructions through a processor and understand what limits its throughput.
Starting knowledge: Instructions, registers and basic program execution
Select a concept. Explore its connections, or open the full explanation.
Previewing Pipeline architecture.
From pipeline capacity to useful work
Start with stage timing and width, follow the dependencies that cause stalls, then explore how prediction chooses the next instructions.
From pipeline capacity to useful work
Pipeline architecture
Distinguish latency from throughput, compare pipeline depth and width, and connect ready work to out-of-order execution.
Read conceptUsed in: connections 1 to 1 of 1.
Why clock speed stopped being enough
Explore the power constraint behind architectural choices. This is context for CPU design, not a prerequisite for the pipeline demos.
Lines show suggested reading within a branch. Connections offer optional ways to explore; they are not a checklist of prerequisites.
All Systems & Architecture Concepts
Hazard Detection: Pipeline Dependencies and Solutions
Trace data, structural and control hazards, understand forwarding and load-use stalls, and connect register dependencies to scheduling.
Related
9 min read · advanced
Branch Prediction & Speculation
Replay branch outcomes to compare predictors, then connect local and global history to speculative execution, recovery and profiling.
Related
9 min read · intermediate
Dennard Scaling: From Free Speed to the Power Wall
Explore how smaller transistors promised more speed at the same power, why voltage limits broke that bargain, and how chip design adapted.
Related
8 min read · intermediate
How RAM Works: Interactive Deep Dive into Computer Memory
Explore the inner workings of RAM through beautiful animations and interactive visualizations. Understand memory cells, addressing, and the memory hierarchy.
Related
12 min read · intermediate
Memory Controllers: The Brain Behind RAM Management
Learn how memory controllers manage CPU-RAM data flow. Interactive demos of channels, ranks, banks, and command scheduling for optimal bandwidth.
Related
18 min read
Memory Interleaving: Parallel Memory Access
Discover how memory interleaving distributes addresses across banks for parallel access. Boost memory bandwidth in DDR5 and GPU systems.
Related
6 min read · intermediate
NUMA Architecture: Non-Uniform Memory Access
Explore NUMA architecture and memory locality in multi-socket systems. Understand local vs remote memory access latency and optimization strategies.
Related
8 min read · advanced
CPU Cache Lines: The Complete Guide with Interactive Simulator
Deep dive into CPU cache lines — interactive cache simulator with configurable associativity and replacement policies, false sharing MESI protocol visualization, access pattern benchmarks, and optimization techniques.
Related
22 min read · intermediate
Memory Access Patterns: Sequential vs Strided
Master sequential vs strided memory access patterns. Learn how cache efficiency and hardware prefetching affect application performance.
Related
8 min read · intermediate
SoA vs AoS: Data Layout Optimization
Structure of Arrays vs Array of Structures as instruments: cache-line fill, SIMD gather vs contiguous load, GPU coalescing, and AoSoA hybrids — when layout is a 10× decision.
Related
12 min read · intermediate
Virtual Memory & TLB: Complete Guide to Address Translation
Master virtual memory and TLB address translation with interactive demos. Learn page tables, page faults, and memory management optimization.
Related
16 min read · advanced
Linux Memory Management: Virtual Memory, Paging, and Beyond
Explore Linux memory management through interactive visualizations. Understand virtual memory, page tables, TLB, swapping, and memory allocation.
Related
22 min read
Transparent Huge Pages (THP): Reducing TLB Pressure
Learn how Transparent Huge Pages (THP) reduces TLB misses by promoting 4KB to 2MB pages. Understand performance benefits and memory bloat tradeoffs.
Related
18 min read · intermediate
Linux Kernel Architecture: From User Space to Hardware
Explore Linux kernel architecture: user and kernel space, cooperating subsystems, cached and uncached file reads, and how containers share one kernel.
Related
10 min read
Linux System Calls: The User-Kernel Interface
Linux system calls visualized: how user programs communicate with the kernel, protection rings, argument registers, error handling, and syscall performance.
Related
12 min read
Linux Process Management: Fork, Exec, and Beyond
Master Linux process management through interactive visualizations. Understand process lifecycle, fork/exec operations, zombies, orphans, and CPU scheduling.
Related
15 min read
Linux Kernel Modules: Extending the Kernel at Runtime
Master Linux kernel modules through interactive visualizations. Learn how to load, unload, develop, and debug kernel modules that extend Linux functionality.
Related
15 min read
Linux Boot Process: From Power-On to Login
Visualize the complete Linux boot sequence from BIOS/UEFI to login. Learn how GRUB, kernel, and systemd work together with interactive visualizations.
Related
15 min read
initramfs: The Initial RAM Filesystem Explained
Learn how initramfs enables Linux boot by loading essential drivers before the root filesystem mounts. Explore early userspace initialization.
Related
15 min read
Linux Init Systems: From SysV to systemd
Compare Linux init systems through interactive visualizations. Understand the evolution from SysV Init to systemd, service management, and boot orchestration.
Related
15 min read
Filesystems: The Digital DNA of Data Storage
Explore Linux filesystems through interactive visuals. Learn VFS, compare ext4 vs Btrfs vs ZFS, and understand file operations.
Related
10 min read
Inodes: The Hidden Metadata That Powers Every File
Understand Linux inodes - the metadata structures behind every file. Learn about hard links, soft links, and inode limits.
Related
15 min read
Mount Options: Filesystem Behavior and Performance
Master Linux mount options like noatime and async for performance tuning and security hardening. Interactive guide to fstab configuration.
Related
12 min read
Filesystem Journaling: Write-Ahead Logging
Follow a filesystem transaction from journal to checkpoint. Explore crash recovery, ext4 journal modes, and the limits of data durability.
Related
8 min read
Copy-on-Write (CoW): Blocks, Snapshots, and Atomic Commits
Follow filesystem copy-on-write from a changed block to a committed root. Explore snapshot sharing, space reclamation, and the trade-offs in Btrfs and ZFS.
Related
10 min read
RAID: Redundant Arrays for Speed and Safety
RAID storage visualized: RAID 0, 1, 5, 6, and 10 levels explained. Learn how they work, when to use them, and disk failure recovery.
Related
18 min read
Filesystem Data Integrity: Detecting Silent Corruption
Explore checksum verification, Merkle-tree reads, mirror repair, and scrubbing through interactive examples of silent corruption and recovery.
Related
8 min read
FUSE: Filesystem in Userspace Explained
Learn FUSE (Filesystem in Userspace) for building custom filesystems. Understand how NTFS-3G, SSHFS, and cloud storage work.
Related
18 min read
ext4: The Linux Workhorse Filesystem
Explore ext4, the default Linux filesystem with journaling, extents, and proven reliability. Learn how ext4 protects your data.
Related
8 min read
XFS: High-Performance Parallel Filesystem
XFS internals end-to-end: allocation groups for lock-free parallel metadata, B+ trees instead of bitmaps, extent-based allocation that scales to terabytes, and delayed allocation that turns scattered writes into contiguous extents.
Related
10 min read
Btrfs: Modern Copy-on-Write Filesystem
Trace how Btrfs shares extents, creates snapshots, distributes copies, compresses writes, and repairs checksum errors when a good replica exists.
Related
13 min read · intermediate
ZFS: The Ultimate Filesystem
Master ZFS filesystem with pooled storage, RAID-Z, snapshots, and checksums. Learn enterprise-grade data integrity on Linux.
Related
20 min read · intermediate
FAT32 & exFAT: Universal Filesystems
Learn FAT32 and exFAT filesystems for cross-platform USB drives and SD cards. Understand file size limits and compatibility.
Related
12 min read
NTFS Filesystem: The Master File Table
NTFS internals from the Master File Table outward: 1 KB attribute records, resident vs non-resident $DATA, run lists, alternate data streams, the $LogFile journal, and why dual-boot Linux distros prefer ntfs3 over ntfs-3g.
Related
10 min read
Linux Namespaces: The Foundation of Container Isolation
Master Linux namespaces — the kernel mechanism that makes containers possible. Learn how mount, PID, network, and user namespaces create isolated environments, with interactive demos.
- Linux
- Containers
- Namespaces
- Isolation
- Docker
- Mount Namespace
- PID Namespace
- Network Namespace
- User Namespace
- Clone
- Unshare
- Pivot Root
- OverlayFS
Related
15 min read · intermediate
Linux cgroups: Resource Limits for Processes
Control groups as instruments: noisy neighbors, v1 vs v2 membership, CFS cpu.max periods, memory.high vs memory.max OOM, and how Docker flags become cgroup files.
Related
12 min read · intermediate
Containers Under the Hood: From Primitives to Docker
Discover how containers work by combining namespaces, cgroups, and OverlayFS. Build a mental model of Docker internals through interactive visualizations.
Related
18 min read · advanced
How Docker Works with GPUs: Device Files, Bind Mounts, and Driver Stacks
Understand how containerized processes access GPU hardware through device files, bind mounts, and the NVIDIA container runtime. Learn the kernel driver vs user-space library distinction.
Related
12 min read · advanced
Understanding TCP/IP Protocol Stack
Explore the TCP/IP protocol stack, packet encapsulation, and how data travels through network layers from application to physical transmission.
Related
10 min read · intermediate
Linux Networking Stack: From Packets to Applications
Master the Linux networking stack through interactive visualizations. Understand TCP/IP layers, sockets, iptables, routing, and network namespaces.
Related
30 min read · intermediate
NAT: How Many Devices Share One Public Address
Step a packet through a home router to see how NAT rewrites addresses and ports, what it breaks, how hole punching and NAT-T work around it, and why it is not security.
Related
9 min read · beginner
VPN: How a Tunnel Changes the Address Websites See
Follow a packet inside an encrypted VPN tunnel, separate wrapping from NAT, compare full and split routing, and see what Wi-Fi, ISPs and VPN servers can observe.
Related
9 min read · beginner
Client-Server Communication: Polling vs WebSockets
Learn client-server communication patterns including short polling, long polling, and WebSockets. Compare HTTP protocols for real-time web applications.
Related
13 min read · beginner
Short Polling: The Impatient Client Pattern
Learn short polling in networking - a simple HTTP pattern for periodic data fetching. See why 70-90% of requests waste bandwidth and when to use alternatives.
Related
4 min read · beginner
Long Polling: The Patient Connection
Learn HTTP long polling - a server-side technique that holds connections open until data arrives. Achieve near real-time updates with standard protocols.
Related
4 min read · beginner
WebSockets: Real-Time Bidirectional Communication
Master WebSocket protocol for real-time bidirectional communication over TCP. Learn handshakes, frames, and building low-latency web applications.
Related
4 min read · beginner
Wayland vs X11: Modern Display Server Architecture
Compare Wayland vs X11 display servers on Linux. Learn about architecture, performance, security, and modern graphics stack.
Related
20 min read
nvidia-modeset: Kernel Mode-Setting for NVIDIA GPUs
Learn nvidia-modeset for display configuration on Linux. Understand kernel mode-setting, DRM integration, and GPU drivers.
Related
20 min read · intermediate