A new video from the popular coding channel Fireship claims to cover every operating system concept in a single sitting. The video, titled "Every operating system concept in one video…," walks through the entire lifecycle of what happens inside your computer from the instant you press the power button to the moment you shut it down. While the video itself is aimed at developers and CS students, the concepts it covers are fundamental to understanding how modern computers work.

According to the video description, the topics include bootloader, privilege ring, virtual memory, filesystem, drivers and interrupts, processes, syscalls, scheduler, threads, IPC, and shutdown SIGKILL. That is a lot of ground for one video. But each of these concepts plays a critical role in making sure an operating system does its job: managing hardware and software resources, isolating programs from one another, and providing a stable environment for users.

It all starts with the bootloader

When you press the power button, the first piece of code that runs is the bootloader. The bootloader lives in the first sector of your hard drive or SSD and is responsible for loading the operating system kernel into memory. Without a bootloader, the CPU would have no instructions to execute beyond whatever firmware (like BIOS or UEFI) provides. The bootloader is small, but it has to be exactly right, because any mistake prevents the system from starting.

Fireship's breakdown likely explains that the bootloader hands off control to the kernel, which then sets up the rest of the operating system. The kernel operates at the highest privilege level, often called ring 0.

Privilege rings keep user code in check

Privilege rings are a hardware-enforced security mechanism. Most modern CPUs support multiple rings, with ring 0 being the most privileged (kernel mode) and ring 3 being the least privileged (user mode). Applications run in ring 3, which prevents them from directly executing sensitive CPU instructions or accessing hardware. When a user program needs to do something like read a file or send network data, it must ask the kernel via a system call. That transition from ring 3 to ring 0 is one of the most important mechanisms in operating system design. It stops a buggy or malicious program from crashing the whole machine.

The video reportedly covers how privilege rings are used in practice. On x86 processors, rings 1 and 2 are rarely used by mainstream operating systems, but the concept remains central to security.

Virtual memory makes every program think it owns the house

Virtual memory is an abstraction that gives each process its own private address space. The operating system, with help from the CPU's memory management unit (MMU), maps these virtual addresses to physical RAM. This means a program can use more memory than is physically available by swapping parts of its address space to disk. More importantly, virtual memory isolates processes from one another: one program cannot read or write another program's memory unless explicitly allowed. That is foundational for stability and security.

Fireship's treatment of this topic probably shows how page tables, TLB (translation lookaside buffer), and paging work together. It is a dense subject, but the video aims to make it digestible.

The filesystem organizes persistent data

Without a filesystem, your hard drive would be a giant unlabeled blob. The filesystem provides structure: directories, file metadata, permissions, and data blocks. Different filesystems (like NTFS, ext4, APFS) use different approaches to journaling, indexing, and allocation. The video likely covers the basic responsibilities of the filesystem layer and how it interacts with the virtual file system (VFS) interface in the kernel.

Drivers and interrupts connect hardware to software

Drivers are kernel modules that speak the language of specific hardware devices. They handle input/output operations and translate generic kernel requests into device-specific commands. Interrupts are signals sent by hardware to the CPU to indicate something needs attention, like a key press or a network packet arrival. The interrupt handler in the kernel responds quickly, often deferring heavy work to a bottom half or tasklet so the system stays responsive.

The video reportedly explains how drivers register interrupt handlers and how the kernel manages interrupt requests (IRQs). This is where real-time behavior and latency matter.

Processes are the units of execution

A process is an instance of a running program. It has its own address space, file descriptors, environment, and state. The operating system keeps track of all processes in a process table. Each process can be in one of several states: running, ready, waiting, or terminated. The video likely covers the basic process lifecycle and the fork/exec model used by Unix-like systems.

Syscalls are the bridge between user and kernel

System calls are the official way for user-space programs to request services from the kernel. Common syscalls include read(), write(), open(), close(), fork(), exec(), and mmap(). The video probably walks through how a syscall triggers a trap into kernel mode, the kernel performs the requested operation, and then returns to user space. Understanding syscalls is essential for debugging performance issues and writing efficient code.

The scheduler decides who runs next

On a single-core CPU (or even on multi-core systems), many processes may be ready to run at any given moment. The scheduler chooses which process gets CPU time and for how long. Modern schedulers aim to balance throughput, latency, and fairness. The Completely Fair Scheduler (CFS) in Linux is a common example. The video likely touches on scheduling policies like round-robin, priority-based, and real-time schedulers.

Threads are light weight processes

A thread is the smallest unit of execution within a process. Threads share the same address space and can communicate with each other without using IPC mechanisms. The kernel schedules threads, not processes. Multi-threading allows programs to exploit multiple CPU cores and keep the UI responsive while doing background work. Fireship's coverage probably includes the difference between kernel-level threads and user-level threads (like green threads).

IPC lets processes talk to each other

Inter-process communication (IPC) mechanisms allow processes to exchange data and synchronize actions. Common IPC methods include pipes, sockets, shared memory, message queues, and signals. The video likely explains when you might use each one and the trade-offs involved. For example, pipes are simple but only work between parent and child processes, while sockets can work across a network.

Shutdown: the ultimate signal — SIGKILL

The final topic covered is shutdown and specifically SIGKILL. When you shut down your computer, the kernel sends termination signals to running processes. SIGKILL (signal 9 on Unix) cannot be caught or ignored; it forces immediate termination. The system then unmounts filesystems, halts device drivers, and finally powers off. The video probably explains the difference between graceful shutdown (SIGTERM) and forced kill (SIGKILL), and why you should always try the gentle approach first.

What the video means for developers

For anyone learning systems programming, these concepts form the core curriculum. Fireship's video is not a deep dive into any single topic, but it provides a high-level map that helps beginners connect the dots. The channel is known for fast-paced, visually engaging explanations that prioritize breadth over depth. That format works well for gaining conceptual understanding before digging into textbooks.

If you have watched the video, you might notice that some topics like file descriptors, cgroups, or containerization are not listed. That is fine. The video sticks to the classic operating system concepts that have remained relevant for decades. Modern additions like containers or eBPF build on these foundations.

The bigger picture

Operating system design is one of the most elegant areas of computer science. Every concept listed in the video — bootloader, privilege ring, virtual memory, filesystem, drivers, interrupts, processes, syscalls, scheduler, threads, IPC, and shutdown — interacts with every other. For example, a syscall might trigger a context switch, which involves the scheduler, which touches virtual memory. The video helps viewers see those connections.

Understanding these concepts also makes you a better programmer. When your code runs slowly, you might realize it is because of too many syscalls. When a program crashes inexplicably, the cause could be a privilege ring violation or a filesystem permission. Debugging becomes easier when you know which layer of the stack to inspect.

Fireship's video is sponsored by Railway, a platform for deploying applications. While the sponsorship is unrelated to the content, it provides context for the audience: many developers watching will be deploying software and need to understand at least some of these concepts to debug deployment issues.

The full video is available on the Fireship YouTube channel, and the description links to a newsletter (Bytes) and courses (fireship.dev) for deeper learning. For now, this single video serves as a rapid-fire tour of everything your operating system does behind the scenes.