Nub – JavaScript toolkit that augments Node.js (instead of trying to replace it)

Nub — an all-in-one toolkit for Node.js — Nub

NewIntroducing Nub→The all-in-one JavaScript toolkit that augments Node.js instead of trying to replace it A TypeScript-first toolchain for Node.js. Run TypeScript files, package.json scripts, and local CLIs on the node and package manager you already have. No new runtime, no lock-in. macOS / LinuxWindowsnpm $curl -fsSL https://nubjs.com/install.sh | bash

Copy agent prompt

$ nub index.ts # TypeScript-first Node.js runtime $ nub run dev # 24× faster pnpm run $ nubx prisma generate # 19× faster npx $ nub install # 2.7× 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

The toolchain An all-in-one toolkit for Node.js One Rust binary to run your files and scripts, install dependencies, and manage Node itself.

File runnerScript runnerPackage runnerPackage managerNode version manager

$nub A TypeScript-first Node.js Run .ts, .tsx, and .jsx on stock Node with full support for tsconfig.json, .env loading, and modern syntax and Web APIs. Replacestsxts-nodetsconfig-pathsdotenv

# run a TypeScript file $ nub index.ts # restart on changes $ nub watch src/server.ts

$nub A TypeScript-first Node.js Nub adds support for TypeScript, JSX, decorators, .env files, YAML/TOML imports, and modern syntax and APIs on top of stock Node. Flag-for-flag compatible with node. Powered by Rust and oxc.

Architecture Transpiles in Rust, runs on real Node Nub transpiles your code in memory with oxc (compiled into a native Node addon) and runs the output on the stock node binary. There’s no Nub runtime, just real Node. Runs on Node.js 18 LTS and newer.

$ nub app.ts # oxc transpiles in memory, then stock node runs it running on node v26.3.0

TypeScript-first Full TypeScript support, not just type stripping Recent versions of Node support type stripping, which erases annotations but rejects non-erasable syntax. Nub’s load hook transpiles each file through its native addon instead, so enums, parameter properties, and extensionless imports that Node doesn’t allow all just work.

import { Model } from "./base" // extensionless → ./base.ts

enum Status { Draft, Sent, Paid }

class Invoice extends Model { constructor(public status = Status.Draft) {} // parameter property

tsconfig Respects your tsconfig.json Nub resolves your tsconfig.json (including "extends") and feeds its paths into Node’s own resolver through a module.registerHooks() resolve hook. No more tsconfig-paths or disagreement between Node.js and your editor.

// tsconfig.json "compilerOptions": { "baseUrl": ".", "paths": { "@/*": ["src/*"], "@db": ["src/db/index.ts"]

Environment Loads .env files automatically Nub reads .env, .env.local, and .env.[NODE_ENV] and injects them before Node starts. No dotenv required. Automatic var expansion via ${VAR} just like Vite and Next.js.

# .env APP=acme DATABASE_URL=postgres://localhost/${APP}_dev

# No dotenv. No cross-env. No import "dotenv/config". $ nub server.ts

Modern syntax Decorators, JSX, and using Nub supports decorators and JSX, transpiling it according to your tsconfig.json settings. Full support for emitDecoratorMetadata and explicit resource management, no build step required.

await using db = await connect() // disposed at scope end

@sealed // legacy decorator class User {}

const view = Hello name="world" /> // JSX in .tsx

Loaders Import JSON, YAML, and TOML Import .yml, .yaml, .toml, .json5, and .jsonc files directly. A module.registerHooks() load hook routes them through fast Rust parsers in Nub’s native addon, resolving each import to a plain JavaScript object. (Oh, .txt works too)

import config from "./config.yaml" // parsed object import flags from "./feature.jsonc" // comments stripped import pkg from "./Cargo.toml" // parsed object import prompt from "./prompt.txt" // string

import { host, port } from "./config.yaml" // named exports

Auto-restart A dependency-aware watch mode Powered by node --watch, Nub’s watch command watches for changes to your entrypoint or any file transitively imported. It also adds TypeScript/JSX sourcemap support and watches your package.json, tsconfigs, and .env files.

$ nub watch src/server.ts Listening on http://localhost:3000

↺ src/db.ts changed — restarting Listening on http://localhost:3000

Node version management Auto-installs Node, on demand Nub reads your .node-version, .nvmrc, or engines/devEngines pin and runs your code on exactly that version. If it isn’t on your machine, Nub downloads it from nodejs.org, verifies the checksum, and installs it on the fly — replacing nvm and fnm. You can also manage versions manually.

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

Performance Negligible overhead over plain Node Nub transpiles each file in memory through its native Rust addon, then runs it on the real node binary. Its own startup is a few...

Nub – JavaScript toolkit that augments Node.js (instead of trying to replace it)

Related Articles

Apple WWDC 2026 Livestream

Claude Fable 5

US Government directive to suspend access to Fable 5 and Mythos 5

Is AI ruining our skills? Early results are in – and they're not good

German ruling declares Google liable for false answers in AI Overviews