Bun: The JavaScript Runtime That Replaced 15 Tools With One Binary

Jarred Sumner, Bun's creator, said it plainly: "We didn't build Bun to replace Node.js. We built it to replace the 15 tools you need alongside Node.js.""

npm. webpack. babel. jest. ts-node. nodemon. tsc. One binary replaces all of them — and runs TypeScript natively, no compilation step required.

In December 2025, Anthropic acquired Bun. Claude Code, the Claude Agent SDK, and future AI coding products now run on it. With 7.2 million monthly downloads before the acquisition and 85% YoY growth, Bun stopped being an experiment and became infrastructure.

Why Bun is faster

Node.js uses V8 (Chrome's engine), optimized for long-running processes. Bun uses JavaScriptCore (Safari's engine), optimized for fast startup. That single architectural decision explains most benchmark results.

On top of that, Bun is written in Zig — a low-level systems language — and uses io_uring on Linux for efficient async I/O. No TypeScript transpilation. No unnecessary compatibility layers. Less work per operation.

Installation

# macOS / Linux
curl -fsSL https://bun.sh/install | bash

# Windows
powershell -c "irm bun.sh/install.ps1 | iex"

# Verify
bun --version

Native TypeScript — zero configuration

This is the first difference developers feel day-to-day. With Node.js, running TypeScript requires ts-node, or compiling with tsc, or using --experimental-strip-types (which only removes types, no type-checking).

Package manager — 25x faster than npm

Bun's package manager is npm-compatible but uses a different strategy: a global binary cache and hard-links directly into node_modules. No re-downloading. No re-validation on every install.

# Install dependencies (replaces npm install)
bun install

# Add package
bun add zod
bun add -d typescript

# Remove
bun remove lodash

# Run package.json scripts
bun run dev
bun run build
bun run test

# Execute without global install
bunx create-hono my-app

Native HTTP server

Bun ships a built-in HTTP server based on Web Standard APIs — the same Request and Response interface you already know from the browser and Cloudflare Workers.

// server.ts
Bun.serve({
  port: 3000,
  fetch(req) {
    const url = new URL(req.url);

    if (url.pathname === '/') {
      return new Response('Hello from Bun!');
    }

    if (url.pathname === '/json') {
      return Response.json({ runtime: 'bun', fast: true });
    }

    return new Response('Not Found', { status: 404 });
  },
});

console.log('Running at http://localhost:3000');

Bun's native server reaches around 68,000 req/s in hello world benchmarks — competing with Rust frameworks. At the application layer, frameworks like Hono extract the most from that throughput with optimized routing, Zod validation and a typed RPC client.

Built-in test runner (Jest-compatible)

No @jest/core, no ts-jest, no environment setup. The API is intentionally compatible with Jest.

// math.test.ts
import { describe, it, expect } from 'bun:test';
import { sum, average } from './math';

describe('math functions', () => {
  it('sums two numbers', () => {
    expect(sum(2, 3)).toBe(5);
  });

  it('calculates average correctly', () => {
    expect(average([1, 2, 3, 4])).toBe(2.5);
  });

  it('throws on empty array', () => {
    expect(() => average([])).toThrow('Array cannot be empty');
  });
});

// Run
// bun test
// bun test --watch
// bun test --coverage

Native bundler

Bun ships a bundler that replaces esbuild, webpack, and rollup for the most common cases. TypeScript, JSX, tree-shaking, and minification — all native, no plugins.

# CLI — simple build
bun build ./src/index.ts --outdir ./dist
bun build ./src/index.ts --outdir ./dist --minify
bun build ./src/index.ts --outdir ./dist --sourcemap

# Different targets
bun build ./src/index.ts --outdir ./dist --target node
bun build ./src/index.ts --outdir ./dist --target browser
bun build ./src/index.ts --outdir ./dist --target bun

// Programmatic API
await Bun.build({
  entrypoints: ['./src/index.ts'],
  outdir: './dist',
  minify: true,
  splitting: true, // automatic code splitting
  target: 'browser',
  define: {
    'process.env.NODE_ENV': '"production"',
  },
});

Native APIs that replace external packages

// File I/O — no fs.readFile callback
const text = await Bun.file('./data.txt').text();
const json = await Bun.file('./config.json').json();
await Bun.write('./output.txt', 'content here');

// Native hashing — no library needed
const hash = Bun.hash('my string');
const sha256 = new Bun.CryptoHasher('sha256').update('data').digest('hex');

// Spawn processes
const proc = Bun.spawn(['ls', '-la'], { stdout: 'pipe' });
const output = await new Response(proc.stdout).text();

// SQLite — no driver needed
import { Database } from 'bun:sqlite';
const db = new Database('./app.db');
const users = db.query('SELECT * FROM users WHERE active = ?').all(1);

// Native WebSocket in the server
Bun.serve({
  port: 3000,
  fetch(req, server) {
    if (server.upgrade(req)) return; // upgrade to WebSocket
    return new Response('Regular HTTP');
  },
  websocket: {
    message(ws, msg) { ws.send(`Echo: ${msg}`); },
    open(ws) { console.log('connected'); },
    close(ws) { console.log('disconnected'); },
  },
});

Node.js compatibility in 2026

Bun claims drop-in Node.js compatibility. The real number in 2026 is 95% — production-ready for most stacks, but with important exceptions.

Bun as dev tooling + Node.js in production

If you have compatibility concerns, there's a gradual adoption strategy that works well: use Bun as development tooling and keep Node.js in production until you're confident.

// package.json — Bun for tooling, Node.js for deployment
{
  "scripts": {
    "dev": "bun --watch src/index.ts",
    "test": "bun test",
    "build": "bun build src/index.ts --outdir dist --target node",
    "start": "node dist/index.js"  // production still on Node.js
  }
}

// The team gains:
// - Native TypeScript in dev (no ts-node)
// - 25x faster installs
// - Much faster tests
// - Zero compatibility risk in production

When to use Bun in production

The bigger picture: Bun + Anthropic

Anthropic's acquisition of Bun in December 2025 wasn't coincidental. Claude Code runs entirely on Bun — a runtime that needs fast startup, low memory footprint, and native TypeScript. Bun delivers all three.

The project remains open-source under MIT license. What changed is access to resources — Anthropic has a direct incentive to keep Bun fast and stable because its own products depend on it.

Bun wasn't built to win benchmarks. It was built to eliminate the friction between having an idea and having a server running.

In 2026, that friction was real — and Node.js had accumulated 15 years of external tools to compensate for it. Bun decided to solve it at the root.