# Deep Dive Node JS

> Understanding V8 engine, process.binding(), and how LibUV manages the event loop and thread pool in Node.js.

- Author: [Berkay Bindebir](https://berkaybindebir.dev/about/)
- Published: 2019-10-22
- Topics: NODEJS, V8, LIBUV, JAVASCRIPT
- Canonical URL: https://berkaybindebir.dev/posts/deep-dive-node-js/

---

What really happens under the hood when you run a Node.js application? What makes it an *"asynchronous, event-driven JavaScript runtime"*?

Let's dissect the core internals: Google's V8 engine, internal bindings, and LibUV.

## 1. The V8 Engine

V8 is Google's open-source JavaScript compiler written in C++. It compiles JavaScript directly to native machine code, manages the call stack, allocates heap memory, and handles garbage collection.

V8 executes JavaScript in a single thread, following an event loop sequence. However, V8 alone provides no file system access, network socket primitives, or operating system bindings.

*Image: Crypto library flow through V8 and Node.js C++ bindings*

## 2. process.binding() — The C++ Bridge

Node.js is approximately **30% JavaScript and 70% C++**.

`process.binding()` (and internal C++ bindings in modern Node.js) acts as the bridge connecting high-level JavaScript APIs (like `fs`, `crypto`, `net`) to native C++ implementations.

When you call `fs.readFile()` in JavaScript, execution traverses down into `src/node_file.cc` to communicate directly with OS kernel system calls.

*Image: Node.js runtime architecture*

*Image: C++ implementation behind the Node.js file system module*

## 3. LibUV & The Event Loop

LibUV is the multi-platform C library providing asynchronous I/O, event notification, and thread pooling to Node.js.

*Image: LibUV architecture and operating system integrations*

*Image: Checks performed during the Node.js event loop lifecycle*

### The Thread Pool

While the JavaScript runtime executes in a single thread, blocking operations (such as file I/O, DNS lookups, and intensive cryptographic routines) are delegated to the **LibUV thread pool** (defaulting to 4 threads).

*Image: LibUV thread pool in Node.js*

Once the OS or background worker completes the task, LibUV places the callback onto the event loop poll queue for JavaScript execution.

## Summary

- Node.js is single-threaded in JavaScript execution, but multi-threaded under the hood through LibUV and the OS kernel.
- The event loop only exits when all timers, pending OS tasks, and thread pool workers have completed.
- Understanding the boundary between JS abstractions and C++ threads prevents event loop starvation in production.