How the Compatibility Checker works.

The fit formula

The Checker grades a model against your estimated total VRAM need: the model's weights at a given quantization, plus roughly 1.5 GB of runtime overhead for the inference server itself. KV cache — the memory that grows with your context length — is deliberately not included, because it depends on how you use the model, not on the model. Long contexts need real headroom beyond any verdict here.

• Comfortable — the model fits with at least 2 GB of VRAM to spare above its estimated requirement. Context can grow without immediate risk of eviction.
• Usable, but tight — the model fits, but with less than 2 GB to spare. Close other GPU apps and avoid very long prompts.
• Runs via CPU RAM offload — GPU VRAM alone is not enough, but your system RAM can hold the overflow. This needs roughly 1.6× the model's weights in system RAM — weights alone, not the weights-plus-overhead figure above. The multiplier was calibrated end-to-end on real offloaded runs and already absorbs the runtime overhead, so applying it to the larger figure would count that overhead twice. For dense models expect 1–5 tokens/s. A sparse mixture-of-experts model activates only a fraction of its parameters per token, so offload stays usable — each result says which case applies.
• Does not fit — neither VRAM nor RAM offload can hold the model at any catalogued quantization.

Quantization selection

For each model the Checker picks the best quantization your memory can hold, preferring higher precision when it fits: FP16 or Q8_0 (near full precision) over Q4_K_M (roughly half the size with moderate quality loss). This pick depends on your memory alone — your “Preference” choice never changes which quantization a given model is offered. What Preference changes is the ranking between models: Speed first ranks models that run at the smaller quantization higher, Quality first boosts models running at FP16 or Q8_0 and penalizes offload fits. The quantization named in a verdict is the one that was actually graded.

Apple unified memory

Apple Silicon shares one memory pool between the CPU, the GPU, and everything else you have open — so not all of it is available to a model. The Checker sizes every Apple fit against about 75% of the reported total as usable model memory. A 64 GB Mac is graded as roughly 48 GB of effective model memory.

Runtime suggestions

The runtimes a result suggests follow your effective memory tier. They are starting points, not endorsements of one tool over another:

• Workstation (48 GB+ VRAM) — Ollama, LM Studio, vLLM, SGLang, GPUStack
• Strong GPU (24–47 GB VRAM) — Ollama, LM Studio, GPUStack, vLLM
• Mid-to-high GPU (16–23 GB VRAM) — Ollama, LM Studio
• Mainstream GPU (8–15 GB VRAM) — Ollama, LM Studio
• Entry GPU (4–7 GB VRAM) — Ollama, LM Studio
• CPU-only (32 GB+ system RAM, no discrete GPU) — Ollama

What a copied result contains — and what it never contains

The Checker's “Copy result summary” button produces a plain-text snapshot built for pasting into a GitHub issue, a forum thread, or a chat. Three rules govern it:

• Hardware appears as ranges, never exact figures. Your VRAM and RAM are reduced to bands like “12–15 GB”, and your GPU to a vendor class (NVIDIA, AMD, Apple, Intel). The free text you typed into the form is never echoed — a snapshot is safe to paste in public.
• Assumptions travel with the claim. Every snapshot carries the same threshold sentences this page documents, so a verdict can't circulate without the rules that produced it.
• Nothing is transmitted. Copying happens entirely in your browser via the clipboard. No result, hardware detail, or identifier is sent to us or anyone else when you copy — and results are deliberately not encoded into shareable URLs.

Each snapshot ends with Contract v3 — the version of the result format. The version changes only when the shape or meaning of a result changes (v2 added honest wording for sparse mixture-of-experts offload; v3 corrected the offload RAM rule to state its weights-only basis), so an old citation can always be read against the rules that were in force when it was made.

Honest limits

These are sizing rules, verified against vendor documentation and hands-on runs — not a benchmark of your machine. Real generation speed depends on memory bandwidth, thermals, drivers, and context length. To measure what your running setup actually does, use the benchmark tool; to understand the memory arithmetic in depth, read What is VRAM? and What is quantization?.

When you pick a hardware preset, the Checker also shows an estimated speed class per model — a coarse tokens-per-second band derived from the GPU’s memory bandwidth divided by the model’s size, derated to match our own measured bench runs. It is an estimate calibrated against real measurements, never a measurement of your machine, and it never affects which models are recommended or how they are ranked. Where no honest estimate exists — manually entered hardware, Apple Silicon, multi-GPU rigs, sparse mixture-of-experts models, CPU-offload fits — the Checker shows no class rather than a guess.

Found a verdict that disagrees with your real-world experience? Tell us — hands-on corrections outrank our own estimates.