weckoai/modelfit-hardware-dataset

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. This dataset is a mirror of the live JSON export at modelfit.io/api/dataset, refreshed from the same GitHub repo that generates it: 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
• JSON API (same data, machine-readable, CORS open): modelfit.io/api/dataset
• Source repo (generator script + CSV/JSON): 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.