Can Nub Threaten Bun’s Dominance? A Former Bun Engineer’s New Tool Gains Vite Creator’s Praise

Background and Goal

Colin McDonnell, creator of Zod, Standard Schema and tRPC, launched Nub to bring the integrated developer experience of Bun to projects that keep the native Node.js runtime. Unlike Bun, which rewrites its runtime (Zig → Rust) and bundles tools, Nub retains Node.js and rebuilds the surrounding toolchain.

Consolidated Toolchain

Typical Node projects combine many separate utilities: node – runs code npm run / pnpm run – executes scripts npx / pnpm exec – runs CLIs tsx / ts-node – handles TypeScript dotenv – loads environment variables nodemon – watches files nvm / fnm / mise – switches Node versions

These tools form a long “shopping list”. Nub’s answer is to keep the Node runtime and provide a single entry point that replaces the above utilities.

Command Overview

nub index.ts

Runs a TypeScript entry file. nub run dev Executes a script defined in package.json (equivalent to npm run dev). nub watch src/server.ts Watches files and restarts on change (replaces nodemon). nubx prisma generate Runs a local CLI binary (replaces npx). nub install Installs dependencies using Nub’s built‑in package manager. nub node install 26 Installs and switches to Node version 26 (replaces nvm, fnm, mise).

TypeScript Support

Node can execute some TypeScript but relies on type erasure, which fails for enums, namespaces, parameter properties, and other non‑erasable syntax. Nub transpiles TypeScript, TSX, and experimental decorators in memory before handing the JavaScript to Node. It also adds the following conveniences:

Respects paths, baseUrl, and inheritance chains defined in tsconfig.json.

Automatically loads .env, .env.local, and environment‑specific configuration files.

Allows direct import of YAML and TOML files.

Supports JSX, TSX, and legacy experimental decorators.

Generates inline source maps so runtime errors point to the original TypeScript source.

Nub does not introduce new global APIs (no Nub.*) or special fields in package.json, keeping the toolchain lightweight.

Performance Benchmarks

Official benchmarks focus on the overhead of script/CLI startup, not on business‑logic execution. nub run is reported as 24× faster than pnpm run. nubx is reported as 19× faster than npx.

In a macOS “warm install” test that rebuilds a create‑t3‑app project with 222 dependencies, the measured times are:

Nub – 1122 ms

Bun – 1444 ms

pnpm – 2847 ms

npm – 4163 ms

A separate test of a simple TypeScript script shows Bun running roughly 4× faster than Nub because Bun avoids the Node.js startup cost. The speed advantage of Nub therefore resides in the tooling layer (script dispatch, package‑manager boot) rather than in raw JavaScript/TypeScript execution.

Integrated Package Manager and Security Policy

Nub includes a built‑in package manager that can read and write lockfiles for npm, pnpm, and Bun (Yarn lockfiles are read‑only). For pnpm projects it supports workspaces, hooks, and related environment variables.

The default security policy is aggressive:

Lifecycle scripts (e.g., postinstall) are disabled unless explicitly approved.

Indirect dependencies from git+, file:, or raw tarball URLs are blocked.

Newly published versions are held back for 24 hours before being allowed into the dependency tree.

Packages with missing or suspicious provenance information are rejected.

These measures reduce supply‑chain attack risk but may cause compatibility problems for packages that rely on post‑install build steps.

Relation to Vite Plus

Yu Yuxi (creator of Vite) linked Nub to the Vite Plus concept, noting that both aim to simplify the fragmented JavaScript tooling ecosystem by providing a cached monorepo task runner and an integrated development experience.

Scope of Replacement and Trade‑offs

Nub does not replace Node.js; it depends on Node.js. It also does not fully replace Bun, which bundles its own runtime, bundler, test runner, and broader integration.

What Nub replaces is the surrounding toolchain that developers normally assemble from tsx, dotenv, nodemon, npm/pnpm, npx, and version managers. The migration cost is low because no runtime change or new global API is required, and lockfiles remain largely compatible.

The trade‑off is that Nub now touches many domains—script execution, package management, version management, and task scheduling—each with edge cases and stability concerns. The project is newly released, so production‑grade stability remains to be demonstrated.

Conclusion

Nub shows that a complete rewrite of the Node runtime is not the only path to a faster, more integrated development experience. By keeping the native Node.js engine and re‑implementing the surrounding toolchain, Nub offers a low‑friction entry point for developers who want Bun‑like convenience without abandoning Node. The approach merits close observation as the ecosystem continues to move toward integrated toolchains.