How do closures work at the engine level?

A closure is a function bundled together with references to its surrounding lexical environment. When a function is defined, the engine stores the current environment chain in the function's internal [[Environment]] slot. Later, when the function is invoked, the engine creates a new execution context whose outer environment reference points to that captured [[Environment]], not to the caller's environment. This mechanism allows the function to access variables from the scope where it was defined, even if that scope has technically finished executing and been popped off the call stack.

When the JavaScript engine parses a function declaration, it doesn't just create machine code—it creates a function object that encapsulates both the code and the current lexical environment. This happens at function definition time, not at call time. The [[Environment]] slot is set once and never changes, which is why closures are said to capture variables by reference and why they maintain access to the variables as they change over time.

The environment record that becomes the closure is not simply a copy of the variables at the time of function creation—it's a live reference to the actual environment. This is why closures can see updates to variables made after the function was created, and why multiple closures sharing the same outer scope see the same variables. The environment record is allocated on the heap (not the stack) specifically to support this longevity.

The implementation varies across engines. V8 uses a technique called "context allocation" where variables that are captured by closures are allocated in a separate heap-allocated context object rather than on the stack. The optimizing compiler (TurboFan) can sometimes eliminate closures entirely through inlining when it can prove they aren't needed. SpiderMonkey (Firefox) uses similar techniques with its "analysis of captures" during bytecode generation to determine which variables need closure allocation.

Understanding closures at the engine level explains why they are so powerful and why they must be used carefully. The ability to retain access to lexical environments is what enables functional programming patterns, private variables, and module encapsulation in JavaScript. But this power comes with responsibility—each closure that outlives its creator keeps its environment alive, which can lead to memory leaks if not managed properly. Modern engines are increasingly smart about optimizing closures, but the fundamental mechanism of environment capture remains one of the most elegant and distinctive features of JavaScript's implementation.