vx - Universal Development Tool Manager
Built for AI-Native Development
vx follows the Unix Philosophy and Scriptability principles recommended by Anthropic for AI-native development tools:
| Principle | How vx Implements It |
|---|
| Unix Philosophy | One tool, one job -- vx manages all runtimes transparently |
| Scriptability | Full bash integration, CI/CD ready, headless mode support |
| Composability | Works with any AI coding assistant (Claude Code, Cursor, Copilot) |
| Zero Configuration | AI agents can use any tool without environment setup |
When AI agents like Claude Code need to execute commands across different ecosystems:
# Without vx: AI must handle complex environment setup
# "First install Node.js, then configure npm, set PATH..."
# With vx: AI just runs commands directly
vx npx create-react-app my-app # Works immediately
vx uvx ruff check . # Works immediately
vx cargo build --release # Works immediately
vx enables AI to have full-stack development capabilities without worrying about environment management and dependencies.
Design Philosophy
The Problem
Every time we start a new development project, we face the same frustrating cycle:
- Install Node.js and npm for frontend tools
- Set up Python and pip/uv for scripts and automation
- Configure Go for backend services
- Manage Rust toolchain for system tools
- Deal with version conflicts and PATH issues
- Repeat this process across different machines and environments
With the rise of MCP (Model Context Protocol), this problem has become even more pronounced. Many MCP servers require uvx for Python tools and npx for Node.js packages, forcing developers to manage multiple tool ecosystems just to get AI assistance working.
The Solution: Zero Learning Curve
vx eliminates this complexity while maintaining zero learning curve:
# Instead of learning and managing multiple tools:
npx create-react-app my-app # Requires Node.js setup
uvx ruff check . # Requires Python/UV setup
go run main.go # Requires Go installation
# Just use vx with the same commands you already know:
vx npx create-react-app my-app # Auto-installs Node.js if needed
vx uvx ruff check . # Auto-installs UV if needed
vx go run main.go # Auto-installs Go if needed
Quick Start
Installation
Linux/macOS:
curl -fsSL https://raw.githubusercontent.com/loonghao/vx/main/install.sh | bash
Windows (PowerShell):
powershell -c "irm https://raw.githubusercontent.com/loonghao/vx/main/install.ps1 | iex"
Stable Installation in Rate-Limited Networks
# 1) Pin a stable installer version (recommended for CI and enterprise networks)
VX_VERSION="0.9.6" curl -fsSL https://raw.githubusercontent.com/loonghao/vx/main/install.sh | bash
# 2) Configure multi-source release mirrors (comma separated)
VX_RELEASE_BASE_URLS="https://mirror.example.com/vx/releases,https://github.com/loonghao/vx/releases" \
curl -fsSL https://raw.githubusercontent.com/loonghao/vx/main/install.sh | bash
# Windows mirror fallback (comma/semicolon separated)
$env:VX_RELEASE_BASE_URLS="https://mirror.example.com/vx/releases,https://github.com/loonghao/vx/releases"
powershell -c "irm https://raw.githubusercontent.com/loonghao/vx/main/install.ps1 | iex"
> The installer will try all configured release base URLs automatically, then fallback across different asset naming patterns.
Start Using Immediately
# No setup needed - just prefix your commands with 'vx'
vx node --version # Auto-installs Node.js
vx python --version # Auto-installs Python via UV
vx go version # Auto-installs Go
vx cargo --version # Auto-installs Rust
Two Ways to Use vx
1. Direct Execution (For Quick Tasks)
Just prefix any command with vx -- tools are auto-installed on first use:
# Run any tool instantly
vx npx create-react-app my-app
vx uvx ruff check .
vx go run main.go
vx cargo build --release
2. Project Development Environment (For Teams)
Create a vx.toml file to define your project's tool requirements:
# Initialize a new project
vx init
# Or create vx.toml manually
cat > vx.toml << 'EOF'
[tools]
node = "20"
python = "3.12"
uv = "latest"
go = "1.21"
[scripts]
dev = "npm run dev"
test = "npm test"
lint = "uvx ruff check ."
EOF
Then use the development environment commands:
# One-click setup: install all project tools
vx setup
# Enter development shell with all tools available
vx dev
# Run project scripts
vx run dev
vx run test
vx run lint
# Manage project tools
vx add bun # Add a tool
vx remove go # Remove a tool
vx sync # Sync tools with vx.toml
Command Reference
Tool Execution
| Command | Description |
|---|
vx [@version] [args...] | Execute a runtime (auto-installs if needed) |
vx [@version]:: [args...] | Execute specific executable from a runtime |
vx :[::executable] [args...] | Execute a package (RFC 0027) |
vx --with [@version] | Inject companion runtimes for this invocation |
vx install @ | Install a specific runtime version |
vx uninstall [@version] | Uninstall runtime versions |
vx switch @ | Switch to a different version |
vx which | Show which version is being used |
vx versions | Show available versions |
vx list | List all supported runtimes |
vx search | Search available runtimes |
Shell and Environment
| Command | Description |
|---|
vx shell launch [@version] [shell] | Launch shell with runtime environment (canonical) |
vx dev | Enter development shell with project tools |
vx dev -c | Run a command in the dev environment |
Global Package Management (vx pkg)
| Command | Description |
|---|
vx pkg install : | Install a global package |
vx pkg uninstall : | Uninstall a global package |
vx pkg list | List globally installed packages |
vx pkg info : | Show package information |
Project Management
| Command | Description |
|---|
vx init | Initialize project configuration (vx.toml) |
vx setup | Install all tools defined in vx.toml |
vx sync | Sync installed tools with vx.toml |
vx lock | Generate or update vx.lock for reproducibility |
vx check | Check version constraints and tool availability |
vx add | Add a runtime to project configuration |
vx remove | Remove a runtime from project configuration |
| `vx run | |
