E-Waste GPUs Benchmarked: What This Means for Your Homelab

The #1 mistake people make with “cheap old GPU” builds isn’t buying the wrong card – it’s buying any card before reading a benchmark that actually tests the workload they care about. That’s why the esologic post benchmarking 15 e-waste GPUs exploded on Hacker News this week. It gives you the numbers instead of vibes.

This guide isn’t a summary of that post. It’s how to actually use its data to build a working e-waste GPU rig for LLMs, Whisper, or ViT – plus three findings buried in the results that most build guides don’t surface.

The scenario: you want cheap VRAM, not fast VRAM

Picture this. You’ve got a Ryzen box in the closet, you want to run a 30B model locally, and a new RTX 4090 costs more than your car insurance. The used enterprise market is right there – K80 24GB for around $60, P100-16GB around $75, V100-16GB under $200 (prices from esologic community reporting, as of early-to-mid 2026).

The trap: people see “24GB for $60” and assume more VRAM = better local AI. It doesn’t. VRAM lets you load the model. Memory bandwidth, compute mode support, and driver longevity decide whether it’s actually usable.

What counts as an “e-waste GPU” in 2026

Loosely: decommissioned datacenter Teslas from the Kepler, Maxwell, Pascal, and Volta eras. K80, M40, M60, P4, P40, P100, V100. Cards that were $5,000+ new and now show up on eBay pulled from retired servers.

These aren’t equivalent. Here’s the honest split based on the community benchmarks and the trending esologic run:

Prices are eyeballed from esologic and InsiderLLM community reporting as of early-to-mid 2026 – expect them to drift as consumer Ampere cards get cheaper.

Reading the benchmark like a skeptic

The most-quoted finding: P40 beats P100 for LLM usage. True, but incomplete. Check the llama.cpp CUDA benchmark thread on GitHub and you’ll find the P40 landing around 54 tok/s on the standard test while the M40 sits near 38 tok/s – despite having the same 24GB and a similar bus width. Same VRAM. Very different card.

Why? The P40 (compute capability 6.1) has no native FP16 support. FP16 operations run at 1/64th the speed of FP32 – NVIDIA deliberately disabled it to protect P100 sales, according to InsiderLLM’s analysis of the Pascal architecture. The P100 and V100 have proper FP16; the P40 and M40 don’t. Since llama.cpp and most inference engines default to FP16, on the P40 you need to force FP32 or use integer quantization (Q4, Q8).

That’s the invisible knob. Skip it and your P40 benchmark tanks. Most people blame the card.

Watch out: On P40 or M40, always run llama.cpp with a Q4_K_M or Q5_K_M quant and verify that FP16 fallback is disabled. The integer path routes around the crippled FP16 unit and you’ll see the numbers the community actually reports. Check the llama.cpp benchmark discussion for the specific build flags – flag names change between releases.

Practical setup for a P40 build

The P40 is the community-consensus pick. Setup is mostly unremarkable – until it isn’t. Buy from a seller with returns first; ex-datacenter pulls can arrive with bent brackets or missing thermal pads, and that’s a $0 fix if caught before acceptance.

Power is where people get hurt. The P40 uses an 8-pin EPS connector – that’s CPU-style, not standard PCIe power (InsiderLLM). You need a 2×PCIe 8-pin to 1×8-pin EPS adapter. Forcing a PCIe cable into the socket can damage the card. This is the mistake that’s hardest to diagnose after the fact because the card may appear to work but throttle under load.

Cooling next. The Tesla P40 is a passive card with no fans (documented by Like2Byte and InsiderLLM). In a standard desktop case without forced airflow it will thermal-throttle hard. A bolt-on blower kit or a 3D-printed shroud with a 92mm blower is the standard fix – search your card model on Printables for community-designed mounts.

For software: install CUDA 12.x rather than bleeding-edge. Pascal is still supported, but newer toolkits increasingly assume newer kernel features. Pin a version, especially if you’re targeting a specific llama.cpp build. Then load a Q4_K_M quant of your target model and run the benchmark to confirm you’re on the integer path.

# Quick sanity check after install
nvidia-smi
./llama-bench -m models/qwen2.5-14b-instruct-q4_k_m.gguf -p 512 -n 128

# If tokens/sec looks 10x too low, you're on the FP16 slow path
# Check llama.cpp docs for the current flag to force integer quantization
# (flag names change - verify against your installed version)

Three findings from the trending post that most guides skip

The esologic run tests things the standard “buy a P40” guides don’t, because it runs multiple generations side by side. Three results stand out.

1. Mixing generations hurts the fast card, not the slow one. The esologic results show the V100 in a mixed box being held back to P100 speeds on LLM workloads – the slowest card sets the pace for the whole cluster. Buying one great card plus one mediocre card is worse than buying two matching mediocre cards for LLM tensor-parallel setups. The VRAM pools, but the speed doesn’t.

2. CPU single-core speed matters more than you think. Most homelab guides say grab a 36-core Xeon E5. But the esologic data shows a clear downward trend for Whisper and ViT attention workloads that maps to increasing core count and decreasing single-core performance. Fewer fast cores can beat more slow ones on audio and vision jobs – the opposite of what most server-oriented guides assume.

3. Multi-GPU LLM scaling is broken in llama.cpp right now. LLM throughput in the esologic tests stays flat as more GPUs are added – the author openly attributes this to a llama.cpp configuration issue and asks for PRs. If you’re building a 4-GPU box to speed up single-user chat, today’s llama.cpp will likely give you more VRAM and roughly 1× speed, not 4×. vLLM and TGI scale better but require working FP16 – which brings us back to the P40 problem.

The Whisper detour worth taking

Everyone benchmarks LLMs. Almost nobody benchmarks transcription. Turns out the M60 – findable for around $50 – posted the strongest Whisper numbers among the cards esologic tested. If your actual project is “transcribe 500 hours of podcast audio,” a $50 M60 might do a better job for your specific workload than a $200 P40.

Match the card to the workload, not to the forum consensus.

Honest limitations of the whole e-waste path

Software drift is the real killer. The M40 (Maxwell, compute capability 5.2) is the one to watch: newer CUDA toolkits and frameworks are starting to drop Maxwell support, and if you buy an M40 today, software compatibility is likely to become a problem within a year or two (InsiderLLM, as of mid-2026). Kepler (K80) is already there.

Power draw is the other consideration. The P40 is community-reported at up to 250W under load – four of them running 24/7 at $0.25/kWh (a rough US average as of 2026; your rate will differ) runs around $2,000/year in electricity. The $200 card looks less clever when the power bill catches up.

The tensor cores gap is real but overstated for this use case. An RTX 3060 12GB is community-reported to outrun any Pascal Tesla at workloads that fit in 12GB – the modern architecture wins on throughput. The P40’s memory bandwidth is 347 GB/s, roughly 1/3 of the RTX 3090 (InsiderLLM). But none of that matters if your model is 30B and won’t fit in 12GB at all. You buy e-waste for capacity, not speed.

FAQ

Is the K80 still worth buying in 2026?

No. It splits into two 12GB logical cards, Kepler support is dying in modern CUDA, and P100s are only $15-75 more. Skip it.

Can I run Stable Diffusion or Flux on a P40?

Community reports suggest SD 1.5 works. SDXL and Flux are a different story – both rely heavily on fast FP16, which is the P40’s weakest mode. You’ll get output eventually, but a used RTX 3060 12GB will run much faster for image generation. The P40 earns its keep only when you need model capacity that a 3060 physically can’t load – think 30B+ LLMs, not image pipelines.

What’s the smallest useful e-waste build?

One P40, an X99 motherboard, 64GB DDR4, and a 750W PSU. For the CPU, the esologic single-core finding matters here: fewer fast cores will serve you better than a high-count slow Xeon. Total under $500 if you’re patient on eBay (as of mid-2026 pricing). That gets you a 24GB single-user local LLM box that runs most 14B-class models comfortably.

Your next action: before you buy anything, open the llama.cpp CUDA benchmark thread, find the exact model size you want to run, and check the tokens/sec numbers for every card on your shortlist. If nobody has posted a result for a card, that’s a data point too.