ForgeMiner

A fast, native NVIDIA GPU miner — Pearl (PRL), QubitCoin (QTC), KawPow (Ravencoin, Quai, Neurai), Cryptix (CYTX), BTX (btx.dev), Xelis (XEL), Conflux (CFX) and NOID (Parano1d)

Contents

• Overview
• Download
• Quick start
• Coins & dev fee
• Features
• Options
• Monitoring API
• CMP hardware unlock (Linux)
• Supported GPUs
• Resources

Overview

ForgeMiner is a high-performance, fully native NVIDIA GPU miner. It talks to the GPU directly through the CUDA Driver API — no Python, no WSL, no extra runtimes — so it starts instantly and runs lean even on low-spec rigs. It mines Pearl (PRL), QubitCoin (QTC), KawPow (Ravencoin RVN, Quai QUAI, Neurai XNA), Cryptix (CYTX), BTX (btx.dev), Xelis (XEL), Conflux (CFX) and NOID (Parano1d) from a single binary — pick the coin with one flag — and more coins are on the way.

Every algorithm ships a separate per-architecture build for each supported card, auto-selected at launch, so each GPU runs at its peak. Rigs with CMP 40HX, 50HX, 70HX or 90HX get built-in hardware unlock on Linux via one command, on any kernel — see CMP hardware unlock.

Website: forgeminer.org · ForgeMiner is closed-source; releases are published here and announced on Telegram and Discord.

Download

Grab the latest build from the Releases page:

Quick start

Windows

1. Download and unpack the Windows release.
2. Open the .bat for your coin/pool/region and set your wallet and worker. There is one folder per coin, 102 ready-made launchers in all (-SSL = encrypted connection):
   • Pearl (PRL)\ — 22: Kryptex, LuckyPool, HeroMiners, BaikalMine, 2Miners, AlphaPool
   • Ravencoin (RVN)\ — 19 · Quai (QUAI)\ — 14 · Neurai (XNA)\ — 12
   • Conflux (CFX)\ and Xelis (XEL)\ — 10 each
   • QubitCoin (QTC)\ — 6 · BTX\ — 4 · NOID (Parano1d)\ — 3 · Cryptix (CYTX)\ — 2
3. Double-click to start. Run as Administrator to apply the built-in overclock.

Linux

chmod +x forge
# Pearl
./forge --algorithm pearlhash --wallet YOUR_PRL_WALLET --pool prl.kryptex.network:7048 --worker rig01
# QubitCoin
./forge --algorithm qhash --wallet YOUR_QTC_WALLET --pool ru.luckypool.io:8610 --worker rig01
# KawPow — RVN / QUAI (coin auto-detected from the pool) or XNA (set --coin xna)
./forge --algorithm kawpow --wallet YOUR_RVN_WALLET --pool rvn.kryptex.network:7031 --worker rig01
# Cryptix
./forge --algorithm cryptix --wallet YOUR_CYTX_WALLET --pool cytx.baikalmine.com:9010 --worker rig01
# BTX — 8666 is LuckyPool's new protocol. Its old port is still up and needs the scheme:
#       --pool stratum+tls://btx-eu.lproute.com:8665
./forge --algorithm btx --wallet YOUR_BTX_WALLET --pool btx-eu.lproute.com:8666 --worker rig01
# Xelis
./forge --algorithm xelis --wallet YOUR_XEL_WALLET --pool xel.kryptex.network:7019 --worker rig01
# Conflux (needs a 12 GB card; see the note under the table below)
./forge --algorithm cfx --wallet YOUR_CFX_WALLET --pool cfx.kryptex.network:7027 --worker rig01
# NOID (RTX 30-series and newer)
./forge --algorithm noid --wallet YOUR_NOID_WALLET --pool stratum+ssl://eu2.innovlab.cc:19601 --worker rig01

The Linux binary is built against glibc 2.17, so it runs on anything from CentOS 7 / Ubuntu 14.04 upwards — no CUDA toolkit, no extra libraries, just the NVIDIA driver. Add --api-bind 0.0.0.0:7777 to any of the commands above and open http://<rig>:7777 for the built-in dashboard.

Docker

docker pull hashraptor/forge
docker run --rm --gpus all hashraptor/forge \
  --algorithm pearlhash --wallet YOUR_PRL_WALLET --worker rig01 --pool prl.kryptex.network:7048
# dashboard: add -p 7777:7777 and --api-bind 0.0.0.0:7777

HiveOS

Custom miner flight sheet — installation URL https://github.com/0xHashRaptor/ForgeMiner/releases/download/v<version>/ForgeMiner-<version>.tar.gz (e.g. v1.8.4/ForgeMiner-1.8.4.tar.gz), wallet template %WAL%.%WORKER_NAME%.

To upgrade, change the version in that URL (both places) and update the flight sheet — every rig on it reinstalls. HiveOS installs a custom miner once per URL: with an unchanged URL it reports Already installed and keeps the old version. Rigs set up with the old .../releases/latest/download/ForgeMiner.tar.gz link stay on the release they first installed; switch them to the versioned URL, or run custom-get https://github.com/0xHashRaptor/ForgeMiner/releases/latest/download/ForgeMiner.tar.gz -f on the rig and restart the miner.

Extra config accepts both forms, one per line, and you can mix them:

FORGE_ALGO=xelis            # or pearlhash / qhash / kawpow / cryptix / btx / cfx / noid
FORGE_COIN=xna              # KawPow only: rvn | quai | xna
--gpu 0,1,3                 # mine only these cards
--cclk 1500 --moff 1000     # overclock: also --coff / --mclk / --plimit
--fan 70                    # or --fan-curve 45:30,60:55,70:75,80:100
--cmp-install               # unlock any CMP 40HX/50HX/70HX/90HX on the rig (safe to leave in permanently)
--temp-limit 80 --temp-resume 70   # pause a card on overheat, resume once it cools

Hashrate, temperatures and shares appear in the HiveOS dashboard on their own — no extra flag needed. Add --api-bind 0.0.0.0:7777 only if you also want the miner's own web dashboard.

Ready-made flight sheets: forgeminer.org/#flightsheets.

Coins & dev fee

Conflux needs about 8.6 GB of video memory, and that requirement grows slowly as the chain advances: 8 GB cards cannot mine it, 10 GB is tight, 12 GB and up is comfortable. The miner checks your card at startup and says so with the actual numbers rather than failing partway through.

NOID runs on the RTX 30-series and newer, CMP 90HX included. On a mixed rig the older cards stay idle and say so once, while the rest of the rig mines it.

The dev fee is interleaved (no graph dips) and verifiable on your pool. No hidden second fee. More algorithms are on the way.

Features

• Multiple coins, one binary — Pearl, QubitCoin, KawPow (RVN / QUAI / XNA), Cryptix, BTX, Xelis, Conflux, NOID or Quantus; select with --algorithm.
• Architecture-tuned kernels — a dedicated kernel per GPU generation (Pascal / Volta / Turing / Ampere / Ada / Blackwell), auto-selected at launch.
• CMP 40HX / 50HX / 70HX / 90HX hardware unlock (Linux) — one embedded command unlocks any of these cards from the stock throttled hashrate to full speed; no external scripts, no exact kernel requirement (driver 610.43.03 still required).
• Native and lightweight — direct CUDA Driver API, near-zero CPU load; no Python, WSL or extra runtimes. Starts in a second, runs on weak hosts and many-GPU boxes.
• Efficient on crowded rigs — keeps the GPUs fed even with many cards on a weak CPU, several miner instances or slow x1 risers.
• One self-contained binary — everything embedded; no CUDA runtime or loose kernel files to manage. Even KawPow ships as a single executable.
• Built-in overclocking & fan control — lock clocks, apply offsets, set a power limit and drive fans straight from the miner — a different OC per card on mixed rigs. No third-party tool.
• Temperature protection — --temp-limit / --temp-resume pause a card automatically if it overheats, and resume once it cools back down.
• Multi-pool with fail-over — standard Stratum for every coin. An encrypted pool is detected on its own, so a bare host:port works whether the pool speaks TLS or not; list several addresses through a comma and the miner moves to the next one when a pool drops.
• Live dashboard & read-only API — the per-card table stays pinned at the top with the log scrolling underneath (press L for the classic view). Per-GPU hashrate, temps (incl. VRAM on Windows), clocks, fans, power and shares, plus a delivery figure showing how much of the hashrate the pool actually credits — and JSON, Prometheus and Claymore-compatible endpoints.
• HiveOS ready — drops straight into a custom-miner slot.

Options

Anything you pass on the command line has a FORGE_* environment-variable twin — handy for HiveOS Extra config and .bat files.

# per-GPU (values map to --gpu order)
--gpu 0,1,2,6 --coff 300,250,300,200 --plimit 280,280,300,260

# * = leave that card alone: GPU 2 keeps its current clocks and automatic fan
--gpu 0,1,2,6 --cclk 1500,1500,*,1500 --fan 70,70,*,70

Monitoring API

Off by default and read-only — it only reports stats; it can never control or reconfigure the miner.

--api                    on 127.0.0.1:7777 (this machine only)
--api-bind 0.0.0.0:7777  on the LAN (watch from your phone / another PC)

On HiveOS set FORGE_API=127.0.0.1:7777 in Extra config.

Keep the default 127.0.0.1 for local-only access; use 0.0.0.0 only behind your own router / firewall / VPN.

CMP hardware unlock (Linux)

CMP 40HX, 50HX, 70HX and 90HX ship with a hardware throttle that keeps their hashrate at a small fraction of what the chip can actually do. Forge can install a hardware-unlock helper directly on the rig — one command, one reboot, the card then runs at full speed. The helper is embedded in the miner binary; no external download, no manual steps.

Builds from source for whatever kernel the rig is actually running — no exact kernel version required (NVIDIA driver 610.43.03 is still required), tested clean across 10 different kernel versions. Only the detected CMP cards are touched; every other GPU on a mixed rig runs untouched. CMP 30HX is detected but never attempted — it's a permanent hardware limitation on that chip, not a bug or an oversight.

Safe to leave --cmp-install at the end of the flight-sheet command line permanently — if the unlock is already active, forge prints one line and drops straight into mining. Full guide (verification, FAQ): wiki · CMP hardware unlock.

Supported GPUs

Kernels are tuned per architecture, so a whole generation is covered — desktop and laptop alike.

Every coin runs on every listed generation except three: BTX and Conflux need Turing (RTX 20 / CMP 40HX-70HX) or newer and do not run on Pascal, Volta or the CMP 170HX; NOID needs Ampere (RTX 30 / CMP 90HX) or newer.

Resources

• Website: forgeminer.org
• Releases & news: t.me/ForgeMiner
• Support & chat: t.me/ForgeMinerChat
• Discord: discord.gg/CyU6ASQWSy
• CMP hardware unlock guide: wiki · CMP hardware unlock

_{© 2026 ForgeMiner. Not affiliated with NVIDIA. Mine responsibly.}