Deploy

Run it: a node, or an access point

A GPN node is always both a miner and an AI provider — no role option. It mines and serves AI jobs on the same box, auto-yielding its one GPU to a job while it runs. An access point is the public front door. Start with whichever fits your hardware and goals. New here? See Download first.

On this page: Node (mine + serve) · How serving works · Access point · Windows · Config · Ports

One GPU, one job at a time — a node does both

A single GPU does one job at a time, but a GPN node is always miner + AI provider: it mines by default and, when it accepts an AI job, it fully stops mining and frees VRAM for the model, then resumes the instant the job completes. No profitability switch, no mode to pick — the node auto-yields the GPU per job.

Node

Run a node (mine + serve)

The node holds chain state, syncs, mines on its GPU, and serves AI compute — one entity, one command. It auto-yields the GPU to a job while it runs.

Install

Run ./install.sh (see Download). It builds the binaries, generates a wallet, and writes ~/.gpn/gpn.env.

Start the node

gpn_node

One command brings up the chain node/miner, the provider heartbeat, and the AI provider loop together. Watch the log for GPU Ethash miner online: <device> to confirm real GPU mining (not the CPU fallback).

Or mine against a remote node (lighter)

gpn_external_miner <rpc_url> [device_index] [batch] [poll_ms]

No local chain required — handy for a small box.

Get paid

Producing a block is the proof of GPU work: after a small number of authored blocks your node is pay-eligible and the reward goes to the block producer's own account (Bitcoin-style). Staking remains optional — it raises your tier, not a gate.

Heads-up: a long-running --dev --tmp node eventually discards old state; restart it or use a persistent --base-path.

Serving

How a node serves AI (LLM / image / video / fine-tune)

Every node is an AI provider too: it registers, attests its GPU, and serves jobs routed to it, earning GPN from job escrow. The chain enforces the capability gate; providers are discovered by the scheduler. There is nothing to switch on — serving runs alongside mining.

Run the node + REST API

gpn-node --dev --tmp --rpc-port 9944      # mines by default

# serving LLMs needs ollama running (http://127.0.0.1:11434):
#   scripts/install-ollama.sh   (Linux)   |   scripts\install-ollama.ps1  (Windows)

gpn_api --listen 127.0.0.1:8082 \
  --endpoint ws://127.0.0.1:9944 \
  --signer-uri //Alice

Onboard the GPU (one-time, per fresh chain)

curl -X POST http://127.0.0.1:8082/providers/register \
  -H 'Content-Type: application/json' -d '{"min_gflops":800}'

curl -X POST http://127.0.0.1:8082/providers/attest \
  -H 'Content-Type: application/json' \
  -d '{"gpu_count":1,"compute_gflops":831,"gpu_info":"RTX 4060 8GB"}'

Start the executors

gpn_llm_provider       ws://127.0.0.1:9944 //Alice 3000   # LLM chat

GPN_DIFFUSE_SCRIPT=$PWD/gpn_diffuse.py \
  gpn_diffusion_provider ws://127.0.0.1:9944 //Alice 3000  # image + video

GPN_FINETUNE_SCRIPT=$PWD/gpn_finetune.py \
  GPN_SERVEMODEL_SCRIPT=$PWD/gpn_servemodel.py \
  gpn_finetune_provider ws://127.0.0.1:9944 //Alice 3000   # LoRA fine-tune

Advertise a reachable status URL

The scheduler discovers providers from the chain via their endpoint. Expose a public /status and register it (port 8093 by default). A job is routed to the lowest-latency idle provider that meets its capability gate.

Testnet free-AI

On the public testnet the access point can run a hot wallet that pays escrow for you, so a client's price_gpn is cosmetic. On mainnet this endpoint is disabled and callers sign with their own wallet.

Access point

Run an access point

An access point (gpn_scheduler) is a public job API. Callers hit one URL; it routes each job to the best provider. Permissionless and redundant — run several for the decentralized front door.

Install + run

./install-accesspoint.sh
# or install + start a systemd --user service:
GPN_INSTALL_SERVICE=1 ./install-accesspoint.sh

gpn-accesspoint-run

Verify

curl http://127.0.0.1:8092/health     # {"providers":N,"status":"ok"}
curl http://127.0.0.1:8092/providers  # live registry (gflops, latency_ms, models, active)

Expose it

Point callers at http://<your-host>:8092. Non-loopback POSTs require Authorization: Bearer <GPN_AP_TOKEN> (or X-Api-Key) — set your own token in the env; never commit it.

See the current public entry point and how to add yours on the Access Points page.

Windows

Windows node (mine + serve)

Your Windows box can be a client (no install needed) or a full node that mines and serves AI jobs, earning GPN. There is no provider-only mode — the node runs both. You need the three things below plus the gpn-windows binaries.

1 · Backend (Ollama)

Install Ollama — winget install Ollama.Ollama or ollama.com/download — then start it (ollama serve) and pull a model, e.g. ollama pull llama3.2:1b. Without Ollama the box still mines but cannot serve LLM jobs. One-shot: powershell -ExecutionPolicy Bypass -File scripts\install-ollama.ps1. No Python or CUDA needed.

2 · A wallet

Drip a fresh account from the testnet faucet — you need GPN for the one-time registration fee and to sign claims. The signer you pass to the provider is the source of truth for its identity.

3 · Reachable /status

Forward port 8093 on your router so the URL you advertise resolves from the internet. The scheduler discovers providers from the chain.

AMD / Radeon boxes

Mining is vendor-agnostic (OpenCL) — install rocm-opencl-runtime on Linux (then reboot) or the AMD/OpenCL driver on Windows; a GPU node detects the card automatically (rocm-smi/lspci, or Win32_VideoController) so gpu_class/vram_mb/tflops are accurate.

Serving LLMs differs by OS: on Linux ollama runs on ROCm (RX 6000/7000; pin HSA_OVERRIDE_GFX_VERSION=11.0.0 / 10.3.0 if you see "unsupported gfx") — use ./scripts/install-ollama-amd.sh. On Windows, ollama's ROCm support is limited, so an AMD box often falls back to the CPU (slow) or a DirectML build: it mines fine but LLM jobs are latency-heavy. Prefer Linux for full AMD GPU serving.

Run it

.\run-windows-provider.ps1 -Signer "<your seed or //Alice>" `
    -PublicStatusUrl "http://<your-public-ip>:8093/status" -Gflops 2500

The script checks Ollama, calls gpn_register.exe, then runs gpn_node.exe, which brings up the chain node/miner, the :8093 heartbeat, and the claim/infer/settle loop together. Verify from another box with Invoke-RestMethod "…:8093/status".

Windows firewall + bootnode extras

New-NetFirewallRule -DisplayName "GPN p2p" -Direction Inbound -Protocol TCP -LocalPort 30333 -Action Allow
New-NetFirewallRule -DisplayName "GPN RPC" -Direction Inbound -Protocol TCP -LocalPort 9944  -Action Allow
New-NetFirewallRule -DisplayName "GPN web" -Direction Inbound -Protocol TCP -LocalPort 8082  -Action Allow

Config

Config & environment

Installers write env files under ~/.gpn/. Keep secrets there (chmod 600) — never in a repo or a webpage.

Miner / node — `~/.gpn/gpn.env`

GPN_NETWORK=testnet
GPN_ENDPOINT=wss://<testnet-rpc>:9944
GPN_WALLET=<your-ss58-address>
GPN_DATA=~/.gpn/data
OLLAMA_BIN=~/.gpn/ollama/bin/ollama
OLLAMA_MODELS=~/.gpn/models

Access point — `~/.gpn/accesspoint.env`

GPN_LISTEN=0.0.0.0:8092
GPN_ENDPOINT=ws://127.0.0.1:9944
GPN_PROVIDERS=http://127.0.0.1:8093
# GPN_SIGNER_URI=          # testnet free-AI hot wallet (omit for mainnet client-signed)
# GPN_AP_TOKEN=            # required for non-loopback POSTs
# GPN_PUBLIC_URL=http://your-host:8092

Reference

Ports & endpoints

Port	Service	Purpose
`30333`	p2p (libp2p)	Peer discovery & block gossip (bootnode inbound).
`9944`	RPC (ws)	Chain RPC — jobs, escrow, attestation, result hashes.
`8092`	Access point	Public job API + scheduler (`gpn_scheduler`).
`8093`	Provider heartbeat	`GET /status` — capabilities, load, latency.
`8082`	REST API / explorer	Local `gpn_api` / read-only explorer.
`8081`	Faucet	Dev/testnet GPN drip.
`8080`	dapp (web UI)	No-code chat / image / video / fine-tune.

Open the firewall (and port-forward, for remote peers) on whichever of these you expose. Outbound joins never need port-forwarding — only the receiving host does. If your ISP uses CGNAT, inbound forwarding won't work at all.

Next: use the AI → Full run-a-node guide

Run it: a node, or an access point

Run a node (mine + serve)

Install

Start the node

Or mine against a remote node (lighter)

Get paid

How a node serves AI (LLM / image / video / fine-tune)

Run the node + REST API

Onboard the GPU (one-time, per fresh chain)

Start the executors

Advertise a reachable status URL

Run an access point

Install + run

Verify

Expose it

Windows node (mine + serve)

1 · Backend (Ollama)

2 · A wallet

3 · Reachable /status

Config & environment

Miner / node — ~/.gpn/gpn.env

Access point — ~/.gpn/accesspoint.env

Ports & endpoints

Miner / node — `~/.gpn/gpn.env`

Access point — `~/.gpn/accesspoint.env`