Mine Monero. On the computer you already own.
RandomX is proof of work designed so an ordinary CPU stays competitive. This is the doing page: what to install, what to run, and what it costs you to know.
CPU-focused mining with RandomX is simple, hyper-decentralized, and open to almost any practical device with a CPU.
Three programs on one machine: your node, P2Pool, a miner. No account, no operator, no application, no minimum balance. Nothing to be approved for.
RandomX is “optimized for general-purpose CPUs” and uses “random code execution together with several memory-hard techniques to minimize the efficiency advantage of specialized hardware”. The consequence is the point: the machine you already own is not obsolete against a machine built to beat it.
A 64-bit CPU and enough free memory for the miner's dataset — 2080 MiB in fast mode, or 256 MiB in light mode, which works and is much slower. A laptop qualifies. A Pi 5 qualifies. A phone qualifies.
One half is protocol: the tail emission pays 0.6 XMR per block with no end date, so there is always a reward to mine for — Monero has no security cliff waiting for it. The other half is not a law of nature. “RandomX stays CPU-friendly” is a decision the network keeps making, and work on a successor proof of work is live upstream in the Monero Research Lab. This page links that work and asserts nothing about it — no parameters, no dates, no performance claims, because none have been published to assert.
Three ways to point a miner, and they are not equivalent. P2Pool's own README puts it plainly: “While pool mining is the easiest to set up, it centralizes the Monero network and the pool admin gets full power over your hashrate and your unpaid funds. Solo mining is 100% independent and the best for the network. P2Pool mining has all the advantages of solo mining, but also makes regular payouts possible.” This page recommends P2Pool, and the walkthroughs below all target it.
Easiest: install a miner, point it at someone's server, done. In exchange the operator holds your unpaid funds, decides what you mine, and — in P2Pool's own words — “can execute attacks against the network”. Fees run 0–3%, minimum payouts 0.001–0.01 XMR.
Your node builds the block, so nobody else chooses anything. 0% fee, 100% under your control, as stable as your own node. The cost is rarity: you are paid when YOU find a block, which means a minimum payout of 0.6 XMR or more and long silences between.
A separate blockchain merge-mined with Monero, so the pool has no server and no admin. “There is no pool wallet, funds are never in custody. All pool blocks pay out to miners directly.” 0% fee, no payout fee, minimum around 0.00027 XMR. You run a node and a P2Pool daemon beside your miner — that is the whole extra cost.
P2Pool states its own downside and so does this page: if the sidechain does not have enough hashrate to find Monero blocks faster than about every six hours, not all your shares result in a payout — and even above that, luck can carry a share through the window unpaid. Upstream's position is that it averages out over time. That is a claim about the long run, not a promise about your week.
Because it cannot be measured from the chain. A Monero coinbase transaction does not identify the pool that mined it, so any published pool ranking is somebody's survey of self-reported figures, not an on-chain fact — and this page has no way to check one. The Skyline simulator models pool concentration with figures it labels illustrative, for exactly that reason. A number here would be decoration wearing a data badge.
Wallet addresses are public on P2Pool. The sidechain is a real blockchain and payouts are made directly to miners, which means the address you mine to is visible to anyone reading it. Upstream's own recommendation is to create a new mainnet wallet for mining, and on a site about transaction privacy that recommendation is not a footnote — it is the first instruction. Monero's on-chain privacy is unaffected either way; what leaks here is the association between an address and a miner, and a fresh wallet is the whole fix.
Two more from the same source, worth the ten seconds: run mining under a separate restricted user account on your OS, and note that P2Pool supports mining over Tor and I2P if your threat model asks for it.
Each block is complete on its own — install, configure, point at P2Pool and your node, then check it is really hashing. Almost every command below is quoted verbatim from the README named beside it. Three are not, and each says so where it appears: P2Pool's macOS build steps are joined into one line so a single copy does the whole build, XMRig's build guide lives somewhere this page cannot quote from so those are the standard CMake steps, and the Android miner points at your LAN instead of localhost. Nothing here was invented. Substitute your own wallet address wherever YOUR_WALLET_ADDRESS appears; it is a primary address, the one starting with 4.
Download the latest P2Pool and XMRig releases and expand them into one folder, then create a Monero folder inside it and put the Monero binaries there. Windows SmartScreen may block files downloaded from the internet: open each once, choose “More info”, then “Run anyway”, and close it again. XMRig needs huge pages, which on Windows 10 and above means running it as Administrator once.
$ .\Monero\monerod.exe --zmq-pub tcp://127.0.0.1:18083 --out-peers 32 --in-peers 64 --add-priority-node=p2pmd.xmrvsbeast.com:18080 --add-priority-node=nodes.hashvault.pro:18080 --enforce-dns-checkpointing --enable-dns-blocklist$ .\p2pool.exe --host 127.0.0.1 --wallet YOUR_WALLET_ADDRESS --mini$ .\xmrig.exe -o 127.0.0.1:3333XMRig prints its own speed once it connects, and P2Pool logs each share it accepts from you — those two together are the check that it is really working. Any wallet address configured in XMRig is ignored when mining to P2Pool: the address in step 2 is the one that gets paid.
Take the latest P2Pool release and the linux-static-x64 XMRig build, or compile both. All three programs want huge pages, so reserve them first. Open ports 18080 (Monero peer-to-peer) and 37888 (P2Pool mini) in your firewall for better connectivity.
$ sudo sysctl vm.nr_hugepages=3072$ ./monerod --zmq-pub tcp://127.0.0.1:18083 --out-peers 32 --in-peers 64 --add-priority-node=p2pmd.xmrvsbeast.com:18080 --add-priority-node=nodes.hashvault.pro:18080 --enforce-dns-checkpointing --enable-dns-blocklist$ ./p2pool --host 127.0.0.1 --wallet YOUR_WALLET_ADDRESS --mini$ ./xmrig -o 127.0.0.1:3333$ grep -E 'WARNING|ERROR' p2pool.logA quiet log plus XMRig's own speed readout is the healthy state. Initial P2Pool sync should not take more than five to ten minutes. If your upload bandwidth is under 10 Mbit, upstream suggests --out-peers 8 --in-peers 16 instead. To build rather than download, P2Pool's README carries the exact package list per distribution.
XMRig publishes official macOS binaries. P2Pool is built from source, which is five commands and needs no prior C++ knowledge. For the node itself, the node page covers the click-to-install macOS bundle.
$ brew update && brew install git cmake libuv zmq libpgm curl$ git clone --recursive https://github.com/SChernykh/p2pool$ cd p2pool && mkdir build && cd build && cmake .. && make -j$(sysctl -n hw.logicalcpu)$ ./monerod --zmq-pub tcp://127.0.0.1:18083 --out-peers 32 --in-peers 64 --add-priority-node=p2pmd.xmrvsbeast.com:18080 --add-priority-node=nodes.hashvault.pro:18080 --enforce-dns-checkpointing --enable-dns-blocklist$ ./p2pool --host 127.0.0.1 --wallet YOUR_WALLET_ADDRESS --mini$ ./xmrig -o 127.0.0.1:3333A laptop mining under load runs hot and loud, and thermal throttling will quietly take the speed back. If the fans matter to you, cap XMRig's thread count rather than leaving it to claim the machine.
Android mining is a Termux job, and it is the one platform here with no ready-made binary at either end. Install Termux from F-Droid or from its own GitHub releases — Termux's maintainers describe the Google Play build as an experimental branch with missing functionality, and recommend F-Droid or GitHub for everyone who can use them. Do not mix APKs from different sources; they are signed with different keys and will refuse to install over each other.
Two hard constraints before you start. The device must be 64-bit: P2Pool does not support ARMv7 or any 32-bit CPU, because RandomX is too slow in 32-bit mode. And there is no packaged XMRig in Termux, so it is compiled — with hwloc disabled, since Termux does not package that library either.
$ pkg install git build-essential cmake libuv libzmq libcurl openssl$ git clone https://github.com/xmrig/xmrig && mkdir xmrig/build && cd xmrig/build$ cmake .. -DWITH_HWLOC=OFF && make -j$(nproc)XMRig documents its build at xmrig.com/docs, which this page does not quote from. These are the ordinary CMake steps plus the one flag Termux forces, so check them against that guide rather than trusting this page for them.
$ ./xmrig -o 192.168.1.10:3333This is upstream's own miner invocation with the HOST changed: XMRig's documented line points at 127.0.0.1, which is right when P2Pool runs on the same box and wrong here, because it does not. Replace that address with your own P2Pool host on your LAN. Running the full stack on the phone is possible — P2Pool's README carries a Termux build for the daemon too — but a phone is a poor place for a synced node, and pointing it at a machine you already run is the shape that actually makes sense.
Sustained full-core load on a phone means heat, a flat battery and a throttled CPU within minutes, and heat is what ages a battery fastest. Mine on a charger, on a cool surface, in short sessions, and treat the result as participation rather than income. That is the honest framing for every device on this page, and it is unavoidable on this one.
XMRig donates 1% of your mining time to its authors by default — one minute in every hundred — and its README says so plainly. The level is a configuration option and can be turned down. This page is telling you to run the software, so it is this page's job to tell you that, rather than leaving you to find it in a config file later.
A network of equals, which is what a CPU-friendly proof of work plus a pool with no operator actually produces. Nothing in the picture is bigger than anything else, and there is no middle for anyone to occupy.
Illustrative topology. Peer positions come from a fixed seed, not from a map of the network — this site queries no peer crawler and draws no figure it cannot source. The one live reading on this page is the network hashrate above, from the node this site reads.
Every walkthrough above starts with a synced node of your own. That is the prerequisite page, and it is the item directly above this one in the Operate section.
/operate/node →The Superbrain community store packages P2Pool and XMRig as one Umbrel app that takes external miners over your LAN. The hub publishes the line that points one at it, and this page deliberately does not restate it — one surface owns that command.
/operate/superstress →The legality matrix carries a dedicated mine column, per jurisdiction, each row dated and cited. That is the answer to this question, and restating it here would only give it a second place to go stale.
Activated on the Monero network on 30 November 2019, after four independent security audits that year. The timeline has the event; the network page has the live seed hash and the difficulty it feeds.