How Linux Works

A free, interactive course from Stencel Academy. Type real shell commands — ls, cd, kill, fork — and watch signals, processes, memory and containers animate across a living map of the machine, until how Linux works finally clicks.

Choose your learning path

Prompt Engineer — The terminal literacy an AI engineer actually needs. For prompt & AI engineers. Move around a shell, read & write files, set permissions, and pipe commands — enough to live inside a sandbox or container prompt.
Daily Linux User — Run and manage a machine, day to day. For developers who live on Linux. Everything in Prompt Engineer, plus how programs become processes — fork/exec, the process tree, states, signals.
Power User — See into the kernel that everything sits on. For engineers who debug the hard stuff. Adds the kernel: the user/kernel boundary, virtual memory, the address space, and scheduling.
Superuser — The whole machine — boot to containers. For systems & platform engineers. The complete arc: boot, systemd, namespaces, cgroups, and the punchline — a container is just a process wearing a costume.

All 21 lessons

The Round Trip — Watch one command travel and return. Every command is a round trip from you, through the kernel, to hardware, and back.
The Filesystem Tree — Everything is a file. Walk the tree. The filesystem is one tree from /; a path is just directions through it.
Reading & Writing — See where text goes when you read and write. Reading streams a file in; > replaces its contents, >> appends to them.
Permissions — the gate — Watch the kernel check if you're allowed. Every access passes a permission gate: read, write, AND execute — keyed to user, group, other.
Names vs Things — inodes & links — A filename is a label, not the file. Names point to inodes; the inode owns the data. Links are extra pointers.
From Program to Process — Watch a program on disk come alive in memory. A program is a file on disk; a process is that program loaded and running in memory.
The Process Tree — Every process has a parent. Meet PID 1. Processes form a tree rooted at PID 1 — every process has a parent.
fork() & exec() — See one program become two, then something else. Running a command = the shell forks, the copy exec's the program, the shell reaps it.
Process States — A process is a state machine. Processes move between running, sleeping, stopped, and zombie — the scheduler cares which.
Signals — Processes talk by sending signals. SIGTERM asks politely (handlers run); SIGKILL is unstoppable and immediate.
Pipes & Redirection — Wire one program's output into another's input. A pipe connects fd 1 of one process to fd 0 of the next; redirection rewires the fd table.
The User/Kernel Boundary — Cross the wall between your code and the kernel. Programs can't touch hardware directly — they trap into the kernel via system calls.
Inside the Kernel — Meet the kernel's organs. The kernel is a set of subsystems — each syscall is routed to the organ that handles it.
Virtual Memory — Every process thinks it owns all the RAM. Each process gets its own private virtual address space; page tables translate it to real RAM.
The Process Address Space — See where code, data, heap, and stack live. A process's memory has fixed code/data, a heap that grows up, and a stack that grows down.
Scheduling & Context Switch — One CPU, many processes, taking turns. One core runs one process at a time; the scheduler time-slices and context-switches between them.
Boot — the ignition chain — Watch the machine wake up. Boot is a relay: firmware starts the bootloader, which starts the kernel, which starts systemd, which starts you.
systemd — How services start in the right order. systemd starts services by resolving a dependency graph, not a fixed list.
Namespaces — Wrap a process so it sees its own world. Namespaces don't move a process — they change what it can see. Same kernel, different worlds.
cgroups — Put a process on a resource budget. cgroups cap what a process can use; namespaces cap what it can see. Together: containment.
"A Container Is Just a Process" — Assemble the thing you already use every day. A container isn't a tiny VM — it's one host process wearing namespaces, cgroups, and its own root.

Learn how Linux works by typing real commands and watching a live map of the machine move — no walls of text. Runs entirely in your browser — nothing to install.