A fast all-in-one toolkit that augments Node.js instead of replacing it

A Bun-like DX on top of stock node, written in Rust.

nub index.ts             # TypeScript-first Node.js runtime
nub run dev              # 24× faster pnpm run
nubx prisma generate     # 19× faster npx
nub install              # 2.5× faster pnpm install
nub watch src/server.ts  # native watch mode
nub pm shim              # built-in Corepack-style shims
nub node install 26      # Node version manager
nub upgrade              # self update

One tool to run your files and scripts, install dependencies, and manage Node itself. No new runtime, no vendor-specific API surface, no lock-in.

# macOS / Linux
curl -fsSL https://nubjs.com/install.sh | bash

# Windows (PowerShell)
irm https://nubjs.com/install.ps1 | iex

# Homebrew (macOS / Linux)
brew install nubjs/tap/nub

# Nix (flakes)
nix run github:nubjs/nub

# Or via npm (pnpm / yarn global add work too)
npm install -g --ignore-scripts=false @nubjs/nub

For GitHub Actions, use nubjs/setup-nub in place of actions/setup-node. It's one-to-one compatible.

- - uses: actions/setup-node@v4
+ - uses: nubjs/setup-nub@v0

Run a file. Supports .js, .ts, .mjs, .cjs, .mts, .cts, .jsx, and .tsx. Flag-for-flag and var-for-var drop-in compatible with node (mostly via passthrough).

nub index.ts             # TypeScript, JSX, no build step
nub --watch app.ts       # same path, restart-on-change

It augments stock Node with some of Bun/Deno's best features:

• 🦆 Full TypeScript support, including enum, namespace
• 🧭 TypeScript-friendly resolution: extensionless imports, tsconfig.json#paths
• ⚛️ JSX / TSX
• 🎂 Decorators and emitDecoratorMetadata
• 🆕 Modern syntax like using (downleveled in transpiler when needed)
• 🔐 Automatic .env* loading — Next.js/Vite parity
• 🗂️ Built-in loaders for common data formats — .yaml, .toml, .jsonc, .json5, .txt
• 🌐 Polyfills for Temporal, Worker, URLPattern (when needed)
• 🔥 Unflags experimental features like node:sqlite, vm.Module, localStorage, WebSocket, EventSource
• ⚡ 2.9× faster startup than tsx

How it works — Nub takes advantage of Node extension surfaces that mostly didn't exist when Deno and Bun were built:

• --import/--require preloads
• module.registerHooks() for transpilation and resolution
• N-API native addons: Nub embeds oxc for pre-transpilation

When you run a file with nub, it infers the version of Node your project expects and auto-installs it if needed. It respects (in precedence order):

• NODE_EXECUTABLE (override)
• package.json#devEngines
• .node-version
• .nvmrc
• package.json#engines

This resolved version of Node is installed and your file is executed with it (with Nub's augmentations).

$ echo 26 > .node-version
$ nub hello.ts
Using Node.js 26.3.0 (resolved from .node-version)
Installed in 9.8s
Hello world!

Modern API work out of the box under Nub. Node.js experimental APIs are unflagged, others are auto-polyfilled (e.g. Temporal on Node 25 and earlier), and others are downleveled in the transpiler (using).

Restart-on-change driven by the resolved dependency graph plus the off-graph files that still invalidate a run — no glob list to maintain:

nub watch src/server.ts
nub --watch src/server.ts   # same path

• 👀 Tracks the resolved dependency graph automatically
• 🧷 Also watches the off-graph invalidators — .env*, the tsconfig.json extends chain, package.json
• ⚙️ Runs on Node's own --watch engine, preserving output by default

View the full runtime docs 👉.

A drop-in for npm run and pnpm run. The runner is a Rust binary with no JavaScript startup of its own, so it dispatches a warm script roughly 24× faster than pnpm run:

nub run build
nub run -r --filter "@org/*" test     # supports --filter

It's fast compared to existing JavaScript-based script runners.

script dispatch · warm · 50 runs · macOS — view benchmark

• 🚀 Feels instantaneous — 14ms vs a detectable 300ms+ lag for npm/pnpm
• 🔁 Full lifecycle support — pre/post hooks and the complete npm_* environment
• 🧰 Local node_modules/.bin on PATH, with args forwarded without the -- separator
• 🗃️ The full pnpm workspace surface — -r, --filter, --parallel, --workspace-concurrency, --resume-from, --stream
• 🎯 pnpm's --filter grammar verbatim — graph (...@org/web) and changed-since ([main]) selectors

View the full script runner docs 👉.

A drop-in for npx and pnpm dlx. Local-first with a download-and-execute registry fallback (same as npx). Eliminating the double-Node.js-spawn performance penalty paid by JavaScript-based tools like npx and pnpm.

nubx eslint . --fix
nubx -y cowsay@1.5.0 "hi"   # fetched from the registry (auto-approved via -y)

esbuild --version · macOS — view benchmark

• ⚡ Runs a local bin ~19× faster than npx, with no Node in the wrapper
• 🔎 Resolves node_modules/.bin regardless of which package manager installed it
• 🌐 Registry fallback for uninstalled bins — fetched, run, then discarded
• 🧩 Full pnpm exec / pnpm dlx flag parity, shell mode included
• 🪜 Walks the resolution chain — member .bin, then workspace root, then ancestors

View the full package runner docs 👉.

Nub is a package manager powered by the Aube engine. The CLI is flag-for-flag compatible with pnpm for muscle memory, but

nub install                    
nub ci
nub add -E -D --save-catalog react
nub remove lodash
nub update
nub dedupe

It's fast — avoids the per-command Node.js bootstrap lag incurred by JS-based package managers.

warm frozen install · create-t3-app · 222 deps · macOS — view benchmark

• 🛡️ Blocks postinstall by default
• 🦠 Checks osv.dev for known-malicious package versions during resolution by default
• 🔻 Refuses provenance downgrades by default
• ⏳ 24-hour minimumReleaseAge by default

When you run nub install inside a project, it detects the incumbent package manager (based on your package.json#packageManager or any detected lockfiles). It then runs in compat-mode, respecting the config files and environment variables for that package manager.

Under each incumbent, Nub reads that tool's branded config and no other's; the neutral .npmrc cascade and npm_config_* are read under every one.

View the full package manager docs 👉.

Corepack's job, in native Rust: provision and run the exact pnpm / npm / yarn your project pins:

nub pm shim              # registers global shims (Corepack-style)

Like corepack enable, this registers global shims for npm, yarn, and pnpm. When you run a command using one of these shim aliases anywhere on your file system, the shim will:

• Detect the version used in your project
• Install that version if needed
• Run the command using the proper version

Nub provides this functionality as a convenience for users who prefer to keep their current package manager. Corepack itself was unbundled from Node itself in v25.

View the full nub pm docs 👉.

Though Node.js versions will generally be auto-installed and cached as needed, you can manage versions manually as well.

$ nub node -h 
nub node — manage Node versions

Usage: nub node <command>

Commands:
  which                    print the resolved Node binary path (why → stderr)
  install [<version>...]   provision version(s) into nub's cache
  ls                       list versions in nub's cache
  uninstall <version>      remove a version from nub's cache
  pin <version>            write the project's Node pin

View the full nub node docs 👉.

MIT

⭐️ If you read this far, consider starring the repo :) ⭐️