Understanding Node.js Architecture: Core Modules, libuv, V8, and Event Loop

Node.js Overview

Node.js consists of four main parts: the Node Standard Library, Node Bindings, the V8 JavaScript engine, and libuv. The Standard Library provides everyday modules such as http and buffer; Bindings bridge JavaScript and C++ and expose low‑level APIs; V8 executes JavaScript code; libuv supplies cross‑platform asynchronous I/O.

Node Standard Library : core modules like http, buffer, etc.

Node Bindings : C/C++ bridge that wraps V8 and libuv.

V8 : Google’s JavaScript engine, the execution engine of Node.

libuv : Provides asynchronous I/O, DNS, file system, and other facilities across platforms.

Code Structure

The repository layout can be inspected with the tree command:

➜  nodejs git:(master) tree -L 1
├── AUTHORS
├── BSDmakefile
├── BUILDING.md
├── CHANGELOG.md
├── CODE_OF_CONDUCT.md
├── COLLABORATOR_GUIDE.md
├── CONTRIBUTING.md
├── GOVERNANCE.md
├── LICENSE
├── Makefile
├── README.md
├── ROADMAP.md
├── WORKING_GROUPS.md
├── android-configure
├── benchmark
├── common.gypi
├── config.gypi
├── config.mk
├── configure
├── deps
├── doc
├── icu_config.gypi
├── lib
├── node.gyp
├── out
├── src
├── test
├── tools
└── vcbuild.bat

Key third‑party dependencies are located in the deps directory:

➜  nodejs git:(master) tree deps -L 1
├── cares
├── gtest
├── http_parser
├── npm
├── openssl
├── uv
├── v8
└── zlib

libuv

Node.js started in 2009 as a JavaScript runtime outside the browser. It originally used Google’s V8 engine and libev for event handling. Because libev only runs on Unix, libuv was introduced to provide a cross‑platform abstraction, using IOCP on Windows.

libuv is a high‑performance, event‑driven I/O library used not only by Node.js but also by languages such as Rust.

V8 Engine

Typical JavaScript execution flow: source code → abstract syntax tree → bytecode → JIT → native code. V8 skips the bytecode stage, directly JIT‑compiling the AST to native machine code, then uses a profiler to collect runtime information for further optimization.

JIT (Just‑In‑Time compiler) generates native instructions from frequently executed bytecode at runtime.

Why Use Node.js?

Node targets high‑concurrency, I/O‑intensive scenarios, offering a non‑blocking, event‑driven model that outperforms traditional Java or PHP servers for such workloads.

I/O‑intensive tasks: file, network, database operations.

High concurrency: many simultaneous connections.

Node.js Runtime Features

Based on Chrome V8 engine.

Event‑driven, non‑blocking I/O model.

Package manager npm with the largest open‑source ecosystem.

Process and Thread Model

Node’s main thread runs JavaScript; libuv creates a thread pool for I/O operations. The event loop repeatedly pulls tasks from the queue, executes JavaScript, delegates I/O to libuv, and returns results to V8.

V8 parses JavaScript.

Parsed code calls Node APIs.

libuv executes the APIs on worker threads.

Results are passed back to V8 and then to the user.

Synchronous vs Asynchronous

Synchronous calls block the thread until a result is returned; asynchronous calls return immediately and deliver results later via callbacks, promises, or events.

// macro‑task example
setTimeout(() => {
  console.log(1);
  setTimeout(() => console.log(4), 1000);
}, 1000);
setTimeout(() => console.log(2), 2000);
setTimeout(() => console.log(3), 3000);

// setImmediate example (IE only)
setImmediate(function () {
  console.log('setImmediate');
});
setTimeout(function () {
  console.log('timeout');
}, 4);
console.log(1);

// MessageChannel example
let messageChannel = new MessageChannel();
let port2 = messageChannel.port2;
messageChannel.port1.postMessage('111');
console.log(1);
port2.onmessage = function (e) {
  console.log(e.data);
};
console.log(2);

Blocking vs Non‑Blocking I/O

Blocking I/O suspends the thread until the operation completes; non‑blocking I/O returns immediately and notifies the caller later.

Combining Sync/Async and Blocking/Non‑Blocking

Synchronous + Blocking

Asynchronous + Blocking

Synchronous + Non‑Blocking

Asynchronous + Non‑Blocking

When to Choose Node.js?

Use Node.js when an application must handle a large number of concurrent I/O operations without heavy computational processing before responding to the client.

Chat servers

E‑commerce websites