Bun vs Node vs Deno: Complete Comparison and Migration Guide 2026

// Traditional Node.js server
const http = require('http');
const fs = require('fs');
const path = require('path');

const server = http.createServer((req, res) => {
    const filePath = path.join(__dirname, 'public', req.url === '/' ? 'index.html' : req.url);
    
    fs.readFile(filePath, (err, data) => {
        if (err) {
            res.writeHead(404);
            res.end('Not Found');
            return;
        }
        
        res.writeHead(200, { 'Content-Type': 'text/html' });
        res.end(data);
    });
});

server.listen(3000, () => {
    console.log('Server running on port 3000');
});

// Node.js with ES Modules (package.json: "type": "module")
import http from 'http';
import fs from 'fs/promises';
import path from 'path';
import { fileURLToPath } from 'url';

const __dirname = path.dirname(fileURLToPath(import.meta.url));

const server = http.createServer(async (req, res) => {
    try {
        const filePath = path.join(__dirname, 'public', req.url === '/' ? 'index.html' : req.url);
        const data = await fs.readFile(filePath);
        
        res.writeHead(200, { 'Content-Type': 'text/html' });
        res.end(data);
    } catch (err) {
        res.writeHead(404);
        res.end('Not Found');
    }
});

server.listen(3000, () => {
    console.log('Server running on port 3000');
});

// Modern Deno server
import { serve } from "https://deno.land/[email protected]/http/server.ts";

const handler = async (req: Request): Promise<Response> => {
    const url = new URL(req.url);
    
    if (url.pathname === "/") {
        return new Response("Hello from Deno!", {
            headers: { "content-type": "text/plain" },
        });
    }
    
    return new Response("Not Found", { status: 404 });
};

serve(handler);

// 1. Secure by default - must explicitly grant permissions
// deno run --allow-read --allow-net server.ts

// 2. Built-in TypeScript support (no compilation needed)
interface User {
    id: number;
    name: string;
    email: string;
}

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

// 3. Top-level await
const data = await fetch("https://api.example.com/data");
const json = await data.json();

// 4. URL-based imports (no node_modules)
import { serve } from "https://deno.land/std/http/server.ts";
import _ from "https://cdn.skypack.dev/lodash";

// 5. Built-in testing
Deno.test("example test", () => {
    assertEquals(2 + 2, 4);
});

// 6. Built-in formatter and linter
// deno fmt
// deno lint

// Deno Deploy - Edge serverless
import { serve } from "https://deno.land/[email protected]/http/server.ts";

interface Env {
    DB: Deno.Kv;
}

export default {
    async fetch(request: Request, env: Env): Promise<Response> {
        const kv = env.DB;
        
        // Read from KV store
        const key = ["users", "count"];
        const result = await kv.get(key);
        
        const count = (result.value as number) || 0;
        
        return new Response(JSON.stringify({ count }), {
            headers: { "Content-Type": "application/json" },
        });
    },
};

// Bun server - incredibly simple
const server = Bun.serve({
    port: 3000,
    fetch(request) {
        return new Response("Hello from Bun!", {
            headers: { "Content-Type": "text/plain" },
        });
    },
});

console.log(`Server running on port ${server.port}`);

# Benchmark: Hello World HTTP server
# (Higher is better - requests per second)

# Bun:      ~180,000 req/s
# Node:     ~50,000 req/s  
# Deno:     ~45,000 req/s

# Benchmark: Reading file
# Bun:      ~2.5x faster than Node
# Deno:     ~1.2x faster than Node

# Benchmark: JSON parsing
# Bun:      ~3x faster than Node
# Deno:     ~1.5x faster than Node

# Bun startup time: ~5ms vs Node ~50ms

// 1. All-in-one (runtime, package manager, bundler, test runner)
# Instead of:
npm install
npm run build
npm test
node server.js

# With Bun:
bun install
bun run build
bun test
bun run server.ts

// 2. Native TypeScript support
const greet = (name: string): string => {
    return `Hello, ${name}!`;
};

// 3. Bun.file() - Optimized file operations
const file = Bun.file("data.json");
const data = await file.json();

// 4. Bun.sqlite() - Built-in SQLite
const db = new Bun.Database("app.db");
db.exec(`
    CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)
`);
db.exec("INSERT INTO users (name) VALUES ($1)", ["John"]);

// 5. Bun.which() - Find executables
const path = Bun.which("node");

// 6. Automatic .env loading
// Just use process.env.VAR_NAME - no setup needed

// 7. Web-standard APIs (fetch, Request, Response)
const response = await fetch("https://api.example.com");
const data = await response.json();

// Using Elysia (Bun's fastest web framework)
import { Elysia, t } from "elysia";

const app = new Elysia()
    .get("/", () => "Hello World")
    .get("/users/:id", ({ params }) => {
        return { id: params.id, name: "John" };
    })
    .post("/users", ({ body }) => {
        // Type-safe body validation
        return { success: true, user: body };
    }, {
        body: t.Object({
            name: t.String(),
            email: t.String({ format: "email" }),
        })
    })
    .listen(3000);

console.log(`Server running at http://localhost:${app.server?.port}`);

# Framework Benchmarks (Fastify, Express, Elysia)
# Operations per second (higher is better)

# JSON Serialization
Bun:      1,200,000 ops/s
Deno:     450,000 ops/s
Node:     380,000 ops/s

# HTTP Routing
Bun:      850,000 ops/s
Deno:     180,000 ops/s
Node:     125,000 ops/s

# File I/O
Bun:      2,800 MB/s read
Deno:     1,400 MB/s read
Node:     1,100 MB/s read

# Startup Time (hello world)
Bun:      6ms
Deno:     45ms
Node:     55ms

// Node.js - CommonJS (default)
const fs = require('fs');
const { readFile } = require('fs/promises');

// Node.js - ES Modules (with "type": "module")
import fs from 'fs';
import { readFile } from 'fs/promises';

// Deno - ES Modules (URL imports)
import fs from "https://deno.land/std/fs/mod.ts";
import { serve } from "https://deno.land/std/http/server.ts";

// Bun - ES Modules (like Node + URL imports)
import fs from "fs";
import { serve from "https://deno.land/std/http/server.ts"; // Also works

# Node.js - npm
npm init -y
npm install express lodash
npm install -D typescript @types/node

# Deno - No installation needed
# Just import from URL!
import express from "https://deno.land/x/express/mod.ts";

# Or use deno.land/x (Deno's package registry)
import { serve } from "https://deno.land/[email protected]/http/server.ts";

# Bun - bun CLI
bun init
bun add express lodash
bun add -d typescript

// Node.js - Full system access by default
// npm install can run arbitrary scripts
// require() can load any file

// Deno - Secure by default
// Must explicitly grant permissions:
deno run --allow-read --allow-net server.ts
deno run --allow-env server.ts
deno run --allow-all server.ts (not recommended)

// Security manifest (deno.json)
{
    "tasks": {
        "server": "deno run --allow-net server.ts"
    },
    "permissions": {
        "net": ["api.example.com"],
        "env": ["DATABASE_URL"]
    }
}

// Bun - Similar to Node, less strict
// Bun.unsafe - bypasses some checks

// Step 1: Update imports
// Before (Node)
import fs from 'fs';
import path from 'path';
import express from 'express';

// After (Deno)
import fs from "https://deno.land/std/fs/mod.ts";
import path from "https://deno.land/std/path/mod.ts";
import express from "https://deno.land/x/express/mod.ts";

// Step 2: Handle environment variables
// Before (Node)
const port = process.env.PORT || 3000;

// After (Deno)
const port = Deno.env.get("PORT") || 3000;

// Step 3: Update file system
// Before (Node)
fs.readFileSync('file.txt', 'utf8');
fs.readFile('file.txt', 'utf8', callback);

// After (Deno)
await Deno.readTextFile('file.txt');
// Or use std/fs
import { readTextFile } from "https://deno.land/std/fs/mod.ts";
await readTextFile('file.txt');

// Step 4: Add Deno-compatible types
/// <reference types="https://deno.land/std/node/types.d.ts" />

// Step 1: Just run TypeScript!
// Before: npm install typescript, ts-node
// After: bun run server.ts

// Step 2: Replace npm with bun
// npm install lodash -> bun add lodash
// npm install -D typescript -> bun add -d typescript

// Step 3: Update shebang
#!/usr/bin/env node
#!/usr/bin/env bun

// Step 4: Use Bun APIs
// Before
const data = require('./data.json');

// After (more efficient)
const file = Bun.file('./data.json');
const data = await file.json();

// Step 5: Use Bun.spawn
// Before
const { execSync } = require('child_process');
const output = execSync('ls -la');

// After
const output = await Bun.spawn(['ls', '-la']).text();

// package.json - Deno compatibility
{
    "name": "my-app",
    "type": "module",
    "deno": {
        "imports": {
            "express": "https://deno.land/x/express/mod.ts"
        }
    }
}

# Run with different runtimes
# Node
node server.js

# Bun  
bun run server.ts

# Deno
deno run --allow-net server.ts

# All in one script
// Use conditional imports
const isDeno = typeof Deno !== 'undefined';
const isBun = typeof Bun !== 'undefined';

const fs = isDeno 
    ? await import("https://deno.land/std/fs/mod.ts")
    : require('fs');

// ✅ Enterprise applications requiring stability
// ✅ Teams with existing Node.js experience
// ✅ Maximum ecosystem compatibility needed
// ✅ Long-term projects requiring maintainability
// ✅ When you need specific npm packages only available for Node

const express = require('express'); // Only works in Node
const next = require('next');        // Only works in Node

// ✅ Security-sensitive applications
// ✅ Edge computing (Deno Deploy)
// ✅ TypeScript-first projects
// ✅ When you want built-in formatting/linting
// ✅ Modern JavaScript/TypeScript without build tools

// Security-first web service
Deno.serve(async (req) => {
    // Sandboxed by default
    const data = await req.json();
    return new Response(JSON.stringify(data));
});

// ✅ Performance-critical applications
// ✅ CLI tools and scripts
// ✅ Small to medium projects
// ✅ When you want fastest development experience
// ✅ Simple APIs and services

// Fast API server
const app = new Elysia()
    .get('/api/users', () => db.query('SELECT * FROM users'))
    .listen(3000);