Bun 2.0 vs Deno 2.0: Complete Comparison for JavaScript runtimes in 2026

# macOS/Linux
curl -fsSL https://bun.sh/install | bash

# Windows (PowerShell)
irm bun.sh | iex

# Using npm
npm install -g bun

# Using Docker
docker pull oven/bun

# macOS/Linux
curl -fsSL https://deno.land/install.sh | sh

# Windows (PowerShell)
irm https://deno.land/install.ps1 | iex

# Using Scoop
scoop install deno

# Using Docker
docker pull denoland/deno

// Both runtimes can execute this directly

interface User {
  id: number
  name: string
  email: string
}

function greetUser(user: User): string {
  return `Hello, ${user.name}!`
}

const user: User = {
  id: 1,
  name: "John",
  email: "[email protected]"
}

console.log(greetUser(user))

# Bun
bun run server.ts

# Deno
deno run server.ts

# Bun
bunx tsc --noEmit

# Deno (built-in)
deno check server.ts

# Install dependencies
bun install

# Add package
bun add express

# Add dev dependency
bun add -d typescript

# Remove package
bun remove express

# Run scripts
bun run dev

// package.json works as-is
{
  "name": "my-app",
  "scripts": {
    "dev": "bun run index.ts",
    "build": "bun build"
  },
  "dependencies": {
    "express": "^4.18.0"
  }
}

// Import from URL
import express from "https://esm.sh/[email protected]"

const app = express()

app.get("/", (req, res) => {
  res.send("Hello!")
})

app.listen(3000)

// deno.json
{
  "imports": {
    "express": "https://esm.sh/[email protected]",
    "lodash": "https://esm.sh/[email protected]"
  }
}

// Now use like npm
import express from "express"
import _ from "lodash"

const server = Bun.serve({
  port: 3000,
  fetch(request) {
    return new Response("Hello, World!")
  }
})

console.log(`Server running at ${server.url}`)

Deno.serve(async (request) => {
  return new Response("Hello, World!")
})

// Read file
const content = await Bun.file("data.txt").text()

// Write file
await Bun.write("output.txt", "Hello!")

// Read directory
const files = await Bun.readdir("./src")

// Read file
const content = await Deno.readTextFile("data.txt")

// Write file
await Deno.writeTextFile("output.txt", "Hello!")

// Read directory
const files = await Deno.readDir("./src")

// Access env vars
const port = Bun.env.PORT || 3000

// .env file automatically loaded

// Access env vars
const port = Deno.env.get("PORT") || 3000

// Or use dotenv
import "https://deno.land/x/dotenv/mod.ts"

import { test, expect, describe } from "bun:test"

describe("math", () => {
  test("add", () => {
    expect(1 + 1).toBe(2)
  })
  
  test("multiply", () => {
    expect(3 * 4).toBe(12)
  })
})

bun test

import { assertEquals } from "https://deno.land/[email protected]/testing/asserts.ts"

Deno.test("math add", () => {
  assertEquals(1 + 1, 2)
})

Deno.test("math multiply", () => {
  assertEquals(3 * 4, 12)
})

deno test

# Bundle for production
bun build ./src/index.ts --outdir=./dist --target=bun

# Bundle for browser
bun build ./src/index.ts --outdir=./dist --target=browser

# Bundle for node
bun build ./src/index.ts --outdir=./dist --target=node

# Using deno_bundle
deno bundle https://deno.land/[email protected]/examples/chat/server.ts

import * as esbuild from "https://deno.land/x/[email protected]/mod.ts"

await esbuild.build({
  entryPoints: ["./src/index.ts"],
  bundle: true,
  outfile: "./dist/bundle.js"
})

# Explicitly grant permissions
deno run --allow-read --allow-net server.ts

# Granular permissions
deno run \
  --allow-read=. \
  --allow-net=localhost:3000 \
  --allow-env \
  server.ts

# Grant permissions
bun run --allow-read server.ts
bun run --allow-net server.ts

# Deny specific
bun run --deny-write server.ts

import { Client } from "pg"

const client = new Client({
  connectionString: process.env.DATABASE_URL
})

await client.connect()
const result = await client.query("SELECT * FROM users")
console.log(result.rows)

import { Client } from "https://deno.land/x/pg/mod.ts"

const client = new Client({
  connectionString: Deno.env.get("DATABASE_URL")
})

await client.connect()
const result = await client.queryObject("SELECT * FROM users")
console.log(result.rows)

# Dockerfile
FROM oven/bun:1
WORKDIR /app
COPY . .
RUN bun install --production
CMD ["bun", "run", "start.ts"]

# Dockerfile
FROM denoland/deno:1.38
WORKDIR /app
COPY . .
RUN deno cache server.ts
CMD ["deno", "run", "--allow-net", "server.ts"]