Deno 2.0: The Modern JavaScript Runtime — Node Compatibility, npm Support & New Features

Deno 2.0 is a major milestone that addresses the biggest barrier to adoption: Node.js compatibility. With native npm support, package.json compatibility, and a stabilised standard library, Deno is now a drop-in replacement for many Node.js projects.

🦕 Why Deno 2.0 Matters

• Backwards Compatible with Node — Run existing Node.js projects with zero or minimal changes
• Native npm Support — Use any npm package without a separate install step
• Built-in TypeScript — No tsconfig or transpilation needed
• Security First — Explicit permissions for file, network, and environment access
• Workspaces — Monorepo support built into the runtime

1. Node.js Compatibility

Deno 2.0 supports package.json, node_modules, and Node built-in modules. Most Express/Fastify apps work out of the box.

// This Express app works in Deno 2.0 unchanged!
import express from 'npm:express';

const app = express();

app.get('/', (req, res) => {
  res.json({ message: 'Hello from Deno 2.0!' });
});

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

// Run with: deno run -A server.ts
// No npm install, no tsconfig, no build step!

2. Native npm Package Support

Import any npm package with the npm: specifier — Deno downloads and caches it automatically.

// Use npm packages directly — no install needed
import chalk from 'npm:chalk@5';
import lodash from 'npm:lodash';
import { z } from 'npm:zod';

// Define a schema with Zod
const UserSchema = z.object({
  name: z.string().min(2),
  email: z.string().email(),
  age: z.number().int().positive(),
});

const user = UserSchema.parse({
  name: 'Mortex',
  email: 'info@mortex.com',
  age: 5,
});

console.log(chalk.green('✓ Valid user:'), lodash.pick(user, ['name', 'email']));

3. Permissions — Security by Default

Unlike Node.js, Deno requires explicit permissions for sensitive operations:

# Granular permissions
deno run --allow-net=api.example.com \
         --allow-read=./data \
         --allow-env=DATABASE_URL,API_KEY \
         server.ts

# In code — check permissions programmatically
const netPermission = await Deno.permissions.query({
  name: 'net',
  host: 'api.example.com'
});

if (netPermission.state === 'granted') {
  const resp = await fetch('https://api.example.com/data');
  console.log(await resp.json());
} else {
  console.log('Network access denied — running in offline mode');
}

4. Deno Standard Library (Stable)

Deno ships a high-quality standard library — no more hunting for basic utilities:

import { serve } from "jsr:@std/http";
import { join } from "jsr:@std/path";
import { parse } from "jsr:@std/csv";
import { encodeBase64 } from "jsr:@std/encoding/base64";
import { assertEquals } from "jsr:@std/assert";

// Built-in HTTP server
serve((req) => {
  const url = new URL(req.url);

  if (url.pathname === '/api/health') {
    return new Response(JSON.stringify({ status: 'ok' }), {
      headers: { 'content-type': 'application/json' },
    });
  }

  return new Response('Not Found', { status: 404 });
}, { port: 8000 });

// Built-in test runner
Deno.test('addition works', () => {
  assertEquals(2 + 2, 4);
});

// Run tests: deno test

5. Workspaces for Monorepos

// deno.json — workspace configuration
{
  "workspace": ["./packages/core", "./packages/api", "./packages/web"],
  "imports": {
    "@app/core": "./packages/core/mod.ts",
    "@app/api": "./packages/api/mod.ts"
  }
}

// packages/api/server.ts
import { createUser } from "@app/core";

Deno.serve(async (req) => {
  if (req.method === 'POST') {
    const body = await req.json();
    const user = createUser(body);
    return Response.json(user, { status: 201 });
  }
  return new Response('Method not allowed', { status: 405 });
});

Deno vs Node.js — Quick Comparison