> ## Documentation Index
> Fetch the complete documentation index at: https://node-guide.dria.co/llms.txt
> Use this file to discover all available pages before exploring further.

# Running a Node

> Install and run the Dria Compute Node to serve AI models and earn rewards

## Introduction

The **Dria Compute Node** (`dria-node`) is a single Rust binary that lets you serve AI models on the Dria network and earn rewards. It runs models locally using llama.cpp — no Ollama or external dependencies required.

> [!TIP]
>
> **Single binary** — no Docker, no Ollama, no complex setup.

> [!TIP]
>
> **Built-in model management** — downloads, caches, and benchmarks GGUF models automatically.

> [!TIP]
>
> **GPU acceleration** — supports Apple Metal, NVIDIA CUDA, and AMD ROCm out of the box.

> [!TIP]
>
> **Auto-updates** — checks for new versions on startup and updates itself.

> [!TIP]
>
> **Reconnection** — automatically reconnects with exponential backoff if the connection drops.

## Installation

**macOS / Linux (Homebrew)**

```bash theme={null}
brew install firstbatchxyz/dkn/dria-node
```

**macOS / Linux (Shell Script)**

```bash theme={null}
curl -fsSL https://raw.githubusercontent.com/firstbatchxyz/dkn-compute-node/master/install.sh | sh
```

**Windows (PowerShell)**

Open PowerShell and run:

```powershell theme={null}
irm https://raw.githubusercontent.com/firstbatchxyz/dkn-compute-node/master/install.ps1 | iex
```

**AMD ROCm (Linux)**

For AMD GPUs with ROCm 6.x on Linux x86\_64:

```bash theme={null}
curl -fsSL https://raw.githubusercontent.com/firstbatchxyz/dkn-compute-node/master/install-rocm.sh | bash
```

**Build from Source**

Requires the [Rust toolchain](https://www.rust-lang.org/), cmake, and build-essential (Linux) or Visual Studio Build Tools + LLVM (Windows).

```bash theme={null}
git clone https://github.com/firstbatchxyz/dkn-compute-node.git
cd dkn-compute-node
cargo build --release
```

**Optional GPU feature flags:**

```bash theme={null}
# Apple Metal (macOS)
cargo build --release --features metal

# NVIDIA CUDA
cargo build --release --features cuda

# AMD ROCm
cargo build --release --features rocm
```

## Setup

Run the interactive setup wizard to select and download a model:

```bash theme={null}
dria-node setup
```

The wizard will:

1. **Detect your available RAM** and filter models that fit your system.
2. **Let you pick a model** from the supported list.
3. **Download the GGUF model file** from HuggingFace.
4. **Run a test inference** and print your benchmark TPS.

> [!TIP]
>
> Models are cached in `~/.dria/models/`. You only need to download each model once.

## Starting Your Node

Once setup is complete, start your node:

```bash theme={null}
dria-node start --wallet <YOUR_PRIVATE_KEY> --model <MODEL_NAME>
```

For example:

```bash theme={null}
dria-node start --wallet abc123...def --model qwen3.5:9b
```

You can also serve **multiple models** by separating them with commas:

```bash theme={null}
dria-node start --wallet abc123...def --model qwen3.5:9b,lfm2.5:1.2b
```

> [!WARNING]
>
> Your wallet is an Ethereum-compatible private key (64 hex characters). This is used for node identity, authentication, and reward tracking. **Never share your private key.**

Stop the node with <kbd>CTRL+C</kbd> (Linux/Windows) or <kbd>CMD+C</kbd> (macOS). The node will gracefully drain in-flight tasks before shutting down.

## Configuration

All flags can also be set via environment variables:

| Flag | Env Var | Default | Description |
| :- | :- | :- | :- |
| `--wallet` | `DRIA_WALLET` | *(required)* | Ethereum private key (hex, 32 bytes) |
| `--model` | `DRIA_MODELS` | *(required)* | Model(s) to serve, comma-separated |
| `--gpu-layers` | `DRIA_GPU_LAYERS` | `0` (CPU only) | GPU layers to offload (`-1` = all) |
| `--max-concurrent` | `DRIA_MAX_CONCURRENT` | `1` | Max parallel inference tasks |
| `--data-dir` | `DRIA_DATA_DIR` | `~/.dria` | Directory for cached models |
| `--quant` | `DRIA_QUANT` | Per-model default | Override GGUF quantization (e.g. `Q8_0`) |
| `--context-size` | `DRIA_CONTEXT_SIZE` | Model's native | Max context window (tokens) |
| `--kv-quant` | `DRIA_KV_QUANT` | `q8_0` | KV cache quantization (`f16`, `f32`, `q8_0`, `q4_0`, `q4_1`, `q5_0`, `q5_1`) |
| `--router-url` | `DRIA_ROUTER_URL` | `quic.dria.co:4001` | Router URL |
| `--skip-update` | `DRIA_SKIP_UPDATE` | `false` | Skip auto-update check on startup |

> [!NOTE]
>
> Set `RUST_LOG=debug` for verbose logging during troubleshooting.

## GPU Acceleration

`dria-node` supports GPU acceleration for faster inference:

* **Apple Metal** — Enabled automatically on macOS with Apple Silicon.
* **NVIDIA CUDA** — Use the CUDA build or `--features cuda` when building from source.
* **AMD ROCm** — Use the ROCm install script or `--features rocm` when building from source.

To offload all model layers to GPU:

```bash theme={null}
dria-node start --wallet <KEY> --model qwen3.5:9b --gpu-layers -1
```

## System Requirements

* **OS:** macOS (Intel + Apple Silicon), Linux (x86\_64, arm64), Windows (x86\_64)
* **RAM:** Minimum \~1 GB (for smallest model) to \~27 GB (for largest model) — see [Selecting Models](/selecting-models.md) for details
* **Disk:** Space for GGUF model files (0.5 GB to 24.5 GB depending on model)
* **Network:** Outbound UDP port 4001 (QUIC connection to router)
* **GPU (optional):** Apple Metal, NVIDIA CUDA, or AMD ROCm 6.x

## How It Works

Your node connects to the Dria router network via **QUIC** (a fast, encrypted UDP-based protocol). Here's what happens:

1. **Authentication** — The router sends a random challenge. Your node signs it with your private key to prove identity.
2. **Registration** — Your node announces which model(s) it can serve.
3. **Task assignment** — The router forwards inference requests from users to your node based on model availability and capacity.
4. **Inference** — Your node runs the model locally and streams results back.
5. **Backpressure** — If your node is at capacity, it rejects new tasks and the router re-routes to another node.

> [!NOTE]
>
> The node supports text, vision (image), and audio inference depending on the model. See [Selecting Models](/selecting-models.md) for model capabilities.

## Running Multiple Nodes

You can run multiple nodes on the same machine or network, but **each node must use a unique private key (wallet)**. Using the same key for multiple nodes will cause conflicts.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.