bun

name	bun
description	Bun is an all-in-one JavaScript/TypeScript toolkit that ships as a single binary. It includes a runtime (drop-in Node.js replacement), package manager, test runner, and bundler.
access_date	"2026-07-14T11:49:23.000Z"
current_date	"2026-07-14T11:49:23.800Z"

Bun

Docs

• Bytecode Caching: Speed up JavaScript execution with bytecode caching in Bun's bundler
• CSS: Bun's bundler has built-in support for CSS with modern features
• esbuild: Migration guide from esbuild to Bun's bundler
• Single-file executable: Generate standalone executables from TypeScript or JavaScript files with Bun
• Fullstack dev server: Build fullstack applications with Bun's integrated dev server that bundles frontend assets and handles API routes
• Hot reloading: Hot Module Replacement (HMR) for Bun's development server
• HTML & static sites: Build static sites, landing pages, and web applications with Bun's bundler
• Bundler: Bun's fast native bundler for JavaScript, TypeScript, JSX, and more
• Loaders: Built-in loaders for the Bun bundler and runtime
• Macros: Run JavaScript functions at bundle-time with Bun macros
• Minifier: Reduce bundle sizes with Bun's JavaScript and TypeScript minifier
• Plugins: Universal plugin API for extending Bun's runtime and bundler
• Standalone HTML: Bundle a single-page app into a single self-contained .html file with no external dependencies
• Feedback: Share feedback, bug reports, and feature requests
• Convert an ArrayBuffer to an array of numbers
• Convert an ArrayBuffer to a Blob
• Convert an ArrayBuffer to a Buffer
• Convert an ArrayBuffer to a string
• Convert an ArrayBuffer to a Uint8Array
• Convert a Blob to an ArrayBuffer
• Convert a Blob to a DataView
• Convert a Blob to a ReadableStream
• Convert a Blob to a string
• Convert a Blob to a Uint8Array
• Convert a Buffer to an ArrayBuffer
• Convert a Buffer to a blob
• Convert a Buffer to a ReadableStream
• Convert a Buffer to a string
• Convert a Buffer to a Uint8Array
• Convert a DataView to a string
• Convert a Uint8Array to an ArrayBuffer
• Convert a Uint8Array to a Blob
• Convert a Uint8Array to a Buffer
• Convert a Uint8Array to a DataView
• Convert a Uint8Array to a ReadableStream
• Convert a Uint8Array to a string
• Deploy a Bun application on AWS Lambda
• Deploy a Bun application on DigitalOcean
• Deploy a Bun application on Google Cloud Run
• Deploy a Bun application on Railway: Deploy a Bun application to Railway from the CLI or dashboard, with optional PostgreSQL setup and automatic SSL
• Deploy a Bun application on Render
• Deploy a Bun application on Vercel
• Build an app with Astro and Bun
• Create a Discord bot
• Containerize a Bun application with Docker
• Use Drizzle ORM with Bun
• Build an HTTP server using Elysia and Bun
• Build an HTTP server using Express and Bun
• Use Gel with Bun
• Build an HTTP server using Hono and Bun
• Read and write data to MongoDB using Mongoose and Bun
• Use Neon Postgres through Drizzle ORM
• Use Neon's Serverless Postgres with Bun
• Build an app with Next.js and Bun
• Build an app with Nuxt and Bun
• Run Bun as a daemon with PM2
• Use Prisma with Bun
• Use Prisma Postgres with Bun
• Build an app with Qwik and Bun
• Build a React app with Bun
• Build an app with Remix and Bun
• Add Sentry to a Bun app
• Build an app with SolidStart and Bun
• Server-side render (SSR) a React component
• Build an HTTP server using StricJS and Bun
• Build an app with SvelteKit and Bun
• Run Bun as a daemon with systemd
• Use TanStack Start with Bun
• Bun Redis with Upstash
• Build a frontend using Vite and Bun
• Extract links from a webpage using HTMLRewriter
• Extract social share images and Open Graph tags
• Start a cluster of HTTP servers: Run multiple HTTP servers concurrently with the "reusePort" option to share the same port across multiple processes
• Send an HTTP request using fetch
• fetch with unix domain sockets in Bun
• Upload files via HTTP using FormData
• Hot reload an HTTP server
• Proxy HTTP requests using fetch()
• Common HTTP server usage
• Write a simple HTTP server
• Server-Sent Events (SSE) with Bun
• Stream a file as an HTTP Response
• Streaming HTTP Server with Async Iterators
• Streaming HTTP Server with Node.js Streams
• Configure TLS on an HTTP server
• Guides: Code samples and walkthroughs for common tasks with Bun
• Add a dependency
• Add a development dependency
• Add a Git dependency
• Add an optional dependency
• Add a peer dependency
• Add a tarball dependency
• Using bun install with an Azure Artifacts npm registry
• Install dependencies with Bun in GitHub Actions
• Override the default npm registry for bun install
• Migrate from npm install to bun install
• Configure git to diff Bun's lockb lockfile
• Using bun install with Artifactory
• Install a package under a different name
• Configure a private registry for an organization scope with bun install
• Add a trusted dependency
• Configuring a monorepo using workspaces
• Generate a yarn-compatible lockfile
• Parse command-line arguments
• Listen for CTRL+C
• Spawn a child process and communicate using IPC
• Get the process uptime in nanoseconds
• Listen to OS signals
• Spawn a child process
• Read stderr from a child process
• Read stdout from a child process
• Read from stdin
• Read a file to an ArrayBuffer
• Read a file to a Buffer
• Check if a file exists
• Read a JSON file
• Get the MIME type of a file
• Read a file as a ReadableStream
• Read a file as a string
• Read a file to a Uint8Array
• Watch a directory for changes
• Build-time constants with --define
• Install and run Bun in GitHub Actions
• Codesign a single-file JavaScript executable on macOS: Fix the "can't be opened because it is from an unidentified developer" Gatekeeper warning when running your JavaScript executable.
• Define and replace static globals & constants
• Delete directories
• Delete files
• Inspect memory usage using V8 heap snapshots
• Import a HTML file as text
• Import a JSON file
• Import a JSON5 file
• Import a TOML file
• Import a YAML file
• Read environment variables
• Set environment variables
• Run a Shell Command
• Set a time zone in Bun
• Re-map import paths
• Install TypeScript declarations for Bun
• Debugging Bun with the VS Code extension
• Debugging Bun with the web debugger
• Convert a Node.js Readable to an ArrayBuffer
• Convert a Node.js Readable to a Blob
• Convert a Node.js Readable to JSON
• Convert a Node.js Readable to a string
• Convert a Node.js Readable to an Uint8Array
• Convert a ReadableStream to an array of chunks
• Convert a ReadableStream to an ArrayBuffer
• Convert a ReadableStream to a Blob
• Convert a ReadableStream to a Buffer
• Convert a ReadableStream to JSON
• Convert a ReadableStream to a string
• Convert a ReadableStream to a Uint8Array
• Bail early with the Bun test runner
• Selectively run tests concurrently with glob patterns: Set a glob pattern to decide which tests from which files run in parallel
• Generate code coverage reports with the Bun test runner
• Set a code coverage threshold with the Bun test runner
• Write browser DOM tests with Bun and happy-dom
• Migrate from Jest to Bun's test runner
• Set the system time in Bun's test runner
• Mock functions in bun test
• Re-run tests multiple times with the Bun test runner
• Run your tests with the Bun test runner
• Skip tests with the Bun test runner
• Use snapshot testing in bun test
• Spy on methods in bun test
• import, require, and test Svelte components with bun test
• Using Testing Library with Bun
• Set a per-test timeout with the Bun test runner
• Mark a test as a "todo" with the Bun test runner
• Update snapshots in bun test
• Run tests in watch mode with Bun
• Encode and decode base64 data
• Check if two objects are deeply equal
• Compress and decompress data with DEFLATE
• Detect when code is executed with Bun
• Check if the current file is the entrypoint
• Escape an HTML string
• Convert a file URL to an absolute path
• Compress and decompress data with gzip
• Hash a password
• Get the directory of the current file
• Get the file name of the current file
• Get the absolute path of the current file
• Generate a UUID
• Get the absolute path to the current entrypoint
• Convert an absolute path to a file URL
• Sleep for a fixed number of milliseconds
• Upgrade Bun to the latest version
• Get the current Bun version
• Get the path to an executable bin file
• Enable compression for WebSocket messages
• Set per-socket contextual data on a WebSocket
• Build a publish-subscribe WebSocket server
• Build a simple WebSocket server
• Append content to a file
• Write a string to a file
• Write a Blob to a file
• Write a file to stdout
• Copy a file to another location
• Write a file incrementally
• Write a Response to a file
• Write to stdout
• Write a ReadableStream to a file
• Delete a file
• Welcome to Bun: Bun is an all-in-one toolkit for developing modern JavaScript/TypeScript applications.
• Installation: Install Bun with npm, Homebrew, Docker, or the official script.
• bunx: Run packages from npm
• Catalogs: Share common dependency versions across multiple packages in a monorepo
• bun add: Add packages to your project with Bun's fast package manager
• bun audit: Check your installed packages for known security vulnerabilities
• bun info: Display package metadata from the npm registry
• bun install: Install packages with Bun's fast package manager
• bun link: Link local packages for development
• bun outdated: Check for outdated dependencies
• bun patch: Persistently patch node_modules packages in a git-friendly way
• bun pm: Package manager utilities
• bun publish: Use bun publish to publish a package to the npm registry
• bun remove: Remove dependencies from your project
• bun update: Update dependencies to latest versions
• bun why: Explain why a package is installed
• bun --filter: Select packages by pattern in a monorepo using the --filter flag
• Global cache: How Bun stores and manages packages in its global cache
• Global virtual store: Install packages once. Every project links to the same copy.
• Isolated installs: Strict dependency isolation similar to pnpm's approach
• Lifecycle scripts: How Bun handles package lifecycle scripts securely
• Lockfile: Bun's lockfile format and configuration
• .npmrc support
• Overrides and resolutions: Control metadependency versions with npm overrides and Yarn resolutions
• Scopes and registries: Configure private registries and scoped packages
• Security Scanner API
• Workspaces: Develop complex monorepos with multiple independent packages
• Benchmarking: How to benchmark Bun
• Bindgen: Bindgen for Bun
• Building Windows: Building Bun on Windows
• Contributing: Contributing to Bun
• License: License for Bun
• Roadmap: Bun's roadmap and long-term plans
• Quickstart: Build your first app with Bun
• Archive: Create and extract tar archives with Bun's fast native implementation
• Auto-install: Bun's automatic package installation feature for standalone script execution
• Binary Data: Working with binary data in JavaScript
• Bun APIs: Overview of Bun's native APIs available on the Bun global object and built-in modules
• bunfig.toml: Configure Bun's behavior using its configuration file bunfig.toml
• C Compiler: Compile and run C from JavaScript with low overhead
• Spawn: Spawn child processes with Bun.spawn or Bun.spawnSync
• Color: Format colors as CSS, ANSI, numbers, hex strings, and more
• Console: The console object in Bun
• Cookies: Use Bun's native APIs for working with HTTP cookies
• Cron: Schedule and parse cron jobs with Bun
• CSRF Protection: Generate and verify CSRF tokens with Bun's built-in API
• Debugging: Debug your Bun code with an interactive debugger using WebKit Inspector Protocol
• Environment Variables: Read and configure environment variables in Bun, including automatic .env file support
• FFI: Use Bun's FFI module to efficiently call native libraries from JavaScript
• File I/O: Bun provides a set of optimized APIs for reading and writing files.
• File System Router: Bun provides a fast API for resolving routes against file-system paths
• File Types: File types and loaders supported by Bun's bundler and runtime
• Glob: Use Bun's fast native implementation of file globbing
• Globals: Use Bun's global objects
• Hashing: Utility functions for hashing and verifying passwords with various cryptographically secure algorithms
• HTMLRewriter: Use Bun's HTMLRewriter to transform HTML documents with CSS selectors
• Cookies: Work with cookies in HTTP requests and responses using Bun's built-in Cookie API.
• Error Handling: Learn how to handle errors in Bun's development server
• Metrics: Monitor server activity with built-in metrics
• Routing: Define routes in Bun.serve using static paths, parameters, and wildcards
• Server: Use Bun.serve to start a high-performance HTTP server in Bun
• TLS: Enable TLS in Bun.serve
• WebSockets: Server-side WebSockets in Bun
• Image: Decode, transform, and encode images with a fast native pipeline
• Bun Runtime: Execute JavaScript/TypeScript files, package.json scripts, and executable packages with Bun's fast runtime.
• JSON5: Use Bun's built-in support for JSON5 files through both runtime APIs and bundler integration
• JSONL: Parse newline-delimited JSON (JSONL) with Bun's built-in streaming parser
• JSX: Built-in JSX and TSX support in Bun with configurable transpilation options
• Markdown: Parse and render Markdown with Bun's built-in Markdown API, supporting GFM extensions and custom rendering callbacks
• Module Resolution: How Bun resolves modules and handles imports in JavaScript and TypeScript
• DNS: Use Bun's DNS module to resolve DNS records
• Fetch: Send HTTP requests with Bun's fetch API
• TCP: Use Bun's native TCP API to implement performance-sensitive systems like database clients, game servers, or anything that needs to communicate over TCP (instead of HTTP)
• UDP: Use Bun's UDP API to implement services with advanced real-time requirements, such as voice chat.
• Node-API: Use Bun's Node-API module to build native add-ons to Node.js
• Node.js Compatibility: Bun's compatibility status with Node.js APIs, modules, and globals
• Plugins: Universal plugin API for extending Bun's runtime and bundler
• Redis: Use Bun's native Redis client with a Promise-based API
• REPL: An interactive JavaScript and TypeScript REPL with syntax highlighting, history, and tab completion
• S3: Bun provides fast, native bindings for interacting with S3-compatible object storage services.
• Secrets: Use Bun's Secrets API to store and retrieve sensitive credentials securely
• Semver: Use Bun's semantic versioning API
• Shell: Use Bun's shell scripting API to run shell commands from JavaScript
• SQL: Bun provides native bindings for working with SQL databases through a unified Promise-based API that supports PostgreSQL, MySQL, and SQLite.
• SQLite: Bun natively implements a high-performance SQLite3 driver.
• Streams: Use Bun's streams API to work with binary data without loading it all into memory at once
• bun create: Create a new Bun project from a React component, a create-<template> npm package, a GitHub repo, or a local template
• bun init: Scaffold an empty Bun project with the interactive bun init command
• TOML: Use Bun's built-in support for TOML files through both runtime APIs and bundler integration
• Transpiler: Use Bun's transpiler to transpile JavaScript and TypeScript code
• Utils: Use Bun's utility functions to work with the runtime
• Watch Mode: Automatic reloading in Bun with --watch and --hot modes
• Web APIs: Web-standard APIs supported by Bun for server-side JavaScript
• WebView: Control a headless browser from Bun for automation, testing, and scraping — zero dependencies on macOS, Chrome DevTools Protocol everywhere else
• Workers: Use Bun's Workers API to create and communicate with a new JavaScript instance running on a separate thread while sharing I/O resources with the main thread
• YAML: Use Bun's built-in support for YAML files through both runtime APIs and bundler integration
• Code coverage: Use Bun's built-in code coverage reporting to track test coverage and find untested code
• Test configuration: Configure bun test behavior with bunfig.toml and command-line options
• Dates and times: Learn how to manipulate time and dates in your Bun tests using setSystemTime and Jest compatibility functions
• Finding tests: Learn how Bun's test runner discovers and filters test files in your project
• DOM testing: Learn how to test DOM elements and components using Bun with happy-dom and React Testing Library
• Test runner: Bun's fast, built-in, Jest-compatible test runner with TypeScript support, lifecycle hooks, mocking, and watch mode
• Lifecycle hooks: Learn how to use beforeAll, beforeEach, afterEach, and afterAll lifecycle hooks in Bun tests
• Mocks: Learn how to create and use mock functions, spies, and module mocks in Bun tests
• Test Reporters
• Runtime behavior: Learn about Bun test's runtime integration, environment variables, timeouts, and error handling
• Snapshots: Learn how to use snapshot testing in Bun to save and compare output between test runs
• Writing tests: Write tests with Bun's Jest-compatible API, including async tests, timeouts, and test modifiers
• TypeScript: Using TypeScript with Bun, including type definitions and compiler options
• TypeScript 6 and 7: How to configure Bun's type definitions for TypeScript 6.0 and 7.0, which no longer auto-discover @types packages. Fix 'Cannot find name Bun' and other missing type errors after upgrading TypeScript.

Optional

• Reference
• Blog