Node.js — The JavaScript Runtime Built on V8

Introduction

Node.js revolutionized web development by bringing JavaScript to the server. Created by Ryan Dahl in 2009, it enabled full-stack JavaScript development — one language for both frontend and backend. Its non-blocking, event-driven architecture makes it exceptionally efficient for I/O-heavy workloads like web servers, APIs, and real-time applications.

With over 117,000 GitHub stars, Node.js is one of the most popular runtime environments in the world. It powers the backends of Netflix, PayPal, LinkedIn, Uber, NASA, and millions of applications. The npm registry hosts over 2 million packages, making it the largest software registry in existence.

What Node.js Does

Node.js executes JavaScript outside the browser using the V8 engine. Its event loop handles thousands of concurrent connections on a single thread without the overhead of thread-per-connection models. It provides built-in modules for file system access, networking, HTTP, streams, cryptography, and child processes.

Architecture Overview

[JavaScript Application Code]
        |
   [Node.js Runtime]
        |
+-------+-------+-------+
|       |       |       |
[V8     [libuv]  [Built-in
Engine]  Event    Modules]
JS      loop,    http, fs,
execution async I/O path, crypto
        thread   stream, net
        pool
        |
   [Event Loop]
   Single-threaded
   Non-blocking I/O
   Callbacks, Promises, async/await
        |
   [npm / node_modules]
   2M+ packages
   Largest software registry

Self-Hosting & Configuration

// Modern Node.js HTTP server with ES modules
import { createServer } from "node:http";
import { readFile } from "node:fs/promises";

const server = createServer(async (req, res) => {
  if (req.url === "/api/data") {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ message: "Hello", timestamp: Date.now() }));
  } else if (req.url === "/") {
    const html = await readFile("./index.html", "utf-8");
    res.writeHead(200, { "Content-Type": "text/html" });
    res.end(html);
  } else {
    res.writeHead(404);
    res.end("Not Found");
  }
});

server.listen(3000, () => {
  console.log("Server running at http://localhost:3000");
});

// package.json
{
  "name": "my-app",
  "type": "module",
  "engines": { "node": ">=20" },
  "scripts": {
    "start": "node server.js",
    "dev": "node --watch server.js"
  }
}

Key Features

• V8 Engine — fast JavaScript execution with JIT compilation
• Event Loop — non-blocking I/O for high concurrency on a single thread
• npm Ecosystem — 2M+ packages in the largest software registry
• ES Modules — native import/export support alongside CommonJS
• Built-in Watch Mode — --watch flag for auto-restart during development
• Test Runner — built-in node:test module (Node 20+)
• Worker Threads — multi-threading for CPU-intensive tasks
• WebStreams — standard web-compatible stream APIs

Comparison with Similar Tools

FAQ

Q: Node.js vs Deno vs Bun — which should I use? A: Node.js for the largest ecosystem and maximum compatibility. Deno for security-first with TypeScript. Bun for speed. Most production systems use Node.js due to its maturity and ecosystem.

Q: Is Node.js good for CPU-intensive tasks? A: Node.js excels at I/O-bound work (APIs, web servers, streaming). For CPU-intensive tasks, use Worker Threads, child processes, or consider Go/Rust. Node.js is not ideal for heavy computation on the main thread.

Q: How do I manage Node.js versions? A: Use fnm (Fast Node Manager), nvm, or Volta. These tools let you install multiple Node.js versions and switch between them per-project.

Q: Is Node.js single-threaded? A: The event loop is single-threaded, but I/O operations run on a thread pool (libuv). Worker Threads provide true multi-threading for CPU work. In practice, Node.js handles massive concurrency efficiently.

Sources

• GitHub: https://github.com/nodejs/node
• Documentation: https://nodejs.org/docs
• Created by Ryan Dahl (2009)
• License: MIT