Long Article 103: Memory Management – Kernel: In-Depth Slab Allocator Design — Compared with Linux “The Buddy system excels at allocating large chunks, but what about the kernel’s frequent 32-byte task_struct allocations? This article dives into the Slab allocator’s design philosophy, compares Linux’s three implementations (SLAB/SLUB/SLOB), and builds a high-performance, low-fragmentation industrial-grade Slab system.” The... » read more

Writing an OS Kernel from Scratch – Part 31: Paint Tool and Text Rendering — Writing Text in Your Windows! “A graphical interface can’t just be pixels — it needs text! Today, we implement a paint tool and integrate a text rendering engine so title bars, status bars, and canvas can all display text!” In... » read more

Long Article 102: Memory Management – Physical: In-Depth Buddy System Analysis — From Theory to Industrial Implementation “The Buddy allocator is far more than just ‘split and merge.’ This article dives into Linux kernel source-level implementation, systematically analyzing watermark management, migration types, per-CPU page frame caches, compound pages, and other core mechanisms, providing a runnable... » read more

Writing an OS Kernel from Scratch – Part 34: PCIe Basics and Driver Framework — The Highway of Modern Hardware “The e1000 driver got us online, but modern NICs have long upgraded to PCIe! Today, we dive into the PCIe world, implementing configuration space access, MSI interrupts, and device enumeration!” In the previous post, we... » read more

Writing an OS Kernel from Scratch – Part 8: fork and exec — Let Processes “Reproduce”! “A single process running alone? That’s not an OS, that’s a single-player game. Today, we give processes the ability to ‘reproduce’ — duplicating themselves via fork, and transforming into new programs via exec!” In the previous post, we successfully... » read more

Writing an OS Kernel from Scratch – Part 27: Application Launcher — Building Your Desktop Environment Prototype “A graphical interface can’t just have windows — it needs an entry point! Today, we implement an Application Launcher, managing applications via .desktop files and launching them with a click!” In the previous post, we successfully moved the... » read more

Writing an OS Kernel from Scratch – Part 25: Unix Domain Sockets — The Foundation of Inter-Process Communication (IPC) “The Display Server and Client need efficient communication, but pipes are unidirectional and unstructured. Today, we implement Unix Domain Sockets (AF_UNIX), making IPC as natural as file operations!” In the previous post, we built the Display... » read more

Writing an OS Kernel from Scratch – Part 9: User Program Loading — ELF Parsing and Simple Filesystem “Your OS can fork/exec, but where do programs come from? Today, we build the first filesystem, letting the kernel load user programs from ‘disk’!” In the previous post, we implemented fork and exec, but user programs still... » read more

Writing an OS Kernel from Scratch – Part 24: Display Server and Client — Building a Shared Memory Graphics Architecture “Framebuffer lets you draw pixels, but how do multiple applications share the screen? Today, we implement a Display Server + Client architecture, achieving efficient graphics compositing via shared memory!” In the previous post, we implemented... » read more

Writing an OS Kernel from Scratch – Part 20: User Toolchain — Implementing ls, cat, mkdir and Other Basic Commands “No matter how powerful the kernel, without user tools, it’s just an island. Today, we write the first user-mode shell toolset, making your OS truly usable!” In the previous 19 posts, we built a complete... » read more

Writing an OS Kernel from Scratch – Part 32: Integrating LVGL — Text Editor with Open Source GUI Framework “Building wheels from scratch is fun, but industrial-grade GUI needs mature frameworks. Today, we port LVGL (Light and Versatile Graphics Library) to our OS, implementing a professional text editor!” In previous posts, we built from scratch:... » read more

The Essence of AI Models: Using Parameters to Fit High-Dimensional Functions Humans Can Hardly Understand In today’s AI boom, we often hear terms like “large models,” “parameter count,” and “training.” But do you truly understand: the essence of AI models is using a bunch of parameters to fit a set of high-dimensional functions that humans... » read more

Writing an OS Kernel from Scratch – Part 26: User-Mode Display Server and Client — A True Graphics System Architecture “An in-kernel Display Server is controllable but violates the microkernel philosophy; a real graphics system should be in userspace! Today, we move the Display Server and Client entirely to userspace, communicating via Unix domain sockets!”... » read more

Writing an OS Kernel from Scratch | Keyboard — How Keystrokes Become Characters Have you ever wondered about this process: you press a key → a character appears on screen. What does the OS experience in between? How do keyboard scan codes become scancodes? What’s the difference between USB HID and PS/2? From the mechanical... » read more

#233 Conntrack: High-Performance Connection Tracking and NAT Implementation Preface In the previous two articles, we thoroughly understood Netfilter’s HOOK mechanism (Article 231) and iptables’ rule table-chain system (Article 232). However, there’s one system hiding between them, omnipresent yet not yet detailed — Connection Tracking (conntrack). Conntrack is the cornerstone of Linux stateful firewalls. It’s because... » read more

B02 — The ID Card of RAM: What’s Actually Stored in the SPD Chip Key insight: RAM without SPD is like a person without ID — the system doesn’t know who it is. SPD Chip Basics Every DDR memory module has an SPD (Serial Presence Detect) chip, a 256-byte (or 512-byte for DDR5) EEPROM. SPD... » read more

Writing an OS Kernel from Scratch | #345: USB Protocol — From HID to High-Speed Devices Abstract: USB is essentially the “universal serial bus” for all peripherals, but many only know “plug and play.” This article takes you from physical layer topology, transfer types, xHCI controller, to practical lsusb usage, thoroughly understanding USB’s design philosophy... » read more

Writing an OS Kernel from Scratch – Part 7: User-Mode Processes and System Calls — Make Your OS Truly Usable! “No matter how powerful the kernel, if it can’t run user programs, it’s just a fancy bare-metal toy. Today, we embrace user mode, taking the decisive step toward becoming a true OS!” In the previous... » read more

Writing an OS Kernel from Scratch | The Last Jump from BIOS to Kernel — What the CPU Thinks After POST You press the power button, the screen lights up, the fan spins, BIOS POST completes, GRUB countdown ends — then what? How does the kernel actually start running? What state is the CPU in... » read more

B07 — From e820 to Memory Management Initialization: The memblock Allocator Key insight: The kernel’s first step at boot is to figure out how much memory it has to manage. How the Kernel Gets Memory Info At boot, the kernel obtains physical memory info through two methods: Directly from BIOS (legacy): via INT 15h E820h... » read more