Ryan Dahl created Node.js, regretted a bunch of decisions he made in it, gave a famous talk about those regrets at JSConf 2018, and then built Deno. Seven years later, Deno 2.0 is production-ready with full npm compatibility, a built-in standard library, and a more coherent security model than Node has ever had. The question is whether that’s enough to break the gravity of the Node ecosystem.

What Deno 2.0 Actually Fixes

Let’s be concrete about what Dahl’s regrets were and whether Deno 2.0 addresses them.

The node_modules Problem

Node’s node_modules is notoriously bad: enormous directories, symlink issues, version conflicts, and the inability to know what’s actually running without tracing the resolution algorithm. Deno’s original answer was “just use URLs, no package manager needed.”

That turned out to be too radical. Deno 2.0 takes a pragmatic approach:

// deno.json
{
  "imports": {
    "express": "npm:express@4",
    "lodash": "npm:lodash@4",
    "@std/path": "jsr:@std/path@1"
  }
}

// This just works now
import express from "express";
import { join } from "@std/path";
import { pick } from "lodash";

const app = express();
app.get("/", (req, res) => res.send("Hello from Deno!"));
app.listen(3000);

npm packages run without modification in most cases. The resolver downloads to a global cache (~/.deno/npm) instead of project-local node_modules. It’s not perfect — packages that rely on native Node addons or deep __dirname hacks can break — but 95%+ of the ecosystem works.

Photo by Gabriel Heinzer on Unsplash

Security by Default

Node runs with whatever permissions the OS grants. Deno requires explicit permission grants:

# Explicit permissions
deno run --allow-net=api.example.com --allow-read=/tmp --allow-env=DATABASE_URL server.ts

# Or in deno.json for development

{
  "tasks": {
    "dev": "deno run --allow-net --allow-read --allow-env --watch main.ts",
    "prod": "deno run --allow-net=:443 --allow-read=/app/data --allow-env=DATABASE_URL,PORT main.ts"
  }
}

This is more friction in development, but it’s genuinely useful in production. You can look at the permissions a Deno process requests and know exactly what it can touch — something Node has never offered.

TypeScript Without Toolchain Hell

This is perhaps Deno’s biggest win for developer experience:

// This runs directly. No tsconfig. No tsc. No ts-node. No esbuild config.
// deno run types.ts

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

async function fetchUser(id: number): Promise<User> {
  const response = await fetch(`https://api.example.com/users/${id}`);
  if (!response.ok) throw new Error(`HTTP ${response.status}`);
  return response.json() as Promise<User>;
}

const user = await fetchUser(1);
console.log(user.name);

No configuration needed. TypeScript is a first-class citizen, not a compile step you glue on.

JSR: The npm Alternative

Deno 2.0 ships with first-class support for JSR (JavaScript Registry), the npm alternative designed for the modern JavaScript ecosystem:

# Publish to JSR
deno publish

# Install from JSR
import { parseArgs } from "jsr:@std/cli@1";
import { encodeBase64 } from "jsr:@std/encoding@1/base64";

JSR packages are TypeScript-native (no DefinitelyTyped gymnastics), versioned with SemVer, and compatible with both Deno and Node (JSR generates compatible node_modules on install). It’s early, but the Deno standard library, a growing set of popular packages, and frameworks like Fresh have moved to JSR.

Fresh 2.0: Deno’s Answer to Next.js

Fresh is Deno’s full-stack web framework, and version 2.0 is meaningfully better than 1.x.

// routes/blog/[slug].tsx — Fresh 2.0 route with server components
import { define } from "$fresh/server.ts";
import { getPost } from "../../lib/blog.ts";

export const handler = define.handlers({
  async GET(ctx) {
    const post = await getPost(ctx.params.slug);
    if (!post) return ctx.renderNotFound();
    return ctx.render({ post });
  }
});

export default define.page<typeof handler>(function BlogPost({ data }) {
  const { post } = data;
  return (
    <article>
      <h1>{post.title}</h1>
      <time>{post.date}</time>
      <div dangerouslySetInnerHTML= />
    </article>
  );
});

Fresh’s island architecture (only ship JS for interactive components) is elegant:

// islands/Counter.tsx — only this component ships JavaScript to the browser
import { useSignal } from "@preact/signals";

export default function Counter() {
  const count = useSignal(0);
  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={() => count.value++}>+</button>
      <button onClick={() => count.value--}>-</button>
    </div>
  );
}

Everything outside islands/ is server-rendered with zero client JS. This makes Fresh apps fast by default — you have to opt into client JavaScript, not opt out.

Deno Deploy: Edge-First Runtime

Deno’s cloud offering, Deno Deploy, runs your code on V8 isolates at the edge (currently 35+ regions). It’s comparable to Cloudflare Workers but with a better local development story:

// Same code runs locally and on Deno Deploy
Deno.serve({ port: 8000 }, async (req) => {
  const url = new URL(req.url);
  
  if (url.pathname === "/api/time") {
    return Response.json({
      time: new Date().toISOString(),
      region: Deno.env.get("DENO_REGION") ?? "local"
    });
  }
  
  return new Response("Not found", { status: 404 });
});

# Local dev
deno run --allow-net server.ts

# Deploy
deployctl deploy server.ts

No adapter code, no platform-specific APIs. The Web Standard APIs (Request, Response, fetch, Blob) work identically locally and in production.

The Honest Comparison with Node in 2026

Node isn’t going away. The npm ecosystem is too large, and Bun (another Node-compatible runtime) is fighting for the same mindshare. But Deno 2.0 is a genuinely compelling choice for new projects — especially teams that want TypeScript-first development without the toolchain complexity.

Getting Started

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

# Create a new project
deno init my-project
cd my-project

# Run with all the batteries
deno task dev

The tooling is integrated: deno fmt formats your code, deno lint lints it, deno test runs tests with code coverage, deno bench benchmarks. No Prettier config, no ESLint config, no Vitest setup.

For new projects where you have the choice, Deno 2.0 is worth a serious look.

References: Deno 2.0 Announcement, JSR Documentation, Fresh 2.0 Guide

이 글이 도움이 되셨다면 공감 및 광고 클릭을 부탁드립니다 :)