Bun Optimization

Analyze and optimize Bun application performance.

Optimization Areas

Bundle Size Optimization

Analyze current bundle:

const result = await Bun.build({
  entrypoints: ["./src/index.ts"],
  outdir: "./dist",
  minify: true,
  splitting: true,
  sourcemap: "external",
});

for (const output of result.outputs) {
  console.log(`${output.path}: ${output.size} bytes`);
}

Techniques:

1. Enable minification - Reduces size by 40-60%
2. Code splitting - Lazy load non-critical code
3. Tree shaking - Remove unused exports
4. External packages - Don't bundle large deps
5. Drop console/debugger - Remove dev code

await Bun.build({
  entrypoints: ["./src/index.ts"],
  outdir: "./dist",
  minify: true,
  splitting: true,
  drop: ["console", "debugger"],
  external: ["react", "react-dom"],
});

Runtime Performance

1. Use Bun APIs - Prefer Bun.file() over fs
2. Stream large files - Don't load into memory
3. Prepared statements - Reuse SQLite statements
4. Connection pooling - For databases
5. Response caching - Cache expensive operations

// Good: Stream large files
const file = Bun.file("large.json");
const stream = file.stream();

// Good: Prepared statements
const stmt = db.prepare("SELECT * FROM users WHERE id = ?");
for (const id of ids) {
  stmt.get(id);
}

// Good: Cache responses
const cache = new Map();
async function getData(key) {
  if (cache.has(key)) return cache.get(key);
  const data = await fetchData(key);
  cache.set(key, data);
  return data;
}

Memory Optimization

1. Use --smol flag - Reduces memory footprint
2. Stream processing - Avoid loading all data
3. WeakMap/WeakSet - For cached objects
4. ArrayBuffer reuse - Pool buffers
5. Avoid closures - In hot paths

# Run with reduced memory
bun --smol run src/index.ts

// Good: Stream processing
for await (const line of file.stream()) {
  processLine(line);
}

// Good: Buffer pooling
const bufferPool = [];
function getBuffer(size) {
  return bufferPool.pop() || new ArrayBuffer(size);
}
function releaseBuffer(buf) {
  bufferPool.push(buf);
}

Startup Optimization

1. Compile to bytecode - Faster cold start
2. Lazy loading - Defer non-critical imports
3. Smaller entry point - Minimal initial code
4. Preload essentials - Load critical modules first

// Compile to bytecode
await Bun.build({
  entrypoints: ["./src/index.ts"],
  outdir: "./dist",
  target: "bun",
  bytecode: true,
});

// Lazy loading
const heavyModule = async () => {
  const { default: module } = await import("./heavy-module");
  return module;
};

bunfig.toml Optimizations

[install]
# Faster installs
auto-install = true

[run]
# Use Bun runtime
bun = true

[test]
# Faster test execution
preload = ["./test/setup.ts"]

Benchmarking

// Simple benchmark
const start = Bun.nanoseconds();
// ... operation
const end = Bun.nanoseconds();
console.log(`Took ${(end - start) / 1_000_000}ms`);

// HTTP benchmark
const server = Bun.serve({ port: 3000, fetch: handler });
// Run: wrk -t12 -c400 -d30s http://localhost:3000/

Analysis Commands

# Bundle analysis
bun build src/index.ts --outdir=dist --analyze

# Runtime profiling
bun --cpu-prof run src/index.ts

# Memory profiling
bun --heap-prof run src/index.ts

Before/After Checklist

Run these checks before and after optimization:

1. Bundle size (bytes)
2. Startup time (ms)
3. Memory usage (MB)
4. Request latency (ms)
5. Throughput (req/s)

Output

After optimization:

1. Metrics before/after
2. Changes applied
3. Further recommendations
4. Commands to verify improvements