The stack we build runs entirely on testnet — the coins it mines have no monetary value, and nothing in this article is about money. What I can measure honestly is the engineering question underneath the hardware: for a given graphics card, how much work does it do per watt it burns? That’s a capability-and-efficiency question, and it’s the only one I’m answering here.
I pulled seven cards off the used market — the kind you find for a few quid in a drawer or on a local listing — and ran them through four GPU mining algorithms on the testnet demo. Below are the hashrate (raw work done), power draw (what the card pulls at the wall under load), and the number that actually matters when you compare cards: hashes per watt (H/W). Treat every figure as an illustrative measurement from my own bench, not a spec-sheet guarantee — your silicon lottery, drivers, and ambient temperature will move these around.
01 · Why hashes-per-watt is the only fair yardstick
Raw hashrate flatters big, hungry cards. A 320 W card that out-hashes a 120 W card by 50% is less efficient — it’s doing less work for each unit of energy it consumes. If you care about heat, noise, your power bill, or simply the engineering elegance of a tidy rig, H/W is the number to optimise, not the headline hashrate.
So every card below gets measured three ways, and then I rank on the third:
- Hashrate — work per second, in the algorithm’s native unit (MH/s, GH/s, etc.).
- Power draw — wall-equivalent watts under sustained load, read from the card’s own telemetry plus a plug meter sanity-check.
- Efficiency — hashrate divided by power, the figure that lets a 75 W card and a 250 W card be compared honestly.
A card that loses on raw hashrate can win decisively on efficiency. That’s the whole point of the exercise.
02 · The bench setup
Everything ran on the same open-frame rig: a B450 board, a Ryzen 5 handling housekeeping, risers for each card in turn, and a single card mounted at a time so the power figure is clean (no shared-rail guesswork). Power was read at the wall with a plug-through meter and cross-checked against each card’s reported draw; I quote the steady-state figure after a 20-minute warm-up, not the spike at kickoff.
The four algorithms — KAWPOW (the RVN-family proof-of-work), kHeavyHash (the KAS-family algorithm), Autolykos2 (the ERG-family, famously memory-light), and Etchash (an ETC-family DAG algorithm) — were each pointed at the testnet demo. To be explicit: these are testnet networks, the work is real but the coins are valueless, and I let each card settle before recording.
03 · The seven cards, measured
Here’s the full grid. Each row is one card on one algorithm — I’ve listed the algorithm where that card is genuinely at its best, because pairing a card with the wrong algorithm tells you nothing useful. Figures are illustrative testnet-demo measurements.
| Card | Algo | Hashrate | Power draw (W) | Efficiency (H/W) |
|---|---|---|---|---|
| GTX 1650 (4 GB) | kHeavyHash | 0.55 GH/s | 70 W | 7.86 MH/W |
| GTX 1660 Super (6 GB) | kHeavyHash | 0.94 GH/s | 118 W | 7.97 MH/W |
| RTX 2060 (6 GB) | KAWPOW | 17.0 MH/s | 130 W | 0.131 MH/W |
| RX 580 (8 GB) | Etchash | 28.5 MH/s | 135 W | 0.211 MH/W |
| RTX 3060 Ti (8 GB) | Autolykos2 | 122 MH/s | 124 W | 0.984 MH/W |
| RX 6600 (8 GB) | kHeavyHash | 1.62 GH/s | 78 W | 20.8 MH/W |
| RTX 3070 (8 GB) | KAWPOW | 23.8 MH/s | 130 W | 0.183 MH/W |
Two things jump out before I even get to the winner. First, the algorithm matters as much as the card: the same RX 6600 that’s a star on kHeavyHash would be unremarkable on a DAG algorithm. Second, raw hashrate and efficiency rank the cards in completely different orders — which is exactly why I don’t trust hashrate alone.
04 · VRAM is the quiet gatekeeper
Before efficiency even enters the conversation, a card has to be able to run the algorithm. That’s a memory question.
- DAG algorithms (Etchash, and historically Ethash) grow their dataset over time. A 4 GB card that ran a DAG fine two years ago will eventually be locked out as the DAG outgrows its memory. The RX 580 4 GB variant is the classic casualty here; the 8 GB variant I benched still copes.
- KAWPOW wants headroom too — sub-6 GB cards either won’t start it or run with hashrate-sapping workarounds.
- kHeavyHash and Autolykos2 are the merciful ones. They’re light on memory, which is precisely why my 4 GB GTX 1650 only stays in this comparison at all on kHeavyHash. Point that same 1650 at a DAG algorithm and it simply drops off the list.
The practical reading: a <6 GB card is not a general-purpose miner — it’s a kHeavyHash/Autolykos2 card or it’s nothing. If you’re choosing among drawer cards, check the VRAM against the algorithm first, then worry about efficiency.
05 · Thermals and noise — the figures nobody quotes
Spec sheets quote hashrate. They never quote how loud the thing is at 3 a.m. in a box room, and that’s often what decides whether a card is actually liveable.
A few honest observations from the bench:
- Blower-style coolers (common on ex-OEM cards) hold temperature fine but are genuinely unpleasant above ~70% fan. The RX 580 sample was the loudest card here by a wide margin.
- Memory-junction temperature, not core temperature, is what kills cards over time — especially on the GDDR6 cards under DAG load. The RTX 3070 ran a cool core while its memory sat 30°C hotter; that’s the number to watch on a thermal pad re-paste.
- Undervolting is the single biggest lever on every figure in the H/W column. Every card above was at a sensible undervolt; left at stock voltage, the efficiency numbers get noticeably worse for the same hashrate. If you take one practical thing from this piece, it’s that an undervolt buys you efficiency and lower noise at once.
06 · The surprising efficiency winner
On raw hashrate, the RTX 3060 Ti looks like the hero of the table — 122 MH/s on Autolykos2 is comfortably the biggest single number here. But run the efficiency column and the story flips entirely.
The RX 6600 on kHeavyHash is the standout: 1.62 GH/s for just 78 W, which works out to roughly 20.8 MH/W — an order of magnitude ahead of the DAG cards on their own best algorithms, and well clear of every other card on the bench. It’s not the fastest card I tested. It’s the one doing the most work for each watt, and it does it quietly and cool.
That’s the surprise worth sitting with: a mid-range, unglamorous, used-market card beat every flashier option on the only metric that compares them fairly. If you’d bought purely on the headline hashrate, you’d have picked the 3060 Ti and burned more energy for less efficient work.
07 · How to read these numbers for your own cards
You won’t reproduce my figures exactly, and you shouldn’t expect to. What carries across is the method, not the digits:
- Match the card to an algorithm its VRAM can actually run. A 4 GB card is a kHeavyHash/Autolykos2 card; don’t bench it on a DAG and call it slow.
- Warm up, then measure at the wall. Kickoff spikes and core-only telemetry both lie. Steady-state wall power is the honest figure.
- Undervolt before you judge. Stock voltage flatters nobody’s efficiency.
- Rank on hashes-per-watt, not hashrate. It’s the only number that lets a 70 W card and a 250 W card be compared without cheating.
Do that, and you’ll find — as I did — that the “best” card is rarely the biggest one. It’s the one that quietly does the most work for the least energy. That’s an engineering result, measured on a no-value testnet, and it’s the only kind of result this article is about.