---
license: cc-by-4.0
pretty_name: ModelFit Local LLM Hardware Compatibility Dataset
tags:
  - llm
  - local-llm
  - ollama
  - hardware
  - quantization
  - apple-silicon
  - gpu
language:
  - en
size_categories:
  - n<1K
---

# ModelFit Local LLM Hardware Compatibility Dataset

Which local AI models fit which hardware. Maps 107 LLMs (75 of them local-capable via Ollama, llama.cpp or LM Studio) to RAM/VRAM requirements at Q4_K_M quantization, so you can look up "will this model run on my machine" without guessing.

Source of truth: [modelfit.io/data](https://modelfit.io/data). This dataset is a mirror of the live JSON export at [modelfit.io/api/dataset](https://modelfit.io/api/dataset), refreshed from the same GitHub repo that generates it: [github.com/Wecko-ai/modelfit-hardware-dataset](https://github.com/Wecko-ai/modelfit-hardware-dataset) (CSV + JSON, self-updating).

## What it is

One row per model. Each row has the model's parameter count (when disclosed; closed API models like Claude/GPT/Gemini/Grok are marked `null`, vendors don't publish those numbers), its quantization, the minimum RAM/VRAM to run it, an estimated memory load in GB, whether it runs locally at all, which runtimes support it, what it's best suited for, and the exact `ollama pull` command if it's on the Ollama registry.

## Columns

| column | type | meaning |
| --- | --- | --- |
| `model` | string | model name |
| `family` | string | model family (e.g. Llama, Qwen, Gemma) |
| `params` | number or null | parameter count in billions; `null` means vendor-undisclosed (closed API models) |
| `quantization` | string | quantization level the sizing is based on (mostly Q4_K_M, some Q8_0 siblings) |
| `minRamGb` | number | minimum RAM/VRAM in GB to run it |
| `estimatedLoadGb` | number | estimated memory footprint once loaded |
| `kvKbPerToken` | number or null | exact fp16 KV-cache cost in KB per token for hybrid linear-attention models (Qwen3.5/3.6, Qwen3-Next), computed from the published HF config (full_attention layers x kv_heads x head_dim x 2 x 2 bytes; only full-attention layers cache KV); `null` means standard GQA, where KV is estimated by size class. Example: Qwen3.6 35B-A3B is 20 KB/token, so a full 262k-token fp16 cache is ~5 GB |
| `runsLocally` | boolean | true when a registry-verified Ollama build fits a consumer RAM tier tracked here (up to 256GB) |
| `openWeights` | boolean | true when the weights are publicly downloadable; can be true while runsLocally is false (open-weight giants like Nemotron 3 Ultra, 550B ~190GB at 2-bit, exceed every consumer tier) |
| `ggufDiy` | boolean | true when the weights are open and a ~Q4 GGUF (0.6 GB per billion parameters) fits a 256GB-class machine via llama.cpp but no Ollama build exists (e.g. DeepSeek V4 Flash 284B, Xiaomi MiMo-V2-Flash 309B); runnable DIY, not scored for local fit |
| `runtimes` | string | pipe-separated runtimes that can run it (ollama, llama.cpp, lm-studio) |
| `bestFor` | string | short use-case tag |
| `ollamaCommand` | string or null | the exact registry-verified `ollama pull` tag, if one exists |

## The 0.6 GB per billion rule

At Q4_K_M quantization, a local LLM needs roughly 0.6 GB of memory per billion parameters. ModelFit sizes its "fits" recommendation to a tiered memory budget: about 70% of unified memory up to 32 GB, scaling linearly to about 85% at 128 GB and above (high-RAM Macs can wire more memory to the GPU). The rest is headroom for the OS, the context window, and KV-cache. An 8B model needs about 5 GB loaded, comfortable on a 16 GB machine. A 70B model needs about 42 GB, so 64 GB minimum with real headroom at 96 GB or more.

## Links

- Live site and interactive matrix: [modelfit.io/data](https://modelfit.io/data)
- JSON API (same data, machine-readable, CORS open): [modelfit.io/api/dataset](https://modelfit.io/api/dataset)
- Source repo (generator script + CSV/JSON): [github.com/Wecko-ai/modelfit-hardware-dataset](https://github.com/Wecko-ai/modelfit-hardware-dataset)

## License

CC BY 4.0. Attribution: "ModelFit, https://modelfit.io".

## Caveats

Estimated memory load figures are estimates derived from parameter count and quantization, not measured benchmarks. Treat them as a starting point, not a guarantee; actual usage varies with context length, backend, and OS overhead.