My Top 15 OS Books: From Theory and Implementation to Systems Programming
A personal guide to the most useful books for understanding operating systems
Operating systems knowledge is the bedrock of software engineering. It's what separates developers who can write code from those who truly understand how their code runs. Whether you're optimizing performance or debugging complex issues, this knowledge proves invaluable.
I routinely get requested to provide recommendations on books that I've found useful in understanding operating systems and systems programming. In this post, I will share 15 of my favorite books that I've found valuable throughout my career, along with brief remarks about why I found them useful. Some of these books are made freely available by the authors, and I will provide the links where possible.
I will categorize them into three categories:
Theory books: These books, commonly used in computer science courses, cover the theoretical underpinnings of kernel design. While they provide a solid foundation, they usually don't cover specific kernel implementations like Linux or FreeBSD, which can make them feel less practical.
Implementation books: These books focus on specific kernel implementations. Instead of covering all possible approaches to a problem (like page replacement algorithms), they explain the actual solutions implemented in real-world kernels. You learn how production systems work, though at the cost of some theoretical breadth.
Systems programming books: While very few developers work directly on kernel development, many build software that runs on top of these kernels. Whether you're writing a web server, a programming language runtime, a database system, or a distributed system, you need to understand both kernel internals and their programming interfaces to effectively utilize kernel services.
Each category serves different needs and different stages of your systems programming journey. Let's dive in!
Operating System Theory Books
This list is rather short because you usually don’t need to learn the theory multiple times. I studied operating systems in college using the Dinosaur book which was quite good and more recently I refreshed my understanding using the OSTEP book. These are the only two books I’ve ever used as far as theory is concerned.
Operating System: Three Easy Pieces (OSTEP)
This is perhaps the most popular OS book these days, and for a good reason. It breaks down the discussion of a really wide and deep topic into bite-sized chunks. Each chapter is typically less than 20 pages and written in clear, accessible language, making complex concepts digestible without sacrificing depth.
Although the book occasionally references Linux and XV6 for examples, it's not tied to these kernels. Instead, it focuses on universal concepts like how virtual memory works, what happens during a context switch, how file systems manage your data, and how concurrency is handled at the OS level. These concepts remain relevant regardless of which operating system you're working with.
The book is freely available online: https://pages.cs.wisc.edu/~remzi/OSTEP/
Operating System Concepts (AKA The Dinosaur Book)
This is probably the most widely used operating system book in classrooms, my OS course used it as well. I read it 15 years back, so my memory of it is a bit fuzzy. While I initially found its theoretical approach frustrating - I wanted to understand how a real kernel boots and works - I've come to appreciate its value over the years.
The book excels at explaining core OS concepts through abstract models. For example, it walks you through different process synchronization problems like the dining philosophers and the producer-consumer problem, which might seem academic at first but become extremely relevant when you're debugging deadlocks in a real-world application. Its coverage of memory management helps you understand why your program crashes with "segmentation fault" or why adding more RAM doesn't always improve performance.
The theoretical knowledge I gained from it has proven invaluable throughout my career. When you're troubleshooting why your distributed system is experiencing race conditions, or why your high-performance application is page faulting, these fundamental concepts become your debugging toolkit.
Both this and the OSTEP book serve as excellent theory references, but OSTEP has the advantage of being freely available and more digestible. The Dinosaur book remains relevant if you want a more formal, comprehensive treatment of OS concepts.
Implementation Oriented Books
While you don’t need too many books on the theory of operating systems, same cannot be said about the implementation of real-world kernels. Every kernel makes different design choices, and has different characteristics, such as performance vs portability vs security. And even at this level you can have two kinds of books:
Books which discuss the design of the kernel and how the different pieces operate together
Books which are more low level and take you through line by line explanation of a given kernel implementation
I will cover both sub-categories here. My remarks should make it clear what kind of book I’m talking about.
Design of the Unix Operating System
This is an underrated book on operating systems. It explains the internals of the Unix System V kernel, and even though that kernel isn't used anymore and the book is quite old, you'll find that most kernels today use similar algorithms. The book explains each major subsystem of the kernel - processes, file systems, memory - and shows how the system calls are implemented internally using C-like pseudo code.
The book's explanations of file system internals are particularly enlightening. When you understand how the kernel manages inodes, handles file descriptors, and implements the buffer cache, many common issues become clearer - like why calling fsync() is crucial for database systems, or why sharing file descriptors across processes can be dangerous.
Even though hardware has advanced significantly since this kernel, the basic abstractions in most Unix-like kernels are still similar and the same system calls are still around (thanks to POSIX), so the details are still relevant.
Lion’s Commentary on Unix
This book provides a line-by-line code walkthrough of the Sixth Edition Unix operating system from AT&T. While it's now primarily a historical artifact, it offers unique insights into the elegance and simplicity of early Unix design.
The entire Sixth Edition Unix kernel was small enough to be explained in a 200-page book. While the PDP-11 hardware-specific details are no longer relevant, the book shows how fundamental Unix concepts like processes, the file system, and I/O were implemented with remarkable efficiency in just a few thousand lines of code.
These days, I'd recommend this book mainly for historical interest or if you want to understand how Unix evolved. For practical kernel implementation knowledge, modern alternatives like the XV6 book offer more relevant insights for today's systems.
The XV6 Book
XV6 is a tiny educational kernel developed at MIT for teaching operating systems courses. Like Lion's Commentary, it provides a detailed walkthrough of a Unix-like kernel, but for modern hardware architectures. The accompanying book explains the kernel source code in detail, making it an excellent resource for understanding how theoretical OS concepts translate into actual code.
At the time of writing, XV6 exists in two variants:
The Design and Implementation of the FreeBSD Operating System
This is the FreeBSD book. One of the authors, Marshall Kirk McKusick, has been involved in BSD development since its early days at Berkeley and continues to contribute today.
The book offers a deep dive into FreeBSD's design philosophy and implementation details, focusing on the architectural decisions and algorithms rather than line-by-line code explanations. For instance, it explains why certain design choices were made in the Unix Fast File System (FFS), or how the jail subsystem (FreeBSD's version of containers) works.
Although Linux dominates the server market today, FreeBSD is a key player, especially in network appliances and storage systems. Understanding its different approach to kernel design - like having a single, coherent kernel developed as a complete operating system rather than Linux's more distributed development model - gives you a broader perspective on OS design and implementation.
Linux Kernel Development
This book by Robert Love strikes a nice balance between source code details and high-level design overview of the kernel. It avoids getting too deep into hardware architecture specifics, focusing instead on the data structures and algorithms that are central to the kernel's operation. This approach keeps the book's thickness manageable and makes it more broadly useful.
The book is particularly good at explaining the process scheduler and kernel synchronization mechanisms. When you're reading kernel code or writing kernel modules, understanding these aspects is crucial.
However, the book is getting old now and Linux has evolved rapidly in recent years. For instance, while the book has a good explanation of the completely fair scheduler (CFS), Linux has now moved to the earliest eligible virtual deadline first (EEVDF) scheduling algorithm. Many new features like eBPF and io_uring have also been added to the kernel after the book's publication. So while the book is still valuable for understanding core concepts, you'll want to check current kernel documentation for the latest changes.
Understanding the Linux Kernel (UTSL)
People often confuse this book with Robert Love's book. Both complement each other well. UTSL gives a much lower level coverage of the Linux kernel, focusing on how the hardware and kernel interact. The book uses the X86 (32 bit) platform to explain the details of how the kernel boots, how context switching works, interrupts, virtual memory and so on.
The 32-bit X86 platform is outdated now and the current X64 architecture is different in many ways, which makes some discussions in the book obsolete. However, there hasn't been another book that covers the Linux kernel in such detail, so it's still valuable if you want to understand Linux internals. You just need to be aware of what's changed between X86 and X64 platforms.
Operating Systems: A Linux Kernel-Oriented Perspective
I recently found this book (written by Prof Sarangi at IIT Delhi). It gives a good overview of the Linux kernel, connecting theory and implementation nicely. It strikes a good balance between high-level design and source code details. It's freely available and still being updated.
You can download the book from its website here.
Understanding the Linux Virtual Memory Manager
This book from 2004 covers the implementation details of virtual memory in the Linux kernel from that time. It explains both the design and source-level implementation of Linux's memory management subsystem - from page tables and their manipulation to how the kernel manages different types of memory allocations.
However, both hardware and the Linux kernel have evolved significantly in these 20 years. The memory management subsystem has also been heavily modified to handle modern hardware with large amounts of RAM and many CPU cores.
This book is also available freely in the public domain here. Despite its age, it's still useful for understanding the core concepts of memory management in Linux, just keep in mind that you'll need to check current kernel documentation for modern implementations.
Solaris Internals
Sun’s Solaris operating system is considered one of the most advanced operating system of its time, pioneering many ideas which are now commonly available in other kernels and some projects which are still alive. For instance, Docker is being used everywhere these days but Solaris had Zones much before that. The ZFS file system originated from Solaris. The DTrace tracing and system debugging tool was pioneered at Sun for Solaris. The eBPF suite of tracing tools are very similar in nature to DTrace (with a very different implementation).
Even though Solaris itself is no longer actively developed, many of its innovations live on in other systems and many of its design ideas have made into other kernels such as NetBSD. This makes the book valuable not just as a historical reference, but as a way to understand the reasoning behind many features we take for granted in modern operating systems.
Virtual Memory
Let me also shamelessly plug my own minibook on virtual memory. It is a 60-page exploration of everything that you must know about virtual memory as a working software engineer, especially if you build data-intensive systems.
The book starts from the fundamentals of virtual memory, such as why we need virtual memory, page tables, page faults, etc., and goes to more advanced topics that concern the performance of applications and systems, such as data structure packing, memory access patterns, NUMA placement, and TLB shootdowns.
The entire treatment is made very accessible by explaining concepts from first principle reasoning, which is done through a dialogue exchange between a user-space process and the kernel. It is available to read freely on this Substack and is also available to purchase as a PDF at the link below.
Virtual Memory: A Deep Dive into Page Tables, TLBs, and Linux Internals
This post is almost a book-level coverage of virtual memory. I have been working on it for the last couple of months.
Systems Programming Books
Finally, we are at the final category of the OS books: the books which teach you how to write user space systems software to run on these kernels.
Advanced Programming in the Unix Environment (APUE)
If you can get only one book in this category, let it be this one. It's the definitive guide to Unix system programming and has been recently updated with a new edition.
The book walks you through all the POSIX system calls and shows you how to use them correctly. But more importantly, it explains the gotchas and edge cases you'll encounter in real systems programming. For instance, when it covers file I/O, it doesn't just show you how to use read() and write() - it explains why your writes might be buffered, why you need to check for partial reads, and how to handle interrupts during I/O operations.
What makes APUE particularly valuable is that it focuses on portable code. Everything it teaches works across different Unix-like systems because it sticks to POSIX-specified interfaces. When you write code following this book's guidance, it'll work on Linux, FreeBSD, macOS, or any other POSIX-compliant system.
If you read this book, perhaps you will not need to refer any other book in this category.
The Linux Programming Interface
This book is similar in spirit to APUE but focuses specifically on Linux. While APUE sticks to POSIX interfaces to ensure portability, Linux has developed many of its own interfaces over the years that often provide better performance or additional capabilities.
The book does a good job of covering these Linux-specific APIs. This is particularly useful because Linux dominates server deployments, and sometimes you need to use these non-portable interfaces to get the best performance or functionality. It's especially handy when you're trying to understand what's possible beyond the standard POSIX interfaces, or when you're debugging Linux-specific behavior.
Like APUE, it's comprehensive and well-written, though you probably don't need both books unless you're specifically interested in Linux-specific features or need to write high-performance Linux software.
UNIX Systems Programming: Communication, Concurrency and Threads: Communication, Concurrency and Threads
This book shares some overlap with APUE but focuses more heavily on concurrency and inter-process communication. As the title suggests, it dives deep into how processes and threads communicate and coordinate in Unix systems.
While most of what's covered here can also be found in APUE, some people might find this book's focused treatment of concurrency topics helpful. It explains things like pipes, shared memory, and semaphores in detail, though in my experience, APUE covers these topics adequately as well.
Programming with POSIX Threads
This is a focused book about writing multithreaded code using the pthreads library. The pthreads interface has become the standard way to write threaded code on Unix-like systems when programming in C.
The book is particularly useful because thread programming is notoriously tricky to get right. It covers the common pitfalls and patterns you'll encounter when writing threaded code. While other books cover threads as part of broader systems programming, this one gets into the details that matter when you're actually implementing multithreaded software.
Conclusion
These books have served me well over the years, though you don't need to read all of them. Most people will find OSTEP sufficient for theory and APUE adequate for systems programming. If you want to understand kernel internals, pick either the FreeBSD book or a combination of the Linux-focused books depending on your interests.
My personal approach to reading books has been to refer the parts that I need to understand at the moment. I’ve not read all of these books from cover to cover, it is impossible. Instead, I read the parts that are of relevance to the work I am doing at the moment.
Several of these books are freely available online, so you can start exploring without any investment. Even the older books remain valuable because they explain core concepts that haven't changed much over the decades.
Have you read these books? Share your experience with them in the comments, and also share any other books that you have found useful, I’m always looking for more OS books.
Great article. A minor correction, Smruti Sarangi teaches at IIT Delhi not IIT Bombay.
linux-mm dev Lorenzo Stoakes has a book which just went live for pre-order: https://nostarch.com/linux-memory-manager