Model Catalog: File Sizes, Cloud Listings and VRAM Estimates

Compare published local model file sizes, context windows and estimates of weight memory. Cloud entries with no downloadable tag keep their size unknown.

By VRAM Fit editorial Published 2026-10-07 Updated 2026-11-06

Use this catalog to compare file sizes and context windows reported by public model listings. The fit column estimates weight memory from a downloadable tag; it is not a GPU benchmark or a complete serving budget. Cloud entries without a local artifact keep their size and fit unknown.

If you want to know whether your card can run a specific model at a specific context length, the VRAM calculator answers that with your own numbers. This page answers the earlier question: what is out there, how big is it, and roughly what hardware class does it need.

Cloud entries and unknown local sizes

The MiniMax M3.1 Flash listing currently offers a cloud tag without a downloadable local file size. Its local size and single-GPU fit stay unknown here. This does not mean zero memory. The publisher separately provides open weights and deployment notes; an exact artifact, engine and quantisation are needed before estimating local memory.

A blank size can also mean this crawl has not inspected that family’s tags. Follow the source link to distinguish an unobserved local size from a cloud listing. Do not enter zero in a memory calculator for either case.

How to read the numbers

Column	Where it comes from	Confidence
Family	The public listing for that model family	Reported
Parameter sizes	Sizes the publisher lists for the family	Reported
Smallest / largest tag	Reported file size of the smallest and largest quantisation variants	Measured size, reported by the publisher
Fits on	Derived: file size x 1.15 runtime allowance, compared with nominal card memory x 0.9	Estimate
Tags	How many variants the publisher lists	Reported

Two rules keep this table honest. First, the file size is the publisher’s number, not this site’s arithmetic — it is the size of the artefact you actually download. Second, the hardware verdict is arithmetic on top of that number, and it covers weights only. It excludes the KV cache, and the cache is not a rounding error: at long context it can exceed the weights. Cache figures appear only for families whose architecture is in the reference table below.

Families by how widely they are pulled

The forty most-pulled families in the catalog at the last crawl.

Family	Parameter sizes	Smallest tag	Largest tag	Smallest tag fits on	Tags
`llama3.1`	8b / 70b / 405b	3.2 GB	812.0 GB	1 x 8 GB+	93
`nomic-embed-text`	—	274 MB	274 MB	1 x 8 GB+	3
`deepseek-r1`	1.5b / 7b / 8b / 14b / 32b	1.1 GB	713.0 GB	1 x 8 GB+	35
`llama3.2`	1b / 3b	581 MB	6.4 GB	1 x 8 GB+	63
`qwen2.5`	0.5b / 1.5b / 3b / 7b / 14b	338 MB	145.0 GB	1 x 8 GB+	133
`qwen3`	0.6b / 1.7b / 4b / 8b / 14b	523 MB	470.0 GB	1 x 8 GB+	58
`gemma3`	270m / 1b / 4b / 12b / 27b	241 MB	55.0 GB	1 x 8 GB+	29
`gemma2`	2b / 9b / 27b	1.2 GB	54.0 GB	1 x 8 GB+	94
`mistral`	7b	2.7 GB	14.0 GB	1 x 8 GB+	84
`gemma4`	e2b / e4b / 12b / 26b / 31b	4.3 GB	34.0 GB	1 x 8 GB+	51
`llama3`	8b / 70b	3.2 GB	141.0 GB	1 x 8 GB+	68
`qwen3.5`	0.8b / 2b / 4b / 9b / 27b	1.0 GB	81.0 GB	1 x 8 GB+	72
`qwen2.5-coder`	0.5b / 1.5b / 3b / 7b / 14b	338 MB	66.0 GB	1 x 8 GB+	199
`phi3`	3.8b / 14b	1.4 GB	28.0 GB	1 x 8 GB+	72
`mxbai-embed-large`	335m	—	—	—	4
`llava`	7b / 13b / 34b	3.2 GB	69.0 GB	1 x 8 GB+	98
`gpt-oss`	20b / 120b	14.0 GB	65.0 GB	1 x 24 GB+	5
`qwen3-coder`	30b / 480b	19.0 GB	960.0 GB	1 x 32 GB+	9
`glm-ocr`	—	1.8 GB	2.7 GB	1 x 8 GB+	3
`gemma`	2b / 7b	1.2 GB	17.0 GB	1 x 8 GB+	102
`bge-m3`	567m	1.2 GB	1.2 GB	1 x 8 GB+	3
`qwen`	0.5b / 1.8b / 4b / 7b / 14b	395 MB	118.0 GB	1 x 8 GB+	379
`codellama`	7b / 13b / 34b / 70b	2.8 GB	138.0 GB	1 x 8 GB+	199
`phi4`	14b	9.1 GB	29.0 GB	1 x 12 GB+	5
`llama2`	7b / 13b / 70b	2.8 GB	138.0 GB	1 x 8 GB+	102
`qwen3.6`	27b / 35b	17.0 GB	72.0 GB	1 x 24 GB+	35
`qwen3-vl`	2b / 4b / 8b / 30b / 32b	1.9 GB	471.0 GB	1 x 8 GB+	57
`tinyllama`	1.1b	483 MB	2.2 GB	1 x 8 GB+	36
`qwen2`	0.5b / 1.5b / 7b / 72b	338 MB	145.0 GB	1 x 8 GB+	97
`qwen3.8`	27b	18.0 GB	56.0 GB	1 x 24 GB+	13
`qwen2.5vl`	3b / 7b / 32b / 72b	3.2 GB	147.0 GB	1 x 8 GB+	17
`mistral-nemo`	12b	4.8 GB	25.0 GB	1 x 8 GB+	17
`minicpm-v`	8b	4.1 GB	16.0 GB	1 x 8 GB+	17
`llama3.2-vision`	11b / 90b	7.8 GB	177.0 GB	1 x 12 GB+	9
`deepseek-coder`	1.3b / 6.7b / 33b	632 MB	67.0 GB	1 x 8 GB+	102
`qwen3-embedding`	0.6b / 4b / 8b	639 MB	15.0 GB	1 x 8 GB+	12
`llama3.3`	70b	26.0 GB	141.0 GB	1 x 48 GB+	14
`dolphin3`	8b	4.9 GB	16.0 GB	1 x 8 GB+	5
`smollm2`	135m / 360m / 1.7b	88 MB	3.4 GB	1 x 8 GB+	49
`all-minilm`	22m / 33m	—	—	—	10

Smallest downloads first

The same families ordered by their smallest available tag, which is usually the size you want if you are fitting a model onto a modest card.

Family	Parameter sizes	Smallest tag	Largest tag	Smallest tag fits on	Tags
`smollm2`	135m / 360m / 1.7b	88 MB	3.4 GB	1 x 8 GB+	49
`smollm`	135m / 360m / 1.7b	88 MB	3.4 GB	1 x 8 GB+	94
`embeddinggemma`	300m	239 MB	622 MB	1 x 8 GB+	5
`gemma3`	270m / 1b / 4b / 12b / 27b	241 MB	55.0 GB	1 x 8 GB+	29
`nomic-embed-text`	—	274 MB	274 MB	1 x 8 GB+	3
`snowflake-arctic-embed`	22m / 33m / 110m / 137m / 335m	274 MB	274 MB	1 x 8 GB+	16
`qwen2.5`	0.5b / 1.5b / 3b / 7b / 14b	338 MB	145.0 GB	1 x 8 GB+	133
`qwen2.5-coder`	0.5b / 1.5b / 3b / 7b / 14b	338 MB	66.0 GB	1 x 8 GB+	199
`qwen2`	0.5b / 1.5b / 7b / 72b	338 MB	145.0 GB	1 x 8 GB+	97
`qwen`	0.5b / 1.8b / 4b / 7b / 14b	395 MB	118.0 GB	1 x 8 GB+	379
`tinyllama`	1.1b	483 MB	2.2 GB	1 x 8 GB+	36
`qwen3`	0.6b / 1.7b / 4b / 8b / 14b	523 MB	470.0 GB	1 x 8 GB+	58
`granite3.1-moe`	1b / 3b	524 MB	6.6 GB	1 x 8 GB+	33
`llama3.2`	1b / 3b	581 MB	6.4 GB	1 x 8 GB+	63
`deepseek-coder`	1.3b / 6.7b / 33b	632 MB	67.0 GB	1 x 8 GB+	102
`qwen3-embedding`	0.6b / 4b / 8b	639 MB	15.0 GB	1 x 8 GB+	12
`qwen3.5`	0.8b / 2b / 4b / 9b / 27b	1.0 GB	81.0 GB	1 x 8 GB+	72
`deepseek-r1`	1.5b / 7b / 8b / 14b / 32b	1.1 GB	713.0 GB	1 x 8 GB+	35
`starcoder2`	3b / 7b / 15b	1.1 GB	32.0 GB	1 x 8 GB+	67
`falcon3`	1b / 3b / 7b / 10b	1.1 GB	21.0 GB	1 x 8 GB+	17
`gemma2`	2b / 9b / 27b	1.2 GB	54.0 GB	1 x 8 GB+	94
`gemma`	2b / 7b	1.2 GB	17.0 GB	1 x 8 GB+	102
`bge-m3`	567m	1.2 GB	1.2 GB	1 x 8 GB+	3
`phi3`	3.8b / 14b	1.4 GB	28.0 GB	1 x 8 GB+	72
`codegemma`	2b / 7b	1.6 GB	17.0 GB	1 x 8 GB+	85
`glm-ocr`	—	1.8 GB	2.7 GB	1 x 8 GB+	3
`qwen3-vl`	2b / 4b / 8b / 30b / 32b	1.9 GB	471.0 GB	1 x 8 GB+	57
`orca-mini`	3b / 7b / 13b / 70b	2.0 GB	138.0 GB	1 x 8 GB+	119
`mistral`	7b	2.7 GB	14.0 GB	1 x 8 GB+	84
`codellama`	7b / 13b / 34b / 70b	2.8 GB	138.0 GB	1 x 8 GB+	199

Architecture reference and the KV cache

The table below is the only place this site states layer and head counts, because those numbers come from each model’s own published configuration rather than from inference. Where a family matches an entry, the catalog can compute the KV cache; where it does not, the cache is left blank on purpose.

Family pattern	Reference architecture	Layers	KV heads	Head dim
`llama3.1`	Llama 3.1 8B	32	8	128
`llama3.2`	Llama 3.2 3B	28	8	128
`llama3.3`	Llama 3.3 70B	80	8	128
`llama2`	Llama 2 13B (MHA)	40	40	128
`mistral`	Mistral 7B	32	8	128
`qwen2.5`	Qwen 2.5 14B	48	8	128

If a family you care about is not listed, its cache cost is not unknowable — it is just not in this table. The model’s configuration file carries the three values, and the KV cache calculator turns them into gigabytes. For why the cache behaves the way it does, see KV cache size explained.

Search and filter the full catalog

The table below reads the same dataset the section above is built from, but lets you filter and sort it. It is rendered in your browser from a static file served by this site; there is no external request and no tracking.

Jump to the catalog

MODEL CATALOG · 270 FAMILIES

Search by family name Only show families that fit a single card of

The catalog loads on demand: 270 families, 1516 tag records, crawled 2026-11-06. The static tables above the fold are the same data, so nothing here is required to read the page.

What this catalog does not tell you

It does not measure anything. The sizes are published figures, and the memory verdicts are arithmetic on those figures. Nothing here was run on a GPU to check.
It leaves out the KV cache for most families. A cache figure appears only where the model’s architecture is in the reference table, because a cache number without layer and head counts would be invented.
It does not cover licence terms. Open weight does not mean unrestricted use; the licence on each model page decides what you may do with it.
It is not a ranking of quality. Pull count measures attention, not suitability. 270 families are listed because they exist in the catalog, not because each one is worth running.
It cannot see private or self-hosted models, and it only reports what the listing itself exposes.
Numbers age. The crawl timestamp at the top of this page is the only claim about freshness; anything older than the schedule interval should be re-checked at the source.

Reference: parameter sizes seen in this crawl

0.5b · 0.6b · 0.8b · 1b · 1.1b · 1.3b · 1.5b · 1.7b · 1.8b · 2b · 3b · 3.8b · 4b · 6.7b · 7b · 8b · 9b · 11b · 12b · 13b · 14b · 20b · 26b · 27b · 30b · 31b · 32b · 33b · 34b · 35b · 70b · 72b · 90b · 110b · 120b · 122b · 235b · 270m · 335m · 405b · 567m · 671b · e2b · e4b · 1m · 1.2b · 1.6b · 2.4b · 2.7b · 6b · 7.8b · 8x7b · 8x22b · 10b · 10.7b · 15b · 16b · 16x17b · 22m · 22b · 24b · 30m · 33m · 40b · 67b · 80b · 104b · 110m · 111b · 123b · 128x17b · 128b · 132b · 135m · 137m · 141b · 180b · 236b · 278m · 300m · 350m · 360m · 397b · 440m · 480b · 568m · 570m · 600m · 740m

Sizing a specific model is a five-minute job with the VRAM calculator: enter the parameter count, the quantisation bits from the quantization comparison, your context length, and the memory you have. If you are choosing hardware rather than checking it, start with the hardware sizing guide and the file size lookup. For the cost side, local versus hosted cost is the companion question, and whether a local model is the cheaper path at all sets the wider frame.

Asked before trying it

Where do the file sizes in this catalog come from?

They are read from the public model listing pages for each tag, so they are reported sizes rather than estimates. The memory requirement next to each size is derived from that number and is labelled as an estimate.

How is the GPU requirement calculated?

Reported file size is the weight footprint. The catalog multiplies it by 1.15 to allow for runtime buffers and activations, then compares the result against nominal card memory reduced to 90% to leave room for the system and driver. The KV cache is a separate cost and is not included unless the family's architecture is known.

Why is the KV cache missing for most families?

The cache size needs the layer count, KV-head count and head dimension from the model's own configuration. Only families covered by the reference table on this page have that data, so the rest show weights only. The VRAM calculator computes the cache for any architecture you can look up.

How often is this catalog rebuilt?

It is regenerated on a schedule by a crawler that runs outside the browser. Because the output is written to static files, the page works even when the source is unreachable, and a crawl that returns too little data is rejected rather than published.

Does this page recommend which model to run?

No. It reports sizes, context windows and memory requirements. Whether a model is suitable depends on the task, the licence and the quality you need, which are not measured here.