vx

The fastest task runner for JS monorepos.
Measured against Turborepo and Nx, each in its own native config.
vznjs.github.io/vx

Time added over the ideal run, 1,601 projects, 9,603 tasks	vx	Turborepo	Nx	Vite Task
Nothing changed	1.07 s	898 ms (vx 19% slower)	25.45 s (vx 24× faster)	11.75 s (vx 11× faster)
Nothing changed, outputs restored	1.27 s	844 ms (vx 51% slower)	23.82 s (vx 19× faster)	11.83 s (vx 9.3× faster)
Cold build	7.07 s	9.15 s (vx 29% faster)	3 min 48 s (vx 32× faster)	8.16 s (vx 15% faster)
Cold build: CPU the runner burns	32.28 s	1 min 3 s (vx 94% faster)	6 min 6 s (vx 11× faster)	24.82 s (vx 30% slower)

Time each tool adds over the ideal run; vx N% or N× faster means that tool adds N% more or N times as much as vx.

Benchmark workload: a synthetic monorepo of 1,601 projects and 9,603 tasks in 30 dependency levels, five core libraries a quarter of the projects use; build 300 ms, test and typecheck 150 ms, lint 75 ms, publish 30 ms; real repos with uneven task times will differ. Run 2026-10-09 on linux x64, 4 cores: vx at commit 3d48a981d, Turborepo 2.11.7, Nx 23.3.0, Vite Task (vite-plus) 1.1.0.

Same graph, commands and concurrency: how it is measured.

What vx is

A task runner and build cache for JavaScript monorepos. Each task is one shell command with declared inputs and outputs; vx runs them in dependency order and replays results from a content-addressed cache.

Install

npm install -D @vzn/vx     # or: pnpm add -D -w · yarn add -D (-W on Yarn 1) · bun add -d

A prebuilt binary for Linux (glibc, not Alpine's musl) and macOS, x64 and arm64; no Bun needed. The release binary needs no Node either. Windows: run vx inside WSL2.

Quick start

In a git repo with a package.json workspace:

npx vx init               # a vx.config.ts per package, from its scripts

Give a task a cache block, what it reads and writes:

// packages/app/vx.config.ts
import { defineProject } from '@vzn/vx/config'

export default defineProject({
  tasks: {
    build: {
      exec: { command: 'tsc -b' },
      dependsOn: ['^build'], // dependencies build first
      cache: {
        inputs: { files: ['src/**', 'tsconfig.json'] },
        outputs: { files: ['dist/**'] },
      },
    },
  },
})

npx vx run build --all    # builds, in dependency order; stores the results
npx vx run build --all    # nothing changed: up-to-date, in milliseconds
rm -rf packages/*/dist
npx vx run build --all    # restored from the cache, not rebuilt

Starter: examples/basic, run by CI on every commit. More: Quickstart · Configure · CLI · every config field · playground (the planner, in your browser).

Coming from Turbo or Nx

Beside turbo.json or nx.json, npx vx init runs @vzn/vx-migrate: it writes a vx.config.ts per package from turbo.json or the Nx graph, and you keep those and delete the old config. vx init --keep writes only a vx.workspace.ts that maps the old config instead: a temporary start, not a way to run the repo. The numbers above are native vx config. Migration guide.

Why it is faster

• Nothing boots per task: no daemon, no Node process; vx spawns your command.
• No source-file reads to hash: on a clean tree, keys come from git's index; each project's package.json and the lockfile are still read.
• One pass: one git walk per run; each stat and lookup happens once.

More than speed

• A cache you can trust: TypeScript configs are evaluated before hashing, so imports and computed values are in the key. Outputs are wiped before every run and restore: no stale file survives.
• Sandboxed tasks: opt in per task; a workspace file the task did not declare is out of its reach, so it cannot poison the cache.
• Clean exits: Ctrl-C reaps each task's process group.
• Plugins at every stage (14 hooks, commands included): remote cache, remote execution, telemetry, CLI verbs. Core ships none and needs none.
• Free: MIT. No paywall, no cloud, no account.

How it compares

	vx	Turborepo	Nx
Config	TypeScript, evaluated into the cache key	JSON (static)	JSON (static)
Output ownership	Strict: wiped before exec and restore	Additive (stale files survive)	Additive
Clean-tree hashing	No source reads (git index OIDs)	git OIDs	re-hash / daemon
Daemon	None	None for turbo run	On by default
Per-task sandbox	Yes: kernel-level, opt-in, local	No	On Nx Cloud only
Plugin API	Yes: every pipeline stage	No	Yes (TS-tied)
Install	Single binary; no Bun, Node optional	npm + Node	npm + Node

Every gap, and when another tool is the better pick: comparison · vx, Turborepo, Nx, Bazel.

Plugins

Declared in vx.workspace.ts; without any, vx runs and caches locally.

Package	What it adds
@vzn/vx-migrate	Migrate from Turbo or Nx: write native configs, keep its remote cache
@vzn/vx-reapi	Remote cache and remote execution over Bazel's REAPI (NativeLink, BuildBuddy)
@vzn/vx-lockfile	Key each project on its own lockfile slice: pnpm, bun, npm, yarn
@vzn/vx-otel	OpenTelemetry traces, metrics and logs, no SDK
@vzn/vx-ci	GitHub Actions job summary and Checks API
@vzn/vx-mcp	vx mcp: an MCP server for AI coding agents that also runs tasks
@vzn/vx-schedule-history	Schedule by the critical path learned from past runs

Write your own: plugin guide · architecture.

Status

Pre-alpha, dogfooded: this repo lints, tests and builds itself with vx. The schema may still change; 1.0's promise: versioning-1.0.md.

Contributing

git clone https://github.com/vznjs/vx && cd vx
bun install
bun packages/vx/src/bin.ts run ci --all     # lint, test, docs build: every package

Needs Bun ≥ 1.4. Every dev task is a vx task; no package.json scripts. Start with CONTRIBUTING.md and STATUS.md.

License

vx is MIT licensed. The prebuilt binaries embed Bun and a few npm packages under permissive licenses; their notices ship as THIRD_PARTY_NOTICES.txt in each platform package and GitHub release.