Complete Bun Guide | Ultra-Fast JavaScript Runtime, Package Manager, Bundler, Testing & Practical Usage

2026년 4월 7일 · 21분 읽기 · 수정 2026년 4월 7일 Intermediate

Key Takeaways

Complete guide to implementing fast JavaScript development with Bun. Covers Node.js alternative, fast package installation, built-in bundler, and test runner with practical examples.

Real-World Experience: Sharing experience of transitioning from Node.js to Bun, where package installation became 10x faster and test execution became 5x faster.

Introduction: “Node.js is Slow”

Real-World Problem Scenarios

Scenario 1: npm install is too slow
npm is slow. Bun is 10x faster.

Scenario 2: Bundler configuration is complex
Webpack is complex. Bun provides built-in bundler.

Scenario 3: Tests are slow
Jest is slow. Bun is 5x faster.

1. What is Bun?

Core Features

Bun is an ultra-fast JavaScript runtime.

Key Advantages:

Fast Speed: 4x faster than Node.js
All-in-One: Runtime + Package Manager + Bundler + Test
Node.js Compatible: Mostly compatible
TypeScript: Native support
Web API: Built-in fetch, WebSocket

Performance Comparison:

Node.js: 100ms
Deno: 80ms
Bun: 25ms

2. Installation and Basic Usage

Installation

Here’s an implementation example using bash. Try running the code directly to see how it works.

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

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

Basic Commands

Here’s an implementation example using bash. Try running the code directly to see how it works.

# Run file
bun run index.ts

# REPL
bun

# Check version
bun --version

3. Package Management

Package Installation

Here’s an implementation example using bash. Please review the code to understand the role of each part.

# Install dependencies
bun install

# Add package
bun add express
bun add -d typescript

# Remove package
bun remove express

# Global install
bun add -g typescript

Speed Comparison:

npm: 60 seconds
pnpm: 20 seconds
bun: 6 seconds

4. Web Server

HTTP Server

Here’s a detailed implementation using TypeScript. Handle branching with conditionals. Please review the code to understand the role of each part.

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

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

    if (url.pathname === '/api/users') {
      return Response.json([
        { id: 1, name: 'John' },
        { id: 2, name: 'Jane' },
      ]);
    }

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

console.log(`Server running on http://localhost:${server.port}`);

Using Express

Here’s an implementation example using TypeScript. Import necessary modules. Please review the code to understand the role of each part.

import express from 'express';

const app = express();

app.get('/', (req, res) => {
  res.send('Hello Bun with Express!');
});

app.listen(3000, () => {
  console.log('Server running on :3000');
});

5. Bundler

Basic Bundling

Here’s an implementation example using TypeScript. Perform tasks efficiently with async processing, ensure stability with error handling. Try running the code directly to see how it works.

// build.ts
await Bun.build({
  entrypoints: ['./src/index.ts'],
  outdir: './dist',
  target: 'browser',
  minify: true,
  sourcemap: 'external',
});

React Bundling

Here’s an implementation example using TypeScript. Perform tasks efficiently with async processing, ensure stability with error handling. Please review the code to understand the role of each part.

await Bun.build({
  entrypoints: ['./src/index.tsx'],
  outdir: './dist',
  target: 'browser',
  minify: true,
  splitting: true,
  loader: {
    '.png': 'file',
    '.svg': 'file',
  },
});

6. Testing

Basic Tests

Here’s an implementation example using TypeScript. Import necessary modules. Please review the code to understand the role of each part.

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

describe('Math', () => {
  test('add', () => {
    expect(1 + 2).toBe(3);
  });

  test('multiply', () => {
    expect(2 * 3).toBe(6);
  });
});

Async Tests

Here’s an implementation example using TypeScript. Import necessary modules, perform tasks efficiently with async processing. Try running the code directly to see how it works.

import { expect, test } from 'bun:test';

test('fetch users', async () => {
  const response = await fetch('https://api.example.com/users');
  const users = await response.json();

  expect(users).toBeArray();
  expect(users.length).toBeGreaterThan(0);
});

Run

bun test

7. File System

Reading Files

Here’s an implementation example using TypeScript. Perform tasks efficiently with async processing. Try running the code directly to see how it works.

// Text file
const text = await Bun.file('data.txt').text();

// JSON file
const json = await Bun.file('data.json').json();

// Binary file
const buffer = await Bun.file('image.png').arrayBuffer();

Writing Files

await Bun.write('output.txt', 'Hello Bun!');

await Bun.write('data.json', JSON.stringify({ name: 'John' }));

8. Environment Variables

Here’s an implementation example using TypeScript. Try running the code directly to see how it works.

// .env
DATABASE_URL=postgresql://localhost:5432/mydb
API_KEY=secret123

// Usage
console.log(process.env.DATABASE_URL);
console.log(Bun.env.API_KEY);

9. Hot Reload

bun --watch server.ts

10. Real-World Example

REST API

Here’s a detailed implementation using TypeScript. Perform tasks efficiently with async processing, handle branching with conditionals. Please review the code to understand the role of each part.

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

    if (url.pathname === '/api/users' && req.method === 'GET') {
      const users = await db.select().from(usersTable);
      return Response.json(users);
    }

    if (url.pathname === '/api/users' && req.method === 'POST') {
      const body = await req.json();
      const user = await db.insert(usersTable).values(body).returning();
      return Response.json(user[0], { status: 201 });
    }

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

Summary and Checklist

Key Summary

Bun: Ultra-fast JavaScript runtime
All-in-One: Runtime + Package Manager + Bundler + Test
Fast Speed: 4x faster than Node.js
TypeScript: Native support
Node.js Compatible: Mostly compatible
Web API: Built-in fetch, WebSocket

Implementation Checklist

Complete pnpm Guide
Complete Vite 5 Guide
Complete Vitest Guide

Keywords Covered

Bun, JavaScript, Runtime, Package Manager, Bundler, Performance, Node.js

Frequently Asked Questions (FAQ)

Q. Can it completely replace Node.js?

A. Possible in most cases, but some native modules may not be compatible.

Q. Is it safe to use in production?

A. Still version 1.0, but used in many projects. If stability is important, Node.js is recommended.

Q. Can I use npm packages?

A. Yes, most npm packages are compatible.

Q. Does it support Windows?

A. Yes, Windows is supported.