Two death notices arrived for my GTX 1080 Ti. The first came from NVIDIA, which moved Pascal — a 2016 architecture — out of its mainline driver branch and into legacy support, the polite way of saying you are now community property. The second was more poetic: EVGA, the company that built this particular card and treated support like a contact sport, exited the GPU business entirely in 2022. No new stock. No RMA army. No one left to annoy on the phone.
The card's response was to serve my benchmark prompts this evening at up to 42 tok/s.
The box, in full
Context first, because why it still works is the interesting part. The fallback is a Lenovo ThinkStation P520: a single 6-core / 12-thread Xeon W-2133 @ 3.6 GHz, 256 GB of quad-channel DDR4, and the EVGA GTX 1080 Ti (11 GB GDDR5X) in a PCIe Gen3 x16 slot — 484 GB/s of memory bandwidth, which in 2017 was borderline absurd on a consumer card. The box is virtualized these days: the inference service runs as a VM with 128 GB assigned and the GPU passed straight through, so llama.cpp and its monitor see exactly that half of the RAM.
It serves the same Qwen3.8-Flash-Next family as the main box, quantized to IQ4_XS, through strata — a thin service wrapper over llama.cpp with an OpenAI-compatible API and the monitor whose screenshots are in this post. One detail does most of the heavy lifting: the model is a Mixture-of-Experts, and llama.cpp keeps the hot experts resident in the card's 11 GB while streaming the rest from system RAM on demand. The monitor's current tally: 1,492 experts cached, 3.4 GB pinned in VRAM, with the working set spilling across 128 GB of DDR4.
Which means the framing "an 11 GB card running a big model" is wrong. The 128 GB of RAM is the model; the GPU is a cache with compute attached. The 2026 hardware runs the same trick one level up, calling it unified memory.
Receipts, pulled live from the monitor

I fed it load — from a 30-token chat to a 33k-token prompt — and let the monitor record the session:
| prompt | prefill | decode | expert VRAM hit |
|---|---|---|---|
| 30 tok | 29 tok/s † | 36.6 tok/s (99.3 % spec accept) | 76.8 % |
| 2.0k tok | 184 tok/s | — | 25 % + PCIe stream |
| 6.6k tok | 288 tok/s | — | 39 % + PCIe stream |
| 16.4k tok | 305 tok/s | 35.9 tok/s | 75.1 % |
| 32.9k tok | 310 tok/s | 41.9 tok/s (98.2 % accept) | — |
† see the confession below.

And at idle between requests, the whole GPU draws 9 W at 41 °C. A 250 W card spending its retirement at 9 watts is the cheapest high-availability money I will ever not spend.
Confession: my first numbers were wrong
The first draft of this post said this card prefills at 23–29 tok/s — which would mean a 60k-token prompt takes half an hour and the whole fallback was a lie. I measured it with 15-token prompts, trusted the engine's own timing report, and extrapolated.
Re-measuring at realistic sizes showed both ends of that reading were artifacts of the tiny end. A 15-token prefill is dominated by fixed per-request overhead, and decode measured over a 2-token generation is startup noise — one row of my table literally reads 6.0 tok/s decode, while the row beside it, same model loaded, same machine, a real generation, says 36.6. Steady-state prefill doesn't fall with prompt size, it climbs: 184 → 310 tok/s, because attention finally batches properly when there is enough of it. The real number for a 60k-token prompt is three to four minutes, not thirty-five.
The lesson is bigger than one card: timings from micro-prompts describe a different machine. Fixed overheads, cold caches and batch effects mean throughput at n=15 predicts almost nothing about n=16,445. Benchmark at the size you actually serve — or instrument continuously and let the monitor catch you being wrong, which is exactly why that monitor exists.
Why it survived anyway
Read the corrected table and the physics falls out cleanly.
Decode is a bandwidth job — every token means streaming the active weights through the compute units again. 484 GB/s of GDDR5X is still more muscle than my 2026 mini-PC can bring to that specific job, for the slice that stays resident. Speculative decoding multiplies the advantage: the model drafts tokens, the verifier accepted 98–99 % of them, so each PCIe round trip for a cold expert amortizes across many accepted tokens. That is why decode sits at 36–42 tok/s across every prompt size I threw at it, with expert hit rates wandering between 25 % and 77 % without budging the answer much.
Prefill is an attention-kernel job — and here the death notices are real. Pascal doesn't get modern fused attention kernels; nobody writes that CUDA anymore. ~310 tok/s is what this box does where a Strix Halo class machine does ~1,500. The old card is not in the long-context speed business, and never will be again.
What a fallback is actually for
Which is the thing people get wrong when they call this wasteful. A fallback is not a slower copy of the main system. It is a different failure domain that keeps the one capability you refuse to lose: answers.
- Different silicon (NVIDIA vs AMD), different engine stack, different box. Zero shared code path with whatever bad day the main machine is having.
- Messaging traffic — short prompts, human-paced reading — lands at 36+ tok/s. Nobody notices a thing.
- What genuinely degrades is long-context continuity: minutes of prefill instead of seconds. Availability over continuity is the trade I take every time.
And the retirement criteria are crisp, because I write tripwires:
- The legacy driver branch stops receiving security fixes and my distro's packaging follows it off the cliff.
- A model generation whose usable quantization can't keep enough experts resident to hold decode above ~15 tok/s.
- Fallback health-checks failing more than once a quarter — at which point it isn't a fallback, it's a rumor.
It has met none of them, through a full cutover and months of standing by.
Death notices: declined
The lesson has nothing to do with nostalgia. What kills hardware is not silicon — this die is doing 484 GB/s exactly as designed, forever. What kills it is software attention moving on: kernels, quant formats, docs, "tested with" matrices.
The flip side is why this has a happy ending: llama.cpp-class engines are still written for old hardware, eagerly, by people who own old hardware. That open-source current is what keeps both death notices un-cashed — and it is, not coincidentally, the same reason I run local models at all. If my capability depended on a vendor's roadmap, I would have received the same two letters.
The EVGA is still in the slot at 9 watts. The monitor still answers in single-digit milliseconds. Pascal can keep its eulogies; I have receipts.