I built a calculator that says whether a model will run on your hardware. Then I ran the same three models on four of my own machines to see if it was telling the truth.
The short answer
For graphics cards and Macs the speed estimates held up: all six measurements landed inside the range the calculator gave. For memory it was badly wrong on newer models, claiming one needed 20.5 GB when it runs on an 8 GB card, and it was too optimistic about processors. Both are fixed, and the real numbers are below.
Where this comes from
Measured on 12 October 2026 on four machines I own, using the same model files, the same prompt and the same settings on each. The calculator is Will It Run? on this site. Addresses and paths are removed. Where something was not measured properly, it says so.
Why test my own tool
A calculator like this is only useful if you can trust it, and I had built it from formulas, not from measurements. The memory figure came from the model’s dimensions. The speed figure came from how fast each machine can read memory. Neither had been checked against a real run.
Test setup
- Desktop
- Core i9-10900K with an NVIDIA RTX 2060 Super, 8 GB. Docker Desktop on Windows 11
- Mac
- Mac mini, Apple M4, 16 GB. Official llama.cpp build for Mac, run directly
- Mini PC
- Intel NUC8i7BEH, Core i7-8559U, 16 GB dual-channel DDR4, no graphics card used. Docker on Ubuntu
- Old workstation
- HP Z620, Xeon E5-2665, 32 GB four-channel DDR3, processor only. Docker in the Linux subsystem on Windows 11
- Models
- Qwen3.5-4B, Qwen3.5-9B and gemma-4-12b-it, all at Q4_K_M
- Settings
- llama.cpp server, 8,192-token context, 256 tokens generated at temperature 0, three runs after a warm-up
Method
Each machine ran the same three files. For each model I started llama.cpp’s server, sent one short request to load everything, then asked for 256 tokens three times from a fixed prompt and took the middle result. The three runs agreed to within about 1% everywhere.
On the desktop every layer was placed on the graphics card. On the Mac the model ran on Apple’s graphics. The NUC and the old workstation ran on their processors alone.
Measured speed
Qwen3.5-9B at Q4_K_M
tokens per second, higher is betterBlue bars use a graphics chip. Grey bars are processors only.
| Machine | Qwen3.5-4B | Qwen3.5-9B | gemma-4-12b-it |
|---|---|---|---|
| RTX 2060 Super | 83.7 | 54.4 | 27.7 |
| Mac mini, M4 | 29.7 | 17.7 | 13.1 |
| Mini PC, Core i7-8559U | 5.6 | 3.1 | 2.3 |
| Old workstation, Xeon E5-2665 | 6.8 | 4.2 | 2.6 |
Tokens per second. As a rough guide, reading speed is about 5 tokens a second, so anything on the two graphics rows feels instant and the processor rows are usable for short answers.
One result needs a note. The gemma model is 7.1 GB and the card has 8 GB. Forced entirely onto the card it ran at 27.7 tokens a second with the card’s memory full. When I let llama.cpp decide how much to place on the card, it kept some layers in system memory and ran at 11.3.
Where the calculator was right
Before I changed anything, the calculator’s speed ranges for the graphics card and the Mac contained every measurement:
| Machine and model | Predicted | Measured |
|---|---|---|
| RTX 2060 Super, Qwen3.5-4B | 74 to 123 | 83.7 |
| RTX 2060 Super, Qwen3.5-9B | 35 to 59 | 54.4 |
| Mac mini M4, Qwen3.5-4B | 23 to 38 | 29.7 |
| Mac mini M4, Qwen3.5-9B | 11 to 19 | 17.7 |
The idea behind the estimate is simple: generating a token means reading the model’s weights once, so speed is limited by how fast the machine can read memory. Divide memory bandwidth by the file size, apply an efficiency factor, and you are close.
Where it was wrong
The formula assumed every layer remembers the whole conversation. Newer models do not. Gemma 4 keeps only a 1,024-token window in most of its 48 layers. Qwen 3.5 only looks back over the conversation in every fourth layer. The calculator now reads those settings from each model file. For gemma-4-12b the estimate went from 20.5 GB to 8.1 GB.
Some repositories ship a small helper model next to the main one. The calculator was measuring the helper, so eight Gemma models showed 4 layers when they have 48.
I had assumed a processor reaches 60% of its memory bandwidth. Both of mine reached about 40%. The mini PC measured 5.6 tokens a second on the small model where the calculator had promised 7 to 12.
A Xeon E5 has four memory channels, which makes it faster at this than its age suggests. The calculator had only a generic “older PC” row, which undersold it. The 2012 Xeon beat the 2018 mini PC on every model.
Memory: predicted against seen
Measured on the graphics card, where the reading is exact.
| Model | Old estimate | New estimate | Card memory in use |
|---|---|---|---|
| Qwen3.5-4B | 4.3 GB | 3.5 GB | 3.3 GB |
| Qwen3.5-9B | 7.3 GB | 6.4 GB | 5.5 GB |
| gemma-4-12b-it | 20.5 GB | 8.1 GB | 6.4 GB, card full, the rest in system memory |
The new estimates still run a little high. I would rather the calculator say “tight” when it fits than “fits” when it does not.
After the corrections
With the memory formula fixed and the processor factor lowered, the live calculator’s ranges contain 12 of the 13 measurements. The one miss is the Xeon on the 9B model: 4.15 measured against a range that tops out at 4.0.
- The processor factor was tuned on these same runs. So the processor results agreeing afterwards is a fit, not an independent test. The graphics-card and Mac results are the genuine check, because I did not adjust those.
- Four machines is not many. I have no AMD card result, no current-generation NVIDIA card and no high-memory Mac.
- Three models, one quantization. Larger models and other quantizations may behave differently.
- Two machines ran under Windows with a Linux layer on top, which may cost a little speed.
- Memory on the Mac is missing. My reading there was not reliable, so I left it out.
What changed in the calculator
- Context memory is now worked out layer by layer from each model’s own settings.
- Helper files in a repository are ignored.
- The processor speed factor went from 0.6 to 0.4.
- Two machines were added to the list: the RTX 2060 Super, and four-channel DDR3 workstations.
- The page now says it was checked against real runs, and on which machines.
You can try it at Will It Run?. The model list updates every day.
Reproduce it
On a machine with Docker and an NVIDIA card:
docker run -d --gpus all -p 8080:8080 -v /path/to/models:/models:ro \
ghcr.io/ggml-org/llama.cpp:server-cuda \
-m /models/your-model.gguf -c 8192 -ngl 99 --parallel 1
Use the server tag without -cuda and -ngl 0 for a processor-only run. Then ask for a completion and read the speed from the reply:
curl -s http://localhost:8080/completion \
-d '{"prompt":"Explain what a network switch does.","n_predict":256,"temperature":0}' \
| python3 -c "import sys,json; print(json.load(sys.stdin)['timings']['predicted_per_second'])"
Send one request first to warm up, then take the middle of three.
Takeaway
A formula got the graphics-card speeds right and the memory badly wrong, and I only found out by running the thing. If you publish a tool that makes predictions, measure it against something real, and say what you found.
Your turn
How close was the calculator for your machine?
Try it with a model you already run and compare. If it is off, tell me your hardware and your real speed and I will add it.
Keep reading
Will it run? Local LLM calculator
Immich GPU vs CPU: an RTX 2060 Super against two processors
Immich without a GPU: timed on an Intel NUCAI assisted with running the measurements, fixing the calculator and drafting this article. The machines and every figure are from my own setup.