Getting Started with Bun 1.2: A Comprehensive Tutorial

Bun 1.2 is the latest version of the ultra-fast JavaScript runtime that is compatible with Node.js. It offers significant improvements, including built-in Postgres and S3 support, enhanced performance, and a human-readable lockfile. This tutorial will guide you through installing Bun, understanding its new features, and leveraging its capabilities to build high-performance applications.

1. Installing Bun 1.2

Before diving into the features, let's install Bun 1.2. You can install or upgrade using the following command:

curl -fsSL https://bun.sh/install | sh

Verify the installation by checking the version:

bun --version

2. Node.js Compatibility

One of Bun's standout features is its compatibility with Node.js. Bun runs the full Node.js test suite on every commit, ensuring compatibility. Over 90% of Node.js core modules work out of the box. This means you can use Bun as a drop-in replacement for Node.js in most cases.

Key highlights:

• Full Node.js core module compatibility (90%+ pass rate)
• Built-in support for Node.js APIs like node:http2 and node:dgram
• Worker_threads improvements for better concurrency

3. Built-in Postgres Support

Bun comes with a built-in PostgreSQL driver, eliminating the need for external libraries like pg or postgres. Here's how you can use it:

const db = new Bun.sql('postgres://user:password@localhost/database');

const result = await db.query('SELECT NOW()');
console.log(result.rows[0]);

Key features:

• No external drivers required
• Lightning-fast performance
• Simple and clean API

4. Built-in S3 Support

Bun also includes a built-in Amazon S3 client. You can use it to interact with S3 buckets directly:

const s3 = new Bun.s3({
  region: 'us-east-1',
  credentials: {
    accessKeyId: 'YOUR_ACCESS_KEY',
    secretAccessKey: 'YOUR_SECRET_KEY'
  }
});

const result = await s3.putObject({
  bucket: 'my-bucket',
  key: 'file.txt',
  body: 'Hello, World!'
});

Key features:

• No external dependencies like aws-sdk
• Simple, built-in API
• Optimized for performance

5. Human-Readable Lockfile

Bun introduces a new lockfile format called bun.lock, which is both human-readable and more efficient than JSON:

package a @ 1.0.0
  dependencies:
    package b @ 1.0.0
package b @ 1.0.0

Key benefits:

• Easy to read and understand
• Faster diffs and merges
• More efficient than JSON lockfiles

6. 3× Faster Express Performance

Bun significantly outperforms Node.js in HTTP/1.1 and HTTP/2 benchmarks. Here's a simple example of an Express-like server using Bun:

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

new Server({
  port: 3000,
  async fetch(request) {
    return new Response('Hello, World!');
  }
}).listen();

Key highlights:

• 3× faster than Node.js 22
• Built-in support for HTTP/1.1 and HTTP/2
• Optimized for real-world workloads

7. Advanced Features

Bun 1.2 includes several advanced features:

HTTP/2 Server

const { Server } = require('http2');

const server = Server.create();

server.on('request', () => {
  server.response.send('Hello, World!');
});

server.listen(3000);

UDP Support

const { dgram } = require('dgram');

const socket = dgram.createSocket('udp4');

socket.on('message', (message, remoteInfo) => {
  console.log(`Received message: ${message}`);
});

socket.bind(41234);

Worker Threads

Bun includes improved worker thread support for better concurrency:

const { Worker } = require('worker_threads');

const worker = new Worker('worker.js');

worker.on('message', (message) => {
  console.log(`Received message: ${message}`);
});

8. Conclusion

Bun 1.2 is a powerful and fast JavaScript runtime that offers a compelling alternative to Node.js. With its built-in Postgres and S3 support, human-readable lockfile, and superior performance, Bun is an excellent choice for building modern applications.

Start exploring Bun today and take advantage of its cutting-edge features to build faster and more efficient applications!