Low-Level Atlas
From “I can program” to “I understand the machine”
A dense, personal atlas for going under the runtime: the machine model, C and manual memory, pointers, assembly, the toolchain, systems programming, concurrency and performance — with an OS built from scratch as the spine project.
Read it as a map, not as a course catalog.
Start with the machine model, descend through C and pointers to assembly and the toolchain, climb back up into systems and performance, and let the OS-from-scratch project pull it all together.
Orientation
Where to start, what to ignore for now, and how the atlas is organized.
Start Here
The reading path through the Low-Level Atlas — the order that takes you from the machine model to an OS built from scratch without skipping the load-bearing steps.
ExploreMust Know
The load-bearing ideas of low-level programming — the handful of truths that, once internalized, make the rest of the atlas click.
ExploreLow-Level Index
Every branch of the Low-Level Atlas at a glance, grouped by phase — from the machine model down to the metal and back up to an OS built from scratch.
ExploreFoundations
How the machine really works under the runtime — CPU, memory hierarchy, data representation, and the reset of “now you are the runtime.”
The C Layer
C as a thin layer over the machine, undefined behavior, and manual memory: pointers, the heap, allocators, and the classic bugs.
C from the Metal
C for someone who already programs: the weak type system, undefined behavior, the preprocessor, array-to-pointer decay, and a thin layer over the machine.
ExplorePointers & Memory
The heart of it: stack vs heap, malloc/free, pointer arithmetic, alignment and padding, classic memory bugs, and custom allocators.
ExploreDown to the Metal
Reading the assembly your compiler emits, calling conventions, and the full preprocess→compile→assemble→link toolchain with its debuggers.
Assembly & Compiler Output
Reading x86-64 (with an ARM64 appendix): registers, instructions, stack frames, calling conventions, and Compiler Explorer as a daily tool.
ExploreToolchain & Linking
The full pipeline: preprocess, compile, assemble, link. Object files, ELF, static vs dynamic linking, gdb/lldb, sanitizers, and valgrind.
ExploreC++ (optional)
The jump from C to C++ — RAII, smart pointers, move semantics, templates, and the STL. Optional: the OS is C-first.
Systems
Talking to the kernel via syscalls and POSIX, then where low-level pays off: concurrency, memory ordering, and performance.
Systems Programming
Talking to the OS: syscalls, processes, threads, mmap, low-level I/O, signals, and the POSIX layer that bridges your program and the kernel.
ExploreConcurrency & Performance
Where low-level pays off: threads, atomics, memory ordering, lock-free, false sharing, cache-aware code, SIMD, and serious benchmarking.
ExploreThe Project
The spine project that consumes everything else: a small operating system, bootloader to shell, on x86-64 under QEMU.
Always Active
TDD, clean code, and XP carried into C/C++: testing, fuzzing, contracts, and reviewing memory-unsafe code.
You are the runtime now
The managed runtime quietly did bounds checks, freed your memory, normalized your integers, and caught your type errors. Bare metal removes that floor — the CPU...
Registries and operating memory
Registries keep external references, specs, tools, and source material normalized behind short atomic notes.