Provision a hardware-tuned XMRig miner in one command. Companion miner for Pithead (or any RandomX Stratum pool).
Repo p2pool-starter-stack/rigforge, read from GitHub 14 min ago. p2pool-starter-stack has not joined Take My Repo.
p2pool-starter-stack/rigforge is a public repo on GitHub by p2pool-starter-stack. Provision a hardware-tuned XMRig miner in one command. Companion miner for Pithead (or any RandomX Stratum pool). It declares the MIT license on GitHub. It is written mainly in Shell, has 5 stars and last changed on 2026-11-22. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-22.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
RigForge provisions a tuned XMRig mining worker on a fresh Ubuntu/Debian machine. It installs the toolchain, compiles XMRig from source, applies kernel- and CPU-level tuning for RandomX hashrate, and runs it as a managed service. Point it at a pool to start mining.
macOS support is deprecated as of 2026-09-14: unsupported and untested going forward (no CI coverage, no bench). The Darwin code paths still work but get no further investment — see Running on macOS.
It works against any RandomX Stratum pool, and it's the companion miner for Pithead. Connect as many RigForge workers as you like to your stack's single endpoint.
RigForge is not a custom miner. It compiles stock, upstream XMRig and wraps it in the setup, hardware tuning, and service management that are otherwise fiddly to get right by hand.
Sets up the rig:
cmake, libuv, hwloc, …) and compiles a pinned, commit-verified
XMRig from source.hugetlbfs mounts + memlock limits.systemd service on Linux, with a cpupower performance governor and log
rotation..onion pool also offers a Tor SOCKS proxy override.Then keeps it running:
tune measures the fastest XMRig knobs on your actual hardware (live against the running miner,
or offline) and keeps the winners; it can optimize for raw hashrate or hashrate-per-watt, and
autotune in config.json re-tunes on a monthly schedule.watchdog restarts a wedged miner (alive but hashing 0 H/s), and with max_temp_c set
it stops the miner above that temperature and resumes once it cools.doctor health-checks HugePages, the MSR mod, the governor, the service, and the pool
connection (the miner's own view of it); doctor --json emits the same checks for automation,
while status shows live hashrate, pool, uptime, and shares.bios is a guided, resumable walkthrough of the BIOS/UEFI changes RigForge can't make itself
(XMP/EXPO, SMT, PBO/Eco Mode), and re-verifies what took after the reboot.stress --minutes 30 checks Linux stability after BIOS changes; bench checks the computed hash
as well as speed, and offline tuning rejects candidates that fail verification.backup and restore snapshot your config and tuning; support-bundle collects a redacted
tarball for bug reports; completion prints bash/zsh tab-completion.config.json stays authoritative. See
Pithead Integration.uninstall removes the service and reverts every system change it made.RigForge automates upstream XMRig tuning. The benefit depends on the hardware and the starting OS configuration.
The historical benchmark report records live-mining observations on a Ryzen 7800X3D and an EPYC 7642. These are illustrative results, not measurements of the RigForge baked into Pithead 2.0.0. Reported power and efficiency use CPU-package RAPL, not wall power; they do not establish whole-system efficiency or temperature gains.
No percentage uplift is established here for the current candidate. Numeric launch claims require the candidate comparison protocol and a dated report for the exact baked revision.
On the machine you want to turn into a miner:
git clone --branch v1.19.0 https://github.com/p2pool-starter-stack/rigforge.git
cd rigforge
chmod +x rigforge.sh
sudo ./rigforge.sh
The script needs root to install packages and tune the system. First-run setup asks for your pool URL
and optional password. For an .onion pool it offers a validated SOCKS proxy override, defaulting to
127.0.0.1:9050; install and run Tor yourself. It writes a minimal config.json. On Linux, reboot
once afterward to apply the HugePages tuning;
the xmrig service then starts automatically.
Mining to a public pool like SupportXMR? Point
urlat the pool and set your Monero wallet as the pooluser(most pools also want their TLS port). See Configuration › Connecting to a public pool. With a Pithead stack you need no wallet, just the stack'shost:3333.
➡️ Full walkthrough: docs/getting-started.md
Installing from a release download instead of a clone? Verify the checksums first:
sha256sum -c SHA256SUMS --ignore-missing
See SECURITY.md › Release integrity for what this does and doesn't prove — deploying from a git checkout at the release tag is the stronger anchor.
Prefer apt? Debian and Ubuntu installs can track releases through the project's signed apt
repository. Install the signing key and check its printed fingerprint against
packaging/apt/fingerprint in this repository:
sudo install -d -m 0755 /etc/apt/keyrings
curl -fsSL https://p2pool-starter-stack.github.io/rigforge/apt/rigforge.asc |
sudo tee /etc/apt/keyrings/rigforge.asc >/dev/null
gpg --show-keys --with-colons /etc/apt/keyrings/rigforge.asc | awk -F: '/^fpr/{print $10; exit}'
The printed fingerprint must match the pinned one. Then add the Deb822 source and install:
printf 'Types: deb\nURIs: https://p2pool-starter-stack.github.io/rigforge/apt/\nSuites: ./\nSigned-By: /etc/apt/keyrings/rigforge.asc\n' |
sudo tee /etc/apt/sources.list.d/rigforge.sources >/dev/null
sudo apt update && sudo apt install rigforge
sudo apt upgrade rigforge keeps the worker current and first-run setup is unchanged
(rigforge --version confirms the install). What the signature proves, and how the key is held,
is in SECURITY.md › Release integrity. Until the first signed
release is published the feed URL is not live and the pinned fingerprint file is a placeholder.
| Guide | What's inside |
|---|---|
| Getting Started | Prerequisites, install, first-run setup, the Linux reboot, and verification. |
| Hardware Requirements | Worker CPU / RAM / HugePages requirements and the per-CPU tuning profiles. |
| Benchmarks | Historical stock-vs-tuned observations, CPU-package (RAPL) power only, not wall power, and the candidate comparison protocol. |
| Configuration | Every config.json key and default, and how the XMRig config is generated. |
| Shared-host profile | Opt-in CPU and memory bounds for co-resident workloads. |
| Operations & Maintenance | The full command reference, service management, logs, upgrades, and troubleshooting. |
| How It Works | What the script actually does: compile, HugePages, MSR, NUMA, governor, service. |
| Pithead Integration | The worker ↔ dashboard contract: discovery via :3333, the read-only API on :8080 (plus the optional enriched sister API on :8081), and the token rules. |
| FAQ | Common questions, plus why RigForge vs. doing it by hand. |
Browse the full index at docs/.
The everyday tasks, each a single command. There's a task-by-task cheat sheet in Operations › Common tasks.
# Change a setting — edit config.json first, then:
sudo ./rigforge.sh apply # regenerate config + restart (no rebuild)
# Upgrade to a new release (your clone is pinned to a tag, so check out the new one):
git fetch --tags && git checkout vX.Y.Z && sudo ./rigforge.sh upgrade # apply the release: regenerate config, reinstall units, restart
sudo ./rigforge.sh tune --now # run a live tune now — keep the best prefetch mode
sudo ./rigforge.sh doctor # health check: HugePages, MSR, governor, service, pool connection
./rigforge.sh logs # follow live logs, no root needed (also: status; sudo for start / stop / restart)
sudo ./rigforge.sh # provision (or re-provision) the worker — idempotent
See Operations › Commands for the full reference.
RigForge runs as root, so it's worth being explicit about what it does and doesn't do:
upgrade --check queries the
GitHub releases API, but only when you run it — nothing is scheduled and nothing else calls it.)
The only outbound traffic is
to your pool, to the pinned XMRig source on GitHub (cloned and commit-verified before building),
to RigForge's own origin for an opted-in remote upgrade, and to your distro's package mirrors.
tor_socks5 routes the GitHub fetches (upgrade --check, the XMRig clone, the remote-upgrade fetch)
through a SOCKS5 proxy; package installs stay yours to route. Explicit bench --submit and bench --verify ID also contact
the upstream benchmark service; submission publishes hardware and performance information."DONATION" to a nonzero percentage to support
the XMRig developers. After the one-time build migration on upgrade, lowering it takes effect
with apply, without rebuilding. Explicit values in config.json are preserved.:8080 for the
Pithead dashboard. It's restricted (read-only,
can't control the miner) and open by default (set ACCESS_TOKEN in config.json to require a Bearer token). It binds the LAN by default; if you mine solo or to a public
pool you don't need it at all and can firewall the port off.Full detail, and the exact ufw commands to lock down :8080, are in SECURITY.md.
RigForge ships a dependency-free test suite plus an opt-in container end-to-end run. Both mirror the
CI jobs, so make test locally is what CI checks.
make lint # shellcheck + shfmt the script, utilities, and test scripts
make test # lint + the dependency-free suite (runs on macOS or Linux, no Docker)
make test-e2e # full end-to-end in disposable Linux containers (needs Docker)
make test-e2e-macos # native macOS e2e: real rigforge.sh, real launchctl/nohup/BSD tools (macOS only, deprecated, not run in CI)
make coverage # measure rigforge.sh + util coverage via kcov, enforce the floor (needs Docker)
make smoke # release pre-tag gate (quick): real xmrig --bench proves the built worker hashes (manual)
make e2e-real # release pre-tag gate (full): real build+tune+bench+doctor+uninstall on a rig (root)
What make test covers. It sources rigforge.sh and exercises its functions in isolation, with
every external/privileged command (git, make, cmake, sudo, systemctl, modprobe,
apt-get, …) and all hardware detection (uname, lscpu, sysctl, nproc, hostname) replaced by
fakes on PATH. Because the hardware is faked, one run on any machine simulates every supported
platform. It asserts the generated XMRig config for EPYC / Ryzen X3D / generic-Linux inputs and the
deprecated macOS path, plus config parsing, DONATION validation, host resolution, and a full stubbed
deployment run (executed twice to prove idempotency).
What make test-e2e adds. It runs the real rigforge.sh end-to-end inside a throwaway
ubuntu container (RigForge's documented Linux target, linux/amd64), against a real, disposable
/etc. This validates the Linux-only deploy path with genuine tools (GNU sed, envsubst, the
fstab/limits/GRUB edits and their idempotency) which can't run natively on a macOS host. Only the
heavy XMRig compile and the package install are stubbed. It skips cleanly if Docker isn't available.
No XMRig binary is compiled by the tests; the heavy native build is stubbed. The suite asserts the
orchestration (clone → patch donate.h → cmake → make) and the generated configuration instead.
make coverage measures line coverage of rigforge.sh + the shell helpers in util/ by running the
suite under kcov (in a digest-pinned container, since kcov is
Linux/ptrace based). The black-box tests run the real script against a sandbox via RIGFORGE_HOME,
so both the sourced functions and the command-dispatch paths are credited. CI enforces two gates: a
committed total floor (tests/coverage-floor.txt, ratcheted up over
time) and, the important lever, patch coverage (diff-cover against the PR's base branch,
normally develop) so new/changed lines must be tested. Neither needs an external service.
make smoke closes that gap at release time. Because the suites never compile or run XMRig, they
can't prove the shipped binary actually starts and hashes. make smoke benches a real worker
(xmrig --bench, fully offline) on a real rig and passes only if a hashrate is reported and the run is
clean. It's a manual, Linux-only-for-full-effect pre-tag gate, not a CI job. See
RELEASING.md.
For how RigForge is versioned and released, see RELEASING.md and CHANGELOG.md.
If RigForge saved you time and you'd like to support it, donations to this XMR wallet (the maintainer's wallet, separate from XMRig's own dev donation) are appreciated:
486aGn4qhH1MkaASjnEWMDN7stD1SVtPF5fvihmjffeBE5ACL1u1jU95KxiqmoiaPZMexi4R4W11MLXut66XWVVF8wjAE5R
Provided "as-is" under the MIT License.
RigForge itself is MIT; XMRig is GPLv3. RigForge clones and compiles upstream XMRig source on your own machine and redistributes no XMRig binaries.
p2pool-starter-stack/rigforge is a public repo on GitHub by p2pool-starter-stack. Provision a hardware-tuned XMRig miner in one command. Companion miner for Pithead (or any RandomX Stratum pool).
It declares the MIT license on GitHub.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-11-22. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
RandomX, KawPow, CryptoNight and GhostRider unified CPU/GPU miner and RandomX benchmark
The quip network mining stack. This includes a coordinator and links all of the official quip network miners.
以太坊矿池代理,可以自定义抽水地址和比例 ,支持热修改抽水比例。go语言编写,性能极高,唯一正版,明码标价开发费,拒绝暗抽!!!!!!

Private Monero + Tari merge mining — the whole stack in one command: full node, P2Pool, XvB optimizer, and a live dashboard, all behind Tor.
p2pool-starter-stack — the org showcase site: Pithead, RigForge, and the node-starter stacks to come. Built with Hugo.
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/p2pool-starter-stack/rigforgeTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.