Nub — The All-in-One
JavaScript Toolkit for Node.js

Introduction

The JavaScript toolkit landscape just got a major new player. Nub — an all-in-one Rust-powered toolkit created by Colin McDonnell (the creator of Zod and former Bun employee) — launched on June 15, 2026, and it takes a fundamentally different approach to the developer experience problem.

While Bun and Deno try to replace Node.js with from-scratch alternative runtimes, Nub does something smarter: it augments Node.js. It's a single Rust binary that transpiles TypeScript via the oxc native addon, runs scripts 24x faster than pnpm run, installs dependencies 2.5x faster, manages Node versions, and handles .env loading — all on top of the stock node binary you already have.

In this deep-dive, I'll walk through what Nub does, how it works under the hood, how it compares to existing tools like tsx, ts-node, and npx, and whether it's ready for your development workflow.

What Is Nub?

Nub is a single Rust CLI binary that combines six major developer experience tools into one command:

• File runner — nub index.ts: run TypeScript files with full tsconfig support, .env loading, JSX, and decorators
• Script runner — nub run dev: execute package.json scripts ~24x faster than pnpm run
• Bin runner — nubx prisma generate: run node_modules/.bin CLIs ~19x faster than npx
• Package manager — nub install: pnpm-compatible dependency installation ~2.5x faster
• Watcher — nub watch src/server.ts: dependency-graph-driven file watching
• Node version manager — nub node install 26: install and manage Node versions

The tagline sums it up well: "augments the Node you already have." No new runtime, no lock-in, no migration required.

Why Nub Exists: The Problem It Solves

Node.js is the gold standard for server-side JavaScript. It defines the standard library the entire ecosystem depends on and sets the bar for stability and trust. But that stability comes with a cost: Node ships new developer experience features slowly.

Over the years, the community bolted on a fragmented toolchain of separate tools:

• tsx or ts-node for TypeScript execution
• dotenv for environment variable loading
• tsconfig-paths for path alias resolution
• nodemon for file watching and restarts
• npx or pnpm exec for running installed CLIs
• npm run or pnpm run for script execution
• Separate Node version managers like nvm or fnm

Bun and Deno proved there's enormous demand for an all-in-one experience. But six years after Deno 1.0 and two and a half years after Bun 1.0, neither has made a serious dent in Node's production dominance. Neither is a first-class target on AWS, GCP, or Azure, and their Node.js compatibility still trails significantly — Nub passes 98.8% of Deno's own Node-compatibility corpus, versus 77.4% for Deno and 40.5% for Bun.

Nub takes the insight that augmentation beats replacement. Your production infrastructure runs on Node.js, and that's not changing anytime soon. Why fight it?

Installation

Installing Nub is straightforward. On macOS and Linux:

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

On Windows or via npm:

npm install -g --ignore-scripts=false @nubjs/nub

Once installed, you can verify it with:

nub --version

Deep Dive: Every Nub Command

nub <file> — TypeScript-First File Runner

The top-level command runs files. It's a drop-in replacement for node with the same flags, same argv, and same runtime behavior — plus full TypeScript support:

# Run a TypeScript file
nub index.ts

# With tsconfig path resolution
nub src/server.ts

# Restart on file changes
nub watch src/server.ts

# With common Node flags
nub --inspect src/server.ts

Under the hood, Nub transpiles each file through oxc — the Rust-native JavaScript/TypeScript toolchain — compiled into a Node native addon. The transpiled output runs on the stock node binary. This means:

• Full TypeScript — not just type stripping. Enums, parameter properties, decorators, and extensionless imports all work
• tsconfig.json resolution — path aliases, baseUrl, and extends are fed into Node's resolver via module.registerHooks()
• Automatic .env loading — reads .env, .env.local, and .env.[NODE_ENV] with variable expansion via ${VAR}
• Modern syntax — JSX in .tsx, decorators, and the using keyword for explicit resource management
• YAML/TOML/JSON5 imports — import .yml, .yaml, .toml, .json5, and .jsonc files directly

nub run <script> — 24x Faster Script Runner

Running npm run dev or pnpm run dev involves spinning up Node.js to parse the package manager's CLI, which then spawns another process. Nub skips the overhead entirely by reading package.json directly in its Rust core:

# Instead of: pnpm run dev
nub run dev

# Instead of: yarn build
nub run build

# Pass arguments to the underlying script
nub run test -- --coverage

The benchmark: 24x faster than pnpm run in cold-start scenarios. The gains come from eliminating the Node.js interpreter startup time for the tooling layer.

nubx <bin> — 19x Faster Package Runner

npx is famously slow — it checks for updates, downloads packages, and spins up Node for every invocation. nubx does the same job without the overhead:

# Instead of: npx prisma generate
nubx prisma generate

# Instead of: pnpm exec eslint
nubx eslint src/

# Multiple CLIs
nubx jest,typescript tsc --noEmit

Nubx is approximately 19x faster than npx for running local CLIs from node_modules/.bin.

nub install — pnpm-Compatible Package Manager

Nub also handles dependency installation. It's pnpm-compatible and respects your existing lockfile format:

# Install dependencies
nub install

# Add a dependency
nub install add zod

# Add a dev dependency
nub install add -D typescript

# Remove a dependency
nub install remove lodash

Published benchmarks show nub install is ~2.5x faster than pnpm install.

nub watch — Dependency-Graph-Driven File Watching

Unlike nodemon which restarts on any file change, Nub's watch mode tracks the actual dependency graph of your application:

# Watch and restart on dependency changes
nub watch src/server.ts

# Multiple entry points
nub watch src/api.ts src/worker.ts

Only changes to imported files trigger a restart, avoiding unnecessary restarts when you edit unrelated files.

nub node — Built-in Node Version Manager

No more juggling nvm, fnm, or volta:

# Install a specific Node version
nub node install 26

# List installed versions
nub node list

# Set default version
nub node use 26.3.1

Nub also supports Corepack-style package-manager shims via nub pm shim, automatically switching between pnpm, yarn, and npm based on your project's lockfile.

Architecture: How Nub Works Under the Hood

Nub's architecture is the key differentiator. Unlike Bun and Deno, which implement Node.js API surfaces from scratch (and inevitably get some of them wrong), Nub takes a simpler approach:

This design means the runtime underneath IS Node. Your TypeScript code is transpiled by oxc (Rust → native addon), loaded via module.registerHooks(), and executed by the exact same node binary your production environment runs. No surprises, no compatibility gaps, no deployment issues.

For project type-checking, Nub defers to tsc — it doesn't replace the type checker. It only handles transpilation for execution.

Comparison: Nub vs the Existing Toolchain

vs tsx (TypeScript Execute)

Both Nub and tsx let you run TypeScript files with nub index.ts or tsx index.ts. The difference: Nub is built on oxc (Rust), while tsx uses esbuild (Go-based). Both are fast, but Nub adds .env loading, tsconfig path resolution, YAML/TOML imports, and decorator support out of the box — tsx handles only transpilation.

vs dotenv

dotenv requires you to add import 'dotenv/config' at the top of your entry file. Nub loads .env files automatically before Node starts, with variable expansion support (${VAR} syntax like Vite and Next.js).

vs nvm / fnm (Node Version Managers)

Nub includes nub node install so you don't need a separate version manager. It won't replace nvm for power users with complex version-switching workflows, but for most projects, having Node management baked into the toolkit simplifies setup.

Is Nub Production-Ready?

Nub launched on June 15, 2026. Like any v1.0 project, it has some caveats:

• Not a type checker — Nub transpiles but doesn't type-check. You still need tsc --noEmit in CI.
• New project — at the time of writing it's been available for just over a week. The community and plugin ecosystem will take time to mature.
• Not for production runtime — Nub is a development toolkit. In production, you should still run compiled JavaScript with plain node.

For local development, CI script execution, and monorepo tooling — Nub is already a compelling alternative to the fragmented toolchain it replaces.

FAQ

Should You Try Nub?

If your daily Node.js workflow involves juggling tsx, dotenv, tsconfig-paths, nodemon, npx, pnpm run, and nvm — Nub is worth a serious look. It eliminates five separate dependencies from your setup and delivers meaningful performance improvements for common operations.

The key metric: Nub doesn't lock you in. Every file you run with Nub can also run with plain node after compilation. Every package.json script works with or without Nub. There's no new runtime, no new API surface, no migration cost. You can try it today in a single project and walk away any time.

As a full-stack developer who works extensively with the Node.js ecosystem — including React, Vue, Angular, and modern backend tooling — I've been watching the "Node.js vs alternative runtimes" debate for years. Nub is the first approach that makes me feel optimistic about a better developer experience without sacrificing everything that makes Node.js reliable in production.