⚠️ BETA — Universal community fork of NVIDIA PAIR BETA (released 09/03/2026, IFA Berlin). Same intelligent routing, but supports all GPUs (GTX, Tesla, RTX, Quadro, AMD Radeon/Instinct, Intel Arc/iGPU, Apple Silicon M1-M5) and all Linux distros (Debian/Ubuntu, Fedora/RHEL, Arch, openSUSE, NixOS...). No RTX allowlist. Not for critical production — APIs/scheduler may change without notice (seeservices/VERSIONING.md:28).
Original NVIDIA PAIR below — Universal additions are marked 🌐.
NVIDIA Personal AI Router (PAIR) is a local inference router for a group of compatible computers on the same network. It discovers participating nodes, manages supported inference engines, and presents Ollama-compatible and OpenAI-compatible proxy endpoints to applications and agents. Independent requests can be routed to eligible nodes according to engine availability, model availability, and current workload.
PAIR is useful for concurrent local workloads such as multi-agent applications. Prompts and responses are intended to remain on the local network when every configured client, model source, engine, and node is local.
PAIR routes each independent request to one node. It does not pool GPU memory, combine GPUs into a larger logical GPU, shard one model across machines, or split an in-flight inference request between nodes.
Two paired machines: requests arrive on one, run on whichever node suits each one, and both report live GPU and memory use throughout. Watch the full clip.
| Upstream NVIDIA | 🌐 PAIR Universal | |
|---|---|---|
| OS | Windows 11; Linux; macOS | Same |
| Arch | x64 / arm64 (Win ARM experimental) | Same |
| GPU | RTX 20+ / RTX PRO / DGX Spark / M4+ only | All GPUs: GTX 6xx+, Tesla K/P/V/A/H, RTX, Quadro, AMD ROCm, Intel Arc/iGPU, Apple Silicon M1/M2/M3/M4/M5 (via ioreg_parse.go:73 AGX/Apple), CPU-only (detected via nvidia-smi → rocm-smi/amd-smi → DRM sysfs → ghw → IORegistry) |
| Linux installers | .deb only |
Universal: .deb + .rpm + .tar.gz portable + install.sh auto-detects apt/dnf/pacman/zypper + build from source everywhere |
| Mixing nodes | Windows/Linux/macOS can be paired | Same + heterogeneous NVIDIA/AMD/Intel/Apple clusters |
| Engines | Ollama + LM Studio | Same + standalone vLLM proxy (experimental, Linux) |
🌐 Technical differences: services/nvpair-node-info/gpu_linux.go:36 and stats_linux.go:153 patched to enumerate all GPUs via DRM sysfs (/sys/class/drm/card*/device/mem_info_*). No RTX filter. Scheduler is unchanged — it routes each request to an eligible node, does not pool VRAM.
PAIR running on a machine does not mean an engine will. PAIR itself runs on any supported Windows, Linux, or macOS machine. Each engine sets its own requirements for the operating system, GPU, and drivers, and each model needs enough memory to load. Whether a particular engine and model work on a particular machine is between that engine and that machine, so check the engine's own documentation before assuming a node can serve a model. A node only becomes a candidate for a request once it is actually running a compatible engine, and PAIR prefers the nodes it already knows hold the model.
The vLLM proxy currently forwards OpenAI-compatible requests to a vLLM server on the same Linux machine. The desktop and broker do not start, discover, or schedule it yet. See the vLLM proxy guide.
Download a released build and use the desktop application. That is the path we recommend and the one the rest of this guide assumes. Building from source and the terminal interface both exist for good reasons — changing PAIR, and machines with no desktop — but neither is the ordinary way in. Those are covered in Building and running PAIR from source and Terminal interface.
The upstream desktop installer sets up the background services and desktop application together. Universal Linux packages and macOS archives currently contain the headless services and terminal interface. Build the Electron app from source if you need the Universal desktop changes.
Download PAIR Universal from the GitHub releases page (or upstream NVIDIA/Personal-AI-Router). Release downloads include:
- Windows desktop
.exeand macOS desktop.dmgfrom upstream; - Linux universal:
.deb(Debian/Ubuntu) and.tar.gzportable (any distro); - macOS Apple Silicon & Intel headless bundles:
darwin-arm64.tar.gzanddarwin-amd64.tar.gz.
The build workflow for this branch also produces an RPM for Fedora/RHEL/openSUSE releases.
🌐 Linux — universal installer (recommended, any distro):
curl -fsSL https://raw.githubusercontent.com/a11q1/pair-universal/main/scripts/install-universal.sh | bash
# or locally:
chmod +x scripts/install-universal.sh && ./scripts/install-universal.sh
# auto-detects apt/dnf/pacman/zypper, otherwise installs portable tarball to /opt/pair🌐 macOS Apple Silicon (M1/M2/M3/M4/M5) — new:
# Download darwin-arm64 tarball from Releases
curl -LO https://github.com/a11q1/pair-universal/releases/latest/download/pair-universal-0.91.8-universal-darwin-arm64.tar.gz
tar xf pair-universal-0.91.8-universal-darwin-arm64.tar.gz
./pair-universal-0.91.8-universal/bin/nvpair-tui # headless TUI
# Alternative: build from source on Mac (M1/M2/M3/M4 native)
git clone https://github.com/a11q1/pair-universal && cd pair-universal
./services/build.sh && ./services/build/bin/nvpair-tui # Go 1.25+ only, no Node needed for TUI
xattr -dr com.apple.quarantine ./services/build/bin/* # if Gatekeeper blocksLinux manual:
# Debian/Ubuntu/Mint/Pop!_OS
sudo apt install ./pair-universal_0.91.8-universal_amd64.deb
# Fedora/RHEL/openSUSE
sudo dnf install ./pair-universal-*.rpm # or sudo rpm -i / sudo zypper install
# Arch/Manjaro/NixOS/other (portable tarball)
tar xf pair-universal-*-linux-*.tar.gz && sudo ./scripts/install-universal.sh --tarball pair-universal-*-linux-*.tar.gz
# Or build from source (any Linux)
git clone https://github.com/a11q1/pair-universal && cd pair-universal && ./services/build.sh && ./services/build/bin/nvpair-tuiWindows: same as upstream. macOS Intel: darwin-amd64.tar.gz same steps.
If you have kept more than one PAIR package in that directory, install the one you want by its full filename instead.
Linux packages and portable installs include the terminal-interface manual. After installation, open it with:
man nvpair-tui-
Open PAIR the way you would any application — the Start menu on Windows, Launchpad or the Applications folder on macOS, your applications list on Linux. On a machine with no desktop environment, drive it from the terminal interface instead, which starts the same background services and gives you a full-screen view in the terminal.
-
Let it finish starting. Overview shows this machine once the services are up. If it stays on Loading..., open Settings → Service and read the status there.
-
Get an engine running. On the node's card, open Engine settings and select Install next to Ollama or LM Studio. PAIR downloads and sets the engine up for you, so nothing needs to be in place beforehand. If PAIR already found an engine you installed yourself, start that one instead.
-
Add a model. Select Add model on the same card and download one.
qwen4:12bis used for this example; it can be replaced with a model of your choice.
-
Send a request. Two equally good options:
-
Let PAIR generate the traffic. Select Test on Settings → Service and PAIR sends a minute of inference through the same path, so you can watch the jobs appear without writing anything.
-
Send one yourself. Use the
curlcall below. The job then appears under Jobs, naming the node that served it.
-
With Ollama on its default port, this runs as written:
curl http://127.0.0.1:11434/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{"model":"qwen4:12b","messages":[{"role":"user","content":"In one sentence, what does a router do?"}]}'The reply is ordinary OpenAI-shaped JSON, abbreviated here:
{
"object": "chat.completion",
"model": "qwen4:12b",
"choices": [
{
"message": {
"role": "assistant",
"content": "A router decides where each incoming message should go and forwards it there."
},
"finish_reason": "stop"
}
]
}If you changed a port, or you are using LM Studio rather than Ollama, copy the URL from Endpoints → API endpoints instead of assuming the one above.
That is a single machine working. To route across machines, pair a second one from Settings → Cluster and repeat the engine and model steps there. The inviting machine shows a six-digit PIN, and you enter that PIN on the machine you invited.
The Getting Started Guide covers the same ground in detail, plus pairing, ports, and connecting your own applications.
Removing PAIR and removing your data are separate steps, and the default is to keep your data.
Windows. Uninstall from Apps & features, or the Start menu entry. The uninstaller stops PAIR, removes its firewall rules, and asks whether to delete your data. Decline and it stays; accept and it is removed.
Linux (Universal). scripts/install-universal.sh --uninstall or:
- Debian:
sudo apt remove pair-universal/sudo apt purge pair-universal - Fedora/RHEL:
sudo dnf remove pair-universal - Arch:
sudo pacman -R pair-universal - Tarball:
rm -rf /opt/pair && rm -rf ~/.config/"Nvidia Corporation"/"Personal AI Router"Rundpkg -l | grep -i pair/rpm -qa | grep pairfirst if you need to confirm.
macOS. Run the uninstaller that ships inside the app bundle. It stops PAIR, removes its firewall rules, unregisters its privileged helper, and then removes the application:
sudo "/Applications/PAIR.app/Contents/Resources/installer-tools/uninstall-macos.sh"Add --purge to remove your data as well. Dragging PAIR to the Trash instead
leaves the privileged helper registered, so use the uninstaller.
Your data means settings, logs, cluster identity and certificates, and any engine
PAIR installed for you. Model weights are not touched — they live in the
engine's own storage, such as ~/.ollama, so removing PAIR does not delete the
models you downloaded. Delete those through the engine, or by removing its
directory.
To clear your data without uninstalling, use Settings → Service → Reset app data. It removes the same set — settings, logs, cluster identity and certificates, and PAIR-installed engines — then restarts the application as if it were newly installed. Model libraries are left alone here too. This is the quickest way to start over after a broken cluster or a bad engine install.
If this machine belongs to a cluster, deal with membership too — otherwise the other nodes keep listing it as a member. You have two options:
- Leave from this machine before uninstalling: Settings → Cluster →
Leave, or press
Lon the terminal interface's Cluster tab. - Remove it from another node, which any member can do from Settings → Cluster by removing that node from the list.
The second option works after the fact as well, so forgetting to leave first is recoverable.
If you are new to PAIR, reading in this order will get you productive fastest. Each entry assumes the ones before it.
- Overview — what PAIR does and how its pieces fit together. Start here so the vocabulary in every other document makes sense.
- Getting started — install it, pair two machines, prepare a model, and send a first request. This is the only document most users need.
- Managing engines — install, start, stop, update, and uninstall engines; what PAIR restores after you quit or relaunch.
- Terminal interface — the same tasks from a terminal, for a machine with no desktop environment. Skip it if every machine you run has a desktop.
- Troubleshooting — worth skimming once before you need it, so you know where the diagnostics live. Alongside it, Known issues lists the significant limitations we are already aware of, and Collecting and sanitizing logs covers preparing a log you can share.
- Architecture — the process model, how a request is routed, and where the trust boundaries are. Read this before changing anything, or if you want to know why PAIR behaves the way it does.
- Building and running — prerequisites, building from source, running the services without the desktop application, and writing your own client against the JSON-RPC API.
- Developer guide — read this before contributing: where the code lives, how a change travels through the layers, and the conventions the project enforces.
Component references, for when you already know what you are looking for:
- Services — the background services, and from there each component's own reference
- Desktop application — working in the application, and from there its architecture, contracts, and CLI documentation
See the releases page for what changed in each release.
We have plenty of ideas about where to take PAIR, and no fixed commitments about which of them land or when. If you have a thought about the product's direction, something that would make it more useful to you, a workflow it does not support yet, or a use we have not considered — we would like to hear it. Open an issue and start the conversation.
Routing is the clearest example. Today PAIR ships a single scheduling policy that combines queued work with a coarse, smoothed GPU-utilization signal. It does not consider GPU model, available memory, model warmness, or how expensive a request looks, which still makes it a better fit for similar machines than a highly mixed cluster. Making that smarter, and likely letting you choose a policy, is something we want to do — and hearing which of those signals matters on your hardware is exactly the kind of input that would shape it.
Feedback from people running PAIR on their own hardware is more useful to us than any plan written in advance.
See SUPPORT.md for public support channels and scope.
PAIR includes local HTTP endpoints, LAN discovery, a PIN-based trust bootstrap, and cluster networking. Read SECURITY.md before deploying it on an untrusted or shared network. Do not report vulnerabilities in a public issue.
This project is licensed under the Apache License 2.0. See Third-Party Software Notices for bundled dependencies. Inference engines, models, and other software used with PAIR may have separate terms.