Convert Figma logo to code with AI

oven-sh logobun

Incredibly fast JavaScript runtime, bundler, test runner, and package manager – all in one

73,021
2,661
73,021
3,554

Top Related Projects

93,919

A modern runtime for JavaScript and TypeScript.

106,466

Node.js JavaScript runtime ✨🐢🚀✨

37,921

An extremely fast bundler for the web

25,992

Build system optimized for JavaScript and TypeScript, written in Rust

23,768

Unified developer tools for JavaScript, TypeScript, and the web

30,914

Rust-based platform for the Web

Quick Overview

Bun is an all-in-one JavaScript runtime and toolkit designed to be a drop-in replacement for Node.js. It aims to provide faster performance, better developer experience, and enhanced compatibility with existing JavaScript and TypeScript codebases. Bun includes a bundler, transpiler, task runner, and npm client.

Pros

  • Significantly faster performance compared to Node.js due to its use of the JavaScriptCore engine
  • Built-in bundler and transpiler, reducing the need for additional tools
  • Native TypeScript support without requiring separate compilation steps
  • Improved developer experience with features like hot reloading and a unified CLI

Cons

  • Relatively new project, which may lead to stability issues or lack of mature ecosystem support
  • Not 100% compatible with all Node.js APIs and modules, potentially requiring code adjustments
  • Limited community resources and third-party packages compared to Node.js
  • Steeper learning curve for developers already familiar with the Node.js ecosystem

Code Examples

  1. Basic HTTP server:
const server = Bun.serve({
  port: 3000,
  fetch(req) {
    return new Response("Welcome to Bun!");
  },
});

console.log(`Listening on http://localhost:${server.port}`);
  1. Reading a file:
const file = Bun.file("example.txt");
const text = await file.text();
console.log(text);
  1. Using the built-in SQLite database:
const db = new Bun.SQLite(":memory:");
db.query("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)").run();
db.query("INSERT INTO users (name) VALUES (?)").run("Alice");
const users = db.query("SELECT * FROM users").all();
console.log(users);

Getting Started

  1. Install Bun:
curl -fsSL https://bun.sh/install | bash
  1. Create a new project:
bun init my-project
cd my-project
  1. Run a JavaScript file:
bun run index.js
  1. Install dependencies:
bun install <package-name>
  1. Start a development server with hot reloading:
bun --hot index.js

Competitor Comparisons

93,919

A modern runtime for JavaScript and TypeScript.

Pros of Deno

  • Built-in TypeScript support without additional configuration
  • Secure by default with explicit permissions for file, network, and environment access
  • Comprehensive standard library with modern APIs

Cons of Deno

  • Smaller ecosystem compared to Node.js, with fewer third-party packages
  • Limited compatibility with existing Node.js projects and packages
  • Steeper learning curve for developers familiar with Node.js

Code Comparison

Deno:

import { serve } from "https://deno.land/std@0.140.0/http/server.ts";

serve((req) => new Response("Hello World"));

Bun:

export default {
  port: 3000,
  fetch(req) {
    return new Response("Hello World");
  },
};

Both Deno and Bun aim to improve upon Node.js, offering enhanced performance and developer experience. Deno focuses on security and modern JavaScript features, while Bun prioritizes speed and compatibility with the existing Node.js ecosystem. Deno's approach to modules and security may require more adaptation for developers, whereas Bun aims to be a drop-in replacement for Node.js with minimal changes required.

106,466

Node.js JavaScript runtime ✨🐢🚀✨

Pros of Node.js

  • Mature ecosystem with extensive libraries and frameworks
  • Widespread adoption and community support
  • Well-established tooling and debugging capabilities

Cons of Node.js

  • Slower startup times and higher memory usage
  • Less efficient handling of concurrent tasks
  • Lack of built-in TypeScript support

Code Comparison

Node.js:

const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello World\n');
});

server.listen(3000);

Bun:

export default {
  port: 3000,
  fetch(request) {
    return new Response("Hello World");
  },
};

The Bun example showcases its more concise syntax and built-in HTTP server functionality, while Node.js requires more boilerplate code. Bun's approach aims to simplify common tasks and improve developer productivity.

Node.js remains a solid choice for its maturity and extensive ecosystem, while Bun offers potential performance improvements and a more modern development experience. The choice between the two depends on specific project requirements and developer preferences.

37,921

An extremely fast bundler for the web

Pros of esbuild

  • Faster build times for JavaScript and TypeScript projects
  • Highly optimized for performance, written in Go
  • Focused solely on bundling and minification tasks

Cons of esbuild

  • Limited to build-time operations, not a full runtime environment
  • Narrower feature set compared to Bun's all-in-one approach
  • Requires additional tools for tasks like package management

Code Comparison

esbuild:

import * as esbuild from 'esbuild'

await esbuild.build({
  entryPoints: ['app.js'],
  bundle: true,
  outfile: 'out.js',
})

Bun:

import { build } from 'bun';

await build({
  entrypoints: ['./app.ts'],
  outdir: './out',
});

Both esbuild and Bun offer build functionality, but Bun provides a more comprehensive environment for JavaScript and TypeScript development. While esbuild excels in build performance, Bun aims to be an all-in-one toolkit, including a runtime, package manager, and build tool. esbuild's focused approach may be preferable for projects requiring only bundling and minification, while Bun's broader feature set caters to developers seeking an integrated development experience.

25,992

Build system optimized for JavaScript and TypeScript, written in Rust

Pros of Turborepo

  • Specialized in monorepo management and build optimization
  • Provides advanced caching mechanisms for faster builds
  • Integrates well with existing Node.js ecosystems

Cons of Turborepo

  • Limited to build and dependency management tasks
  • Requires additional setup and configuration for optimal use
  • Not a full JavaScript runtime like Bun

Code Comparison

Turborepo (pipeline configuration):

{
  "pipeline": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": ["dist/**", ".next/**"]
    }
  }
}

Bun (script execution):

import { $ } from "bun";

await $`echo "Hello, Bun!"`;

Turborepo focuses on optimizing builds and managing dependencies in monorepos, while Bun aims to be a complete JavaScript runtime and package manager. Turborepo excels in large-scale project organization, whereas Bun offers faster execution and a more streamlined development experience. The code examples highlight their different use cases: Turborepo for build pipeline configuration and Bun for script execution.

23,768

Unified developer tools for JavaScript, TypeScript, and the web

Pros of Rome

  • Comprehensive toolchain with linting, formatting, and bundling capabilities
  • Strong focus on developer experience and ease of use
  • Active community and regular updates

Cons of Rome

  • Slower performance compared to Bun
  • Less mature and stable than Bun
  • More limited ecosystem and third-party integrations

Code Comparison

Rome configuration:

{
  "linter": {
    "enabled": true,
    "rules": {
      "recommended": true
    }
  },
  "formatter": {
    "enabled": true,
    "indentStyle": "space",
    "indentSize": 2
  }
}

Bun configuration:

export default {
  entrypoints: ['./index.ts'],
  outdir: './dist',
  target: 'browser',
  minify: true
};

Rome focuses on providing an all-in-one toolchain with built-in linting and formatting capabilities, while Bun emphasizes speed and performance as a JavaScript runtime and bundler. Rome's configuration is more declarative, while Bun's is more programmatic. Both projects aim to improve the JavaScript development experience, but they take different approaches to achieve this goal.

30,914

Rust-based platform for the Web

Pros of swc

  • Focused solely on JavaScript/TypeScript compilation and bundling
  • More mature project with a longer development history
  • Extensive plugin ecosystem for customization

Cons of swc

  • Limited to JavaScript/TypeScript ecosystem
  • Requires separate runtime for execution
  • Less integrated development experience

Code Comparison

swc:

const swc = require('@swc/core');

const output = swc.transformSync('const x = 1;', {
  jsc: {
    parser: {
      syntax: 'ecmascript'
    },
    target: 'es5'
  }
});

Bun:

const { transpile } = require('bun');

const output = transpile('const x = 1;', {
  loader: 'js',
  target: 'browser'
});

Both swc and Bun offer fast JavaScript/TypeScript compilation, but they serve different purposes. swc is a dedicated compiler and bundler, while Bun is a more comprehensive JavaScript runtime and toolkit. swc excels in its focused approach and extensive plugin system, making it highly customizable for specific compilation needs. However, Bun provides a more integrated experience, combining a runtime, package manager, and bundler in one tool. The choice between them depends on whether you need a specialized compiler or a full-featured JavaScript runtime environment.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Logo

Bun

stars Bun speed

Documentation   â€¢   Discord   â€¢   Issues   â€¢   Roadmap

Read the docs →

What is Bun?

Bun is an all-in-one toolkit for JavaScript and TypeScript apps. It ships as a single executable called bun.

At its core is the Bun runtime, a fast JavaScript runtime designed as a drop-in replacement for Node.js. It's written in Zig and powered by JavaScriptCore under the hood, dramatically reducing startup times and memory usage.

bun run index.tsx             # TS and JSX supported out-of-the-box

The bun command-line tool also implements a test runner, script runner, and Node.js-compatible package manager. Instead of 1,000 node_modules for development, you only need bun. Bun's built-in tools are significantly faster than existing options and usable in existing Node.js projects with little to no changes.

bun test                      # run tests
bun run start                 # run the `start` script in `package.json`
bun install <pkg>             # install a package
bunx cowsay 'Hello, world!'   # execute a package

Install

Bun supports Linux (x64 & arm64), macOS (x64 & Apple Silicon) and Windows (x64).

Linux users — Kernel version 5.6 or higher is strongly recommended, but the minimum is 5.1.

# with install script (recommended)
curl -fsSL https://bun.sh/install | bash

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

# with npm
npm install -g bun

# with Homebrew
brew tap oven-sh/bun
brew install bun

# with Docker
docker pull oven/bun
docker run --rm --init --ulimit memlock=-1:-1 oven/bun

Upgrade

To upgrade to the latest version of Bun, run:

bun upgrade

Bun automatically releases a canary build on every commit to main. To upgrade to the latest canary build, run:

bun upgrade --canary

View canary build

Quick links

Guides

Contributing

Refer to the Project > Contributing guide to start contributing to Bun.

License

Refer to the Project > License page for information about Bun's licensing.

NPM DownloadsLast 30 Days