When we use Node.js we can do many powerful things like making network requests, reading files, working with the operating system or running servers.

But if you think about it for a second, JavaScript originally runs inside the browser. Browsers provide many APIs that JavaScript can use.

So you might wonder:

Does JavaScript itself have all these powers?

Not really.

Inside Node.js there are multiple libraries and components working together that provide these capabilities.

Node.js mainly relies on three important parts:

V8
JS Bindings (C++ layer)
libuv

These pieces work together to allow JavaScript to interact with the system.

V8 (JavaScript Engine)

Node.js runs on V8, which is a JavaScript engine developed by Google.

V8 is responsible for executing JavaScript code.

It does several important things:

Parses JavaScript
Compiles JavaScript to machine code (JIT compilation)
Manages memory (heap and garbage collection)
Maintains the call stack

So when you run a Node.js program like this:

console.log("Hello Node")

V8 is the component that reads and executes this JavaScript code.

The Limitation of V8

Even though V8 is very powerful, it cannot perform system operations by itself.

For example V8 cannot directly:

read files
open network sockets
perform DNS lookups
interact with the operating system

So something else is needed to handle these tasks.

This is where Node.js bindings and libuv come in.

JS Bindings (C++ Layer)

Node.js is written mainly in C++ and it exposes many system capabilities to JavaScript through a layer called JS bindings.

This layer works like a bridge between JavaScript and native system code.

When you write JavaScript like this:

const fs = require("fs")

fs.readFile("data.txt", () => {
  console.log("file read")
})

The fs module is not pure JavaScript.

Behind the scenes it connects to C++ code inside Node.js.

So JS bindings do two main things:

expose system functionality as JavaScript APIs
convert JavaScript calls into C/C++ calls

You can think of it like a translator between JavaScript and the lower level system code.

libuv (Async I/O Engine)

Now we reach one of the most important parts of Node.js: libuv.

libuv is a large C++ library that handles many of Node.js asynchronous operations.

JavaScript itself is single threaded, meaning it executes one thing at a time.

But Node.js still manages to handle thousands of operations concurrently. This is possible because of libuv.

libuv provides:

Event loop
Non-blocking I/O
Thread pool
File system operations
Networking
DNS operations
Child processes

For example when you run something like:

const fs = require("fs")

fs.readFile("file.txt", () => {
  console.log("done")
})

The file reading work is handled by libuv, not V8.

libuv processes the operation asynchronously and notifies Node.js when the task is completed.

This is why Node.js can remain fast and handle many requests at the same time.

Full Node.js Architecture

So when you run a Node.js application, these components work together like this:

V8 executes JavaScript
JS bindings connect JavaScript to native APIs
libuv performs asynchronous I/O operations

In simple terms:

JavaScript code runs in V8, Node’s C++ bindings translate JavaScript calls into native operations and libuv interacts with the operating system to perform tasks like networking and file handling.

Diagram idea:

JavaScript Application
        ↓
       V8
(JavaScript Engine)
        ↓
   Node C++ Bindings
        ↓
      libuv
(Event Loop, Thread Pool)
        ↓
   Operating System

Node.js looks simple from the outside because we write JavaScript.

But internally there are multiple layers working together to make everything possible.