Tiny Trick: Embedded Filesystem in Kernel — Stuffing init Right Into the Kernel Binary! When your kernel doesn’t yet support reading disks or filesystems, how do you support a simple filesystem in a temporary way? Today’s trick — compile the filesystem directly into the kernel! No disk needed, no driver needed, the kernel executes init... » read more

Writing an OS Kernel from Scratch | Windows GPT+UEFI Boot: ESP Partition, NVRAM Boot Entries & Secure Boot Explained The previous chapter covered MBR+BIOS mode Windows boot, where the System Reserved partition is the core anchor — BOOTMGR and BCD live in that 100MB FAT32 partition, and BIOS finds it via the MBR active partition... » read more

Writing an OS Kernel from Scratch – Part 2: Hello World Analysis “You think ‘Hello World’ is just printing a line? In an OS kernel, it hides the secrets of boot flow, memory layout, and hardware protocols.” In the previous post, we successfully had our kernel output “Hello from the kernel!” on QEMU. Looks simple,... » read more

Long Article 101: Memory Management – Boot Phase: Memory Layout from Real Mode to Paging “The kernel code is linked at 1MB+, but the CPU starts in real mode — today we unveil the boot phase memory layout and see how the kernel safely enables paging!” In the OS boot process, memory management is the... » read more

15 Lines of Code to Teach AI to Turn Lights On and Off: A Smart Energy-Saving Butler with Neural Networks No rules, no if-else, just “trial and error + reward” — let AI learn to intelligently control lighting. This is the magic of Reinforcement Learning! Problem: When Should the Light Be On? Is your home... » read more

Writing an OS Kernel from Scratch – Part 2: Hello World Analysis “You think ‘Hello World’ is just printing a line? In an OS kernel, it hides the secrets of boot flow, memory layout, and hardware protocols.” In the previous post, we successfully had our kernel output “Hello from the kernel!” on QEMU. Looks simple,... » read more

Writing an OS Kernel from Scratch – Part 10: Virtual File System and ext2 Implementation “Initramfs is just a toy; a real OS needs persistent storage. Today, we design the VFS abstraction layer and implement the first disk filesystem — ext2!” In the previous post, we used an in-memory Initramfs for user program loading, but... » read more

Writing an OS Kernel from Scratch – Part 21: Implementing a Terminal — Make Your Shell Truly Interactive! “Your shell can run commands, but how does the user edit commands, handle backspace, or respond to Ctrl+C? Today, we implement a full terminal (Terminal) supporting line editing, signals, and job control!” In the previous post, we... » read more

Teach an AI Beginner to Define Their Own Model and Implement Image Classification in 30 Minutes Have you ever wondered: “What does an AI model actually look like? Can I write one myself?” “Online tutorials are too complex, all code, totally incomprehensible” “I want to learn AI but don’t know where to start” Don’t worry!... » read more

Writing an OS Kernel from Scratch 201: Storage System – VFS: Designing a Unified File Abstraction Layer “In a custom OS, how do you make open/read/write work with both ext2 and procfs? This article designs a VFS abstraction layer from scratch, building four core objects, implementing path resolution and caching, providing a unified interface for... » read more

Writing an OS Kernel from Scratch – Part 19: User and Kernel Address Space — Building Secure Virtual Memory Boundaries “All processes share kernel code, but must never peek at each other; user programs roam freely but cannot cross the boundary. Today, we design the higher-half kernel mapping, achieving perfect isolation and efficient sharing of... » read more

Writing an OS Kernel from Scratch – Part 28: Window Manager — Controlling Windows via Keyboard “No mouse? No problem! Real geeks control everything with the keyboard. Today, we implement a Window Manager (WM), moving and resizing windows via keyboard shortcuts!” In previous posts, we built a userspace Display Server, Launcher, and multiple applications, but... » read more

Writing an OS Kernel from Scratch – Part 18: Multi-core Support — Make Your OS Truly Parallel! “Single-core scheduling is just pseudo-concurrency; the real performance leap is multi-core! Today, we wake up all CPU cores and implement SMP (Symmetric Multi-Processing) support!” In the previous post, we implemented a preemptive scheduler, but all tasks still switched... » read more

Writing an OS Kernel from Scratch – Part 3: Multiboot Protocol Explained — The “Universal Language” Between Kernel and Bootloader Your kernel is written, but how does GRUB “recognize” it? The secret lies in a protocol called Multiboot. In the first two posts, we successfully ran our kernel on QEMU and understood the linker script... » read more

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