Introduction & Architecture

// versions.mjs
const { node, v8, uv, llhttp, undici, modules, napi, openssl, icu } = process.versions;
console.log({ node, v8, uv, llhttp, undici, modules, napi, openssl, icu });
console.log(process.release.name, process.release.lts ?? 'not LTS');

{ node: '26.10.0', v8: '14.6.202.34-node.34', uv: '1.52.1', llhttp: '9.4.3', undici: '8.10.2', modules: '147', napi: '10', openssl: '3.5.8', icu: '78.3' }
node not LTS

{ node: '24.21.0', v8: '13.6.233.17-node.53', uv: '1.52.1', llhttp: '9.4.3', undici: '7.29.1', modules: '137', napi: '10', openssl: '3.5.8', icu: '78.3' }
node Krypton

{ node: '22.23.3', v8: '12.4.254.21-node.57', uv: '1.51.0', llhttp: '9.4.3', undici: '6.28.1', modules: '127', napi: '10', openssl: '3.5.8', icu: '78.3' }
node Jod

// hello.mjs
import { createServer } from 'node:http';

const server = createServer((req, res) => {
  res.writeHead(200, { 'content-type': 'text/plain; charset=utf-8' });
  res.end('Hello from the Bookshelf\n');
});

server.listen(0, '127.0.0.1', async () => {
  const { port } = server.address();
  const response = await fetch(`http://127.0.0.1:${port}/`);
  console.log(response.status, await response.text());
  server.close();
});

200 Hello from the Bookshelf

// pool.mjs
import { pbkdf2 } from 'node:crypto';

const started = performance.now();
let done = 0;
for (let i = 0; i < 8; i++) {
  pbkdf2('password', 'salt', 400_000, 64, 'sha512', () => {
    console.log(`hash ${i} finished after ${Math.round(performance.now() - started)} ms`);
    if (++done === 8) console.log('threadpool size:', process.env.UV_THREADPOOL_SIZE ?? '4 (default)');
  });
}

hash 3 finished after 68 ms
hash 2 finished after 69 ms
hash 0 finished after 69 ms
hash 1 finished after 70 ms
hash 4 finished after 135 ms
hash 5 finished after 137 ms
hash 6 finished after 137 ms
hash 7 finished after 137 ms
threadpool size: 4 (default)

// order.mjs
import { readFile } from 'node:fs';

console.log('1 main script starts');
readFile(import.meta.filename, () => {
  console.log('5 file read finished (callback runs on the main thread)');
  setTimeout(() => console.log('7 timer (0 ms)'), 0);
  setImmediate(() => console.log('6 setImmediate'));
});
Promise.resolve().then(() => console.log('4 promise microtask'));
process.nextTick(() => console.log('3 process.nextTick'));
console.log('2 main script ends');

1 main script starts
2 main script ends
4 promise microtask
3 process.nextTick
5 file read finished (callback runs on the main thread)
6 setImmediate
7 timer (0 ms)

// blocking.mjs
const tick = setInterval(() => console.log('tick'), 100);
setTimeout(() => {
  const end = Date.now() + 350;
  while (Date.now() < end) { /* busy loop blocks the only main thread */ }
  console.log('blocked ~350 ms, no tick could run meanwhile');
}, 150);
setTimeout(() => clearInterval(tick), 600);

tick
blocked ~350 ms, no tick could run meanwhile
tick

// worker.mjs
import { Worker, isMainThread, threadId, parentPort, workerData } from 'node:worker_threads';

if (isMainThread) {
  const worker = new Worker(import.meta.filename, { workerData: { n: 40 } });
  worker.on('message', (value) => console.log(`main thread ${threadId} received`, value));
  worker.on('exit', (code) => console.log('worker exited with code', code));
} else {
  const fib = (n) => (n < 2 ? n : fib(n - 1) + fib(n - 2));
  parentPort.postMessage({ threadId, fib: fib(workerData.n) });
}

main thread 0 received { threadId: 1, fib: 102334155 }
worker exited with code 0

// stack.mjs
import { readFile } from 'node:fs/promises';
import { lookup } from 'node:dns/promises';

const started = performance.now();
const text = await readFile(import.meta.filename, 'utf8'); // fs binding, read(2) on the pool
const address = await lookup('localhost');                   // getaddrinfo on the pool
console.log({ characters: text.length, address: address.address, ms: Math.round(performance.now() - started) });

{ characters: 494, address: '::1', ms: 4 }

// trace.mjs
import { createHook } from 'node:async_hooks';
import { readFile } from 'node:fs';
import { createServer, connect } from 'node:net';

// Record the native request and handle objects (the C++ binding layer) that each step creates.
// TickObject (process.nextTick) and PROMISE entries are JavaScript-level and are left out.
let created = [];
const hook = createHook({
  init(asyncId, type) { if (type !== 'TickObject' && type !== 'PROMISE') created.push(type); },
});
hook.enable();
const report = (step) => { console.log(step.padEnd(28), created.join(' → ')); created = []; };

readFile(import.meta.filename, () => {
  report('fs.readFile:');
  const server = createServer((socket) => socket.end('hi\n'));
  server.listen(0, '127.0.0.1', () => {
    report('net server.listen:');
    const client = connect(server.address().port, '127.0.0.1');
    client.on('data', () => report('net connect + accept + data:'));
    client.on('close', () => { report('net close:'); hook.disable(); server.close(); });
  });
});

fs.readFile:                 FSREQCALLBACK
net server.listen:           DNSCHANNEL → TCPSERVERWRAP
net connect + accept + data: TCPWRAP → TCPCONNECTWRAP → TCPWRAP → SHUTDOWNWRAP
net close:                   SHUTDOWNWRAP

fs.readFile:                 FSREQCALLBACK → FSREQCALLBACK → FSREQCALLBACK → FSREQCALLBACK
net server.listen:           DNSCHANNEL → TCPSERVERWRAP
net connect + accept + data: TCPWRAP → TCPCONNECTWRAP → TCPWRAP → SHUTDOWNWRAP
net close:                   SHUTDOWNWRAP

// env-diff.mjs: the same lines behave differently in Node.js and in a browser
import { createServer } from 'node:http';

// 1. Timers: a browser returns a number, Node.js returns a Timeout object with extra methods.
const t = setTimeout(() => {}, 1000);
console.log('setTimeout returns:', t.constructor.name, '| hasRef():', t.hasRef(), '| as a number:', typeof +t);
t.unref(); // Node.js only: this timer no longer keeps the process alive
clearTimeout(t);

// 2. Module scope: import.meta.url is a file: URL, not an https: URL of a page.
console.log('import.meta.url scheme:', new URL(import.meta.url).protocol);

// 3. Binary data: Buffer is a Node.js subclass of the standard Uint8Array.
const buf = Buffer.from('Bookshelf');
console.log('Buffer extends Uint8Array:', buf instanceof Uint8Array, '| base64:', buf.toString('base64'));

// 4. No same-origin policy: a cross-origin response without CORS headers is fully readable.
const server = createServer((req, res) => res.end(JSON.stringify({ origin: req.headers.origin ?? null })));
server.listen(0, '127.0.0.1', async () => {
  const res = await fetch(`http://127.0.0.1:${server.address().port}/`);
  console.log('cross-origin read without CORS:', res.status, await res.text(),
    '| access-control-allow-origin:', res.headers.get('access-control-allow-origin'));
  server.close();
});

setTimeout returns: Timeout | hasRef(): true | as a number: number
import.meta.url scheme: file:
Buffer extends Uint8Array: true | base64: Qm9va3NoZWxm
cross-origin read without CORS: 200 {"origin":null} | access-control-allow-origin: null

// features.mjs: probe a few recent ECMAScript additions instead of trusting a version number
const probes = {
  'Array.prototype.findLast (ES2023)': () => typeof [].findLast === 'function',
  'Object.groupBy (ES2024)': () => typeof Object.groupBy === 'function',
  'Promise.withResolvers (ES2024)': () => typeof Promise.withResolvers === 'function',
  'Set.prototype.union (ES2025)': () => typeof new Set().union === 'function',
  'Iterator helpers (ES2025)': () => typeof Iterator?.prototype?.map === 'function',
  'Promise.try (ES2025)': () => typeof Promise.try === 'function',
  'RegExp.escape (ES2025)': () => typeof RegExp.escape === 'function',
  'Float16Array (ES2025)': () => typeof Float16Array === 'function',
  'Error.isError (ES2026)': () => typeof Error.isError === 'function',
  'Math.sumPrecise (ES2026)': () => typeof Math.sumPrecise === 'function',
  'Uint8Array.fromBase64 (ES2026)': () => typeof Uint8Array.fromBase64 === 'function',
  'Temporal (ES2027)': () => typeof Temporal === 'object',
};
console.log(`Node.js ${process.versions.node}, V8 ${process.versions.v8}`);
for (const [name, probe] of Object.entries(probes)) console.log(probe() ? '  yes' : '  no ', name);

Node.js 26.10.0, V8 14.6.202.34-node.34
  yes Array.prototype.findLast (ES2023)
  yes Object.groupBy (ES2024)
  yes Promise.withResolvers (ES2024)
  yes Set.prototype.union (ES2025)
  yes Iterator helpers (ES2025)
  yes Promise.try (ES2025)
  yes RegExp.escape (ES2025)
  yes Float16Array (ES2025)
  yes Error.isError (ES2026)
  no  Math.sumPrecise (ES2026)
  yes Uint8Array.fromBase64 (ES2026)
  yes Temporal (ES2027)
Node.js 24.21.0, V8 13.6.233.17-node.53
  yes Array.prototype.findLast (ES2023)
  yes Object.groupBy (ES2024)
  yes Promise.withResolvers (ES2024)
  yes Set.prototype.union (ES2025)
  yes Iterator helpers (ES2025)
  yes Promise.try (ES2025)
  yes RegExp.escape (ES2025)
  yes Float16Array (ES2025)
  yes Error.isError (ES2026)
  no  Math.sumPrecise (ES2026)
  no  Uint8Array.fromBase64 (ES2026)
  no  Temporal (ES2027)
Node.js 22.23.3, V8 12.4.254.21-node.57
  yes Array.prototype.findLast (ES2023)
  yes Object.groupBy (ES2024)
  yes Promise.withResolvers (ES2024)
  yes Set.prototype.union (ES2025)
  yes Iterator helpers (ES2025)
  no  Promise.try (ES2025)
  no  RegExp.escape (ES2025)
  no  Float16Array (ES2025)
  no  Error.isError (ES2026)
  no  Math.sumPrecise (ES2026)
  no  Uint8Array.fromBase64 (ES2026)
  no  Temporal (ES2027)

node -p process.versions.v8
node --v8-options | grep "in progress"

14.6.202.34-node.34
  --harmony-shadow-realm (enable "harmony ShadowRealm" (in progress / experimental))
  --harmony-struct (enable "harmony structs, shared structs, and shared arrays" (in progress / experimental))
  --harmony-intl-best-fit-matcher (enable "Intl BestFitMatcher" (in progress / experimental))
  --js-decorators (enable "decorators" (in progress / experimental))
  --js-source-phase-imports (enable "source phase imports" (in progress / experimental))
  --js-defer-import-eval (enable "defer import eval" (in progress / experimental))

node -p "typeof Temporal"
node --harmony-temporal -p "typeof Temporal + ' ' + Temporal.Now.plainDateISO().constructor.name"

undefined
object PlainDate

// runtime.mjs: portable code that uses only web-standard APIs and node: built-ins
import { createHash } from 'node:crypto';   // Deno and Bun both implement node: specifiers

function detectRuntime() {
  if (typeof globalThis.Deno !== 'undefined') return `Deno ${globalThis.Deno.version.deno}`;
  if (typeof globalThis.Bun !== 'undefined') return `Bun ${globalThis.Bun.version}`;
  if (typeof process !== 'undefined' && process.release?.name === 'node') return `Node.js ${process.versions.node}`;
  return 'unknown';
}

const body = JSON.stringify({ title: 'Dune', rating: 5 });
const digest = createHash('sha256').update(body).digest('hex').slice(0, 16);
const url = new URL('/books?sort=title', 'https://bookshelf.example');
console.log(detectRuntime(), '| navigator.userAgent:', navigator.userAgent);
console.log('sha256:', digest, '| URL:', url.searchParams.get('sort'), '| structuredClone:', structuredClone({ a: [1] }).a[0]);

Node.js 26.10.0 | navigator.userAgent: Node.js/26
sha256: 5e6bd6bf64ecbf22 | URL: title | structuredClone: 1
Node.js 24.21.0 | navigator.userAgent: Node.js/24
sha256: 5e6bd6bf64ecbf22 | URL: title | structuredClone: 1
Node.js 22.23.3 | navigator.userAgent: Node.js/22
sha256: 5e6bd6bf64ecbf22 | URL: title | structuredClone: 1