How we estimate compatibility
CanIHost recommendations come from the open-source llmfit engine. This page documents the full method — what is calculated, what is estimated, and where the limits of those estimates are.
1. The inputs
A profile contains four numbers: VRAM (dedicated GPU memory), RAM (system memory), CPU threads (logical), and the backend (CUDA, ROCm, Metal, CPU). The engine grades every model in the catalogue against these — there is no telemetry, no account, and no storage of your profile.
2. The memory math
Model size is estimated from parameter count and bits per weight:
- 4-bit (Q4 class): ~0.55 GB per billion parameters
- 8-bit (Q8 class): ~1.0 GB per billion parameters
- FP16: ~2.0 GB per billion parameters
On top of weights, inference reserves memory for the KV cache (which grows with context length) and for runtime overhead (compute buffers, CUDA context) — roughly 0.5–2 GB depending on model and runtime. Our guide on context and memory covers the cache term; the VRAM guide shows the arithmetic end to end.
3. Fit thresholds
The engine compares the estimated memory requirement with your VRAM and RAM to assign one of six fit levels:
| Perfect | Full model + context + overhead fit in VRAM with generous headroom; no offload. |
|---|---|
| Excellent | Everything fits in VRAM with comfortable margin at the recommended context. |
| Good | Fits in VRAM; limited headroom for very long context or parallel sessions. |
| Tight | Fits, but a meaningful share of the working set spills to system RAM — expect slowdowns under load. |
| Marginal | Runs via partial CPU offload; interactive but well below full-GPU speed. |
| Bad | Would not load, or would offload so much that the experience is not practical. |
Fit levels are about capacity, not speed: a "good" fit on a slow card is still good — it will just produce tokens slower than the same model on a wider bus (see tokens per second).
4. Estimated speed, honestly labeled
The speed column is an estimate, not a benchmark. It is derived from your hardware profile — chiefly memory bandwidth and, for offload scenarios, CPU capability — using throughput models that track community-measured results well on typical configurations. It cannot account for everything:
- laptop power limits and thermals (see laptop vs desktop)
- driver, runtime and quantization-kernel differences
- prompt processing versus generation (different bottlenecks)
- background load and reserved VRAM from your display
Treat the numbers as a ranking signal — "this model will be much faster than that one on your machine" — rather than a promise of exact tok/s. The definitive test is running the model; the estimate's job is to prevent downloading the wrong one first.
5. What is measured versus estimated
Measured or authoritative
- Your hardware inputs (read locally by the scan)
- Model parameter counts and context windows
- Bits-per-weight of each quantization format
Estimated
- Memory footprint (weights + cache + overhead)
- Tokens per second
- Fit thresholds (heuristic bands, not hard OS limits)
6. Known limitations
- Context memory is modeled approximately. Real KV-cache size varies by architecture (GQA shrinks it dramatically); we use conservative defaults so "good" fits stay good in practice.
- Multimodal and MoE models are harder to size. Mixture-of-experts models (e.g. Mixtral-class) run faster per parameter than dense math suggests; estimates for those are deliberately cautious.
- Speculative decoding and draft models can exceed estimated speed; they are not modeled.
- Unified-memory machines (Apple Silicon) blur the VRAM/RAM distinction; we model the practical limit as a share of unified memory, which underestimates what a 64 GB Mac can host.
When an estimate and your measured experience disagree, trust your measurement — and consider that the next profile you try may cross a fit tier. Questions or corrections are welcome via the contact page.
7. Reproduce it yourself
Everything the site does is a thin interface over llmfit's public API, and the engine itself is MIT-licensed on GitHub if you prefer to run it locally.