Indie & Hobbyist Operating Systems 2026 Deep Dive - SerenityOS, Ladybird, Haiku, ReactOS, Redox OS, Theseus, Plan 9, 9front, ArcaOS, MenuetOS

Prologue - Why People Still Build New Operating Systems in 2026

Linux took the data center, Windows the desktop, macOS, iOS, and Android the pocket. The operating system market looks closed. Yet every week new OS projects appear on GitHub.

The reasons are simple.

• They want to understand - the Linux kernel is too big. A 250,000-line simple OS fits in one person's head.
• They want to see another paradigm - microkernels, unikernels, capability-based security, formal verification, single address spaces - paths Linux did not take.
• It is fun - as Terry Davis showed with TempleOS, an OS can be art.
• Career and learning - embedded, systems, security, OS courses - almost every systems engineer track values "I wrote a small OS once."

This article surveys that whole landscape. We look at who builds which OS, with which philosophy, under which license.

One-line summary: "An indie OS is a laboratory that deliberately takes a path that mainstream OSes have abandoned."

Chapter 1 - Why Hobbyist OSes Matter - Learning, Alternative Paradigms, Fun

Fixing one line in a giant OS and building a small OS end-to-end yourself are completely different learning experiences.

• You see the whole stack from bootloader to shell - memory init, page tables, interrupt dispatch, system calls, scheduler, file system, user space, shell - all of it written by one person.
• You feel the cost of abstractions - what a single malloc does inside, why a context switch is expensive - you see it by hand.
• Roads the mainstream abandoned - microkernels, capabilities, single address space, persistent memory, distributed single-system images - still live somewhere.
• A strong portfolio for systems jobs - an applicant who has written a small OS stands out among 100 who have not.

The motivation of "fun" is also stronger than before. SerenityOS began as a Twitch live-coding stream. TempleOS was one person's profession of faith. The 9front manuals are full of jokes. OS development is no longer a grey academic domain.

Chapter 2 - SerenityOS - Andreas Kling's 1990s Unix Graphical OS

SerenityOS is a project started in 2018 by former Apple WebKit and Nokia engineer Andreas Kling during his recovery. It began as a small graphical shell for his own PC, but after he opened it on GitHub, hundreds of contributors joined.

Highlights:

• 1990s Unix aesthetic - graphics in the spirit of Motif, CDE, BeOS, and NeXTSTEP
• C++23 - the standard library is rewritten from scratch. The AK library, custom JS and DOM engines, and even a self-hosting compiler exist.
• BSD 2-Clause license
• Vertical integration - bootloader, kernel, libc, drivers, shell, terminal, text editor, image viewer, web browser, email client, messenger, and even a karaoke app live in one repo.
• Ladybird the browser spun out as a separate project in 2024-2025.

Kling's favorite phrase is "code should be fun." Nearly every decision in SerenityOS deliberately avoids external dependencies so that the team can enjoy "the pleasure of building it themselves."

References: https://serenityos.org, https://github.com/SerenityOS/serenity.

Chapter 3 - Ladybird - An Independent Browser Spun Out of SerenityOS

Ladybird was originally SerenityOS's internal browser, but in 2024 Andreas Kling handed off SerenityOS leadership to the community and chose to work on Ladybird full time, making it an independent project.

Highlights:

• A fourth browser engine attempt - aiming to become a new family alongside Chromium (Blink), WebKit, and Gecko.
• Custom LibWeb and LibJS - DOM, CSS, JavaScript, and WebAssembly all reimplemented from scratch.
• 2026 alpha release - an alpha build became public in the summer of 2026, with a beta targeted for 2027.
• The non-profit Ladybird Browser Initiative - funded by Shopify, Chris Wanstrath (GitHub co-founder), and Andreas Kling himself.
• Multi-platform - Linux, macOS, Windows, and SerenityOS.

Ladybird is no longer "a hobby OS's browser." It is "a new attempt at the browser industry that came out of a hobby OS." A very rare case where an OS one person built spun off a real industrial-scale browser.

References: https://ladybird.org, https://github.com/LadybirdBrowser/ladybird.

Chapter 4 - Haiku - The BeOS Heir, Multimedia-First OS

Haiku is a project started in 2001 after Be Inc. went bankrupt, with the goal of reproducing BeOS R5. Twenty-five years later, R1/beta5 was released in September 2024, and in 2026 it is still in beta but very stable.

Highlights:

• BeAPI compatible - BeOS R5 binaries run as-is.
• MIT license
• Multimedia first - pulse-coded audio, MIDI, and video decoding are first-class OS citizens.
• Pervasively multithreaded - every GUI window runs on its own thread, every application is genuinely multithreaded.
• BFS file system - a 64-bit journaling file system with extended attributes and live queries (Spotlight before Spotlight).
• POSIX, gcc, LLVM all supported - Mesa3D, Qt, and GTK have been ported.

Haiku still shows that "crisp responsiveness no other desktop quite matches" that BeOS once did. Live queries and attribute-based file systems make search a first-class OS feature.

References: https://www.haiku-os.org, https://www.haiku-os.org/docs/welcome/welcome_en.html.

Chapter 5 - ReactOS 0.4.15 - The Windows NT-Compatible Open Source OS

ReactOS is a project started in 1998 with the goal of running Windows NT 5.x (Windows 2000, XP, Server 2003) binaries as-is. In 2024 0.4.15 shipped as the stable release, and the same series is maintained through 2026.

Highlights:

• Not the same as Wine - Wine is a library on top of Linux that emulates the Windows API. ReactOS reimplements the NT 5.x kernel, HAL, and drivers themselves.
• GPLv2 kernel and LGPL user space
• Partial support for NTFS, FAT32, and ext
• In-house Win32k, USER32, GDI32
• Some older Windows apps like Office 2007, Photoshop CS6, and AutoCAD run.

ReactOS is an "endless marathon." Because of the vast surface area of the Windows API and the lack of public NT internals, 0.5.0 keeps being "ready next year." But the 0.4.x series alone delivers enough value for "preserving old Windows software."

References: https://reactos.org, https://github.com/reactos/reactos.

Chapter 6 - Redox OS - A Rust Microkernel Unix from Scratch

Redox OS is a Rust microkernel OS started in 2015 by Jeremy Soller. In 2026 the 0.10.x series is active, with its own bootloader, self-hosted compilation, and a custom GUI (Orbital).

Highlights:

• Microkernel - drivers, file systems, and the network stack run in user space.
• Pure Rust - a memory-safe system that minimizes unsafe.
• MIT license
• POSIX-friendly shell ion and a custom package manager pkgar
• RedoxFS - a transactional file system
• Cookbook build system - builds a live USB with one command

Redox is the most serious answer to "what would Unix look like if you wrote it again in Rust?" A microkernel plus memory safety plus modern packaging - all three in one OS. Its system calls closely resemble Linux and POSIX, so porting is cheap.

References: https://redox-os.org, https://gitlab.redox-os.org/redox-os/redox.

Chapter 7 - Theseus OS - A Single-Address-Space Rust OS

Theseus is a research OS that grew out of Kevin Boos's PhD work. It explores reducing state spill and using language-based safety in a single address space to achieve isolation.

Highlights:

• Pure Rust - kernel, drivers, and applications share an address space but are isolated by the compiler.
• Isolation without an MMU - the unit of isolation is the Rust type system and module boundary.
• MIT/Apache 2.0
• Live evolution - kernel modules can be swapped at runtime.
• Still research in 2026 - not for production, but loved by OS researchers.

Theseus asks: "Do we really need the traditional OS isolation model?" If you have a safe language like Rust, do you still need expensive page tables and context switches to build a safe OS? It answers in code.

References: https://www.theseus-os.com, https://github.com/theseus-os/Theseus.

Chapter 8 - Plan 9 from Bell Labs - The Distributed OS Claiming Unix's Throne

Plan 9 is the OS the very people who built Unix made in the late 1980s at Bell Labs as their answer to "what do we build after Unix?" Rob Pike, Ken Thompson, Dennis Ritchie, and Dave Presotto were among the authors.

Highlights:

• Everything is a file - truly - if Unix says "almost everything is a file," Plan 9 says "really everything is a file." Network connections, graphical windows, processes, and CPUs are all files.
• 9P protocol - even resources across the network are accessed through the same file system interface.
• Distributed single system image - multiple machines look like one machine.
• UTF-8 - was invented for Plan 9.
• Per-process namespaces - two processes on the same machine see different file trees.
• MIT license - Bell Labs released the code in 2014.

Plan 9 was never an industry success, but its influence is everywhere. Go is a spiritual descendant, and the namespace isolation used by containers is directly influenced by Plan 9's per-process namespaces.

References: https://plan9.io, https://9p.io.

Chapter 9 - 9front - The Living Community Fork of Plan 9

9front is the community fork that has been actively maintained since Bell Labs's Plan 9 4th edition effectively froze. The 9P protocol, the ACME editor, the rio window manager, and the plumb messaging system all still work.

Highlights:

• Modern hardware support - USB, Wi-Fi, NVMe, UEFI
• MIT license
• Manuals full of jokes - the 9front manual pages are a unique style mixing actual usage with humor.
• Drawterm - a terminal that connects to 9front from other OSes
• Active in 2026 - using 9front instead of Bell Labs Plan 9 is essentially the default.

If you want to try Plan 9 for the first time, do not install the Bell Labs 4th edition. Install 9front. Its installer is clean and it boots on modern laptops.

References: http://9front.org, http://fqa.9front.org.

Chapter 10 - The 9P Protocol and Inferno - Children of Plan 9

9P is the protocol that exposes Plan 9's file operations over the network. A small message set (Tversion, Tattach, Twalk, Topen, Tread, Twrite, Tclunk, and so on) expresses the entire file system interface.

Influence:

• Linux v9fs - the Linux kernel ships a 9P client. Virtualization guests mount host directories over 9P.
• QEMU virtio-9p - QEMU's file-sharing backend
• WSL2 - Microsoft uses 9P as the file system bridge between Windows and Linux.
• diod - Lawrence Livermore's distributed 9P server

Inferno OS is the heir that took the Plan 9 spirit into embedded and portable devices. It uses a custom language Limbo and the Dis VM. It targeted portable devices but never gained market share. Limbo, however, is a direct ancestor of Go - channels and goroutine-like concurrency came from Limbo.

References: https://en.wikipedia.org/wiki/9P_(protocol), https://www.vitanuova.com/inferno/.

Chapter 11 - MenuetOS and KolibriOS - Assembly-Written Floppy OSes

MenuetOS is a Finnish OS that first ran as 32-bit (M32) and then as 64-bit (M64). It is written in pure assembly, and even the 64-bit version fits on a 1.4 MB floppy.

KolibriOS is a Russian and Eastern European community OS forked from the 32-bit MenuetOS in 2004. It is also written in assembly and ships a graphical shell, a text editor, a web browser, and games while remaining tiny.

Summary:

The fact that an entire OS fits on a single floppy is, by itself, living proof against the idea that "an OS must be huge."

References: https://www.menuetos.net, https://kolibrios.org.

Chapter 12 - ArcaOS - The Modernized OS/2 Heir

ArcaOS is the successor to IBM's OS/2 Warp. With IBM no longer maintaining OS/2, Arca Noae - via eComStation - signed a licensing deal with IBM and built a commercial successor.

Highlights:

• OS/2 4.x binary compatibility - 1990s OS/2 business apps still run.
• Modern hardware support - UEFI, ACPI, USB, SSD, NVMe
• Paid license - about USD 130 for personal use, more for commercial
• 5.1.x releases through 2024-2026
• The only realistic upgrade path for ATMs, kiosks, and industrial controllers still running OS/2.

ArcaOS shows how aging industrial infrastructure survives. The market is small, but there are users with clear willingness to pay license fees.

References: https://www.arcanoae.com/arcaos/.

Chapter 13 - HelenOS and Genode - The Frontier of Microkernel Research

HelenOS is a research OS born at Charles University in Czechia that targets multiple compatible microkernels. It runs on its own Spartan microkernel and has its own user space, and it has been alive for about 25 years.

Genode is a component OS framework built by Germany's Genode Labs that runs on top of microkernels and hypervisors. It runs on seL4, NOVA, Fiasco.OC, Linux, and others, and the same user-space components are compatible across different kernels.

Genode-based Sculpt OS is still used as a daily driver secure laptop desktop by some researchers in 2026. It is the living example that most consistently delivers on the microkernel promise.

References: https://www.helenos.org, https://genode.org.

Chapter 14 - Fuchsia and Hubris - Company-Built Microkernels

Fuchsia is Google's Zircon microkernel-based OS. It went commercial in 2021 on the Nest Hub, but around 2024 Google scaled the Fuchsia team down, and it is effectively in maintenance mode.

Highlights:

• Zircon microkernel - a custom kernel, not Linux-compatible.
• Apache 2.0
• Component Framework v2 - everything is a capability-isolated component.
• FIDL IDL - the IPC interface definition language for components.
• Flutter and Dart as first-class citizens

Hubris is the Rust microkernel RTOS built by Oxide Computer. It actually runs on the baseboard management controllers (BMCs) and service processors (SPs) of data center hardware.

Highlights:

• Every task in its own address space - a clean microkernel structure
• Predefined task set - no dynamic task creation, prioritizing security and predictability
• Mozilla Public License 2.0
• Targets ARM Cortex-M chips like STM32 and NXP iMX

If Fuchsia is the result of a "giant computing platform" ambition, Hubris is a "microkernel built to do one job very well." Both took company capital, so they are not exactly indie - but as "non-mainstream OSes" they belong to the same family.

References: https://fuchsia.dev, https://github.com/oxidecomputer/hubris.

Chapter 15 - Unikernels - Hermit, Unikraft, OSv, MirageOS, Nanos

A unikernel packs the operating system and the application into a single binary. It runs as a single process on a virtual machine or on bare metal.

The main names:

Strengths:

• Tiny attack surface - no shell, no other processes.
• Fast boot - tens of milliseconds.
• Low memory footprint - a few MB.

Weaknesses:

• Hard to debug - the usual OS tools are not there.
• Single process - sidecars and multiple services are not supported.
• Public cloud integration - it is awkward to operate on AWS, GCP, and Azure with standard tooling.

Unikernels in 2026 have not "replaced all containers," but they hold real production traffic in FaaS, edge compute, 5G UPF, and CDN middleboxes.

References: https://unikraft.org, https://github.com/hermit-os/hermit-rs, https://mirage.io, https://nanovms.com.

Chapter 16 - TempleOS - One Person's Faith and Their OS

TempleOS is the OS Terry A. Davis (1969-2018) built alone over roughly a decade. He said he built it following his religious vision, and he wrote essentially every line himself.

Highlights:

• HolyC - a custom C variant compiled and run inside a REPL shell
• Fixed 640x480 resolution, 16 colors - intentional simplification
• Single user, single address space, ring-0 only - all code runs in kernel mode
• Public domain
• Entire OS plus compiler in 128 KB on disk

Its industrial value is near zero, but it is the most often-cited work in OS-development history. One person, fighting mental illness, wrote the whole thing himself. He insisted that an OS can be the expression of a religious vision. These extremes keep TempleOS from being forgotten.

Terry Davis died in 2018, but ShrineOS and Zeal Operating System forks still live.

References: https://templeos.org (unofficial mirror), https://github.com/Zeal-Operating-System/ZealOS.

Chapter 17 - MorphOS and AROS - The Living Heirs of Amiga

The Amiga by Commodore was once at the frontier of multimedia computing in the 1980s and 1990s. The company died, but the OS survived through two heirs.

MorphOS - compatible with Amiga OS 3.x, runs on PowerPC machines. 3.18 shipped in 2024, and the project is still active in 2026.

AROS Research Operating System - an open source project to port the Amiga OS API to every platform. Runs on x86_64, ARM, and PowerPC.

If you want to preserve Amiga demoscene, games, or DTP software, one of these two is the answer. The user base is small but extremely dedicated.

References: https://www.morphos-team.net, https://aros.sourceforge.io.

Chapter 18 - The Microkernel Debate - Mach, L4, seL4

A never-ending debate in OS-development circles is microkernel versus monolithic.

The main microkernel families:

• Mach - developed at CMU in the 1980s. The base of NeXTSTEP, macOS, iOS, OSF/1, and GNU Hurd. But it was criticized as "first-generation microkernels are too slow."
• L4 - the second-generation microkernel that Jochen Liedtke built in the 1990s. System calls are extremely fast (tens of cycles).
• L4Re and Fiasco.OC - L4 variants from TU Dresden
• seL4 - a mathematically formally verified microkernel in the L4 family. About 10,000 lines of C code are proven equivalent to a specification in Isabelle/HOL.

seL4 is actually used in safety- and security-critical domains - aviation, defense, automotive, cryptographic key management. The US DARPA HACMS project ran an autonomous helicopter on seL4, and a demonstration ported part of a Boeing 707 OFP onto seL4.

References: https://sel4.systems, https://l4re.org.

Chapter 19 - Bare-Metal Rust with Tock, Tonk, and Vanadium

Rust has been a first-class citizen in OS development for more than five years. In 2026, even the Linux kernel has merged some Rust modules.

Notable Rust embedded and OS projects:

• Tock OS - a microkernel for embedded devices, Apache 2.0. Supports Cortex-M and RISC-V.
• Tonk - a partial successor prototype to Tock for IoT security
• Vanadium - a Rust OS that runs on Ledger's secure chips for hardware wallets
• Hermit RS - a Rust unikernel
• Embassy - a Rust embedded async framework
• RTIC - Real-Time Interrupt-driven Concurrency, Rust embedded real time

Learning materials:

• Phil Opp - Writing an OS in Rust - https://os.phil-opp.com, builds an x86_64 OS from scratch.
• Rust Embedded Book - https://docs.rust-embedded.org/book/
• Embedded HAL - the Rust embedded standard abstraction layer
• probe-rs - the embedded debugging toolkit

Writing an OS in Rust is no longer an experiment. Parts of seL4, Theseus, Redox, Hubris, and Tock are all production-grade OSes written in Rust.

References: https://os.phil-opp.com, https://www.tockos.org, https://github.com/LedgerHQ/vanadium.

Chapter 20 - Korean and Japanese Indie OSes - Minimix, KumihaOS, Mona

OS development is not only an English-speaking world thing. Korea and Japan have their share of one-person OSes too.

Korea:

• Minimix - a Minix variant, used for teaching
• KumihaOS - a hobby OS that grew out of an undergraduate OS course, runs on x86
• Hanlife - a Korean-language desktop environment experiment
• Many university OS course projects are public on GitHub.

Japan:

• Mona OS - a Japanese hobby OS by M.HiyoX. Very active in the early 2000s and the symbol of Japan's OS-development culture.
• OSASK - an OS by Hidemi Kawai, author of the book "30-Day OS Self-Development Introduction"
• Toaru OS - a US-based undergraduate-style hobby OS by Japanese developer K. Lange, still active in 2026

Japan in particular has the book 30-Day OS Self-Development Introduction as a cultural icon for OS development. Its English translation exists only in part, but more developers got started by reading the Japanese original than by reading any English source - according to some informal counts.

References: https://github.com/hiyohiyo/mona, https://book.mynavi.jp/ec/products/detail/id=22078.

Chapter 21 - Educational and Template OSes - xv6, MIT, LFS, Buildroot, Yocto

Before you write your own OS, you copy someone else's small one.

xv6 is the teaching Unix used by MIT's 6.S081 OS course. It is roughly a 10,000-line OS rewritten from UNIX V6 into ANSI C and RISC-V. Every fall, thousands of students read and modify this code.

Linux From Scratch (LFS) - build a Linux distribution from scratch. You do not write the kernel yourself, but everything in user space - bootloader, init, glibc, shell - is compiled by hand.

Buildroot and Yocto - embedded Linux build systems. You do not write an OS, but you see exactly how embedded devices like routers and set-top boxes are produced.

References: https://pdos.csail.mit.edu/6.828/2023/xv6.html, https://www.linuxfromscratch.org, https://buildroot.org, https://www.yoctoproject.org.

Chapter 22 - OS-Development Resources - OSDev.org, Three Easy Pieces, and the Small Books

The hardest part of starting your own OS is "where do I begin." In 2026 there is plenty of material.

OSDev.org - https://wiki.osdev.org. The Wikipedia of OS development. Bootloaders, page tables, interrupts, GDT/IDT, ELF loading, file systems - there is an article on almost everything.

Books:

• Operating Systems: Three Easy Pieces (OSTEP) - by Remzi and Andrea Arpaci-Dusseau, free PDF. The virtualization, concurrency, persistence trilogy.
• The Little Book About OS Development - by Erik Helin and Adam Renberg, course notes from KTH in Sweden
• Writing an OS in Rust - by Phil Opp, an x86_64 OS in Rust
• The xv6 book - the textbook for MIT 6.S081
• The Design and Implementation of the 4.4BSD Operating System - BSD internals
• Linux Kernel Development - by Robert Love, Linux kernel internals
• Operating System Concepts (Silberschatz) - the so-called "dinosaur book," the standard undergraduate OS textbook
• The Plan 9 Papers - the original Bell Labs Plan 9 design papers

Communities:

• r/osdev - the Reddit hobby OS-developers subreddit
• #osdev on Libera.Chat - IRC
• OSDev Discord

References: https://wiki.osdev.org, https://pages.cs.wisc.edu/~remzi/OSTEP/, https://littleosbook.github.io, https://os.phil-opp.com.

Chapter 23 - If You Want to Build Your Own OS - A Six-Step Roadmap

If OS development has caught your attention, the following six steps are the recommended route.

1. Print a single line from a bootloader - on top of GRUB or Limine, print Hello, world to the serial port or VGA text mode.
2. Set up the GDT and IDT and take interrupts - handle keyboard and timer interrupts.
3. Page tables and a physical memory allocator - manage 4 KB pages.
4. A simple scheduler and system calls - round-robin two processes.
5. A simple file system and shell - implement echo, cat, and ls on a RAM disk.
6. Add your own flavor - microkernel, unikernel, Rust, Plan 9-style namespaces - whatever you actually want to try.

The first three steps are almost identical across every hobby OS. From step 4, things diverge. You can go monolithic like Linux, microkernel like Redox, or stop at a single-process unikernel.

Recommended learning combination:

• Books: OSTEP plus The Little Book About OS Development or Writing an OS in Rust
• Code: read xv6, then start your own OS
• Tools: QEMU, GDB, Bochs, probe-rs (embedded)
• Community: OSDev.org plus r/osdev plus Korean and Japanese OS-development Discords

Chapter 24 - Closing - Why Indie OSes Keep Getting Built

In 2026, with Linux looking like it will take everything, people keep building new OSes.

The reasons are the same.

• They want to understand - a big system does not fit in one person's head. A small OS does.
• A different path - microkernels, unikernels, capability-based, formal verification, single address space, distributed single-system images - the mainstream abandoned them but they are still alive.
• Fun - code should be fun. SerenityOS, TempleOS, and the 9front manuals prove that every day.
• Career and learning - systems, embedded, security, kernel development - every position values "I wrote a small OS once."

A 2026 recommendation in one line:

• A modern graphical OS to look at -> SerenityOS, Haiku
• A safe OS in Rust -> Redox, Theseus, Hubris
• A new paradigm -> Plan 9, 9front, MirageOS, Tock
• Windows or OS/2 compatible -> ReactOS, ArcaOS
• Formally verified -> seL4
• Unikernel -> Unikraft, MirageOS, Nanos
• Education and starting out -> xv6, Phil Opp's Rust OS book, OSTEP

OS development is not a finished field. It is not too late to start now. Write one line, catch one interrupt, build one system call, and you will finally truly understand how the OS you use every day stays alive - and what really happens inside it.

Code should be fun. Operating systems are no exception.

References

1. SerenityOS - https://serenityos.org
2. SerenityOS GitHub - https://github.com/SerenityOS/serenity
3. Ladybird - https://ladybird.org
4. Ladybird GitHub - https://github.com/LadybirdBrowser/ladybird
5. Haiku OS - https://www.haiku-os.org
6. ReactOS - https://reactos.org
7. Redox OS - https://redox-os.org
8. Theseus OS - https://www.theseus-os.com
9. Plan 9 - https://plan9.io
10. 9front - http://9front.org
11. Inferno OS - https://www.vitanuova.com/inferno/
12. MenuetOS - https://www.menuetos.net
13. KolibriOS - https://kolibrios.org
14. ArcaOS - https://www.arcanoae.com/arcaos/
15. HelenOS - https://www.helenos.org
16. Genode - https://genode.org
17. Fuchsia - https://fuchsia.dev
18. Hubris (Oxide) - https://github.com/oxidecomputer/hubris
19. Unikraft - https://unikraft.org
20. MirageOS - https://mirage.io
21. Nanos / NanoVMs - https://nanovms.com
22. seL4 - https://sel4.systems
23. Tock OS - https://www.tockos.org
24. Writing an OS in Rust - https://os.phil-opp.com
25. OSDev Wiki - https://wiki.osdev.org
26. OSTEP - https://pages.cs.wisc.edu/~remzi/OSTEP/
27. The Little OS Book - https://littleosbook.github.io
28. xv6 - https://pdos.csail.mit.edu/6.828/2023/xv6.html
29. Linux From Scratch - https://www.linuxfromscratch.org
30. Buildroot - https://buildroot.org