cloudparts

Node.js

The JavaScript runtime for servers and command-line tools: Google’s V8 engine plus libuv’s event loop, so one thread serves many connections while I/O happens in the background.

OpenJS · Impact
What it is
Runtime virtual machines,Event loop
Type
Open source
Made by
OpenJS Foundation
Foundation
OpenJS Foundation, impact, joined March 2019. A founding project, from the Node.js Foundation formed in 2015. Part of the Linux Foundation
License
MIT
Facts checked
28 October 2026
Website Source code

What it is

Node.js runs JavaScript outside the browser. It takes V8, the engine in Chrome, which compiles JavaScript to machine code as it runs and collects its garbage, and adds what a browser doesn’t have: files, sockets, processes, HTTP and a module system. Almost no function in its standard library blocks. A call such as fs.readFile or http.get starts the work and returns at once, and its callback or promise runs later. After running the main script, Node enters the event loop, implemented by the C library libuv, and exits when there are no callbacks left. Network I/O goes to the operating system’s own readiness APIs; work that has no asynchronous system call, such as file system operations, dns.lookup(), zlib and some crypto, runs in libuv’s thread pool, four threads by default (UV_THREADPOOL_SIZE).

Your JavaScript itself runs on one thread, so there are no locks to deadlock on, but a slow synchronous callback stalls every connection. CPU-heavy work goes to worker_threads, and child_process and cluster spread a server over several cores. Over the years the runtime has absorbed what used to need packages, such as a stable test runner (node:test) and, in 2026, a release-candidate node:sqlite module. It runs TypeScript files directly, stable since v24.12 and v25.2, by replacing type annotations with whitespace and refusing syntax that needs code generation, such as enum. require() can load ES modules without top-level await, and the --permission flag, stable since v22.13, restricts file, network, child-process and worker access as a seat belt for trusted code, not a sandbox for hostile code.

Releases are planned by the Release Working Group. Until now a major version came out every April and October, and only even-numbered ones got long-term support. On October 28, 2026, Node.js 26 entered Active LTS, supported until April 2029, with 24 (“Krypton”) in maintenance until April 2028 and 22 until April 2027; 20 reached end of life in April 2026. From Node.js 27 there is one major a year: an alpha from October, a Current release in April, then 30 months of LTS, so every version gets LTS.

Why teams pick it

  • Many concurrent connections on little memory: an idle socket costs a callback and some state, not a thread
  • One language across browser, server and build tooling, with npm’s registry of packages behind it
  • A broad standard library that now covers testing, TypeScript type stripping and a permission model without extra packages
  • Predictable support: 30 months of LTS per even-numbered line today, and for every line from Node.js 27

Watch out for

  • One JavaScript thread per process: a heavy JSON.parse, regex or synchronous call blocks every request until it returns, so CPU work must move to worker threads or other processes
  • libuv’s thread pool has four threads by default, so many concurrent file, DNS lookup or zlib calls queue behind each other unless UV_THREADPOOL_SIZE is raised at start-up
  • Built-in TypeScript only strips types: no type checking, no tsconfig paths, no enum or decorators, and .tsx isn’t supported
  • The permission model doesn’t protect against malicious code; the docs say Node trusts any code it is asked to run, including every dependency

Alternatives

What all runtime virtual machines have in common →Compare side by side →
.NET runtime (CLR)Open sourceMicrosoft’s open-source runtime for C#, F# and Visual Basic: the Common Language Runtime loads intermediate language, compiles it with a tiered JIT or ahead of time, and manages memory with a generational garbage collector.BEAM (Erlang virtual machine)Open sourceThe virtual machine in Erlang/OTP that runs Erlang and Elixir: millions of lightweight processes, each with its own heap and garbage collection, preemptively scheduled across all cores, with code that can be replaced while the system runs.eBPFOpen sourceA small virtual machine inside the Linux kernel: programs are checked by a verifier, compiled to machine code and attached to kernel or app events, so tracing, networking and security tools run in the kernel without kernel modules.Java Virtual Machine (HotSpot)Open sourceThe abstract machine that runs Java bytecode, and OpenJDK’s HotSpot, the implementation most people use: an interpreter, two JIT compilers and a choice of garbage collectors behind Java, Scala, Clojure and other languages.

How it fits with other technologies

An HTTP server in TypeScript, run directly by Node.js 26 · ts

// server.ts
import { createServer } from 'node:http';
import { setTimeout as sleep } from 'node:timers/promises';

const server = createServer(async (req, res) => {
  const ms: number = Number(new URL(req.url ?? '/', 'http://x').searchParams.get('ms') ?? 0);
  await sleep(ms);                  // waits without holding the thread
  res.end(`waited ${ms} ms\n`);
});
server.listen(3000);

// $ node server.ts                  # types are stripped, no build step
// $ time (curl -s 'localhost:3000/?ms=500' & curl -s 'localhost:3000/?ms=500' & wait)
// waited 500 ms
// waited 500 ms
// both answer after about half a second, not one: one thread, two waits in flight

See it in a real stack

No architecture uses Node.js yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2009–2026

Ryan Dahl presented Node.js at JSConf EU in Berlin in November 2009, in a 45-minute talk that ended in a standing ovation. Servers of the time mostly handled concurrency with threads; he argued that network programs, which spend their time waiting on I/O, were better served by events and callbacks on one thread. He had tried Ruby, C and Lua first, but their libraries were built around blocking calls; server-side JavaScript had no such habits to unlearn, and its closures suited callbacks. A month after the talk Joyent hired Dahl, and the company became the project’s sponsor.

By 2014 many core contributors were unhappy with how Joyent ran the project and how slowly it shipped, and in late 2014 they forked it as io.js, which released faster and tracked newer V8 versions. The Linux Foundation brokered a settlement: the Node.js Foundation, launched on June 16, 2015, with IBM, Intel, Joyent, Microsoft and PayPal among its platinum members, gave the project neutral governance under a Technical Steering Committee. Node.js 4.0, in September 2015, merged the two codebases, adopted semantic versioning and introduced the LTS schedule that lasted a decade. In March 2019 the Node.js Foundation merged with the JS Foundation to form the OpenJS Foundation.

In 2026 the Release Working Group said that schedule had outlived its purpose: odd-numbered releases saw little use, the odd/even split confused newcomers, and security releases across four or five active lines had become hard for volunteers to sustain. Node.js 26 is the last line under the old model, and from Node.js 27 there is one release a year, with an alpha channel for breaking changes.

Why it’s built this way

Non-blocking I/O everywhere, with one JavaScript thread
Dahl meant Node for I/O-heavy network programs, where thread-based servers are inefficient and hard to use. If no library call blocks, one thread can wait on many sockets, and code never needs locks.
JavaScript on V8
Server-side JavaScript had no blocking I/O libraries to unlearn, its closures suited callbacks, and browser developers already knew the language.
Neutral foundation governance after io.js
The fork showed that one company’s control could split the community. Moving the project into a Linux Foundation project with an open steering committee let the two sides merge their code.
One major release a year from Node.js 27
Few people used the odd-numbered releases, and patching four or five lines at once overloaded volunteer releasers. One release a year, each with LTS, means fewer lines to patch and a simpler rule for users.

Timeline

  1. 2009

    Ryan Dahl presents Node.js at JSConf EU in Berlin in November

  2. 2014

    Core contributors fork it as io.js late in the year

  3. 2015

    Node.js Foundation forms on June 16; Node.js 4.0 merges io.js in September

  4. 2019

    Becomes a founding project of the OpenJS Foundation on March 12

  5. 2025

    Running TypeScript by stripping types becomes stable (v24.12, v25.2)

  6. 2026

    Node.js 26 ships in May and enters LTS on October 28; Node.js 27 alpha begins under one-release-a-year

Sources11 · facts checked 28 October 2026

Improve this page on GitHub