Overview
Bun is an incredibly fast all-in-one JavaScript runtime, bundler, test runner, and package manager designed to replace Node.js, webpack, Babel, yarn, and more with a single, cohesive tool. Built from scratch in Zig and powered by JavaScriptCore (Safari's JavaScript engine), Bun delivers performance that's orders of magnitude faster than traditional JavaScript tooling.
As a runtime, Bun is a drop-in replacement for Node.js that implements Node.js APIs and adds many enhancements. It starts up to 4x faster than Node.js and runs JavaScript/TypeScript code with exceptional performance. Bun natively supports TypeScript and JSX without requiring any transpilation step, eliminating the need for separate build tools during development.
Bun's built-in bundler is dramatically faster than webpack, esbuild, or Parcel, capable of bundling projects in milliseconds rather than seconds. The bundler supports code splitting, tree shaking, minification, and all modern bundling features out of the box. It also includes a built-in transpiler that handles TypeScript, JSX, and modern JavaScript syntax without external dependencies.
The package manager is one of Bun's standout features, installing npm packages up to 30x faster than npm and 20x faster than pnpm. It's compatible with the npm registry and package.json format, making migration from existing Node.js projects seamless. Bun's package manager also includes a global cache that saves disk space and speeds up installations across projects.
Bun includes a built-in test runner that's significantly faster than Jest or Vitest, with a familiar API that makes migration straightforward. The test runner supports mocking, snapshots, code coverage, and watch mode, providing everything needed for comprehensive testing without additional dependencies.
With built-in support for Web APIs (fetch, WebSocket, Streams), environment variables, hot reloading, and SQLite, Bun provides a batteries-included experience that eliminates the need for numerous third-party packages. Whether you're building APIs, full-stack applications, CLI tools, or microservices, Bun offers a modern, fast, and delightful developer experience.
Key Features
Blazing Fast Performance
4x faster startup than Node.js, with significantly faster execution powered by JavaScriptCore engine
Native TypeScript Support
Run TypeScript and JSX files directly without compilation step, transpiles on-the-fly
Ultra-Fast Package Manager
Install npm packages 30x faster than npm with global cache and full compatibility
Built-in Bundler
Bundle JavaScript/TypeScript projects in milliseconds with code splitting, tree shaking, and minification
Integrated Test Runner
Fast test runner compatible with Jest API, includes mocking, snapshots, and coverage
All-in-One Tooling
Runtime, bundler, transpiler, package manager, and test runner in a single binary
Käytä tapauksia
• **API Development**: Build blazing-fast REST APIs and GraphQL servers with native TypeScript support
• **Full-Stack Applications**: Develop modern web applications with fast bundling and hot reloading
• **CLI Tools**: Create command-line utilities with instant startup and minimal dependencies
• **Microservices**: Deploy lightweight, high-performance microservices with fast cold starts
• **Development Tooling**: Speed up development workflow with fast package installation and testing
• **Edge Computing**: Run JavaScript at the edge with minimal overhead and fast execution
• **Build Scripts**: Replace complex build pipelines with simple, fast Bun scripts
Installation Guide
**Installation on Ubuntu/Linux:**
```bash
# Install Bun
curl -fsSL https://bun.sh/install | bash
# Verify installation
bun --version
# Update Bun to latest version
bun upgrade
```
**Quick Start - Create New Project:**
```bash
# Initialize new project
bun init
# Run TypeScript/JavaScript file
bun run index.ts
# Install dependencies
bun install
# Run with watch mode (hot reload)
bun --watch run index.ts
```
**Run Existing Node.js Project:**
```bash
# Install dependencies (much faster than npm)
bun install
# Run with Bun runtime instead of Node
bun run start
# Or use as drop-in Node replacement
bun run dev
```
Configuration Tips
**Essential Configuration:**
**package.json scripts:**
```json
{
"scripts": {
"dev": "bun --watch run src/index.ts",
"build": "bun build src/index.ts --outdir dist",
"test": "bun test",
"start": "bun run dist/index.js"
}
}
```
**Bundling with Bun:**
```bash
# Bundle for production
bun build ./src/index.ts --outdir ./dist --target browser
# Bundle with minification
bun build ./src/index.ts --outdir ./dist --minify
# Bundle for Node.js target
bun build ./src/index.ts --outdir ./dist --target node
```
**Testing:**
```bash
# Run all tests
bun test
# Run specific test file
bun test auth.test.ts
# Watch mode
bun test --watch
# With coverage
bun test --coverage
```
**Environment Variables:**
- Automatically loads `.env` files
- Access via `process.env` or `Bun.env`
- No dotenv package needed
**Performance Tips:**
- Use native Bun APIs (Bun.file, Bun.serve) instead of Node equivalents
- Enable HTTP/2 with Bun.serve for better performance
- Use bun:sqlite for fast database operations
- Leverage built-in fetch instead of axios