whichaipc

GPU for local LLM · workstation

NVIDIA Tesla P40

The cult cheapest 24GB card, if you'll sort the cooling and enjoy the tinkering.

VRAM
24 GB
TDP
250 W
Bandwidth
347 GB/s
£ / GB
£10

What it runs

With 24 GB you can comfortably load, at 4-bit quantisation, a dense model up to roughly

~44B params

Verdict

The cheapest 24GB going, at the cost of a cooling project, no display output, and modest speed.

BEST FOR

  • + maximum VRAM per pound
  • + homelab tinkerers
  • + slow big-model runs

NOT FOR

  • - plug-and-play builds
  • - speed
  • - quiet always-on machines

The Tesla P40 is the cult pick for one reason: it’s the cheapest 24GB card going. It’s an old Pascal datacentre board with no display output, passive cooling you’ll have to solve yourself, and weak half-precision maths. But 24GB for around £250 is a hard number to argue with, and that’s why homelabbers keep buying them.

The take

Buy it purely for cheap VRAM, with your eyes open about the faff. On pure £/GB it beats everything here, a used 3090 included. The catches are real, though. It’s a passive card built for server airflow, so you’ll need to bolt on a fan shroud or it’ll cook itself. It has no video output, so it can’t be your only GPU. And Pascal’s half-precision performance is poor, so it leans on quantised formats and older code paths. It’s a project, not a plug-and-play card. But the maths at the checkout is unbeatable.

What it’ll actually run

Twenty-four gigabytes runs the same big models a 3090 does on paper: a 32B at Q4 with context fits fine, and two P40s will hold a 70B at Q4. The capacity is the whole appeal, and it’s real. What you give up is speed. The 347 GB/s GDDR5 and weak FP16 mean throughput sits well below any modern 24GB card. Expect roughly 10 to 20 tokens/sec on a 13B at Q4, and slower again on bigger models. Quantised GGUF quants through llama.cpp are your friend here, since they lean on the integer and FP32 paths the P40 handles far better than half precision.

On value, nothing touches it. Around £250 for 24GB is roughly £10 per gigabyte, comfortably the best figure on this page. You’re trading speed, quiet, and convenience for the cheapest large-model capacity there is. Just budget for cooling and a second GPU for display, and treat the driver setup as part of the fun rather than a chore.

Who should buy it, and who shouldn’t

Buy it if you love a tinker and you want maximum VRAM for minimum outlay, especially for running big models slowly at home. Homelab builders adore these for exactly that. It’s the cheapest door into 70B-class models if you’ll stack two, and getting one purring is a satisfying weekend.

Skip it if you want speed, quiet, or a card that just works out of the box; the cooling job, the missing display output, and the modest pace rule it out for anyone who wants a simple life. For a few hundred more, a used 3090 gives you the same 24GB with none of the hassle and far more speed. But if the goal is the most VRAM per pound and you enjoy the build, nothing beats a P40.

Settings people actually run

The configs owners land on, pulled from the community. A sensible starting point, not gospel - tune to your own kit.

Big model, cheap

GGUF Q4_K_M or Q5_K_M via llama.cpp / Ollama

Lives on INT8 and quantised paths; never run FP16, which the Pascal die does at roughly 1/64 of FP32.

Cooling mod (mandatory)

3D-printed blower shroud plus a radial fan

Passive server card with no fan of its own; it overheats in a desktop without forced airflow.

Power and display

EPS-style 8-pin (not PCIe) plus a second GPU or iGPU

Wrong PCIe cable can damage the card, and the P40 has no video output at all.

Long-context caveat

keep prompts short where you can

No Flash Attention on Pascal, so prompt processing on big contexts is noticeably slow.

What owners report

Real first-hand experience gathered from owners and the community.

  • A single P40 runs Qwen3 Coder 30B (a mixture-of-experts model, roughly 3B active per token) at about 50 tokens/sec under Ollama, which is viable even for agentic coding if you are disciplined about context. Card cost around 200 dollars used.

    RBA (Robert Sarvis)

  • Older chipsets can fail to POST with the P40's 24GB (you need Above-4G decoding / resizable BAR), and the card takes an EPS-style CPU power connector, not PCIe. A 3D-printed blower shroud with a radial fan handles the passive cooling.

    RBA (Robert Sarvis)

  • Community single-card Q4 generation lands around 15 to 25 tokens/sec on a 7B to 8B, 8 to 12 on a 13B to 14B and 4 to 7 on a 32B; a 70B needs two cards. FP16 is effectively unusable, so you stay in GGUF quants throughout.

    Local AI Master

  • Running a $200 eBay P40 in a dual-Xeon server, Frank Fu worked through 7B, 14B and 32B models and was surprised how well it held up on the larger ones, though prompt processing lags a modern card.

    AI Researcher & Robotics Developer Frank Fu

Fact-checked 18 Jul 20268 claims verified against primary sources.
1 claim(s) we couldn't fully verify
  • · typical used price around GBP 250 / USD 300 (mid-2026) - No primary source tracks used-market pricing; community listings span roughly 150 to 330 dollars, figure is indicative only.

Hands-on reviews we drew on

We don't just copy the spec sheet. These are the teardowns and hands-on reviews behind this page - worth watching in their own right.

Common questions

Why does the Tesla P40 need extra cooling?+

It's a passive datacentre card, designed to sit in a server with fans blasting air through it. In a normal desktop it has no fan of its own, so it'll overheat without help. Most people 3D-print or buy a fan shroud that bolts onto the end and forces air through the heatsink. Budget for that on day one.

Can the Tesla P40 be my only graphics card?+

No. It has no video output at all, so you need a second GPU or integrated graphics to drive a display. Plan for that in your build; the P40 is a compute card that sits alongside something else, not on its own.

Why is the P40 slow if it has 24GB?+

Two reasons. The GDDR5 memory only manages 347 GB/s, well under any modern card, and Pascal's half-precision maths is weak. For LLMs you lean on quantised GGUF formats through llama.cpp, which use integer and FP32 paths the P40 handles better than FP16. It runs big models, just slowly.