Methodology

Every page separates three kinds of information, and labels them:

Factual data: specifications from manufacturers and model files. Checked by an editor before publishing.
Estimates: numbers we calculate from those facts, such as whether a model fits or its speed ceiling. The method is below, so you can check it.
Editorial opinion: our scores, recommendations, pros and cons.

Will a model fit? (fact-based calculation)

The memory a model needs while running is the sum of three parts:

Weights. The size of the model file for each quantisation. We use the real GGUF files published for each model (Q4_K_M and Q8_0) instead of estimating from the parameter count, because real files differ: some layers are kept at higher precision, and some models (like gpt-oss) ship their experts in 4-bit already.
Context cache (KV cache). Grows with the context length. We calculate it from the model's own configuration (config.json): for every full-attention layer, keys and values for each KV head, at 16-bit. Sliding-window layers add a small fixed amount; the linear-attention layers of Qwen3.5 and Qwen3.6 keep a tiny fixed state, which we ignore. Runtimes can quantise the cache to 8 bits to halve it; we do not assume that.
Runtime overhead. About 1.5 GB for buffers and the GPU runtime.

We then compare this with the memory the hardware can use for a model by default:

Graphics cards: all of their memory.
Macs: macOS lets the GPU use about two thirds of memory on machines with up to 36 GB, and about three quarters above that. The limit can be raised by hand; we use the default.
Unified-memory PCs and boards: a share we state on each page (for example about 90% on Ryzen AI Max with Linux).

The verdict is runs (fits comfortably), runs, tight (uses over 90% of usable memory), partly in system RAM (a graphics card can keep some expert layers of a mixture-of-experts model in system memory: it works, but much slower), or not enough memory. Devices that only run models compiled by their vendor (such as the Raspberry Pi AI HAT+ 2) are marked not supported for anything else.

How fast? (theoretical ceiling)

When a model generates text, every new token reads the model's active weights from memory once. So the memory bandwidth sets an upper limit:

speed ceiling (tokens/s) ≈ memory bandwidth ÷ bytes read per token

For mixture-of-experts models only the active parameters are read, which is why they are so fast. Real runs usually reach about half to three quarters of this ceiling, and the time to process a long prompt depends on compute power instead. That is why we label it as an estimate and never present it as a measurement.

Measured speeds

We only publish measured speeds with their source (or when we tested the hardware ourselves), together with the model, quantisation and software version. If a page has none, it says so.

Prices

Launch price: the manufacturer's price at release.
Typical price: a street price we saw on the date shown. In 2026 the shortage of memory chips has pushed many prices far above launch, so these are references, not live prices.
Live prices from retailers appear only if they were updated in the last 24 hours, with the date and time.

Scores and recommendations

Scores from 0 to 10 are our opinion and weigh model capacity, speed, software support, value and how well the device fits a homelab (power, noise and size). Recommendations are never affected by affiliate commissions: see the affiliate disclosure.

Corrections

Hardware and models change fast. If you find a mistake, tell us and we will fix it and update the review date.