Matador Miner

> matador-miner --mode pool --worker rig1

A fast, headless GPU miner for BTX and its ENC_RC proof-of-work. Point it at your own node and keep 100% of every block, or pool-mine with one flag. It is fully decoupled from the node, so the miner can update or restart without ever touching btxd. Thousands of rigs run it today.

// ENC_RC is dense INT8 matmul. Ampere is a hard floor, not a preference.

[VIEW_REPOSITORY][LATEST_RELEASE]

[FLEET]

1000s

Rigs Mining

[DOWNLOADS]

121K

Release Pulls

[SHIPPED]

132

Releases

[LICENSE]

MIT

Open Source

Install_And_Mine

// Two commands from a bare rig to a rising ep/s

# fetch the latest release, verify the sha256, drop it on $PATH
curl -fsSL https://raw.githubusercontent.com/vanities/\
  matador-miner/main/install.sh | bash

# pool mine (repeat --pool for automatic failover to a backup)
matador-miner --mode pool \
  --pool stratum+tcp://stratum.minebtx.com:3333 \
  --worker rig1 --payoutaddress btx1...

Key_Capabilities

// What it does

[1] One Static Binary

No CUDA toolkit, no Python, no drivers beyond the NVIDIA one already on the rig. The CUDA backend auto-detects and starts solving in seconds.

[2] Solo Or Pool

Solo mines against your own btxd over the block-template RPC and keeps every block self-custodied. Pool mode speaks stratum with automatic failover. Same solver either way.

[3] Self-Updating, Safely

Atomically upgrades itself in-place — same PID, no node restart. Every release is sha256-verified before the swap, and a bake-time delay keeps the fleet off a brand-new build until a canary has proven it.

[4] Fleet-Ready

One coordinator holds the chain; disposable rigs hop on and off with zero warmup, share one wallet, and never collide thanks to a per-rig coinbase extranonce.

Technical_Stack

CUDA / C++

INT8 Tensor Cores

Stratum

Bitcoin-Core RPC

HiveOS Packages

systemd

Python Hub

MIT Licensed

Fleet_Architecture

The stateful, uptime-bearing parts — the archive node and the chain — live on one coordinator host. Everything else is a disposable, stateless solver. A worker can join for twenty minutes between jobs and contribute with zero warmup, because it carries no chain state. The coordinator exposes a least-privilege work proxy that forwards getblocktemplate and submitblock and refuses every other RPC method, so a compromised rig can never reach the wallet.

        COORDINATOR HOST (long uptime)
        +------------------------------------------+
        |  btxd  (archive/full node)                |
        |  matador-gbt-proxy :4071  least-privilege |
        |  matador-hub       :4070  telemetry       |
        +--------------------+---------------------+
                             |  LAN / VPN, token + firewall
      +--------------+-------+--------+--------------+
      v              v                               v
  +---------+   +---------+                     +---------+
  | worker  |   | worker  |        ...          | worker  |
  | no node |   | no node |                     | no node |
  +---------+   +---------+                     +---------+
  one fleet wallet; a per-rig coinbase extranonce keeps work disjoint

The_Hard_Part

BTX activated ENC_RC on mainnet and the proof-of-work stopped being a hash. The unit of work is now the episode: one full dependent INT8 GEMM chain per nonce, roughly 825ms on a 5090. That reshapes everything downstream.

The hardware list got short. NVIDIA Ampere or newer only. A card without INT8 tensor units is not slow at this work, it is out of the game — so Apple Silicon, AMD, and pre-Ampere builds were removed rather than shipped as decoration.
Correctness is byte-exact or it is nothing. A golden episode digest gates every build, and a CUDA build additionally has to report gpu == cpu == golden before it can ship. A solver that is fast and subtly wrong just mines rejects.
The health metric had to change. Hashrate is meaningless here. Rigs report ep/s and board power, and the value is small and fractional by design — which meant rewriting the dashboards, the HiveOS integration, and the watchdog rules around a degraded-rate signal instead of a hashrate one.
Updating a fleet is the real feature. 132 releases have gone out to rigs that nobody logs into. That only works because the update path verifies the sha256 before the swap, refuses a tampered download and keeps running the version it is on, and bakes new releases on a canary before the fleet is allowed to adopt them.

The public repo ships binaries; the solver source stays private. Everything around it — install, fleet, hub, HiveOS packaging, the verification guide for node and pool operators — is MIT and open.