---
title: Installation
description: Get Vane running on your preferred platform
icon: Download
---
import { Tab, Tabs } from 'fumadocs-ui/components/tabs';
import { Callout } from 'fumadocs-ui/components/callout';
import { Steps, Step } from 'fumadocs-ui/components/steps';
Vane provides first-class pre-compiled binaries for modern Linux and macOS systems, alongside a Docker image for containerized environments. For developers and rolling-release distributions, source-based installation is also fully supported.
These targets are statically compiled (Linux) or native (macOS), and pass the full integration test suite on every commit.
| Target | Note |
| :--------------------------- | :------------------------------------ |
| `aarch64-apple-darwin` | Native binary for Apple Silicon macOS |
| `x86_64-unknown-linux-musl` | Static binary for 64-bit x86 Linux |
| `aarch64-unknown-linux-musl` | Static binary for 64-bit ARM Linux |
| `x86_64-unknown-linux-gnu` | Dynamic binary for 64-bit x86 Linux |
| `aarch64-unknown-linux-gnu` | Dynamic binary for 64-bit ARM Linux |
Binaries are automatically built and released, but run without platform-specific integration tests.
| Target | Note |
| :------------------------------- | :---------------------------------------- |
| `x86_64-unknown-netbsd` | Binary for 64-bit NetBSD |
| `x86_64-unknown-freebsd` | Binary for 64-bit FreeBSD |
| `armv7-linux-gnueabihf` | Binary for 32-bit ARMv7 with hard-float |
| `i686-unknown-linux-gnu` | Dynamic binary for 32-bit x86 Linux |
| `riscv64gc-unknown-linux-gnu` | Dynamic binary for 64-bit RISC-V Linux |
| `loongarch64-unknown-linux-gnu` | Dynamic binary for 64-bit LoongArch Linux |
| `loongarch64-unknown-linux-musl` | Static binary for 64-bit LoongArch Linux |
Experimental. Codebase compatibility is maintained, but no pre-built binaries are provided in the main release channel. Build from source.
| Target | Note |
| :--------------------------------- | :-------------------------------------------------- |
| `x86_64-pc-windows-gnu` | Binary for 64-bit Windows with GNU toolchain |
| `x86_64-pc-windows-msvc` | Binary for 64-bit Windows with MSVC toolchain |
| `mips64-openwrt-linux-musl` | Static binary for 64-bit MIPS OpenWrt |
| `mips64-unknown-linux-muslabi64` | Static binary for 64-bit MIPS Linux (big-endian) |
| `mips64el-unknown-linux-muslabi64` | Static binary for 64-bit MIPS Linux (little-endian) |
The easiest and most recommended way to run Vane is via Docker. We publish multi-arch images for `amd64` and `arm64` to [Docker Hub](https://hub.docker.com/r/canmi/vane) and [GitHub Container Registry](https://github.com/canmi21/vane/pkgs/container/vane).
For quick testing or simple deployments:
```bash
docker run -d \
--name vane \
-p 80:80 \
-p 443:443/tcp \
-p 443:443/udp \
-p 127.0.0.1:3333:3333 \
-v /opt/vane:/etc/vane \
--restart unless-stopped \
canmi/vane:latest
```
Or use GitHub Container Registry
```bash
docker run -d \
--name vane \
-p 80:80 \
-p 443:443/tcp \
-p 443:443/udp \
-p 127.0.0.1:3333:3333 \
-v /opt/vane:/etc/vane \
--restart unless-stopped \
ghcr.io/canmi21/vane:latest
```
<Callout type="info">
We recommend storing your Docker Compose configuration at `/opt/vane/docker-compose.yml` for
consistency. You'll need to create a `.env` file and a dedicated Docker network before starting.
</Callout>
<Steps>
<Step>
**Create the directory structure**:
```bash
sudo mkdir -p /opt/vane
cd /opt/vane
```
</Step>
<Step>
**Create a `.env` file** for environment variables:
```bash
touch .env
```
Edit the `.env` file to add your configuration (optional, depending on your needs).
</Step>
<Step>
**Create the Docker network**:
```bash
docker network create vaneproxy
```
</Step>
<Step>
**Create `docker-compose.yml`**:
```yaml title="/opt/vane/docker-compose.yml"
services:
vane:
image: canmi/vane:latest
# image: ghcr.io/canmi21/vane:latest
container_name: vane
networks:
- vaneproxy
env_file:
- ./.env
ports:
- '80:80/tcp'
- '443:443/tcp'
- '443:443/udp'
- '127.0.0.1:3333:3333/tcp'
volumes:
- /opt/vane:/etc/vane
restart: unless-stopped
networks:
vaneproxy:
external: true
```
<Callout type="tip">
If you don't need network isolation, you can simplify by using host network mode. Remove the
`networks` section and add `network_mode: host` instead.
</Callout>
</Step>
<Step>
**Start the service**:
```bash
docker compose up -d
```
</Step>
</Steps>
---
For bare-metal servers, we provide **statically linked** binaries built with **musl libc** that work on **any** Linux distribution (Debian, Alpine, RHEL, etc.) without external dependencies.
<Callout type="info">
This script automatically detects your system architecture and downloads the appropriate binary
from the [latest release](https://github.com/canmi21/vane/releases).
</Callout>
<Steps>
<Step>
Ensure you have `curl` and `tar` installed:
```bash
sudo apt-get update && sudo apt-get install -y curl tar
sudo dnf install -y curl tar
sudo apk add curl tar
sudo pacman -S curl tar
```
</Step>
<Step>
**Run the auto-install script**:
```bash
curl -fsSL https://vaneproxy.com/install.sh | bash
```
Or for manual control, download and install with architecture detection:
```bash
OS=$(uname -s | tr '[:upper:]' '[:lower:]')
ARCH=$(uname -m)
case "$OS-$ARCH" in
linux-x86_64) FILE="vane-v*-linux-musl-x86_64.tar.gz" ;;
linux-aarch64) FILE="vane-v*-linux-musl-aarch64.tar.gz" ;;
linux-armv7l) FILE="vane-v*-linux-gnu-armv7.tar.gz" ;;
darwin-arm64) FILE="vane-v*-macos-aarch64.tar.gz" ;;
*) echo "Unsupported platform: $OS-$ARCH"; exit 1 ;;
esac
VERSION=$(curl -s https://api.github.com/repos/canmi21/vane/releases/latest | grep -Po '"tag_name": "\K[^"]*')
FILENAME=$(echo "$FILE" | sed "s/\*/$VERSION/")
curl -L -o vane.tar.gz "https://github.com/canmi21/vane/releases/download/$VERSION/$FILENAME"
tar -xzf vane.tar.gz
if [ "$OS" = "darwin" ]; then
sudo mv vane /usr/local/bin/
sudo chmod +x /usr/local/bin/vane
sudo xattr -d com.apple.quarantine /usr/local/bin/vane 2>/dev/null || true
else
sudo mv vane /usr/local/bin/
sudo chmod +x /usr/local/bin/vane
fi
rm vane.tar.gz
vane --version
```
</Step>
</Steps>
<Tabs items={['Linux (x86_64)', 'Linux (ARM64)', 'Linux (ARMv7)', 'macOS (Apple Silicon)']}>
<Tab value="Linux (x86_64)">
<Steps>
<Step>
**Prerequisites**: Install required tools if not already present:
```bash
sudo apt-get update && sudo apt-get install -y curl tar
sudo dnf install -y curl tar
```
</Step>
<Step>
**Set the version** (check [GitHub Releases](https://github.com/canmi21/vane/releases) for the latest):
```bash
VERSION=v{a.b.c}
```
</Step>
<Step>
**Download** the release:
```bash
curl -L -o vane.tar.gz https://github.com/canmi21/vane/releases/download/${VERSION}/vane-${VERSION}-linux-musl-x86_64.tar.gz
```
</Step>
<Step>
**Extract** the archive:
```bash
tar -xzf vane.tar.gz
```
</Step>
<Step>
**Install** to your system path:
```bash
sudo mv vane /usr/local/bin/
sudo chmod +x /usr/local/bin/vane
```
</Step>
<Step>
**Verify** installation:
```bash
vane --version
```
</Step>
<Step>
**Clean up**:
```bash
rm vane.tar.gz
```
</Step>
</Steps>
</Tab>
<Tab value="Linux (ARM64)">
<Steps>
<Step>
**Prerequisites**: Install required tools:
```bash
sudo apt-get update && sudo apt-get install -y curl tar
sudo apk add curl tar
```
</Step>
<Step>
**Set the version** (check [GitHub Releases](https://github.com/canmi21/vane/releases) for the latest):
```bash
VERSION=v{a.b.c}
```
</Step>
<Step>
**Download** the release:
```bash
curl -L -o vane.tar.gz https://github.com/canmi21/vane/releases/download/${VERSION}/vane-${VERSION}-linux-musl-aarch64.tar.gz
```
</Step>
<Step>
**Extract** the archive:
```bash
tar -xzf vane.tar.gz
```
</Step>
<Step>
**Install** to your system path:
```bash
sudo mv vane /usr/local/bin/
sudo chmod +x /usr/local/bin/vane
```
</Step>
<Step>
**Verify** installation:
```bash
vane --version
```
</Step>
</Steps>
</Tab>
<Tab value="Linux (ARMv7)">
<Steps>
<Step>
**Prerequisites**: Install required tools:
```bash
sudo apt-get update && sudo apt-get install -y curl tar
```
</Step>
<Step>
**Set the version** (check [GitHub Releases](https://github.com/canmi21/vane/releases) for the latest):
```bash
VERSION=v{a.b.c}
```
</Step>
<Step>
**Download** the release:
```bash
curl -L -o vane.tar.gz https://github.com/canmi21/vane/releases/download/${VERSION}/vane-${VERSION}-linux-gnu-armv7.tar.gz
```
</Step>
<Step>
**Extract and install**:
```bash
tar -xzf vane.tar.gz
sudo mv vane /usr/local/bin/
sudo chmod +x /usr/local/bin/vane
```
</Step>
<Step>
**Verify** installation:
```bash
vane --version
```
</Step>
</Steps>
</Tab>
<Tab value="macOS (Apple Silicon)">
<Steps>
<Step>
**Prerequisites**: macOS comes with `curl` and `tar` pre-installed. No additional setup needed.
</Step>
<Step>
**Set the version** (check [GitHub Releases](https://github.com/canmi21/vane/releases) for the latest):
```bash
VERSION=v{a.b.c}
```
</Step>
<Step>
**Download** the release:
```bash
curl -L -o vane.tar.gz https://github.com/canmi21/vane/releases/download/${VERSION}/vane-${VERSION}-macos-aarch64.tar.gz
```
</Step>
<Step>
**Extract** the archive:
```bash
tar -xzf vane.tar.gz
```
</Step>
<Step>
**Install** to your system path:
```bash
sudo mv vane /usr/local/bin/
sudo chmod +x /usr/local/bin/vane
```
</Step>
<Step>
**Remove quarantine attribute** (macOS security):
```bash
sudo xattr -d com.apple.quarantine /usr/local/bin/vane
```
</Step>
<Step>
**Verify** installation:
```bash
vane --version
```
</Step>
</Steps>
</Tab>
</Tabs>
---
For desktop Linux users and developers, Vane is available via community repositories and the Rust package registry. This ensures the binary is compiled specifically for your system architecture with native optimizations.
For Arch Linux, Manjaro, and EndeavourOS users, Vane is automatically pushed to the [AUR](https://aur.archlinux.org/packages/vane) by our CI pipeline.
```bash
yay -S vane
paru -S vane
```
If you have the Rust toolchain installed, you can compile and install Vane directly from [crates.io](https://crates.io/crates/vane). This is the **most compatible method** for Tier 2 and Tier 3 platforms, including Windows, BSD systems, and exotic architectures.
<Callout type="tip">
This method compiles Vane from source on your machine. Ensure you have the following build
dependencies installed: `cmake` and a C compiler (`gcc`, `clang`, or MSVC on Windows)
</Callout>
**Install build dependencies:**
```bash
sudo apt-get update && sudo apt-get install -y build-essential cmake pkg-config libssl-dev
sudo dnf install -y gcc gcc-c++ cmake openssl-devel
sudo pacman -S base-devel cmake openssl
brew install cmake openssl
```
**Install Vane via Cargo:**
```bash
cargo install vane
vane --version
```
<Callout type="warn" title="Compatibility Note">
If your system or architecture doesn't support the default `aws-lc-rs` cryptographic backend
(e.g., lacks assembly support), you can use the pure Rust `ring` implementation instead: ```bash
cargo install vane --no-default-features --features full,ring ``` This provides 100% Rust-based
cryptography for maximum portability.
</Callout>
---
## Distribution-Specific Packages
Our release pipeline automatically generates native packages for major Linux distributions.
- **Alpine Linux**: `.apk` packages
- **Debian/Ubuntu**: `.deb` packages
- **OpenWrt**: `.ipk` packages
- **RHEL/Fedora**: `.rpm` packages
- **Arch Linux**: `.pkg.tar.zst` packages
**Example installation:**
First, set the version variable (check [GitHub Releases](https://github.com/canmi21/vane/releases) for the latest):
```bash
VERSION=v{a.b.c}
```
Then install using your distribution's package manager:
```bash
wget https://github.com/canmi21/vane/releases/download/${VERSION}/vane-${VERSION}-debian-x86_64.deb
sudo dpkg -i vane-${VERSION}-debian-x86_64.deb
wget https://github.com/canmi21/vane/releases/download/${VERSION}/vane-${VERSION}-rhel-x86_64.rpm
sudo rpm -i vane-${VERSION}-rhel-x86_64.rpm
wget https://github.com/canmi21/vane/releases/download/${VERSION}/vane-${VERSION}-alpine-x86_64.apk
sudo apk add --allow-untrusted vane-${VERSION}-alpine-x86_64.apk
```