The std/node part of the Deno standard library is a Node.js compatibility layer. Its primary focus is providing “polyfills” for Node.js’s . It also provides a mechanism for loading CommonJS modules into Deno.

The library is most useful when trying to use your own or private code that was written for Node.js. If you are trying to consume public npm packages, you are likely to get a better result using a CDN.

The standard library provides several “replacement” modules for Node.js built-in modules. These either replicate the functionality of the built-in or they call the Deno native APIs, returning an interface that is compatible with Node.js.

• (partly)
• assert/strict (partly)
• console (partly)
• crypto (partly)
• (partly)
• dns (partly)
• fs (partly)
• (partly)
• http (partly)
• net (partly)
• (partly)
• path
• (partly)
• querystring
• (partly)
• stream
• sys (partly)
• timers/promises
• (partly)
• url (partly)
• (partly)
• worker_threads

Following modules are not yet implemented:

• cluster
• dgram
• http2
• https
• repl
• tls
• zlib

If you try to run a Node code that requires any of the not implemented modules, please open an issue in with example code.

In addition, there is the std/node/global.ts module which provides some of the Node.js globals like global, process, and Buffer.

Loading CommonJS modules

Deno only supports natively loading ES Modules, but a lot of Node.js code is still written in the CommonJS format. As mentioned above, for public npm packages, it is often better to use a CDN to transpile CommonJS modules to ES Modules for consumption by Deno. Not only do you get reliable conversion plus all the dependency resolution and management without requiring a package manager to install the packages on your local machine, you get the advantages of being able to share your code easier without requiring other users to setup some of the Node.js infrastructure to consume your code with Node.js.

That being said, the built-in Node.js module "module" provides a function named createRequire() which allows you to create a Node.js compatible require() function which can be used to load CommonJS modules, as well as use the same resolution logic that Node.js uses when trying to load a module. createRequire() will also install the Node.js globals for you.

Example usage would look like this:

import { createRequire } from "https://deno.land/std@$STD_VERSION/node/module.ts";
// import.meta.url will be the location of "this" module (like `__filename` in
// Node.js), and then serve as the root for your "package", where the
// `package.json` is expected to be, and where the `node_modules` will be used
// for resolution of packages.
const require = createRequire(import.meta.url);
// Loads the built-in module Deno "replacement":
const path = require("path");
// Loads a CommonJS module (without specifying the extension):
const cjsModule = require("./my_mod");
// Uses Node.js resolution in `node_modules` to load the package/module. The
// package would need to be installed locally via a package management tool
// like npm: