1. History

Deno was announced on JSConf EU 2018 by Ryan Dahl in his talk "10 Things I Regret About Node.js".^[1] In his talk, Dahl mentioned his regrets about the initial design decisions with Node.js, focusing on his choices of not using promises in API design, usage of the legacy build system GYP, node_modules and package.json, leaving out file extensions, magical module resolution with index.js and breaking the sandboxed environment of V8.^[2] He eventually presented the prototype of Deno, aiming to achieve system call bindings through message passing with serialization tools such as Protocol Buffers, and to provide command line flags for access control.

Deno was initially written in Go and used Protocol Buffers for serialization between privileged (Go, with system call access) and unprivileged (V8) sides.^[3] However, Go was soon replaced with Rust due to concerns of double runtime and garbage collection pressure.^[4] Tokio was introduced in place of libuv as the asynchronous event-driven platform,^[5] and FlatBuffers was adopted for faster, "zero-copy" serialization and deserialization^[6] but later in August 2019, FlatBuffers was removed^[7] after publishing benchmarks that measured a significant overhead of serialization in April 2019.^[8]

A standard library, modeled after Go's standard library, was created in November 2018 to provide extensive tools and utilities, partially solving Node.js' dependency tree explosion problem.^[9]

The official Deno 1.0 was released on May 13, 2020.^[10]

On March 29, 2021, Deno Land Inc was announced, with backing in millions of dollars from Shasta Ventures, Mozilla Corporation and a few others. It was established to further the development of Deno and provide a commercial offering to users.^[11] A year on, Deno announced a further $21 million in Series A funding led by Sequoia Capital.^[12]

Deno Deploy, inspired by Cloudflare Workers,^[13] was released on June 23, 2021.^[14]

2. Overview

Deno aims to be a productive and secure scripting environment for the modern programmer.^[15] Similar to Node.js, Deno emphasizes event-driven architecture, providing a set of non-blocking core I/O utilities, along with their blocking versions. Deno could be used to create web servers, perform scientific computations, etc. Deno is open source software under the MIT License.^[16]

2.1. Comparison with Node.js

Deno and Node.js are both runtimes built on Google's V8 JavaScript engine, the same engine used in Google Chrome. They both have internal event loops and provide command-line interfaces for running scripts and a wide range of system utilities.

Deno mainly deviates from Node.js in the following aspects:^[15]

1. Supports only ES Modules like browsers where Node.js supports both ES Modules and CommonJS. CommonJS support in Deno is possible using a compatibility layer.^[17][18][19]
2. Supports only URLs for loading local or remote dependencies, similar to browsers. Node.js supports both URLs ^[20] and modules.
3. Does not require a package manager for resource fetching, thus no need for a registry like npm.^[21]
4. Supports TypeScript out of the box,^[22] using a snapshotted TypeScript compiler or the swc compiler ^[23] with caching mechanisms.
5. Aims for better compatibility with browsers with a wide range of Web APIs.
6. Restricts file system and network access by default in order to run sandboxed code.
7. Supports a single API to utilize promises, ES6 and TypeScript features whereas Node.js supports both promise and callback APIs.
8. Minimizes core API size, while providing a large standard library with no external dependencies.
9. Uses message passing channels for invoking privileged system APIs and using bindings.

3. Releases

The table above was created using the official Releases page.^[24]

4. Example

This runs a basic Deno script without any file system or network permissions (sandbox mode):

deno run main.ts

Explicit flags are required to enable permissions:

deno run --allow-read --allow-net main.ts

To inspect the dependency tree of the script, use the info subcommand:

deno info main.ts

A basic Hello, World! program in Deno looks just like it would in Node.js:

console.log("Hello, World!");

A global Deno namespace exposes APIs that are not available in the browser. A Unix cat program could be implemented as follows:

/* cat.ts */

/* Deno APIs are exposed through the `Deno` namespace. */ const { stdout, open, copy, args } = Deno;

// Top-level await is supported for (let i = 0; i < args.length; i++) {

 const filename = args[i]; // Obtains command-line arguments. const file = await open(filename); // Opens the corresponding file for reading. await copy(file, stdout); // Performs a zero-copy asynchronous copy from `file` to `stdout`. 

}

The Deno.copy function used above works much like Go's io.Copy, where stdout (standard output) is the destination Writer, and file is the source Reader. To run this program, we need to enable read permission to the filesystem:

deno run --allow-read cat.ts myfile

The following Deno script implements a basic HTTP server:

// Imports `serve` from the remote Deno standard library, using URL.

import { serve } from "https://deno.land/std@v0.21.0/http/server.ts";

// `serve` function returns an asynchronous iterator, yielding a stream of requests for await (const req of serve({ port: 8000 })) {

 req.respond({ body: "Hello, World!\n" }); 

}

When running this program, Deno will automatically download and cache the remote standard library files, and compile the code. Similarly, we can run a standard library script (such as a file server) directly without explicitly downloading, by providing the URL as the input filename (-A turns on all permissions):

$ deno run -A https://deno.land/std/http/file_server.ts Download https://deno.land/std/http/file_server.ts Compile https://deno.land/std/http/file_server.ts ... HTTP server listening on http://0.0.0.0:4500/