What is Bun? A JavaScript Runtime, Bundler, and Package Manager

What is Bun?

Bun is a JavaScript runtime, package manager, test runner, and bundler - all in one binary. It is a drop-in replacement for Node.js that is faster and replaces several separate tools.

It was created by Jarred Sumner and first released in 2022. Instead of building on V8 (Chrome's engine) like Node.js and Deno, Bun uses JavaScriptCore - the engine that powers Safari. This gives it different startup characteristics and performance profile.

What Does Bun Replace?

One binary replaces six separate tools.

How Bun is Fast

Bun's speed comes from three design decisions:

1. Written in Zig - Zig is a low-level systems language with manual memory management, similar to C but safer. This gives Bun fine-grained control over memory allocation and thread scheduling
2. JavaScriptCore - Safari's engine starts faster than V8 because it's optimized for mobile devices where cold start matters. On a server, this means Bun scripts start 2-4x faster than Node
3. Built from scratch - Bun doesn't wrap Node.js APIs. It reimplements them in native code, optimized for the Zig runtime. The package resolver, HTTP client, and file system operations are all custom-optimized

Key Features

Native TypeScript

This is the feature I use most. Bun runs .ts and .tsx files directly:

bun run index.ts

No configuration needed.

Built-in Test Runner

Bun ships a Jest-compatible test runner with zero configuration:

# Write tests with the Jest API
bun test

describe('math', () => {
  it('adds correctly', () => {
    expect(1 + 1).toBe(2);
  });
});

No Jest installation, no jest.config.ts, no @types/jest, no ts-jest.

Fast Package Manager

bun install is roughly 4-10x faster than npm install:

bun install
# Done in under 2 seconds on most projects

It uses a global cache with content-addressable storage - packages are downloaded once and hard-linked into each project's node_modules. The lockfile (bun.lock) is smaller and faster to parse than package-lock.json.

Built-in Bundler

bun build ./src/index.ts --outdir ./dist

This replaces esbuild and webpack for most use cases. It supports code splitting, minification, source maps, and multiple target formats (ESM, CommonJS).

Watch Mode

bun --watch index.ts

Replaces nodemon. When files change, Bun restarts instantly because the cold start is fast enough that a full restart is cheaper than incremental compilation.

Compatibility with Node.js

Bun implements most Node.js APIs:

• fs, path, http, crypto, os, events - all work
• node:assert, node:buffer, node:util - all work
• node:worker_threads - works with some limitations
• Express, Fastify, Koa - work fine
• Prisma - works with some caveats around the engine binary
• Tailwind CSS - works

There are gaps. Native Node.js addons (packages that use node-gyp to compile C++ code) don't work because Bun uses a different JavaScript engine. Most pure JavaScript packages work without changes.

When to Use Bun

• You write TypeScript and want to run it directly with no build step
• You build APIs or scripts and want fast startup and live reload
• You ship CLI tools and want a single binary
• You are tired of managing six separate JavaScript tools
• You run CI/CD pipelines and want faster installs

Limitations

• Native addons - Packages that use node-gyp or native C++ modules don't work
• Serverless - Most serverless platforms (Lambda, Cloud Functions) don't support Bun yet
• Maturity - Bun is stable but newer than Node.js. Some edge cases still surface
• Windows - Windows support exists but is less mature than macOS/Linux

Getting Started

# Install Bun
curl -fsSL https://bun.sh/install | bash

# Create a project
mkdir hello-bun && cd hello-bun

# Initialize
bun init

# Install a package
bun add express

# Run TypeScript directly
echo 'console.log("Hello from Bun! 👋".split("").reverse().join(""))' > hello.ts
bun run hello.ts
# Outputs: !👋 nuB morf olleH

Summary

Bun rolls a runtime, package manager, test runner, and bundler into one binary. It doesn't replace Node.js for every use case. For daily work - writing TypeScript, running tests, building projects - it removes most of the configuration and waiting.