js-engine

JavaScript Engine internals

How V8 runs your code — parsing, bytecode, hidden classes, the JIT, garbage collection, and how to stay fast.

10 units·41 lessons·~10 h

Start track →

00

Start from zero

What a JS engine is, and why internals decide your app's speed.

01 What a JavaScript engine is 10 min 02 The engine landscape: V8, JSC, SpiderMonkey 11 min

01

How JS runs

Source becomes AST, then bytecode the interpreter runs — before any JIT.

01 From source text to AST 12 min 02 Lazy parsing and the pre-parser 13 min 03 Ignition and the bytecode 14 min 04 Inside the interpreter loop 14 min

02

Values & memory

How the engine packs numbers, pointers and objects into machine words.

01 How V8 represents a value 12 min 02 Smis, doubles, and HeapNumbers 13 min 03 Pointer tagging and pointer compression 13 min 04 The V8 heap and object layout 14 min 05 How V8 stores strings 14 min

03

Hidden classes & ICs

Objects with the same shape share a hidden class — that's what makes property access fast.

01 What a Map really is: opening the hidden class 14 min 02 Transition trees, deprecation, and migration 15 min 03 Fast properties, slow properties, and slack tracking 14 min 04 Inline caches, deeply: feedback slots and handlers 15 min 05 Monomorphic, polymorphic, megamorphic — and the stub cache 15 min

04

The JIT

The engine speculates on types, compiles hot code, and deopts when wrong.

01 Four tiers and how warm-up works 13 min 02 Type feedback: the fuel for the optimiser 14 min 03 TurboFan: the sea-of-nodes optimiser 15 min 04 Speculation and guards 15 min 05 Deoptimization: falling off the cliff 16 min 06 On-Stack Replacement: swapping the frame mid-loop 14 min

05

Closures & scope

Closures capture scope into heap-allocated contexts — with a real cost.

01 Scopes, contexts, and the scope chain 13 min 02 What a closure actually retains 14 min 03 When V8 allocates a Context (and what it costs) 14 min 04 Closures, feedback vectors, and call-site polymorphism 15 min

06

Garbage collection

Generational GC bets most objects die young — invisible until it isn't.

01 Why a GC, and reachability 12 min 02 Generational GC and the Scavenger 14 min 03 Major GC: mark, sweep, compact 15 min 04 Write barriers: the price of incremental and generational GC 15 min 05 Leaks in a garbage-collected language 15 min 06 Measuring the heap 15 min

07

Async, deeply

The event loop, microtasks and promise internals that decide execution order.

01 The engine vs the loop 12 min 02 Microtasks vs macrotasks: ordering 13 min 03 Inside a Promise 14 min 04 async/await, desugared 14 min

08

Measuring & optimizing

Use engine traces to keep code monomorphic and JIT-friendly.

01 Tracing optimization and deopt 14 min 02 Monomorphism discipline 14 min 03 Why your microbenchmark lies 15 min 04 Real-world wins 16 min

09

Putting it together

Profile and optimize a real hot path with engine knowledge.

01 Capstone: optimize a hot path 16 min

Build with this track

Guided projects that exercise what you learn here.

Hot-Path Profiler Lab

Take a deliberately slow piece of JavaScript and turn it into a controlled experiment. You'll build a micro-benchmark harness you actually trust, profile the hot path until you can name what the engine is doing, and apply engine-aware fixes — monomorphism, killing megamorphic call sites, cutting allocations — proving each win with numbers instead of vibes. This is the whole discipline of performance work in miniature: measure, form a hypothesis about the engine, change one thing, measure again.

Regex engine

Build a regular expression engine from scratch using Thompson NFA construction and subset simulation — the same technique that makes grep and re2 immune to catastrophic backtracking.

TypeScript type system, deep

From structural typing to type-level programming — generics, conditional and mapped types, and typing real systems.