TL;DR: LLMspeed (llmspeed.dev) streams text at the tokens-per-second a given GPU, Mac, or CPU would actually produce, so you can feel a $1,400 used RTX 3090 or a $3,499 Strix Halo mini PC before paying for it. Its “measured” numbers check out against real benchmarks; its “derived” ranges can span 3x. Know which label you’re looking at.

What you’ll be able to do after this guide:

• Test-drive any of 30 machines against 15 current local models — including hardware that isn’t released yet — and know whether the speed feels usable to you
• Tell the tool’s benchmarked numbers from its interpolated ones, and sanity-check both with one line of bandwidth math
• Replace the simulation with a real number from your own (or a rented) GPU using llama-bench before you spend four figures

Honest take: LLMspeed is the best pre-purchase gut-check the local AI scene has produced this year — not because its numbers are perfect, but because watching 5 tok/s crawl across your screen kills a bad $4,000 purchase faster than any spec sheet. Trust the green “measured” entries, treat the wide “derived” ranges as a coin flip, and confirm with a $0.50 Vast.ai rental before you buy anything over $1,000.

Every week someone on r/LocalLLaMA asks “will a used RTX 3090 feel fast enough for a 27B model?” and gets fifteen conflicting answers, because “fast enough” is not a number — it’s a feeling. LLMspeed, a Show HN project that hit the Hacker News front page in mid-October 2026, attacks exactly that gap: pick a machine, pick a model, and the page streams an answer at the predicted speed, including the pause before the first token appears. No install, no account, MIT-licensed source on GitHub.

This is not a benchmark you run on your own rig — despite how most of the coverage describes it. It’s a simulator of hardware you don’t own yet, which makes it a buying tool. And since this site’s whole beat is helping you not waste money on local AI hardware, we checked its numbers against the benchmarks we’ve been collecting all year. Here’s what holds up, what doesn’t, and how to use it without getting burned.

What LLMspeed actually is

The pitch in one sentence, from the README: “feel how fast a local LLM runs before you buy the hardware.” The mechanics:

• 30 machines x 15 models. The hardware list runs from a $260 used RTX 3060 12GB to an H200 cloud GPU, covering the cards and unified-memory boxes home-labbers actually argue about: used RTX 3090 (936 GB/s), RTX 5090 (1,792 GB/s), RTX 5060 Ti 16GB (448 GB/s), AMD Ryzen AI Max+ 395 “Strix Halo” 128GB (256 GB/s), DGX Spark 128GB (273 GB/s), Mac Studio M5 Ultra (1,200 GB/s), MacBook Pro M5 Max (614 GB/s), plus oddballs like the Intel Arc Pro B70, a modded Tesla V100, and a CPU-only Ryzen 9 9950X with 96GB of DDR5 at 89.6 GB/s. The model list is equally current: Qwen3.6-27B, Qwen3.6-35B-A3B, Gemma 4 (12B/26B-A4B/31B), GPT-OSS 20B and 120B, GLM-5.3 and GLM-5.3 Flash, DeepSeek V4 Flash, Llama 3.1 8B, Nemotron 3.5 Lightning — each at multiple quantizations.
• Real-time streaming. The answer types itself out at the predicted rate, after a simulated time-to-first-token based on prompt length. This is the feature that matters: 12 tok/s sounds fine on paper and feels slow when you watch it.
• Race mode. Two setups side by side. The repo’s own demo race is instructive: RTX 5090 vs Mac Studio M5 Ultra 512GB on GLM-5.3 Flash at Q8 — and the 5090 loses by forfeit, because 32GB of VRAM can’t load the model at all. That’s the single most common mistake first-time buyers make, demonstrated in one click.
• Memory-fit check. For every machine-model pair it shows whether the model fits at each quantization, needs partial offload to system RAM, or won’t run, assuming roughly 93% of VRAM is usable on discrete GPUs and 75% of unified memory on Macs.
• Backends covered: CUDA, Metal, ROCm, Vulkan, and CPU, with per-backend efficiency coefficients.

The project is a fully static Preact/Vite site deployed on GitHub Pages — first commit August 28, 2026, benchmark catalog last refreshed October 17, 2026, which means the data was days old when it front-paged. That freshness is unusual for this category and worth something by itself.

The three trust labels, and why they’re the whole game

Every number LLMspeed shows carries one of three labels, and the difference between them is the difference between a useful tool and a misleading one:

Label	What it means	How much to trust it
Measured	A real benchmark ran on that exact hardware, model, and quantization (sources: r/LocalLLaMA, localscore.ai, llama.cpp discussions, community CSV submissions)	High — spot-checks below land within the ranges we’ve verified all year
Derived	Interpolated from measured results on similar setups	Medium — ranges can span 3x; treat as “order of magnitude”
Projected	Calculated from specs for announced-but-unreleased hardware (e.g., the Mac Studio M5 Ultra 512GB you still can’t order)	Directional only

When no benchmark exists, the fallback model is the same physics we use in every hardware guide on this site: decode speed is memory-bandwidth-bound (each token reads the active weights once — only active parameters for MoE models), and prefill is compute-bound on FP16 throughput. If you’ve read our GPU buying guide, this is the bandwidth ÷ bytes-per-token ceiling formula with calibration coefficients bolted on. That’s a compliment: it means the tool’s worst case is “sane estimate,” not “marketing number.”

We checked its numbers against ours

We’ve been collecting measured tokens-per-second for these exact cards all year. Pulling LLMspeed’s current dataset (the October 17 refresh) and lining it up against benchmarks we’ve independently verified:

Machine	Model (quant)	LLMspeed says	Label	Independently verified
RTX 3090 24GB	Qwen3.6-35B-A3B Q4_K_M	107–169 tok/s	measured	107 tok/s — our 35B-A3B guide
RTX 4090 24GB	Llama 3.1 8B Q4_K_M	86–129 tok/s	measured	~127 tok/s (Local AI Master, site canon)
RTX 5090 32GB	GPT-OSS 20B MXFP4	180–569 tok/s	derived	282.5 tok/s (llama.cpp discussion #15396)
RTX 3090 24GB	Qwen3.6-27B Q4_K_M	11.7–36.9 tok/s	derived	bandwidth ceiling ≈ 59 tok/s; real cards land 30–40
Mac Studio M5 Ultra 256GB	GPT-OSS 120B MXFP4	99–123 tok/s	measured	scales cleanly from M3 Ultra’s measured 79.7 tok/s at 819 vs 1,200 GB/s

The pattern: every “measured” entry we could cross-check landed inside or touching our verified numbers. The “derived” entries are honest but wide — the 5090/GPT-OSS row spans 3.2x, and the real-world number sits in the lower half of the band. If you make a buying decision on the top of a derived range, that’s on you; the label told you.

One number worth doing by hand, because it’s the sanity check that catches every bad benchmark on the internet: decode speed can’t beat memory bandwidth divided by bytes read per token. A dense 27B at Q4_K_M reads roughly 16GB per token; a used RTX 3090 moves 936 GB/s; so ~59 tok/s is the physics ceiling and real results land at 50–70% of it. Any site quoting a 3090 at 100+ tok/s on a dense 27B is wrong, no matter how confident the table looks. LLMspeed’s bands respect this ceiling on every row we checked — which is more than we can say for several “benchmark” sites we’ve had to debunk this year.

Where the simulation will mislead you

The README itself warns that drivers, engine versions, flash attention, power limits, and thermals move real numbers by 10–30%. Real-world usage adds four sharper edges:

1. Multi-GPU doesn’t exist here. Single device only — no tensor split, no layer split. The entire dual-RTX-3090 value play that dominates the $2,500–$3,000 bracket is simply outside the tool’s universe. If that’s your build, our dual-3090 coverage is the reference, not this simulator.

2. “Measured” is still a snapshot of one engine version. The sharpest example in the current dataset: Strix Halo running GPT-OSS 120B shows 45–58 tok/s, labeled measured. When we benchmarked the same chip in the GMKtec EVO-X2 in September, the canon number on then-current builds was ~31 tok/s. Both can be true — AMD’s llama.cpp path picked up major kernel work this fall, the same way Intel Arc roughly doubled overnight in October. But it means a “measured” number from a fast-moving backend can be 50% away from what your build does on day one. Check the engine version in the submissions CSV before treating any entry as a promise.

3. The context-length story is thinner than agentic reality. The simulation applies a slowdown as context grows, and TTFT is modeled from prompt length — but the benchmark unit underneath is llama-bench at a 512-token prompt. A coding agent routinely stuffs 30,000+ tokens of repo context into every request; at that depth, prefill speed and KV-cache pressure dominate the experience, and a machine that “feels fine” in the simulator can feel terrible under Cline. If your purchase is for a local coding backend, weight prefill numbers far more heavily than this tool does.

4. The memory-fit check assumes a clean machine. 93% of VRAM usable is roughly right for a headless Linux box. On a Windows desktop driving monitors from the same GPU, the OS and browser quietly hold 1–2GB, and a model that “fits” in the simulator spills into shared system memory on your machine — the silent 10x slowdown we’ve diagnosed before. If the fit check shows less than ~1.5GB of headroom, treat it as a no on a desktop PC. For the precise version of this calculation — your exact model, quant, and context length — our VRAM calculator does the arithmetic the fit-badge rounds off.

Replace the simulation with a real number: llama-bench in 60 seconds

LLMspeed’s own contribution pipeline tells you how to get ground truth, and it works just as well for checking the tool before a purchase. On any machine running llama.cpp:

llama-bench -m your-model.gguf -p 512 -n 128

Expected output (the repo’s contribution-template example for an RTX 4090 on Llama 3.1 8B Q4_K_M — stddev columns trimmed):

| model           |     size | params | backend | ngl |  test |     t/s |
| --------------- | -------: | -----: | ------- | --: | ----: | ------: |
| llama 8B Q4_K_M | 4.58 GiB | 8.03 B | CUDA    |  99 | pp512 | 9850.0  |
| llama 8B Q4_K_M | 4.58 GiB | 8.03 B | CUDA    |  99 | tg128 |  128.4  |

tg128 is your decode speed — the number LLMspeed simulates. pp512 is prefill — the number that decides whether agentic workloads feel responsive. If you don’t own the hardware yet, this is exactly what a one-hour cloud rental is for: a used-3090-class instance on Vast.ai runs from $0.07/hr, which means verifying a $1,400 purchase costs less than a dime. Run the bench, read the two numbers, then decide. (If you get a number far below the simulator’s range, the usual suspects are in our benchmark-tools roundup: power limit, missing flash attention, or the model silently split across PCIe.)

One real failure mode to watch for when you run this: a llama.cpp binary compiled without GPU support runs the whole bench on CPU without complaining — you’ll see single-digit tok/s on a 4090 and conclude the card (or the simulator) is lying. The tell is the backend column: if it doesn’t say CUDA (or Metal/ROCm/Vulkan), you’re benchmarking your CPU. The fix is to grab an official CUDA release binary or rebuild with the GPU flag on — the full walkthrough, including the exact build errors you’ll hit, is in our llama.cpp CUDA build-error guide.

What the speeds mean, and what to actually buy

Translate tok/s into experience before you shop: ~7–10 tok/s matches human reading speed and feels adequate for chat; 15+ feels fluid; 40+ is where code generation and agent loops stop feeling like waiting. Run your candidate hardware through LLMspeed against the models you’ll actually use, then buy the cheapest machine that clears your bar — not the fastest one on the chart.

Prices as of their listed verification dates (street, not MSRP — see each link):

Your situation	The machine	Price	Where
The simulator says 24GB covers everything you run — you want the floor price for it	Used RTX 3090 24GB, 936 GB/s	~$1,399–$1,450 (Oct 2026)	Check price
Your models are ≤12B dense or small MoE and the budget stops at $800	RTX 5060 Ti 16GB, 448 GB/s	~$679–$805 (MSRP $429, Sep 2026)	Check price
The models you test-drove only fit in 128GB unified memory (GPT-OSS 120B class)	GMKtec EVO-X2 128GB (Strix Halo)	~$3,499–$3,649 (Sep 2026)	Check price
Not convinced by a simulation — want the real llama-bench number first	Rented 3090/4090/5090 for an hour	from $0.07/hr	Vast.ai

The honest ordering of tools for this decision: LLMspeed to shortlist by feel, our VRAM calculator to confirm the fit at your real context length, a one-hour rental to verify the number, and the GPU buying guide for the price-per-VRAM math. That stack costs under a dollar and has talked more than one reader out of a $4,000 mistake.

FAQ

Is LLMspeed a benchmark I run on my own GPU? No. It never touches your hardware — it’s a browser simulation that replays measured or estimated speeds for 30 machines so you can evaluate hardware you don’t own. To benchmark your own rig, use llama-bench (above) or the tools in our benchmark roundup.

How accurate are its numbers? The “measured” entries we cross-checked landed within the ranges we’ve independently verified this year. “Derived” entries are interpolations with bands up to ~3x wide, and the README itself flags 10–30% real-world variance from drivers, power limits, and engine versions. Single-GPU only — multi-GPU builds aren’t simulated at all.

Does it cover unreleased hardware? Yes — “projected” entries are computed from announced specs (memory bandwidth, FP16 throughput). The Mac Studio M5 Ultra 512GB, which still isn’t orderable, is in the list. Treat projections as directional until measurements replace them.

Why does it say a model “won’t run” on my card when Ollama loads it? The fit check assumes the full-precision-of-that-quant weights plus KV cache and overhead within ~93% of VRAM. Ollama may be silently offloading layers to system RAM — it “runs,” at a fraction of the speed. That gap is exactly the shared-memory fallback trap.

Is the data current? The catalog in the repo was refreshed October 17, 2026, and includes October-2026 models (Nemotron 3.5 Lightning, GLM-5.3 Flash, DeepSeek V4.1 Flash). It’s community-fed via CSV pull requests, so coverage will drift with contributor interest — check the submission dates for the specific machine you care about.

Sources

• llmspeed — nicorobinreal, GitHub (MIT)
• llmspeed live site
• Show HN: Llmspeed — Hacker News
• Llmspeed: Test Local LLM Speed Before Buying Hardware — PromptZone
• Local LLM Speed by Hardware: What llmspeed Gets Right — Developers Digest
• GPT-OSS benchmark thread, discussion #15396 — llama.cpp, GitHub
• LocalScore — community local LLM benchmark database
• Used RTX 3090 price history — BestValueGPU

Last updated October 20, 2026. Prices and specs change; verify current rates before purchasing.

Recommended Gear

Products linked in this article:

• Used RTX 3090 24GB — 936 GB/s; still the buy-once answer for everything under 30B
• RTX 5060 Ti 16GB — the sub-$800 entry to 14B-class models
• GMKtec EVO-X2 128GB — the 128GB unified-memory box for 100B-class MoE

Get the numbers before you buy

New GPU and mini-PC benchmarks, VRAM thresholds, and price checks — sent when there's something worth acting on, not on a schedule. No spam, unsubscribe anytime.

Email address Subscribe