Linux

• Hardware & OS
  Linux OS architecture

  User space, the kernel, and the two narrow strips between them: syscalls and hardware abstraction.

  Map
• Hardware & OS
  Linux OS architecture: watch data travel the stack

  Follow data from a user program through the syscall gate, the kernel and down to the hardware.

  Walkthrough
• Hardware & OS
  Where Node ends and the kernel begins

  Node does not implement TCP. Which parts of the network stack belong to Node, the kernel and the hardware.

  Also in Node.js › Sockets & networking

Hardware & storage

• Hardware & OS
  Mechanical sympathy in C

  Memory is not flat and operations do not cost the same: writing code shaped by the real machine.

• Hardware & OS
  The SQLite stack: from db.prepare() to NAND flash

  Six layers of indirection between one TypeScript call and the bytes on silicon.

Engine & execution

• Engine
  The JavaScript engine pipeline

  How console.log("Hello") becomes bytes the CPU can execute, at the moment the program runs.

• Engine
  One await, traced through the runtime

  Closure, iterator, generator, promise, microtask: what a single await is made of.

Binary data

• Engine
  The same bytes: binary data from first principles

  Storage versus view, endianness, the Buffer pool and the seam where chunks split characters.

• Engine
  Own, view, move: how JavaScript holds bytes

  Owning bytes is separate from interpreting them. Switch views; the values change, the bytes never do.

• Engine
  ArrayBuffer, TypedArrays and DataView

  Every constructor, method and option of the binary primitives that Buffer, Blob and streams build on.

Modules

• Framework (build)
  ESM vs CommonJS

  Why a bundler can prove an ESM graph before running it, but has to execute CommonJS to find out.

  Also in Node.js › Modules · Comparisons & decisions

Browser APIs

• Runtime
  fetch(), end to end

  From JavaScript through WebIDL and native C++ into Node.js streams, one block at a time.

  Also in Node.js › HTTP

• Runtime
  fetch() to the wire

  The round trip: process model, CORS preflight, the two-stage await and what JavaScript is allowed to read.

• Runtime
  Events: from interrupt to React

  One word smeared across five layers, from a hardware interrupt to React's batched handler.

  Also in React › Events

• Runtime
  Inside the browser tab: the URL is your state

  push versus replace, URLSearchParams and why the URL should be the source of truth.

• Runtime
  Two stream object models

  WHATWG's ReadableStream and Node's stream.Readable are not two spellings of one abstraction.

  Also in Node.js › Streams

Architecture

• Runtime
  The anatomy of Node.js

  Seven layers between your JavaScript and the kernel; every fs.readFile hops through all of them.

  Map
• Runtime
  Node.js architecture: watch a request travel the stack

  Core modules, the event loop, the thread pool and the two gates between JavaScript and the kernel.

  Walkthrough

Modules

• Runtime
  Modules: resolution, the cache and the cost of cold start

  Most of your cold start is spent asking the kernel whether files exist.

  Mission 01 of 12
• Framework (build)
  ESM vs CommonJS

  Why a bundler can prove an ESM graph before running it, but has to execute CommonJS to find out.

  Also in JavaScript & the Web platform › Modules · Comparisons & decisions

Event loop & dispatch

• Hardware & OS
  How Node.js finds out: a wakeup, or a call

  Fifteen notification mechanisms, from a softirq to a promise reaction, asked the same five questions.

• Runtime
  Who calls your callback

  libuv does not call your JavaScript. Six handoffs, two language boundaries and one copy.

• Runtime
  Handle to pointer: the indirection

  How a JavaScript object safely stands in for a native pointer, and the [native code] tell.

• Runtime
  The event loop: phases, timers and the two queues that jump them

  Six phases in a fixed order, a timer heap that shares one syscall with I/O, and two queues outside them.

  Mission 04 of 12
• Runtime
  The Node.js event loop, deep internals

  Phase by phase, from the V8 heap to libuv's epoll, with no hand-waving.

• Runtime
  The thread pool: four subsystems, one queue, four threads

  Filesystem, DNS, crypto and zlib all share the pool, which is why one slow call delays the others.

  Mission 06 of 12

Bytes & Buffers

• Runtime
  Bytes and the kernel

  Node's binary layer from Buffer and the pool to fs syscalls, backpressure and the Node-API bridge.

• Runtime
  Buffers: a window onto memory outside the V8 heap

  The kernel needs an address that does not move, and a garbage collector cannot promise one.

  Mission 03 of 12
• Runtime
  Bytes to text

  Encodings, decoding and the seam where a character is split across two chunks.

• Runtime
  Whose bytes are these?

  One byte from the socket to the response, in eleven stops.

• Runtime
  Where are my bytes right now?

  Who is holding the data, at every layer, at every instant.

Events

• Runtime
  EventEmitter: emit is a for loop

  A map from names to arrays of functions. emit() is synchronous and queues nothing.

  Mission 02 of 12
• Runtime
  EventEmitter from first principles

  Build it yourself: once, mutation mid-emit, the 'error' case and listener leaks.

Streams

• Runtime
  Streams: an emitter, a queue of Buffers and one advisory rule

  write() returns false when the queue is full, and nothing forces you to listen.

  Mission 07 of 12
• Runtime
  Backpressure: streams from first principles

  One signal, traced from the kernel floor through classic streams and Web Streams.

• Runtime
  stream.Readable and stream.Writable

  Two halves of one wire: the same buffer and mark, one signal running each way.

• Runtime
  The producer names an event, not a consumer

  Why a Node stream emits into the void and how consumers attach to it.

• Runtime
  Node streams, both ends

  The same four questions asked of the read side and the write side.

• Runtime
  Producer, buffer, consumer

  The machinery between a producer that cannot be told to wait and a consumer that runs when it can.

• Runtime
  Two stream object models

  WHATWG's ReadableStream and Node's stream.Readable are not two spellings of one abstraction.

  Also in JavaScript & the Web platform › Browser APIs

• Runtime
  One socket, two objects

  req and res are built the same way: a stream base, an HTTP layer and a framework layer, on one prototype chain.

  Also in Node.js › HTTP

File system

• Runtime
  fs.readFile(), from your JavaScript to the disk and back

  One line traced through CPU, OS, process, thread, syscall, libuv's worker pool and your callback.

  Mission 05 of 12
• Runtime
  The fs module

  What happens between fs.readFile and your callback, and the whole module surface, measured on Node 22.

Sockets & networking

• Hardware & OS
  Where Node ends and the kernel begins

  Node does not implement TCP. Which parts of the network stack belong to Node, the kernel and the hardware.

  Also in OS & hardware › Linux

• Runtime
  The primitives: descriptors, ports and sockets

  What a file descriptor indexes, why a port is not an object, and what a socket really is.

  Mission 00 of 12
• Runtime
  Which of these is the socket?

  Five nested layers, the process/kernel boundary, and the second chain that accept() creates.

• Runtime
  net.createServer()

  Sockets do not use the worker pool. Kernel queues, readiness and epoll instead.

  Mission 08 of 12

HTTP

• Runtime
  fetch(), end to end

  From JavaScript through WebIDL and native C++ into Node.js streams, one block at a time.

  Also in JavaScript & the Web platform › Browser APIs

• Runtime
  http.createServer()

  The TCP skeleton plus llhttp: a request across two machines, two kernels and the poll phase.

  Mission 09 of 12
• Runtime
  The life of one HTTP request

  From name resolution to socket reuse, ordered by what is already true at each moment.

• Runtime
  One socket, two objects

  req and res are built the same way: a stream base, an HTTP layer and a framework layer, on one prototype chain.

  Also in Node.js › Streams

• Runtime
  Node.js HTTP from first principles

  Express, Next.js and Fastify all reduce to raw TCP bytes parsed by llhttp and handed over as req and res.

  Also in HTTP frameworks › Across frameworks

• Framework (runtime)
  Two bloodlines of req and res

  Node, Express and Next compared: who mutates the request, who returns a response, and why.

  Also in HTTP frameworks › Across frameworks · Next.js & RSC › Request · Comparisons & decisions

Concurrency

• Runtime
  worker_threads: a second Node inside your process

  Not a thread as you picture it: a whole second runtime, with its own loop and heap.

  Mission 10 of 12
• Runtime
  cluster: four processes, one port

  Two processes cannot both bind port 3000. The answer involves passing a file descriptor.

  Mission 11 of 12

Express

• Framework (runtime)
  The anatomy of Express

  A function handed to Node's server, a stack of Layer objects, and augmented req/res prototypes.

  Map
• Framework (runtime)
  Express architecture: watch a request travel the whole stack

  Express's Layer stack and next(), on top of the whole Node.js runtime.

  Walkthrough
• Framework (runtime)
  Express: the anatomy of the library

  The source, module by module: application, request, response and the router.

• Framework (runtime)
  Where req and res get their powers

  Express glues keys onto Node's own objects; Next.js subclasses the Web's Request instead.

• Framework (runtime)
  When does req.body exist?

  Your file runs once and a request walks it every time. That one fact explains middleware order.

• Framework (runtime)
  Router, Layer, Route

  How Express 5 routing works and what each composition idiom actually builds.

• Framework (runtime)
  What happens under app.get

  Router, Route, Layer and middleware dispatch in Express 5, driven by a real routing engine.

Fastify

• Framework (runtime)
  Fastify: compiled before the first request

  Routes, schemas and hooks compiled at startup, so the request path does less work.

Across frameworks

• Runtime
  Node.js HTTP from first principles

  Express, Next.js and Fastify all reduce to raw TCP bytes parsed by llhttp and handed over as req and res.

  Also in Node.js › HTTP

• Framework (runtime)
  Two bloodlines of req and res

  Node, Express and Next compared: who mutates the request, who returns a response, and why.

  Also in Node.js › HTTP · Next.js & RSC › Request · Comparisons & decisions

• Framework (runtime)
  Express decorates Node, Next extends the Web

  Two ways to give a request object more power, and the lifecycle each one produces.

  Also in Next.js & RSC › Request · Comparisons & decisions

Foundations

• Framework (runtime)
  React from first principles

  A plain object and a loop that turns it into pixels, built from scratch.

Events

• Runtime
  Events: from interrupt to React

  One word smeared across five layers, from a hardware interrupt to React's batched handler.

  Also in JavaScript & the Web platform › Browser APIs

Request

• Framework (runtime)
  Two bloodlines of req and res

  Node, Express and Next compared: who mutates the request, who returns a response, and why.

  Also in Node.js › HTTP · HTTP frameworks › Across frameworks · Comparisons & decisions

• Framework (runtime)
  Express decorates Node, Next extends the Web

  Two ways to give a request object more power, and the lifecycle each one produces.

  Also in HTTP frameworks › Across frameworks · Comparisons & decisions

• Framework (runtime)
  The anatomy of a Next.js request

  One program across a build pipeline, a server runtime and the browser, from socket to hydrated UI.

• Framework (runtime)
  The App Router, end to end

  From a packet on the wire through routing and the two-pass RSC/SSR render, into the client router.

• Framework (runtime)
  Two renderers, one request

  An App Router page is rendered twice, into two wire formats, over one streamed response.

• Framework (runtime)
  App Router vs Pages Router

  Two complete routing systems in one framework, compared layer by layer.

  Also in Comparisons & decisions

• Framework (runtime)
  Next.js 16 vs TanStack Start

  Two answers to the same question about where rendering and data loading should live.

  Also in Comparisons & decisions

RSC & Flight

• Framework (runtime)
  RSC: the data flow

  The ordered pipeline from request to interactive, crossing the network once.

  Map
• Framework (runtime)
  RSC: the full data flow, explorable

  Every step from browser request to interactive app: payload, hydration and boundaries.

  Walkthrough
• Framework (runtime)
  RSC: between request and interactive

  What the server renders, what it serializes and what the browser does with the stream.

• Framework (runtime)
  Crossing the network boundary

  One program across two computers: bundling decides where code runs and what crosses the wire.

• Framework (runtime)
  The Flight payload from first principles

  self.__next_f.push, tagged tuples and the bootstrap line: one source, two outputs.

• Framework (runtime)
  RootLayout to HTML and Flight

  How your layout.js becomes two coordinated outputs in the initial page response.

• Framework (runtime)
  The exact order: RSC, Flight, HTML, paint, hydrate

  One render, two outputs, braided into one response: what happens first and why.

• Framework (runtime)
  The renderer parks it: async Server Components

  How an async component suspends on await, becomes a Flight task and resumes.

• Framework (runtime)
  The client-reference bridge

  From <Counter/> to proxy, manifest, Flight metadata, __webpack_require__ and hydration.

• Framework (build)
  The 'use client' doorway

  Past the metaphor: the wire format, manifest entries and encrypted closures in Next.js 16.

Data plumbing

• Framework (runtime)
  Three doorways into one server

  Route handlers, Server Actions and Server Components: contract, policy and what crosses the wire.

• Framework (runtime)
  Next.js server primitives and the DAL

  One mutation's round trip through Server Actions, a data access layer and revalidation.

Build

• Framework (build)
  The anatomy of a Next.js 16 build

  Thirteen phases between your app/ directory and the .next folder you deploy.

• Framework (build)
  What happens when you run next build

  Config, route discovery, Rust-based compilation, module tracing and pruning, in order.

• Framework (build)
  The Next.js 16 compiler pipeline

  What the build reads, what it transforms and the runtime maps it leaves behind.

• Runtime
  The runtime royal rumble

  Ten languages, thirty runtimes: a language is a spec, a runtime is what actually runs.

• Framework (runtime)
  Two bloodlines of req and res

  Node, Express and Next compared: who mutates the request, who returns a response, and why.

  Also in Node.js › HTTP · HTTP frameworks › Across frameworks · Next.js & RSC › Request

• Framework (runtime)
  Express decorates Node, Next extends the Web

  Two ways to give a request object more power, and the lifecycle each one produces.

  Also in HTTP frameworks › Across frameworks · Next.js & RSC › Request

• Framework (runtime)
  App Router vs Pages Router

  Two complete routing systems in one framework, compared layer by layer.

  Also in Next.js & RSC › Request

• Framework (runtime)
  Next.js 16 vs TanStack Start

  Two answers to the same question about where rendering and data loading should live.

  Also in Next.js & RSC › Request

• Framework (build)
  ESM vs CommonJS

  Why a bundler can prove an ESM graph before running it, but has to execute CommonJS to find out.

  Also in JavaScript & the Web platform › Modules · Node.js › Modules