What is Nub? The Rust toolkit making Node.js 20x faster

Over the past few years, the JavaScript and TypeScript ecosystem has been dominated by debates over runtimes. When Bun arrived, it raised developer expectations by delivering a fast, all-in-one toolchain. However, for many teams, migrating production codebases from Node.js to a completely new runtime like Bun or Deno remains a high-risk endeavor.

This is where Nub comes in. Nub is a lightweight, Rust-based utility that sits directly on top of Node.js.

Rather than replacing the Node.js runtime entirely, Nub streamlines development workflows by combining version management, script execution, package installation, and environment configuration into a single, high-performance binary.

In this guide, we’ll explore Nub’s primary features, see how it accelerates daily development tasks, and analyze benchmark results to evaluate whether its performance gains live up to the claims.

Prerequisites for running Nub

For this, you will need the following:

• Node 18.19+ installed on your machine to run Nub
• Basic TypeScript knowledge is helpful but not required
• Hyperfine installed if you want to reproduce the benchmarks locally

How to install Nub

You can install Nub through three standard methods depending on your operating system and environment.

Through npm, run this command globally in your terminal:

npm install -g @nubjs/nub

If you prefer to use curl on macOS or Linux, run:

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

You can also install it on Windows via PowerShell:

irm https://nubjs.com/install.ps1 | iex

To verify the installation succeeded, run:

nub --version

This should print the active version of the Nub CLI, confirming that the binary is ready to use in your local environment.

How Nub compares with standard Node.js tools

To understand where Nub fits into your current workflow, look at how its unified interface compares with existing tools in the Node.js ecosystem:

Nub command	Traditional tool it replaces or augments	Purpose
nub app.ts	node, tsx, ts-node	Direct TypeScript execution
nub run dev	npm run, pnpm run	script running
nubx prisma generate	npx, pnpm dlx	Binary task execution
nub install	npm, pnpm, yarn	package management
nub watch app.ts	node --watch, nodemon	Core file watching and live reloading
nub node install 22	nvm, fnm	Node.js version management
nub pm shim	Corepack	Integrated package manager shim management

Now that we see what tools Nub handles, let’s analyze why Node development has historically struggled with tool fragmentation, and look at how Nub addresses this under the hood.

Why Node.js tool fragmentation creates friction

A Node development workspace requires managing several independent dependencies.

While modern runtimes like Bun and Deno solve this by combining these tools natively, they require a total runtime migration.

This brings up another problem. Many teams find Bun or Deno too risky for production because major cloud platforms such as AWS Lambda, Google Cloud Functions, and Azure Functions do not support them natively.

Nub solves this problem while ensuring full compatibility with your standard Node.js production runtimes.

How Nub accelerates Node.js execution

Traditional tooling like npm or pnpm runs on top of Node.js.

For example, when you run npm run build, your shell launches a Node process, parses the package manager’s JavaScript libraries, resolves the command configurations, and finally launches another Node process to run the actual build script.

Nub takes out the intermediate process and uses the following instead:

• Nub binary is pre-compiled to native machine code. It fires up instantly with a minimal footprint
• When running files, Nub compiles and executes your TypeScript code directly in memory
• Nub resolves configuration files and variables natively inside its compiled engine before passing the final execution code string to Node.js

How Nub handles everyday development tasks

Nub consolidates the everyday commands you use across your workflow into a unified CLI tool.

Instead of switching between multiple standalone packages, version managers, and runner wrappers, you can use Nub directly in any existing project without altering your project setup or modifying your configuration files.

Let’s explore how it handles everyday developer workflows, from running scripts and executing TypeScript files to managing packages and environments.

Running scripts with Nub

If you were to start your development environment, you can do it like this:

nub run dev

Executing TypeScript files directly in Nub

Nub allows direct, native execution of TypeScript files without additional tooling or wrappers.

You can go ahead and run a TypeScript file like below:

nub app.ts

Let’s test this in action.

I have a test file named demo.ts with the following code:

enum TaskStatus {
  Pending = "PENDING",
  Complete = "COMPLETE"
}

class BuildTask {
  constructor(
    public readonly name: string,
    public readonly status: TaskStatus = TaskStatus.Pending) {}
}

const task = new BuildTask("Compile CSS");
console.log(`Task [${task.name}] status is: ${task.status}`);

Now, run this typescript file directly through the terminal:

nub demo.ts

On running this command, Nub parses your TSConfig directives, processes enums and class constructors in memory, and passes the parsed execution script to Node.

Take a look at the result below:

Managing packages and dependencies in Nub

There is also an integrated package manager built on top of the native Rust orby engine.

This engine uses a global, content-addressable storage pool, similar to pnpm.

To initialize or update your dependencies, simply run:

nub install

In addition to fast downloads, it also comes with the following security configurations:

• It blocks dependency installation hooks such as postinstall binaries automatically.
• Nub has a default rule requiring software releases to be at least 24 hours old before installation.

Automating Node.js version management with Nub

Nub integrates Node version switching natively into its Rust executable. It automatically scans your directory tree for version pinning indicators, including .nvmrc, .node-version, or the engines parameters inside package.json.

When you enter a folder, it detects the requested Node deployment and switches automatically, downloading and caching the correct platform binaries if they are not already installed on your machine.

You can also run manual switches:

nub node install 22

nub node use 22

nub node list

Loading environment variables natively in Nub

Rather than requiring third-party library integrations to parse environment files in development, Nub includes direct, native environment variable loading.

One more thing: it also loads configurations from .env and .env.local files automatically.

How fast is Nub? Benchmark performance results

Nub advertises performance improvements of up to 20× over traditional Node.js package managers and runtime wrappers.

Rather than relying solely on Nub’s published benchmarks, I wanted to see what those numbers looked like on a real development machine.

I therefore ran my own benchmarks using Hyperfine, comparing Nub across three workloads:

• Script runner overhead
• TypeScript execution
• Script runner combined with TypeScript execution

The results represent measurements from my machine and should not be interpreted as universal performance figures. Hardware, operating system, software versions, file system performance, and cache state can all affect the results.

That being said, here is a breakdown of my laptop specifications:

Component	Specification
CPU	Intel Core i7-7500U @ 2.70 GHz
RAM	8 GB
OS	Windows 10 Pro
Architecture	x64

Benchmark 1: Script runner overhead

I tested a minimal script to measure the baseline wrapper overhead introduced by the package runner before executing actual code.

hyperfine --warmup 10 --runs 20 "nub run noop" "pnpm run noop" "npm run noop"

When executing a basic shell command via package manager scripts, package managers like pnpm and npm incur an average startup overhead of over 800 milliseconds.

Nub operated 2.87× faster than pnpm and 2.99× faster than npm on average.

Benchmark 2: TypeScript execution speed

Next, I measured how quickly Nub executes a single TypeScript file compared to standard JS execution under Node and the popular tsx loader.

hyperfine --warmup 10 --runs 20 "nub hello.ts" "tsx hello.ts" "node hello.js"

In this benchmark, node hello.js was the fastest at 72 milliseconds, but it runs a JavaScript file rather than TypeScript.

For the two tools running hello.ts directly, tsx was 3.82x faster than Node. Node’s JavaScript baseline was 9.21x faster than Nub.

Benchmark 3: Combined script running and TypeScript execution

Finally, I benchmarked a realistic scenario that combines package script parsing with TypeScript compilation by running a hello-ts task.

hyperfine --warmup 3 --runs 20 "nub run hello-ts" "pnpm run hello-ts"

When combining script parsing overhead with TypeScript compilation, pnpm proved slightly more consistent and 1.23× faster than Nub. While Nub’s minimal execution run reached 381 milliseconds, its upper range reached 2.810 seconds.

Here is the full breakdown of the benchmarks:

Benchmark Tool	Mean Time	Standard Dev (σ)	Min Time	Max Time
nub run noop	287.4 ms	±455.2 ms	70.2 ms	1416.6 ms
pnpm run noop	825.8 ms	±75.1 ms	677.2 ms	949.9 ms
npm run noop	859.0 ms	±100.9 ms	680.8 ms	1045.0 ms

Comparing Nub with Bun and Deno

The JavaScript ecosystem has seen a surge of modern tools aiming to fix developer experience and performance bottlenecks. Bun and Deno have gained substantial traction by rethinking runtime architecture from the ground up.

Understanding how Nub compares to these alternative runtimes helps clarify where each tool fits best in real-world projects.

Nub vs Bun

Both Nub and Bun leverage Rust speed to modernize JavaScript development. However, their primary approach is different:

• Runtime strategy: Bun is a complete runtime intended to replace Node.js entirely. Nub acts strictly as a high-performance tooling layer that sits on top of Node.js
• Compatibility risk: Swapping your engine to Bun can introduce runtime bugs and deployment difficulties, especially on cloud serverless systems. Nub maintains absolute compatibility because your code still runs inside your Node.js installation
• When Bun fits better: If you are building new serverless apps where runtime optimization is your paramount concern, Bun is an exceptional choice
• When Nub fits better: For existing production systems, monorepos, and apps that cannot risk runtime lock-in, Nub is the safer and more practical choice to gain speed without any migration risk

Nub vs Deno

Deno represents another major ecosystem shift in the JavaScript landscape:

• Ecosystem integration: Deno relies on its own architecture and custom APIs. Nub works natively with your existing package.json, pnpm-workspace.yaml, and node_modules folders
• Workload migration: Switching to Deno is a major migration project that requires redesigning your build structure. Nub can be adopted incrementally with zero file changes. If you want to stop using it, you can delete the binary and immediately revert to npm or pnpm
• When Deno fits better: If you want static binary builds and are ready to adopt a clean Web API ecosystem, Deno is ideal
• When Nub fits better: For developer teams who want modern toolkit performance today without modifying their existing codebase

Conclusion

We have explored how Nub consolidates version switching, task execution, script running, and package management into a single, fast, Rust-powered tooling layer on top of your existing Node.js setup.

For teams who want the robust, all-in-one developer experience of Bun or Deno but cannot afford the custom runtime migration risk, deployment difficulties, or cloud platform incompatibilities, Nub shines as an excellent, zero-config compromise.

It lets you keep your reliable Node.js runtime while supercharging your everyday workflow.