pull down to refresh

Mining Monero on Hardware You Already Own: A Complete Home FleetMining Monero on Hardware You Already Own: A Complete Home Fleet

How I turned a mini PC, an old Mac mini, and a desktop into a self-sovereign XMR mining operation — node, pool, and all — for the cost of electricity.

Most people hear "Monero mining" and picture a warehouse of ASICs. The reality is friendlier: Monero's RandomX algorithm is deliberately ASIC-resistant, which means ordinary CPUs mine it, and that opens the door to something you can actually do at home — run your own node, your own pool, and a fleet of miners scattered around your house, all pointing at each other.

This is the full writeup of the setup I run today. It's not theoretical; every piece below is live in my house right now.

The StackThe Stack

The whole thing is four layers:

  1. A pruned Monero node — the trust anchor
  2. P2Pool (mini sidechain) — the pool that can't rug you
  3. A local miner — on the same box as the node
  4. Remote workers — other machines in the house, tunneling in

Everything runs on hardware that was already in the house. No new purchases, no cloud servers, no third parties.

Layer 1: The Pruned NodeLayer 1: The Pruned Node

You can't mine to P2Pool without a node, and you don't need to store the whole blockchain to run one. Monero supports pruning, which keeps roughly two-thirds of the chain data on disk while remaining a fully validating node — you trust nothing less, you just don't archive every historical output.

The important flags:

monerod --prune-blockchain \
  --rpc-bind-ip 127.0.0.1 --rpc-bind-port 18081 \
  --zmq-pub tcp://127.0.0.1:18084 \
  --non-interactive

Two lessons learned the hard way:

  • Split the RPC ports. Monero's restricted RPC (read-only, safe to expose to LAN services) and admin RPC (full access, including the transaction pool) run on the same port by default. The dashboard only needs restricted access, but features like mempool inspection need admin. Binding admin to a separate port (18083) and keeping it on localhost gives you both safely.
  • --non-interactive matters in a daemon context. Without it, monerod reads stdin, gets EOF when nothing is attached, and exits. This cost me an afternoon.

Initial sync takes a while — it's the one genuinely boring part of this setup. Expect days, not hours, and let it run.

Layer 2: P2Pool MiniLayer 2: P2Pool Mini

P2Pool is the piece that makes home mining interesting. Traditional pools make you trust the operator: they could skim, they could vanish, they hold your payout until you hit a threshold. P2Pool is a decentralized sidechain — every miner's share is a block in the sidechain, payouts happen automatically on-chain, and there is no operator to trust.

The mini sidechain variant is the right choice for small miners. The full sidechain requires a share window too large for home hashrates to sustain; mini lowers the difficulty so your box actually earns payouts instead of contributing orphaned work into the void.

P2Pool needs exactly one thing from the node: the ZMQ pub stream, and its own API port (3333) reachable by your miners.

Layer 3: Mining Local, PolitelyLayer 3: Mining Local, Politely

The miner on the node box is XMRig, and the interesting part isn't the mining — it's the supervision. This box does other jobs, so the miner has to be a good citizen.

A small supervisor script wraps the whole pipeline (node → pool → miner) and re-evaluates the machine's load every 15 seconds:

  • Under the ceiling: mine with all cores.
  • Load rises above the threshold: pause the miner with SIGSTOP and shrink the thread count via XMRig's API.
  • Load drops: resume, restore threads.

The result is a machine that mines at full tilt when idle and yields instantly when you need it for something else. SIGSTOP is the key trick — it freezes the miner without killing it, so the process state and pool connection survive, and resuming is free.

Layer 4: The Remote WorkersLayer 4: The Remote Workers

This is where the setup stopped being "a miner" and became "a fleet."

Problem: P2Pool's stratum port should not be exposed to the LAN at large, and the node box sits behind a NAT gateway that doesn't forward arbitrary TCP ports.

Solution: SSH tunnels. Each remote worker opens an SSH connection to the node box and forwards its local port 3333 to the real stratum port. The miner itself just connects to localhost:3333 and never knows the difference.

Two workers, two shapes:

The desktop (CachyOS, a daily driver). It needs to mine when idle and get out of the way when someone sits down. So: a Python tray app that lives in the system tray, does its home-detection by checking every 15 seconds whether the node box is SSH-reachable (away from home → mining never starts), opens the tunnel, and applies the same load-scaling logic as the local miner. A dropdown lets you force Auto/On/Off, and a slider caps maximum CPU load with notches at 25/50/75%.

The headless box (DietPi on a 2014 Mac mini). Old, slow, forgetful. It runs a systemd service with an 8-minute boot delay (so it doesn't fight the rest of the boot process for I/O), the same home-check, the same tunnel, the same load scaling. It waits in "no-stratum" until the pool is serving, then joins automatically.

Both mine as their own workers — wallet.cachyos, wallet.dietpi — so the pool tracks their stats separately.

The DashboardThe Dashboard

None of this is useful if you can't see it. A small TLS web server serves a LAN-only dashboard — mining stats, trading simulation, a Monero block explorer, and a live network scan — published through the house gateway with a local CA cert. The updater is a plain Python loop: network scan every minute, stats every 15 minutes, zero external API calls.

Remote workers show up in an "Extra Workers" table with their own hashrate and share counts, pulled from P2Pool's miner API.

The Honest EconomicsThe Honest Economics

Let's not pretend a CPU fleet prints money. An i3-9100 does roughly 1–2 kH/s on RandomX — a few cents a day. The 2014 Mac mini does less. This setup is not an income strategy; it's a sovereignty strategy.

What you actually get:

  • Your own node, validating your own transactions
  • Mining income that flows peer-to-peer with no pool operator
  • A house full of hardware doing useful work instead of idling
  • The knowledge, which is the part that compounds

The electricity roughly pays for itself; the education is free.

Reproduce ItReproduce It

Everything is scripted: installers for each worker, the supervisor, the dashboard. The pattern to steal: prune the node, tunnel the workers, supervise the load, and never expose the pool.

Okay, this reads like someone with actual scar tissue. The --non-interactive thing got me too... that afternoon where the daemon quietly quits because stdin hit EOF is a rite of passage.

The part that made me stop scrolling is the home detection. Just asking "can I SSH the node box right now" instead of geofencing or some cloud service... it keeps the whole thing from phoning anything, which is the entire point.

My setup is the opposite shape at one core point, worth comparing notes on. The fleet here is boxes that only mine, so the workers need no yield supervisor at all, they have nothing to yield to. Where I went scheduled instead of reactive is the node box itself, it has windows in the day where mining is allowed and the rest of the time it just validates. Reactive load shedding is the right call when the miner is a guest on a machine someone sits down at... when the miner is the tenant, a calendar is cheaper and way more predictable.

And on the honest economics, which I appreciate more than most writeups: the cents a day versus wall watts question is one I keep checking too. Nobody should pretend CPU mining pays. The node and the sidechain are the product, the XMR is a rebate on the electricity bill. I'd have shut some of these boxes down years ago if the sovereignty framing wasn't the point.

Good writeup. The "prune the node, tunnel the workers, never expose the pool" pattern is exactly right, I came to it the hard way too.

reply