One command to rule them all β Zero setup, Zero learning curve
δΈζζζ‘£ | π Documentation | π Quick Start | π‘ Examples
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.
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 neededLinux/macOS:
curl -fsSL https://raw.githubusercontent.com/loonghao/vx/main/install.sh | bashWindows (PowerShell):
powershell -c "irm https://raw.githubusercontent.com/loonghao/vx/main/install.ps1 | iex"# 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 RustJust 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 --releaseCreate 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 ."
EOFThen 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 | Description |
|---|---|
vx <tool> [args...] |
Execute a tool (auto-installs if needed) |
vx install <tool>[@version] |
Install a specific tool version |
vx uninstall <tool> [version] |
Uninstall tool versions |
vx switch <tool>@<version> |
Switch to a different version |
vx which <tool> |
Show which version is being used |
vx versions <tool> |
Show available versions |
vx list |
List all supported tools |
vx search <query> |
Search available tools |
| Command | Description |
|---|---|
vx init |
Initialize project configuration (vx.toml) |
vx setup |
Install all tools defined in vx.toml |
vx dev |
Enter development shell with project tools |
vx dev -c <cmd> |
Run a command in the dev environment |
vx sync |
Sync installed tools with vx.toml |
vx add <tool> |
Add a tool to project configuration |
vx remove <tool> |
Remove a tool from project configuration |
vx run <script> |
Run a script defined in vx.toml |
| Command | Description |
|---|---|
vx stats |
Show disk usage and statistics |
vx clean |
Clean up cache and orphaned packages |
vx config |
Manage global configuration |
vx self-update |
Update vx itself |
vx plugin list |
List available plugins |
# VX Project Configuration
# Run 'vx setup' to install all tools
# Run 'vx dev' to enter the development environment
[tools]
node = "20" # Major version
python = "3.12" # Minor version
uv = "latest" # Always latest
go = "1.21.6" # Exact version
rust = ">=1.70" # Version range
[settings]
auto_install = true # Auto-install missing tools in dev shell
parallel_install = true # Install tools in parallel
[env]
NODE_ENV = "development"
DEBUG = "true"
[scripts]
dev = "npm run dev"
test = "npm test && cargo test"
build = "npm run build"
lint = "uvx ruff check . && npm run lint"
format = "uvx black . && npm run format"vx was designed with MCP (Model Context Protocol) in mind. Just change the command from the tool name to vx:
{
"mcpServers": {
"browsermcp": {
"command": "npx",
"args": ["-y", "@browsermcp/mcp@latest"]
},
"python-tool": {
"command": "uvx",
"args": ["some-python-tool@latest"]
}
}
}{
"mcpServers": {
"browsermcp": {
"command": "vx",
"args": ["npx", "-y", "@browsermcp/mcp@latest"]
},
"python-tool": {
"command": "vx",
"args": ["uvx", "some-python-tool@latest"]
}
}
}# New team member joins the project
git clone https://github.com/your-org/your-project
cd your-project
# One command to set up everything
vx setup
# Start developing
vx dev# Frontend (Node.js) + Backend (Go) + Scripts (Python)
cat > vx.toml << 'EOF'
[tools]
node = "20"
go = "1.21"
uv = "latest"
[scripts]
frontend = "npm run dev"
backend = "go run cmd/server/main.go"
migrate = "uvx alembic upgrade head"
EOF
# Install everything
vx setup
# Run different parts
vx run frontend
vx run backend
vx run migratevx uv init my-python-app
cd my-python-app
vx uv add fastapi uvicorn
vx uv add --dev pytest black ruff
vx uv run uvicorn main:app --reload
vx uvx ruff check .vx npx create-react-app my-app
cd my-app
vx npm install
vx npm run devvx go mod init my-go-app
vx go run main.go
vx go build -o appvx cargo new my-rust-app
cd my-rust-app
vx cargo add serde tokio
vx cargo run| Tool | Commands | Description |
|---|---|---|
| Node.js | node, npm, npx |
JavaScript runtime and package manager |
| Bun | bun, bunx |
Fast all-in-one JavaScript runtime |
| Deno | deno |
Secure JavaScript/TypeScript runtime |
| Go | go |
Go programming language |
| Rust | cargo, rustc, rustup |
Rust toolchain |
| Java | java, javac |
Java Development Kit |
| Zig | zig |
Zig programming language |
| Tool | Commands | Description |
|---|---|---|
| UV | uv, uvx |
Fast Python package manager |
| pnpm | pnpm, pnpx |
Fast, disk-efficient package manager |
| Yarn | yarn |
JavaScript package manager |
| Tool | Commands | Description |
|---|---|---|
| Vite | vite |
Next generation frontend tooling |
| Just | just |
Command runner for project tasks |
| Task | task |
Task runner / build tool (go-task) |
| CMake | cmake |
Cross-platform build system generator |
| Ninja | ninja |
Small build system focused on speed |
| protoc | protoc |
Protocol Buffers compiler |
| Tool | Commands | Description |
|---|---|---|
| Docker | docker |
Container runtime and tooling |
| Terraform | terraform |
Infrastructure as Code |
| kubectl | kubectl |
Kubernetes CLI |
| Helm | helm |
Kubernetes package manager |
| Tool | Commands | Description |
|---|---|---|
| AWS CLI | aws |
Amazon Web Services CLI |
| Azure CLI | az |
Microsoft Azure CLI |
| gcloud | gcloud |
Google Cloud Platform CLI |
| Tool | Commands | Description |
|---|---|---|
| pre-commit | pre-commit |
Pre-commit hook framework |
| Tool | Commands | Description |
|---|---|---|
| VS Code | code |
Visual Studio Code editor |
| Rez | rez |
Package management system |
| rcedit | rcedit |
Windows resource editor |
| Feature | vx | nvm/pyenv/etc. |
|---|---|---|
| Zero Learning Curve | β Same commands you know | β New commands to learn |
| Multi-Language | β One tool for all | β One tool per language |
| Auto-Install | β On first use | β Manual installation |
| Project Config | β
vx.toml |
β Varies by tool |
| Team Sync | β
vx setup |
β Manual coordination |
| MCP Ready | β
Just add vx |
β Complex setup |
| Cross-Platform | β Windows/macOS/Linux |
~/.config/vx/config.toml:
[defaults]
auto_install = true
check_updates = true
update_interval = "24h"
[tools.node]
version = "20"
[tools.uv]
version = "latest"# Add to your shell profile for auto-completion
eval "$(vx shell init bash)" # Bash
eval "$(vx shell init zsh)" # Zsh
vx shell init fish | source # Fish# Avoid rate limits in shared environments
vx self-update --token ghp_your_token_here
# Or set environment variable
export GITHUB_TOKEN=ghp_your_token_here
vx self-update# Windows
winget install loonghao.vx
choco install vx
scoop install vx
# macOS
brew tap loonghao/vx && brew install vx
# Arch Linux
yay -S vx-bin
# Cargo
cargo install --git https://github.com/loonghao/vxdocker pull loonghao/vx:latest
docker run --rm loonghao/vx --versionUse vx in your CI/CD workflows:
- uses: loonghao/vx@vx-v0.5.15
with:
github-token: ${{ secrets.GITHUB_TOKEN }}
- run: vx node --version
- run: vx npm ci
- run: vx npm testNote: Use a specific version tag (e.g.,
vx-v0.5.15) instead ofv1. Check releases for the latest version.
See GitHub Action Guide for full documentation.
We welcome contributions! See CONTRIBUTING.md for guidelines.
- Report Issues: Open an issue
- Feature Requests: Start a discussion
- Code Contributions: Submit pull requests
MIT License - see LICENSE for details.
- π Documentation: GitHub Wiki
- π¬ Discussions: GitHub Discussions
- π Issues: Bug Reports
- π§ Contact: hal.long@outlook.com
Made with β€οΈ for developers, by developers