Start a dev server

Run bun ./index.html to start a dev server. TypeScript, JSX, React, and CSS imports work out of the box.

Hot Module Replacement

Built-in HMR preserves application state during development. Changes appear instantly—no manual refresh needed.

Build for production

Build optimized bundles with bun build ./index.html --production. Tree-shaking, minification, and code splitting work out of the box.

import { sql, serve } from "bun";

const server = serve({
  port: 3000,
  routes: {
    "/": new Response("Welcome to Bun!"),
    "/api/users": async (req) => {
      const users = await sql`SELECT * FROM users LIMIT 10`;
      return Response.json({ users });
    },
  },
});

console.log(`Listening on localhost:${server.port}`);

const server = Bun.serve<{ authToken: string; }>({
  fetch(req, server) {
    // use a library to parse cookies
    const cookies = parseCookies(req.headers.get("Cookie"));
    server.upgrade(req, {
      data: { authToken: cookies['X-Token'] },
    });
  },
  websocket: {
    // handler called when a message is received
    async message(ws, message) {
      console.log(`Received: ${message}`);
      const user = getUserFromToken(ws.data.authToken);
      await db.Message.insert({
        message: String(message),
        userId: user.id,
      });
    },
  },
});

console.log(`Listening on localhost:${server.port}`);

const file = Bun.file(import.meta.dir + '/package.json'); // BunFile

const pkg = await file.json(); // BunFile extends Blob
pkg.name = 'my-package';
pkg.version = '1.0.0';

await Bun.write(file, JSON.stringify(pkg, null, 2));

const password = "super-secure-pa$$word";

const hash = await Bun.password.hash(password);
// => $argon2id$v=19$m=65536,t=2,p=1$tFq+9AVr1bfPxQdh...

const isMatch = await Bun.password.verify(password, hash);
// => true

// Run 'bun init --react' to get started
import { serve } from "bun";
import reactApp from "./index.html";

serve({
  port: 3000,
  routes: {
    "/": reactApp,
    "/api/hello": () => Response.json({ message: "Hello!" }),
  },
  development: {
    console: true, // Stream browser logs to terminal
    hmr: true, // Enable hot module reloading
  },
});

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

// Run tests concurrently for better performance
test.concurrent("fetch user 1", async () => {
  const res = await fetch("https://api.example.com/users/1");
  expect(res.status).toBe(200);
});

test.concurrent("fetch user 2", async () => {
  const res = await fetch("https://api.example.com/users/2");
  expect(res.status).toBe(200);
});

test("addition", () => {
  expect(2 + 2).toBe(4);
});

import { sql } from "bun";

// Query with automatic SQL injection prevention
const users = await sql`
  SELECT * FROM users
  WHERE active = ${true}
  LIMIT 10
`;

// Insert with object notation
const [user] = await sql`
  INSERT INTO users ${sql({
    name: "Alice",
    email: "alice@example.com"
  })}
  RETURNING *
`;

// Import YAML files directly
import config from "./config.yaml";

console.log(config.database.host);
// => "localhost"

// Or parse YAML at runtime
const data = Bun.YAML.parse(`
name: my-app
version: 1.0.0
database:
  host: localhost
  port: 5432
`);

import { serve } from "bun";

serve({
  port: 3000,
  routes: {
    "/": (request) => {
      // Read cookies with built-in parsing
      const sessionId = request.cookies.get("session_id");

      // Set cookies
      request.cookies.set("session_id", "abc123", {
        path: "/",
        httpOnly: true,
        secure: true,
      });

      return Response.json({ success: true });
    },
  },
});

import { redis } from "bun";

// Set a key
await redis.set("greeting", "Hello from Bun!");

console.log(db.query("SELECT 1 as x").get());
// { x: 1 }

import { $ } from 'bun';

// Run a shell command (also works on Windows!)
await $`echo "Hello, world!"`;

const response = await fetch("https://example.com");

// Pipe the response body to gzip
const data = await $`gzip < ${response}`.arrayBuffer();

import { dlopen, FFIType, suffix } from "bun:ffi";

// `suffix` is either "dylib", "so", or "dll" depending on the platform
const path = `libsqlite3.${suffix}`;

const {
  symbols: {
    sqlite3_libversion, // the function to call
  },
} = dlopen(path, {
  sqlite3_libversion: {
    args: [], // no arguments
    returns: FFIType.cstring, // returns a string
  },
});

console.log(`SQLite 3 version: ${sqlite3_libversion()}`);