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

H05 — What Happens After RAM Powers On: SPD Chips and BIOS Memory Training Key insight: Every RAM stick works normally in a computer because, in the instant of booting, someone does a lot of calibration work behind the scenes. SPD Chip: The RAM’s “ID Card” Every RAM module has an SPD (Serial Presence Detect)... » read more

Writing an OS Kernel from Scratch | How BIOS/UEFI/GRUB Hand Control to the OS After Boot Have you ever wondered: in the instant you press the power button, where does the CPU’s CS:IP register point? Who set it to that value? Why does the screen light up showing a selection menu instead of black? This... » read more

Writing an OS Kernel from Scratch | Physical Memory Management — The Buddy System A 64KB memory request, but the smallest free block you have is 128KB — do you split it in half and use half, or allocate the whole thing? That’s the core problem the Buddy System solves. Physical memory management is one... » read more

Writing an OS Kernel from Scratch – Part 6: First Look at Multitasking — From Single-Core Loops to Process Switching “A kernel that can only do one thing? That’s a bare-metal program. A real OS must be able to ‘simultaneously’ do multiple things!” In the previous five posts, we completed kernel boot, entering protected mode,... » read more

A08 — Wild Pointers and Dangling Pointers: The Difference Between Two Types of Invalid Pointers Key insight: Pointers can fail in two ways — one is that the memory has been freed (dangling), the other is that it never pointed to a valid address (wild). Dangling Pointer A dangling pointer points to freed memory. Typical... » read more

Writing an OS Kernel from Scratch – Part 15: Slab Allocator — Efficiently Managing Kernel Small Objects “The Buddy system is great at allocating large memory blocks, but what about the kernel’s frequent 32-byte, 128-byte small object allocations? Today, we implement the Slab allocator, making kernel memory allocation lightning fast!” In the previous post, we... » read more