Data Changelog

All 185 entries, newest first.

Last updated 2026-10-20

RSS
  1. 2026-10-20The AMD ROCm guide now covers the Radeon RX 9000 series and integrated Radeon graphics. RX 9070-class cards are on AMD's official ROCm list and need ROCm 7; the guide gives their build targets, and explains how Ryzen AI and older integrated GPUs can run models from system memory. The build commands were re-checked against llama.cpp's current docs and did not change.
  2. 2026-10-20Gemma 4 12B is now sized from its published GGUF files instead of generic rates. At Q4_K_M it needs about 8.5 GB at 32K context; none of the card verdicts changed. The page also notes that bartowski's Q4_K_M file is about half a gigabyte larger than unsloth's.
  3. 2026-10-20Added North Mini Code 1.0, Cohere's open coding model. It is a 30B mixture-of-experts with about 3B parameters active per token, and only 13 of its 49 layers keep a growing cache: at Q4_K_M it needs about 20 GB at 4K and 21 GB at 32K, comfortable on a 24 GB card. A 16 GB card can run the Q3_K_M build, but only just.
  4. 2026-10-20The whole index is now downloadable as JSON. Every model with its architecture, quantization levels and file sizes is at /data/v1/models.json, and every card with its usable memory and bandwidth at /data/v1/gpus.json — regenerated with each update, under the same CC BY 4.0 licence as the rest of the data.
  5. 2026-10-20The model comparison now goes up to 256K of context and judges Macs by the memory they can actually use. Context choices are 4K to 256K, so you can watch a hybrid-attention model overtake a conventional one at long context; a model asked for more context than its window says so instead of showing a size. The "fits your card" row now uses a Mac's usable share of memory — a 16 GB Mac was being judged against all 16 GB — and each model is sized at the same build its own page uses.
  6. 2026-10-19Filtering the Chinese model library no longer drops you into the English one. Picking a card, a size or a format on the Chinese Hub used to switch the whole page to English; it now stays in Chinese. Model cards also label their speed as an RTX 4090 figure right under the number, and on phones they skip the hardware tags to keep the list shorter.
  7. 2026-10-19The memory calculator now draws its estimate as one bar across your card. Weights, KV cache and the working buffer each get a segment, the rest of the card shows as free space, and a dashed line marks where the verdict turns amber, so you can watch a longer context eat into the card. Anything past the card is hatched and labelled as spilling to system RAM or as not fitting.
  8. 2026-10-19Added Gemma 4 12B, Google's mid-sized Gemma 4 from June that we had missed. It is a dense 12B with a 256K window that reads text, images and audio without separate encoders; only 8 of its 48 layers keep a growing cache, so at Q4 it needs about 8.6 GB at 32K, comfortable on a 12 GB card, and a 16 GB card holds the whole window. Sizes are estimates until a GGUF file size can be checked.
  9. 2026-10-19Runtime versions updated: llama.cpp b11721 and vLLM v0.32.0. vLLM now needs Python 3.11 or newer (the install commands here already create a 3.12 environment) and no longer allows browser requests from other origins unless you pass --allowed-origins.
  10. 2026-10-18The Muse Spark Open page now states its licence terms. Meta's repository is gated, products built on it must show "Built with Muse Spark Open", and large companies need a separate agreement to offer it as an API.
  11. 2026-10-18Nous Hermes 3 Llama 3.1 8B no longer shows speeds measured on Llama 3.1 8B. The two share a name fragment, and this site has never run Hermes 3; its GPU-page speeds now come from each card's calibrated range like any other unmeasured model.
  12. 2026-10-18You can now hear a speed before you buy. The calculator links each result to the speed player with the same model, level, context and card, and GPU pages offer side-by-side playback against same-budget cards and against the next card up, on the largest model this card runs comfortably. A link only appears when both cards have a measured or calibrated speed to play.
  13. 2026-10-18Runtime versions re-checked: llama.cpp is at b11716, Ollama at v0.40.6 and ExLlamaV3 at v1.6.3; vLLM (v0.31.0) is unchanged. This Ollama release reads GGUF files that use the new Q2_0 type. No new open-weight model this week was missing from the index.
  14. 2026-10-18GPU pages no longer print an RTX 4090 speed as if it were measured on the card you opened. The column is now that card's own figure: a measured run, a range scaled from its Llama 2 7B benchmark, or a bandwidth ceiling. Mixture-of-experts ceilings use the active parameters, not the whole file. A new tool at /tools/feel/ streams a sentence at that rate for two cards side by side, and refuses to stream a ceiling.
  15. 2026-10-17Download commands for very large models now work when the file is split into parts. Builds over about 48 GB are often published as several files in a folder, and the command used to ask for one exact filename that did not exist, so it downloaded nothing. It now fetches every part and points llama.cpp at the first one. Ling-3.1-flash, whose files use their own naming, now shows a placeholder to fill in instead of a wrong name.
  16. 2026-10-17Reflection AI's Beam is in the index. It is a 501B mixture-of-experts model with about 23B parameters active per token, released with open weights under Apache 2.0. Only 9 of its 52 layers keep a growing cache, so at Q2_K it needs about 191 GB at 4K and 230 GB across its full 1M window: comfortable on a 512 GB Mac Studio, and tight on a 256 GB one up to 128K.
  17. 2026-10-17inclusionAI's Ling-3.1-flash is in the index: a 560B mixture-of-experts reasoning model (25B active per token, MIT) for agents and coding. Only 9 of its 72 layers keep a growing cache, so context is cheap, but the weights alone put it out of reach of any single GPU: about 371 GB at Q4_K_M, which a 512 GB Mac Studio holds only tightly. It is listed so the calculator can say so.
  18. 2026-10-17Runtime versions re-checked: llama.cpp is at b11703; Ollama (v0.40.5), vLLM (v0.31.0) and ExLlamaV3 (v1.6.2) are unchanged. No open-weight model released in the last few days is missing from the index.
  19. 2026-10-16Nemotron 3.5 Lightning and the rest of IBM's Granite 4.2 family are in the index. Lightning is a 30B mixture-of-experts model with about 3B parameters active per token; only 6 of its 52 layers keep a growing cache, so at Q4_0 it needs about 19.8 GB at 4K and still only 20.6 GB at 128K, comfortable on a 24 GB card. Granite 4.2 30B is a dense model that needs about 19.6 GB at 4K, comfortable on 24 GB at short contexts. Granite 4.2 3B needs 2.7 GB and runs on any card here.
  20. 2026-10-16NVIDIA's Nemotron 3.5 Bolt and Super VL are in the index. Bolt is a 74B mixture-of-experts model built to fit a 24 GB card: NVIDIA's 2-bit file needs about 23.1 GB at 4K and 24.1 GB at 128K, tight on 24 GB and comfortable on 32 GB. Super VL is the 120B vision-language model it was compressed from; at Q4_0 it needs about 75 GB, comfortable on a 128 GB Mac or a DGX Spark 128G. Both keep a growing cache on only 8 of 88 layers, so long context is cheap.
  21. 2026-10-16Meta's Muse Spark Open is in the index: an 816B mixture-of-experts model with about 42B parameters active per token and image and audio input. Its smallest build, the 304 GB Q2_K, needs about 319 GB at 4K context and 327 GB at 128K, so it runs on a 512 GB Mac Studio and, tightly, across four 80 GB H100s. Larger builds fit no single machine here.
  22. 2026-10-16llama.cpp's server now listens on port 9931 by default instead of 8080. Its v0.7.0 release (build b11671) changed the default; every llama-server command on this site already sets --port explicitly, so they keep working as written, but a server started without --port will no longer answer on 8080. Ollama is at v0.40.5; vLLM and ExLlamaV3 are unchanged.
  23. 2026-10-15Runtime versions re-checked: llama.cpp is at b11632, Ollama at v0.40.4 and ExLlamaV3 at v1.6.2; vLLM (v0.31.0) is unchanged. This Ollama release can run decision models from the terminal and reuses loaded models for faster starts. No new open-weight model this week was one that fits local hardware and had weights out.
  24. 2026-10-14The calculator now estimates generation speed from each card's own measured llama.cpp run, gives copy-ready llama.cpp, Ollama and vLLM commands for the result, and saves the result as an image. The speed estimate is shown for dense 7B–33B models, the range it was checked against; "I have this card" mode lists one best level per model by default and sorts by speed on the card you picked.
  25. 2026-10-14Liquid AI's LFM2.5 24B-A2B is in the index: a 24B mixture-of-experts reasoning model with about 2.45B parameters active per token, built for on-device agents. Only 10 of its 40 layers keep a growing KV cache, so at Q4_K_M it needs about 15.3 GB at 4K context and still only 17.9 GB across its full 128K window: tight on a 16 GB card, comfortable on 24 GB at any context.
  26. 2026-10-14IBM's Granite 4.2 8B is in the index: a dense reasoning model under Apache 2.0 with a 128K window. At Q4_K_M it needs about 6.3 GB at 4K context, so it runs comfortably on an 8 GB card, and about 11.1 GB at 32K, which takes a 16 GB card for long documents. Thinking is on by default and can be turned off through the chat template.
  27. 2026-10-13Three more calculator conveniences. Multimodal models can now include their vision encoder: enter its size, or read it from the model's GGUF repo with one click. You can pin a result as A and change settings to see the difference, and save the machines you use so one tap brings back the card or cards you have.
  28. 2026-10-13The calculator now estimates how long a long prompt takes before the first word appears. For 59 cards and Macs it starts from each one's measured prompt speed on llama.cpp's community scoreboards and scales it to the chosen model and context. A Mac M3 Pro reads an 8K prompt to Llama 3.1 8B in about 41 seconds, an RTX 4090 reads a 32K one in about 5. Cards without a published run get no figure.
  29. 2026-10-13The calculator handles mixed-card machines, tells you how many people a setup can serve, and shows the download size. Add a second, different card (a 3060 beside a 3090) and the memory adds up the way llama.cpp and Ollama split layers, with the speed bound following the slower card. Each verdict now also counts how many full-length requests fit at once at 4K, 8K and 32K, at the memory share this site's vLLM commands use.
  30. 2026-10-13The calculator now estimates fine-tuning memory. Pick QLoRA, LoRA or a full fine-tune, the LoRA rank, sequence length, batch and gradient checkpointing, and it adds up the base weights, the trainable adapters with their optimizer state, activations and the loss, and compares all three methods on your card. It describes a standard transformers + PEFT run; Unsloth and similar trainers publish lower minimums.
  31. 2026-10-13The VRAM calculator can now size any model on Hugging Face. Paste a repo name or link, including a GGUF repo, and it reads the model's own config: layers, KV heads, sliding-window and hybrid attention, and the parameter count. Your browser asks Hugging Face directly. If the model is already in this index, it offers the indexed entry, whose sizes come from real files.
  32. 2026-10-13The VRAM calculator is quicker to use. You can now search for a model by name, size or task, in English or Chinese ("qwen 27b", "千问", "coding"), and pick a common card with one tap. Once you name your card, it suggests the same three models the homepage would. The card list is grouped by vendor, and on a phone a bar at the bottom keeps the total and the verdict in view while you change settings.
  33. 2026-10-13Mellum2.1 from JetBrains is in the index: an open coding model for 10 and 12 GB cards. It is a 12B mixture-of-experts model with about 2.5B active per token, under Apache 2.0. At Q4_K_M it needs about 8.6 GB at 4K context and 10.5 GB at its full 128K window, so it runs comfortably on a 12 GB card even at 128K and on a 10 GB card at shorter contexts, but not on 8 GB. Several guides' model counts were also corrected, including the RTX 4060 Ti 16G guide, which had fallen well behind.
  34. 2026-10-12Search results now describe each page properly. Bing flagged many of this site's snippets as too short, mostly on Chinese pages. Model, GPU and guide pages now add the facts the page itself states: the size at 4K, the smallest card that runs it, and the cards and models a guide covers. The Chinese format pages also stop showing hardware requirements in English.
  35. 2026-10-12MiMo-V2.6-Pro is in the index, the open-weight model readers asked about most. Xiaomi's 1-trillion-parameter MoE (about 42B active, MIT licence) ships already 4-bit, and even so it needs about 604 GB at 4K context. That is more than any single machine listed here: a 512 GB Mac Studio gives its GPU about 384 GB, and four 80 GB cards hold 320 GB. Its page and the calculator now say so plainly; an 8 × 80 GB server is about the smallest that holds it.
  36. 2026-10-12Runtime versions re-checked: Ollama is at v0.40.3 and llama.cpp at b11559. This Ollama release pauses the background upgrade for embedding models only; chat models still get upgraded in the background. vLLM (v0.31.0) and ExLlamaV3 (v1.6.1) are unchanged, and no new open-weight model this week runs in llama.cpp yet.
  37. 2026-10-11Runtime versions re-checked: llama.cpp is at b11552 and ExLlamaV3 at v1.6.1. Ollama (v0.40.2) and vLLM (v0.31.0) are unchanged. No new open-weight model this week fits this site's hardware yet.
  38. 2026-10-11The small Qwen3.5 sizes are in: 4B, 2B and 0.8B, for 4 to 8 GB cards, base-model Macs, mini PCs and CPU-only machines. At Q4_K_M with 4K context they need about 3.3 GB, 1.5 GB and 0.6 GB. Even their full 256K window stays near 12 GB, 4.8 GB and 3.8 GB, because only a quarter of their layers keep a KV cache. The 0.8B sizes are estimates; the 4B and 2B come from published files.
  39. 2026-10-10Three of the most-used Qwen models were missing and are now in: Qwen3.6 35B-A3B, Qwen3.6 27B and Qwen3.5 9B. Qwen3.6 35B-A3B needs about 23.4 GB at Q4_K_M with 4K context, tight on a 24 GB card and comfortable on 32 GB. Qwen3.6 27B needs 19.1 GB, comfortable on 24 GB. Qwen3.5 9B needs 6.6 GB, comfortable on an 8 GB card, and its full 256K window fits in about 15 GB. All three keep a KV cache on only a quarter of their layers, so long context is cheap. Sizes come from the published GGUF files.
  40. 2026-10-10Qwen3.8-Flash-Next added: a 125B mixture-of-experts model with about 6B parameters active per token, and a preview of Qwen's next architecture. At Q4_K_M it needs about 79 GB at 4K context and only 87 GB at its full 256K window, so a 128 GB Mac or DGX Spark runs it comfortably. Its extra 51B n-gram table is read from RAM or disk, never from VRAM. The table is bundled in the download, so expect files much larger than these sizes. Sizes are estimates.
  41. 2026-10-10Ollama v0.40.2 upgrades older downloaded models the first time you run them. It keeps the original file as a backup, so those models take extra disk space until a later release removes the backups. Worth knowing on a small SSD or a base-model Mac. Runtime versions now read Ollama v0.40.2 and llama.cpp b11539.
  42. 2026-10-09Muse Glimmer 30B added: Meta's first open-weight model since Llama 4, built to run on a single card. It is a dense 28B text model that also reads images, released in August under Apache 2.0. Long context is unusually cheap on it: at Q4_K_M it needs about 17.7 GB at 4K and only 19.4 GB at its full 128K window, comfortable on a 24 GB card either way. Sizes come from the published GGUF files. The vision encoder loads on top and is not included. llama.cpp is now at b11514 and Ollama at v0.40.1.
  43. 2026-10-08The memory calculator now handles models bigger than your card. Choose two to four identical cards and it sizes them together, as llama.cpp splits a model by default. It also says plainly that extra cards add room, not speed. When a model still does not fit, it estimates how many layers stay on the GPU, how much system RAM the rest needs, and the speed ceiling for three common memory setups. Mixture-of-experts models now get an approximate speed ceiling too, counted over the parameters each token actually uses.
  44. 2026-10-08The memory calculator now answers the next three questions, not just the first. With a model and your card chosen, it lists every quantization level that model ships, sized at your context, and marks the best-quality one that fits your card comfortably. It shows the longest context your card can hold, and the generation-speed ceiling your card's memory bandwidth allows. You can also store the KV cache as q8_0 or q4_0, the llama.cpp and Ollama settings that roughly halve or quarter it at long context, with the exact flags shown. You can now pick your card inside the calculator itself.
  45. 2026-10-08The memory calculator's "Calculate" links in GPU-to-models mode now work. Clicking one changed the address but left you on the list; it now opens that model on the card you were browsing. A link naming a card the site does not know no longer claims that nothing fits it. The calculator now warns when the context you picked is longer than the model can use, and shared links to a custom model keep its size and layers. "Smallest card" now means the smallest retail card, and CPU-only memory sizes are no longer counted as cards.
  46. 2026-10-08The language switch on the "page not found" screen now takes you to the other language's home page. It used to point at a missing page of its own. Search engines are also now told only about pages whose content actually changed, rather than most of the site after every update.
  47. 2026-10-08Two 32 GB workstation cards added: AMD's Radeon AI PRO R9700 and Intel's Arc Pro B70. Both carry the same memory as an RTX 5090 at a fraction of its bandwidth. The R9700 (640 GB/s) fits 74 of the 90 models comfortably at 4K and runs AWQ and GPTQ through vLLM on ROCm; the B70 (608 GB/s) fits 72 and, like every Arc card, runs GGUF only. Specs are from AMD's and Intel's own product pages. ExLlamaV3 is now at v1.6.0 and llama.cpp at b11480.
  48. 2026-10-07Ollama v0.40.0 is now its latest release, and on Apple silicon it runs some model families on MLX by default. Ollama names Qwen3.8, Gemma 4, Qwen3.6 and Qwen3.5. This site sizes GGUF builds and Ollama has not published how large its MLX builds are, so the three Mac guides now say so. llama.cpp is at b11458; vLLM v0.31.0 and ExLlamaV3 v1.5.4 are unchanged.
  49. 2026-10-06vLLM v0.31.0 and llama.cpp b11434 are now the current runtime versions on the benchmarks page. Both were read from the projects' own release pages; Ollama (v0.35.1) and ExLlamaV3 (v1.5.4) are unchanged. llama.cpp also cut a v0.6.0 release, its first numbered one in this index's records. No model or size on the site changes with this.
  50. 2026-10-05The site's benchmark and sizing data is now licensed CC BY 4.0. You can copy and reuse it, including commercially, as long as you credit quantized.uk and link back. The terms page has a new section saying so; model weights and third-party names keep their own terms.
  51. 2026-10-05New models and new hardware now appear together near the top of the homepage. The "Latest additions" list sat several screens down and only listed models, so newly added machines such as the DGX Spark had no way onto the front page. It now sits right below the "what fits your card" picker.
  52. 2026-10-05NVIDIA DGX Spark added, in its 64GB and 128GB versions. Both have the same chip and the same 273 GB/s memory, shared by the CPU, the GPU and the operating system, so the site judges fits against the whole pool and treats anything larger than it as not loading. At 4K context the 64GB model fits 82 of 90 models comfortably and the 128GB model 84. GPT-OSS 120B does not fit the 64GB model: its native build is about 66 GB. A new guide covers which version to buy, what each one runs and how to set it up. Card-versus-card answers no longer say two machines hold the same models when their counts differ.
  53. 2026-10-05OLMo 3 7B added, and OLMo 2 7B now points to it. Allen AI's fully open 7B model is published with its training data, code and checkpoints. It reads 64K tokens of context where OLMo 2 stopped at 4K, and needs the same memory at short context. Three of every four layers use a short sliding window, so at Q4_K_M it needs about 6.8 GB at 4K and 10.9 GB at 32K; without the window, 32K would take about 22 GB. Sizes are estimates, since no file size could be checked. Guide figures that count the models in the index were updated to the new total.
  54. 2026-10-04Current runtime versions re-checked on the projects' own release pages: llama.cpp b11390, Ollama v0.35.1, vLLM v0.30.0 (unchanged) and ExLlamaV3 v1.5.4. ExLlamaV2 is still at v0.3.2 from July 2025, and its README still says the project is archived. The FAQ also answers two new questions: which format runs on an Intel Arc card, and whether to choose NVIDIA, AMD or Intel — with the counts worked out from the index, including why a 16GB Arc card fits four fewer models than a 16GB NVIDIA card.
  55. 2026-10-04New guide for the RTX 5090, the one consumer card that had no guide. The honest finding is that 32GB fits only two more of this index's models than a 24GB card at short context; what it buys is long context on 27B–32B models and a higher speed ceiling. The guide shows the sizes at 8K to 128K, what a Blackwell card needs from the software stack, and how to check the model is really on the GPU.
  56. 2026-10-04New guide for 12GB graphics cards — the RTX 3060 12G, the RTX 4070 family, the RTX 5070 and the 12GB RTX 3080s, which until now had no guide of their own. It shows which models fit at 8K, 16K and 32K context, where 14B models stop fitting (comfortable at 4K, tight at 8K, too large at 16K), how to run them with Ollama or llama.cpp, and how to make sure they are really running on the card.
  57. 2026-10-04New guide: running models on Intel Arc cards. It covers both routes — llama.cpp built with Intel's SYCL backend, and Ollama, which reaches Arc through Vulkan with no build step — how to confirm the card is actually doing the work, and what fits on the B580, B570, A770 and A750. The speed figures in it are upper limits worked out from memory bandwidth, not measurements: nobody has run these on Arc for this site yet. Every graphics card page now also links the setup guides written for that card's runtime or memory size — until now none of them linked a guide at all.
  58. 2026-10-03Intel Arc cards are now in the hardware list: the Arc B580 12G, B570 10G, A770 16G and A750 8G, with capacity and bandwidth from Intel's own specification pages. Each has its own page, and the calculator, the format wizard and the command builder all know them. The site recommends GGUF on Arc, run through llama.cpp's SYCL backend or Ollama's Vulkan backend. The command builder's native Linux build for llama.cpp also follows your card now: it used to print the NVIDIA (CUDA) build for everyone, which fails on an AMD card and is the wrong build on a CPU-only machine.
  59. 2026-10-03Four older models are now marked as legacy, each pointing to a newer model from the same maker that fits the same hardware. Gemma 2 2B points to Gemma 4 E2B, Gemma 2 9B to Gemma 4 E4B, Gemma 2 27B to Gemma 3 27B, and Mistral 7B v0.3 to Ministral 3 8B. The newer models read 128K–256K tokens of context where the old ones stopped at 8K–32K, and each needs about the same memory or less at Q4_K_M, except Gemma 4 E2B, which needs about 0.8 GB more. The old pages stay up; the Hub hides them unless you choose to show legacy models.
  60. 2026-10-03Two models added, both picked for modest hardware. SmolLM3 3B is Hugging Face's fully open 3B model, with its training data published. At Q4_K_M it is about 2.3 GB at 4K context, fits an 8 GB card even at its full 64K window, and is realistic on a CPU. ERNIE 4.5 21B-A3B is Baidu's mixture-of-experts model, about 21.8B parameters in total with roughly 3B active per token. At Q4_K_M it is about 14.1 GB, right at the edge of comfortable on a 16 GB card, and comfortable on 24 GB. Both now appear in the homepage picks. Sizes for both are estimates: no file size could be checked, and no quality figures have been published. The RSS feed also lists the newest models again: it had been showing the same 20 older ones since August. Each update in the feed now has a short headline instead of the whole paragraph, and links to the changelog page.
  61. 2026-10-03The format pages no longer say AWQ has the best 4-bit accuracy. On every model in this index that ships both, AWQ INT4 is the smaller file but loses more quality than GGUF Q4_K_M. The pages now say that, and stop claiming AWQ is NVIDIA-only. The six-axis format radar chart has been removed: its scores were typed in by hand, not measured, and one axis contradicted the index's own data. GPTQ and HQQ descriptions now only claim what can be checked.
  62. 2026-10-03The Nginx reverse-proxy guide used an HTTP/2 setting that only newer Nginx versions understand, so its config failed to load on the Nginx that Ubuntu 22.04 and 24.04 install. It now uses the form that works on every version. The guide also says where each part of the config goes, and corrects a claim that llama.cpp and vLLM have no API keys: both accept one, though neither requires it, and Ollama has no key option at all.
  63. 2026-10-03The Qwen2.5-Coder 32B on RTX 4090 guide now gives a verdict for each context length, not only 4K. The GGUF build stops fitting at 16K, and the AWQ build is comfortable to 8K but does not fit at 32K. For long-context coding on a 24GB card it points to Qwen3-Coder 30B-A3B, whose AWQ build stays comfortable at 32K. It no longer calls either model "the best", because this site does not benchmark coding quality.
  64. 2026-10-03The VPS guide for llama.cpp told readers to use their physical core count, then passed every vCPU to the server — on many plans those are hyperthreads that slow it down. The command now leaves the thread count to llama.cpp, which picks physical cores itself. The guide also gives the real memory figures (about 6.2 GB at 8K context, 9.5 GB at 32K; the model's full window does not fit 16 GB), adds a speed check, and drops a provider price and plan name this site could not confirm.
  65. 2026-10-03The guides on quantizing your own GGUF and on CPU inference were checked against llama.cpp's current tools. llama-cli is now a chat program, so the one-off test commands would have sat waiting for more input. The quantize guide now adds the flag that answers once and exits. The CPU guide now measures speed with llama-bench, which reports prompt processing and generation separately. The quantize guide also converts at BF16, as llama.cpp's own example does, and saves the importance matrix in the current file format. The CPU guide notes that llama.cpp already picks your physical core count on its own.
  66. 2026-10-03The two vLLM guides and the command builder were checked against vLLM's current code and docs. The install now creates a virtual environment first, because the install command stops without one. The guides also described a warning that current vLLM no longer prints. When the memory for active requests runs out, vLLM now reports it as a "Preemptions" count in its regular status line and in its metrics, and the guides say where to look. They also note that AutoAWQ, the tool behind most AWQ builds, is deprecated, although existing AWQ models still load.
  67. 2026-10-03The Docker + Ollama guide now covers AMD cards as well as NVIDIA. It adds the step that tells Docker about the NVIDIA runtime, which was missing and leaves containers unable to see the GPU. It also corrects a speed claim: the 218 tok/s it quoted as an Ollama measurement was a different runtime and format. The guide now gives the ceiling and the measured llama.cpp figure instead, and says plainly that a container-versus-native run has not been measured here.
  68. 2026-10-03The Windows Ollama guide said AMD cards run on the CPU only. That was wrong: Ollama's Windows app uses Radeon GPUs, through ROCm on the RX 7600 to 7900 series and through Vulkan, which is on by default, on others such as the RX 6000 series. The guide now covers AMD alongside NVIDIA, says Windows 10 22H2 is enough, and replaces the curl examples, which fail in Windows PowerShell, with commands that work there.
  69. 2026-10-03The site has one contact address now: zjy@quantized.uk, which reaches the maintainer directly. Use it for feedback, corrections and anything else — it is in the footer of every page and on the About page.
  70. 2026-10-03The AMD ROCm guide now ends with three common questions: whether to use ROCm or Vulkan on a Radeon, which Radeon cards can run AWQ and GPTQ models (and that none can run EXL2), and how much more fits on a 24GB RX 7900 XTX than on a 16GB card. One build note was also corrected: the old LLAMA_HIPBLAS flag is not silently ignored — CMake lists it as unused — but the result is still a build that runs only on the CPU.
  71. 2026-10-03The GPT-OSS guide was checked against llama.cpp's own gpt-oss guide. It now shows how to run the 20B on an 8GB or 12GB card by keeping some of its experts in system RAM, gives llama.cpp's documented way to set reasoning effort, adds OpenAI's recommended sampling settings (temperature 1.0, top_p 1.0, no repetition penalty), and drops a speed claim for the 120B that no one here had measured. Three common questions are answered at the end.
  72. 2026-10-03GPT-OSS sizes corrected. We were sizing GPT-OSS 20B and 120B as if every weight were stored at MXFP4's 4.25 bits, but only the expert layers are — the real files, per llama.cpp's own guide, are 11.3 GiB and 59 GiB. GPT-OSS 20B now needs about 12.8GB at 4K context rather than 11.7GB, so it no longer counts as fitting a 12GB card or a 16GB Mac, and it is tight on an 18GB M3 Pro. The GPT-OSS guide also quotes llama.cpp's own, higher totals beside ours. Four guides that printed the old figures were corrected, and the site now checks every size printed in a guide against the calculator whenever it is rebuilt.
  73. 2026-10-03The 8GB GPU starter guide was re-run against the calculator. Three figures had drifted after earlier model-data corrections, and one verdict changed: Llama 3.1 8B at 16K context is 7.3GB, which is 91% of an 8GB card — tight, not a comfortable fit. The guide now lists two models that take images and still fit (Gemma 4 E4B and Qwen3-VL 8B), notes that the AWQ route needs Linux or WSL2 because vLLM does not run on Windows directly, reflects llama.cpp choosing the GPU layer count itself by default, and answers three common questions.
  74. 2026-10-03The Mac M3 Pro guide corrected one wrong claim: it said a model too big for the Mac's GPU memory would fail to load or swap. Ollama actually splits it, running the layers that do not fit on the CPU, and its status shows that as a CPU/GPU percentage, which is the real sign you are over the limit. The guide now also gives the speed ceiling the M3 Pro's memory bandwidth sets (about 8 tokens per second for a 32B at 4-bit, clearly labelled as an upper bound rather than a measurement) and answers three questions.
  75. 2026-10-02EXL2 advice brought up to date. ExLlamaV2, the runtime behind the EXL2 format, is now archived, and TabbyAPI and text-generation-webui load the newer EXL3 format instead — so EXL2 still runs locally, but nothing maintained serves it as an API. The command generator's ExLlamaV2 option had been printing a server command and a Docker image that do not exist; it now gives the library's real local chat command, with the right chat template for the model. The TabbyAPI guide is rewritten for TabbyAPI as it is today, the format wizard no longer recommends EXL2 for an API, and the ExLlamaV2 guide uses the correct template for Llama 3. Every download command on the site now uses the hf command; the older huggingface-cli has been removed from current versions of the Hugging Face tools.
  76. 2026-10-02The two-GPU 70B guide now reflects how current llama.cpp behaves: its automatic memory fitting is on by default and keeps 1 GB free on each card, which can quietly push some of a 70B onto the CPU, so the guide passes the GPU-layer and context settings explicitly. It also covers mixing two different cards and the new experimental split mode, and answers three questions. Separately, we had been telling readers that llama.cpp's old build-flag names are silently ignored; they are not — one still works with a warning and the other stops the build — so that advice is corrected on every page. Docker and Compose commands from the command generator now publish their port on this machine only (127.0.0.1) instead of on every network interface, and the vLLM and Ollama commands no longer listen on the whole network by default.
  77. 2026-10-02The WSL2 + Ollama guide was re-checked against Microsoft's, NVIDIA's and Ollama's current documentation. Two claims were wrong: in WSL's default networking mode your LAN cannot reach the server at all (the real exposure risk is mirrored mode), and the sample status output was missing a column. It now also covers the two failures readers most often hit — the "cuda" package quietly installing a Linux driver that breaks GPU passthrough, and systemd being off so Ollama never starts — and ends with three answered questions.
  78. 2026-10-02Two new models: Gemma 4 E2B and E4B, Google's on-device sizes with image and audio input and a 128K window. Most of their layers reuse an earlier layer's cache, so long context is cheap: at Q4, E2B needs about 3.0 GB at 4K and 3.8 GB at the full window, E4B about 4.9 GB and 7.0 GB — both run comfortably on an 8 GB card or an 8 GB Mac. The format wizard's AMD advice now names the cards vLLM supports.
  79. 2026-10-02AMD recommendations now match what each Radeon card can actually run. AWQ and GPTQ builds on AMD are served by vLLM, and vLLM supports the RX 7700 XT and up, the RX 9000 series and Instinct MI200 or newer — so the RX 6000 series, the RX 7600 XT and the MI100 no longer get AWQ picks they could not load, and their "fits comfortably" counts drop by up to four models. GPTQ, which we had wrongly called NVIDIA-only, is now offered on the supported AMD cards. The "can this card run …" answers on GPU pages also stopped saying a format would not run when the model ships a GGUF build that does — they now size that build instead.
  80. 2026-10-02The command generator's vLLM output now covers AMD cards and matches vLLM's current documentation. AMD owners get vLLM's official ROCm Docker image with the flags its documentation lists, and the ROCm install command; Radeon cards outside vLLM's supported list (such as the RX 6000 series and RX 7600 XT) get a note pointing to llama.cpp or Ollama instead. The non-Docker command now installs with uv and starts the server with "vllm serve", as vLLM documents it — it had still shown an older install and entrypoint that contradicted this site's own vLLM guide.
  81. 2026-10-02The command generator's Docker and Docker Compose output now follows the GPU you picked. Before, everyone got NVIDIA commands: an AMD card was handed a CUDA image it cannot use, and the Ollama Compose file had its GPU section commented out, so even NVIDIA owners ran on the CPU without being told. Now NVIDIA gets the CUDA image with the GPU passed through, AMD gets the ROCm image with the devices ROCm needs, and on a Mac the generator says plainly that Docker cannot reach the Apple GPU and points you to running natively. The notes under each command are now in Chinese on the Chinese site.
  82. 2026-10-02Re-checked the AMD ROCm guide against llama.cpp's current build documentation. The build command now matches the documented form, the guide says ROCm 6.1 or newer is required (older versions are refused at build time), and the note on Windows now says what is actually true: a Windows HIP build is documented, but the workaround for unlisted cards does not work there. The log line that confirms a model is on the GPU now reads "load_tensors: offloaded …" — the older name the AMD and dual-GPU guides told you to look for no longer appears. Also fixed in the command generator: its Docker commands used the CPU-only llama.cpp image while asking for the GPU, so they ran entirely on the CPU without an error. They now use the CUDA image.
  83. 2026-10-02Six popular Macs added, each with its own page and a place in the calculator: the M4 with 16 GB and 24 GB (the base Mac mini and its common upgrade), the M2 with 16 GB, the M1 with 8 GB and 16 GB, and the M1 Max with 64 GB. As on every Mac here, only about three quarters of the memory is counted as usable by a model. Apple does not list the original M1's memory bandwidth directly, so its page gives a figure derived from Apple's own comparisons and says so. The guide for 8 GB M1 Macs now uses the M1's own entry instead of borrowing the M3's.
  84. 2026-10-02Five popular budget cards now have their own pages and appear in the calculator: GeForce RTX 3060 12G, GeForce RTX 5050, Radeon RX 7600 XT, and Radeon RX 9060 XT in both its 16 GB and 8 GB versions. Capacities and memory speeds come from NVIDIA's and AMD's own specification pages. NVIDIA's page for the RTX 5050 does not give its memory speed, so that page shows the card's capacity but no bandwidth figure rather than a guessed one.
  85. 2026-10-01Added Google's Gemma 4 26B-A4B and Gemma 4 31B, the two Gemma 4 sizes that run on a single 16–32 GB card or a Mac. Both have a 256K window, but only one layer in six keeps a cache that grows with context, and those layers use fewer, wider heads — so the calculator now sizes the two kinds of layer separately. The result: the 26B-A4B needs about 17 GB at 32K context at Q4 and fits a 24 GB card comfortably; the 31B is about 21 GB at short context, so a 24 GB card holds it only at short context and a 32 GB card is the comfortable choice. The smaller E2B and E4B models share their cache between layers in a way the calculator cannot yet describe, so they are not listed yet.
  86. 2026-09-30Speeds now say where they came from wherever they appear. This site has run benchmarks on 10 models; the speeds listed for the rest were never run here, but the model cards, homepage picks, calculator list and GPU pages showed them exactly like measured ones. Each unmeasured speed now carries an "Estimated" tag. In the compare tool, a model with no speed figure used to count as zero, so the other model won that row by default, and every speed was labelled "published"; the row now says "measured here" or "unverified", and names a faster model only when both figures were measured. Model cards also showed context length in thousands (131K, 1049K) while the rest of the site uses 128K and 1M; they now match.
  87. 2026-09-30The site said it covered 63 GPUs; four of those entries are CPU-only RAM sizes (16, 32, 64 and 128 GB) kept so the calculator can answer "no GPU". Every place that says "GPUs" now counts the 59 cards and Macs, and the CPU sizes are named separately. The Command R 35B page now says its sizes assume 8 KV heads and that the original March 2024 release keeps about eight times as much cache (about 40 GB at 32K), since which release the entry describes is not recorded.
  88. 2026-09-30Llama 4 Scout and Maverick attend within 8,192-token chunks on three of every four layers, and llama.cpp stores only a chunk's worth of cache for those layers. The calculator had been sizing all 48 layers at full context. At 128K context Scout now needs about 77 GB at Q4 instead of about 95 GB; at its full 10-million-token window the cache estimate falls from about 1.9 TB to about 480 GB. Every other model in the index was checked against llama.cpp's own list of sliding-window architectures; none is affected.
  89. 2026-09-30Checked every model's layer and attention-head figures against published configs and fixed the ones that were wrong. Eight models — Gemma 2 (2B, 9B, 27B), Gemma 3 (4B, 12B, 27B) and GPT-OSS (20B, 120B) — keep a full cache on only some layers; the rest use a short sliding window, which llama.cpp stores at just the window's size. The calculator had been sizing every layer at full context, so long-context figures were far too high: Gemma 3 27B at 32K drops from about 34 GB to about 21 GB and now fits a 24 GB card, and at its full 128K from about 86 GB to about 29 GB. Qwen2.5 3B had the wrong layer and head counts (cache overstated about 1.6×), Phi-4-mini's cache was understated by a quarter, Gemma 3 12B had the wrong head size, and WizardLM-2 7B had been given another model's size and shape — it is a Mistral 7B fine-tune. The GPT-OSS, RTX 4060 Ti and Mac M3 Pro guides were updated to match.
  90. 2026-09-30Removed 47 "tok/s on RTX 4090" figures that could not be RTX 4090 numbers. 43 were on builds too large for the card's 24 GB (a 70B model at Q4 is 43 GB, yet was listed at 38 tok/s); 4 were on dense models and faster than the card's memory bandwidth allows. Those models now show no speed rather than an impossible one, and the build rejects either fault from now on. Model pages had also said "the fastest level measured here" for every model; only 10 models have been benchmarked on this site, and the other pages now say their speed is an estimate. Jamba 1.5 Mini had been sized as a 12B model; it is 52B total with 12B active, so at Q4 it needs about 31 GB, not 8.5 GB, and it no longer appears as fitting on 10–16 GB cards. Mistral Large 3 uses the same compressed attention as DeepSeek; its exact dimensions could not be verified, so its page now says its long-context cache figure is an upper bound.
  91. 2026-09-30Corrected the memory estimates for DeepSeek-V3, DeepSeek-R1, DeepSeek-V2-Lite and DeepSeek-Coder-V2-Lite. All four use MLA attention, which current llama.cpp stores as one compressed vector per token per layer, but this index had been sizing them as conventional attention — too high for current GGUF files, and far too low for old ones. The estimates now follow current files: DeepSeek-V2-Lite at its full 160K context drops from about 47 GB to about 15 GB, and both Lite models now fit comfortably on 10 GB and 16 GB-class hardware. Each page also says what an older conversion costs instead and how to tell the two apart, since the difference is large — about 150 GB of cache at 32K for DeepSeek-V3.
  92. 2026-09-30Two models added, both around 3B active parameters so they run on one card or a Mac: GLM-4.7-Flash (Zhipu, 30B total, 128K context — comfortable on a 24 GB card at Q4) and Kimi Linear 48B-A3B (Moonshot, 1M context — comfortable on a 48 GB Mac at Q4, tight on a 32 GB card). Both use compressed attention caches, and the memory estimates count them the way llama.cpp stores them rather than as conventional keys and values. No GGUF file sizes could be checked for this batch, so their sizes use the calculator's generic rates and are marked estimated. Several larger releases from the same weeks (780B and 744B models) were left out as beyond single-machine hardware.
  93. 2026-09-30Re-checked the current releases of the runtimes named on the benchmarks page against each project's own release list: llama.cpp b11277, vLLM v0.30.0, Ollama v0.35.0 (the newest release marked stable — pre-releases were skipped). ExLlamaV2 is still at 0.3.2 from July 2025; ExLlamaV3, where its maintainer now works, is at v1.5.3. The benchmark figures themselves were not re-measured and still describe the older stack they were run on.
  94. 2026-09-29Each tool page's breadcrumb now reads Home › Tools › the tool, so the page listing all four tools is one click away from any of them — before, nothing inside the tools linked back to it.
  95. 2026-09-29Thirty-one Chinese page titles were long enough to be cut off in search results — every model page with a long English name, the "best for your VRAM" pages and a few section pages. They were shortened, and titles that would still overflow now drop the site name before losing any of their own words. The build now fails if any title runs long or two pages share one.
  96. 2026-09-29The site now checks itself on every build. Many of the errors fixed this month were two hand-typed files drifting apart — a pick naming a quant its model does not ship, a guide linking a model id that no longer exists, a superseded model pointing at a successor that is itself superseded — or a page quietly growing past a limit. Each of those now stops the build with a message saying exactly what is wrong, instead of shipping a page that looks fine and is not. Nothing a reader sees changed today; this is what keeps the recent corrections corrected.
  97. 2026-09-26The VRAM calculator page now carries a quick-reference table by model size — memory at 4K and 32K context and the smallest card that holds each whole size class — so its answers are readable without JavaScript, which the interactive calculator needs. Every figure is the calculator's own arithmetic. The 32K column counts only models whose context window actually reaches 32K; one it does include, Phi-3.5 Mini, needs about 15.6 GB there because it keeps a full-size cache for every attention head, a real property of the model rather than an error.
  98. 2026-09-26Search-result descriptions now fit what a results page shows. 92 English and a dozen Chinese pages had descriptions long enough to be cut off mid-sentence — every GPU page among them — and a few model pages had the opposite problem, a single short line. Long ones now keep whole sentences up to the limit or were rewritten shorter; short model descriptions gain one computed line with the model's size. Two errors turned up on the way: a GPU page description named a model already marked as superseded as the largest one that fits, and the AWQ format was described as NVIDIA-only although this site's own guidance, and its fit calculations, allow it on AMD through vLLM.
  99. 2026-09-26Every guide now shows when it was published and, if it has changed since, when it was last updated — the dates were already in each page's search metadata but nowhere a reader could see them. The sitemap also now reports a guide's real last change: it had been ignoring content updates, so the seventeen guides rewritten this month told search engines they had not changed since their 2025 publication.
  100. 2026-09-26The Format Heat Index on /formats/ no longer prints percentages, and the format comparison pages no longer have an "adoption estimate" row. Those numbers (GGUF 89%, AWQ 45% and so on) were an editorial judgement with no source anyone could re-check, and on the comparison pages they sat directly beside real counts of how many models in this index ship each format, as if the two were the same kind of fact. The ranking stays, labelled as an opinion; the measured part is the per-format model count.
  101. 2026-09-26The homepage Editor's Picks now compute the size and the card beside each pick, the same way the model pages do, instead of carrying them as typed text. The typed versions had drifted: Magistral Small 1.2 was listed for a 16 GB card it only just squeezes onto, Seed-OSS 36B for two RTX 3090s when one 32 GB card holds it, and several named cards were not in this site's GPU list at all. Each pick now shows its size at 4K context and the smallest card that runs it comfortably.
  102. 2026-09-26Model counts per card now say what they count. The site gives two honest numbers for a card — how many models fit comfortably (at most 88% of memory) and how many load at all — and a GPU page shows both, but the homepage card list said only "52 models fit" and the GPU index "52/81", which read as the looser number. Both now say "fit comfortably". The numbers themselves were already consistent everywhere; only the labels were missing.
  103. 2026-09-26Speed figures now say which card they come from. Every model's speed in this index was reported on an RTX 4090, but the model table on each GPU page headed that column simply "tok/s" — so the RTX 4060 page, or a Mac page, showed RTX 4090 speeds as if they were that card's own. The column is now labelled "tok/s on RTX 4090", every GPU page except the 4090's says the column is a reference rather than a speed on that card, and the calculator's per-card list labels its speeds the same way. Speeds actually measured on a card still appear under "Measured on this card".
  104. 2026-09-26Model pages now size a model the way it was released. GPT-OSS 20B and 120B ship natively in MXFP4, but their pages described that build and then sized everything at Q4_K_M, a community requantization that loses quality — so the description, the table and the "where it fits" block quoted different numbers. The "smallest card" line on every model page was also misleading: when several cards share the smallest size that fits, it named whichever the database listed first (an RTX 5080 for a model any 16 GB card runs); it now names the size, how many cards share it, and the entry card among them. It also no longer calls a system-RAM row a card, which on four 70B-class models put "64 GB RAM (CPU)" where a GPU belonged. "Just misses" now lists the closest misses rather than an 8 GB Mac 5.4 GB short, and the note that a mixture-of-experts model must keep every expert in memory now appears on all 13 MoE models, not 4.
  105. 2026-09-23Chinese pages: the footer's "Navigate" and "Ecosystem" headings were still in English on every page, and the "read next" guide links at the end of each Chinese guide showed the English title of the guide they pointed to, although every guide has a Chinese title. Both fixed, along with two calculator labels ("Batch Size", and the "Full" precision chip, now 全精度).
  106. 2026-09-23The homepage block that used to say "This week's updates" is now "Latest additions": the six newest models in the index, newest first, each with the date it was added. It had been showing only the models inside a 45-day window, in file order rather than by date, so it was down to two and would have gone empty within weeks while still claiming to be this week's news. The NEW badge on model cards now counts those 45 days back from the latest data update rather than from the moment you open the page, so the badge, the homepage and the Hub's "recently added" filter always agree, and a page no longer renders one set of badges in its HTML and a different one once the browser takes over.
  107. 2026-09-21Two more older models now point to a newer choice: Mixtral 8x7B Instruct to Qwen3 30B-A3B (longer context, about 19 GB instead of 28.5 GB at Q4, and faster), and Stable LM 2 12B Chat to Falcon 3 10B Instruct (32K context instead of 4K, smaller and faster). Their pages stay up with every figure intact; they are simply no longer recommended first. DeepSeek-V2-Lite Chat was considered and left alone: nothing else its size matches its 160K context and 11 GB footprint.
  108. 2026-09-21Recommendations now check whether your hardware can actually run a format, and Macs are sized by the memory macOS lets the GPU use. Before, a Mac, CPU or AMD page could recommend AWQ, GPTQ or EXL2 builds those systems cannot load (AMD still gets AWQ, which vLLM supports on ROCm). A Mac's unified memory was also counted in full; by default macOS lets the GPU use about 75% of it, so that is the figure used now. This applies to the GPU pages, /best/, the FAQ, the format pages and the VRAM calculator, which now says plainly when a format will not run on your hardware. On a 16 GB Mac M3, 44 of 81 models now fit comfortably, down from 52.
  109. 2026-09-21A round of small corrections: two homepage picks named a card that does not exist ("RTX 4070 Ti 16G" — the 16 GB model is the Ti Super); the About page still said "79+ models"; and the footer's llama.cpp and ExLlamaV2 links pointed at the projects' old GitHub organisations. The contact address is now marked so Cloudflare's email protection leaves it unchanged, a likely cause of occasional page errors — not yet confirmed on the live site.
  110. 2026-09-15The homepage now leads with the question most visitors arrive with — "Will it fit on your card?" — and its main button goes to the GPU pages ("Find models for my GPU") instead of the full model list, with a link to the 8 GB starter guide for first-time readers. The runtime versions on the benchmarks page were refreshed (llama.cpp b10978, Ollama v0.34.1; vLLM v0.29.0 unchanged). ExLlamaV2 has had no release since July 2025; its maintainer now works on ExLlamaV3, which uses a new format, EXL3. The benchmarks page notes this; no model here ships EXL3 yet, so it is not listed as a format.
  111. 2026-09-14Checked the Chinese edition against what Chinese readers actually search for. One common question had no answer — whether CPU-only inference with 32 GB of RAM is realistic — and the FAQ now answers it from the index's own 32 GB RAM entry: what fits is known, speed is not, because it depends on your memory setup. Two popular used cards were added with NVIDIA's published specs: Tesla P40 24G and Tesla P100 16G. The modified "2080 Ti 22G" was not added, since it has no published specification.
  112. 2026-09-14GPU, model, guide, /best/ and format pages now each have their own share image instead of one generic picture for the whole site. Fixed along the way: links shared on Twitter/X from any page, the homepage included, showed the site's general tagline instead of that page's own title and description.
  113. 2026-09-14Looked into a report of the mobile homepage getting stuck while scrolling. It could not be reproduced: in a clean mobile browser, both scrolling and jump links reached the bottom of the page normally, which points to the preview tool used in the report rather than the site. Not yet checked on a real iPhone or Android phone.
  114. 2026-09-14The benchmarks page now says how much it covers: 16 runs on 4 of the 61 cards. A new section lists which cards were measured, what the other 57 rely on instead (the calculator's formula), and what has never been tested here — multi-GPU beyond the dual-3090 guide, batches above 1, prompt-processing speed. The methodology is now shown open rather than collapsed, and anything never recorded, such as tools, machine details and dates, says "not recorded". The page description no longer mentions RTX 4060 Ti results that had been removed earlier.
  115. 2026-09-14The site's structured data now describes what quantized.uk covers (GGUF, AWQ, EXL2, GPTQ and the runtimes that load them), how to contact it and when it started. It deliberately names no founder and links no social accounts: the site is run by an unnamed maintainer and has no public accounts, and it will not invent either.
  116. 2026-09-13The "page not found" screen now helps you find your way: it shows the address that failed, suggests the closest real model, GPU or guide (/quant-hub/qwen3-8/ suggests Qwen3 8B Instruct), offers a search box, and links every section with its current count. It returns a genuine 404 status, and Chinese addresses get the Chinese version.
  117. 2026-09-13Twelve older models (Zephyr 7B Beta, WizardLM-2 7B, OpenChat 3.6 8B, Aya 23 8B, SOLAR 10.7B, both InternLM2 sizes, DBRX Instruct, Jamba 1.5 Mini, StarCoder2 15B, Command R 35B, Yi 1.5 34B) now say which current model to prefer and why — longer context, more quant options, or builds that are still maintained — with a one-click comparison. The model list hides the 13 legacy models by default; a toggle shows them, and their pages stay up. Fixed along the way: the homepage and /best/ had been recommending legacy models — Qwen2-VL-7B held the vision pick on almost every GPU.
  118. 2026-09-13The sitemap now tells search engines when each page actually changed — model pages by the date they were added, guides by their own dates — instead of stamping every page with the latest build date. robots.txt now explicitly welcomes the AI search crawlers (OpenAI, Anthropic, Perplexity, Google, Apple) and points to /llms.txt, while shareable filter links stay open to crawling.
  119. 2026-09-12Page titles tidied up: 63 were long enough to be cut off in search results, mostly model pages and guides carrying redundant suffixes. All now fit, none are duplicated, and none are shortened with "…". The About page's title now says what the page is.
  120. 2026-09-12The site had exactly one return-visit mechanism — a feedback mailto — on a site that ships new data every few weeks. The Footer now has a "Stay current" column, on every page, pointing to /feed.xml and /changelog/ with a line on what each actually is (no email, no tracking); model and GPU pages carry a one-line reminder that their own numbers change with the data, next to the RSS link. The real fix was underneath: four templates — the two dynamic model-page routes and their /zh mirrors — built their own <head> metadata by hand and never included RSS autodiscovery, so roughly 200 of the site's most-visited pages had a working feed nothing could find without knowing the URL by memory. /feed.xml itself already carried real pubDate/guid/link/description on both changelog and model entries — checked, not assumed. No email newsletter: the site's privacy posture (no tracking, no account) is stated on /privacy/ and /about/, and a mailing list would contradict it for an audience RSS already suits
  121. 2026-09-12The last seven thin guides rewritten, closing out the cookbook: all 23 guides now sit between 1,464 and 1,824 words, none reports the fictional "1 min read" any longer, and none carries an unearned verification date. Checking rather than remembering caught real content, not just gaps: OpenBLAS was advertised as a CPU speed-up, and llama.cpp's own build documentation says it helps prompt processing above batch size 32 and does nothing for generation speed at all — the old numbers for what a budget VPS achieves were invented and are gone. A 32B coding model was called a comfortable fit on a 24GB card at a quant level that this site's own calculator puts at 90% of the card — tight, not comfortable — and the two builds now get the honest comparison. And the 8GB Mac guide states plainly that this index has no M1 or M2 base-chip entry and explains exactly what stands in for it and where that substitution overstates the real speed
  122. 2026-09-12The five server-side guides rewritten, and two of them were teaching a command that no longer exists. Both vLLM guides still showed 'python -m vllm.entrypoints.openai.api_server' and an install pinned to a CUDA 12.1 wheel index; the documented form is now 'vllm serve' with a uv install that picks the torch build from your driver. The ExLlamaV2 repository has moved organisation. And TabbyAPI's own README says it is a hobby project not meant for production servers — that now appears at the top of its guide, because the maintainers saying it outranks anything this site could add. One invented figure came out: a claim of ~1400 tok/s at batch 8 that nothing here measured. The guides now cite the runs this index actually holds — 235 tok/s for ExLlamaV2 on a 4090, 218 for vLLM on the same card — and say plainly that batched throughput is not something this site has measured
  123. 2026-09-12Five thin guides rewritten, the first of three batches. Seventeen of the 23 guides were under 365 words of body while their titles promised a full tutorial — one called "llama.cpp on Windows with CUDA" was eighteen words long. The five with the widest beginner intent now follow the structure the six already-rewritten guides established: what you need first, the steps, a way to check the model really ran on the GPU rather than falling back to the CPU silently, what the numbers should look like on that hardware, and what to do when it does not work. Each carries three questions answered in the page and in its structured data. Every memory figure comes from the calculator on the model's own row, and the commands were checked against the projects' current documentation — a documentation check, not a run, so the unearned "verified" date these seventeen had been carrying since July is removed rather than refreshed
  124. 2026-09-11The four sections of this site now link to each other. Measured first: the internal link graph ran almost entirely through the header and footer — fourteen hub addresses appeared on every page while the four format pages had one inbound link each, eight hardware pages had fewer than three, and a model page pointed at similar models and guides but never at a format, a card or a recommendation. Model pages now say where the model fits — the cheapest cards that clear it, the ones it just misses and by how much, the formats it ships in — and guides say what they use: the hardware, the models, the runtime's format and what to read next. Every relationship is computed from data the site already held, so none of it can rot. No content page is now reachable from fewer than three others, and the format pages went from one inbound link to a median of 25
  125. 2026-09-11The site finally answers "what should I run", not just "what fits". A card page gave you a list and the Hub gave you another list, but nobody searching for the best model for a 16GB card wants a list — they want a pick. There are now seven pages, one per memory budget from 8GB to 32GB plus Apple silicon, each naming the model for general use, for coding and for images, with what it costs, what headroom is left, and the published quality loss. Every one is computed from the index by the same function behind the homepage hero, so a tier page and the homepage cannot recommend different models for the same card, and adding a model changes all seven with no edit. Each page also names the nearest model that does **not** fit and by how much, because the boundary is the half a list never gives you
  126. 2026-09-11The model search is a real search box now. Every page advertises a search interface at /quant-hub/?q=…, and that URL did filter correctly — but the control producing it was an input with no name and no form around it, so nothing could submit it without JavaScript and nothing reading the markup could find the interface. It is now a proper search form, so pressing Enter produces the URL the site has been advertising all along. Searching also stopped failing on the obvious words: "coding", "vision", "gguf" and "7b" all returned nothing, because the box only looked at model names — it now covers size, task, hardware and format, and understands that people type "coding" where the data says "code". An empty result offers four suggestions drawn from the index instead of a blank page, and filtered URLs ask not to be indexed while still being crawled, so a shareable filter link cannot turn into thousands of near-duplicate pages
  127. 2026-09-11There is now a FAQ, and every answer in it is computed rather than written. "How much VRAM do I need for a 7B" had a calculator on this site but no answer — 24 questions across sizing, quantization quality, formats, hardware and where the numbers come from now answer from the same index, each ending in a link to where you can check it. Because they are computed, they cannot drift from the calculator the way the guides once did: editing one model row moves the answers that depend on it. Three questions the index genuinely cannot settle — whether quantization hurts coding more than chat, whether an official QAT build beats a community one, and how much Q5 buys over Q4 for models that publish only one of the two — say so instead of guessing
  128. 2026-09-11Every format the index ships now has its own page. "What is AWQ" had nowhere to land on a site named after quantization — there were comparisons of one format against another, but nothing that simply explained one, and the 53 models shipping AWQ had no shared parent. GGUF, AWQ, EXL2 and GPTQ each now get what the format is, which runtimes read it, what one real model costs in it at 4K, the quant levels this index actually carries with their median published loss, and every indexed model that ships it — 159 new links from a format to its models. MXFP4 is explained on the GGUF page rather than made a fifth format, because that is what it is: GPT-OSS's native 4-bit weights are distributed as GGUF files, not as a different container
  129. 2026-09-11Two comparison pages that could not compare anything are gone. "AWQ vs GPTQ" and "EXL2 vs GPTQ" each had an intersection of exactly zero — not one of the 81 models here ships both formats — so neither page could put a single row of the same weights side by side, and both filled ~650 words restating two descriptions next to each other. A pair with no model in common is no longer generated at all; the question itself is answered on the GGUF vs GPTQ page, which now says plainly that nobody ever chooses between GPTQ and AWQ for one model, and what to use instead. The old URLs redirect there permanently rather than 404
  130. 2026-09-11Hardware pages now say something about the hardware. All 61 were the same page with a different name on it, because what fits is decided by memory alone — every 16 GB card returned an identical list. Each page now opens with the card's memory bandwidth, the biggest model it holds, one that leaves room to grow, and a speed ceiling computed from the specification: generating a token means reading every weight once, so an 8B at Q4_K_M tops out near 62 tok/s on a 288 GB/s RTX 4060 Ti and near 159 on a 736 GB/s RTX 4080 Super — the same 16 GB, the same models, very different machines. That ceiling is arithmetic on published numbers, never a benchmark, and the pages say so. Doing the arithmetic also caught three of our own benchmark rows claiming speeds the card they name cannot physically reach; they have been removed rather than adjusted
  131. 2026-09-11The formats page now says something. It was 65 words — the thinnest page on a site named after quantization, and the only way in to the six format comparisons. It now opens with a table counted from the index: how many of the 81 models ship each format, the median published perplexity loss at 4-bit and how many measurements that median is drawn from, and the quant levels this index actually carries. HQQ appears in it as 0 of 81, with a line saying so — it is documented here as reference, and you will not find it in the Hub. Formats where nobody published a perplexity figure show a dash rather than an estimate
  132. 2026-09-11Model pages now explain themselves. Each of the 81 was a table and little else — around 220 words, nothing a person could skim for "will this run on my card" and nothing an AI assistant could quote. Every page now carries three short sections and three questions answered from that model's own numbers: what it costs at 4K, what longer context adds, and which build to download. Nothing is written by hand, so nothing can drift from the data — and a hybrid-attention model gets visibly different text from a conventional one. Deployment guides also declare when they were last changed, and which models and hardware they are actually about
  133. 2026-09-11The hardware database reaches the current generation. Blackwell (RTX 5090 down to 5060), RDNA 4 (RX 9070 XT and 9070) and the M4 and M5 Macs — including the 256GB and 512GB Mac Studio configurations — now have pages, 18 cards in all. Until today the newest NVIDIA consumer card here was the RTX 4090 from 2022, so "what can an RTX 5090 run" had no answer on a site whose whole premise is that question. None of these cards has been benchmarked here, and each page says so rather than implying its estimates were measured
  134. 2026-09-11Findability and honest labels. Every hardware page now has a description that names the card and the largest model it runs — 36 of the 43 previously shared just nine descriptions between them, because the template only knew the memory size. The tools index and the data changelog are real pages instead of 404s, the navigation finally links the 43 hardware pages and the format comparisons, and the homepage stopped printing the same update three times. Model counts are computed from the index rather than typed in six places, and the date beside a NEW badge now says "added" — it is when this index picked the model up, not when the model was released
  135. 2026-09-11The calculator learned that 2026 models do not all cache attention the same way, and the first two are in. Qwen3.8 27B runs only 16 of its 64 layers on full attention — the rest keep a fixed recurrent state — so the old arithmetic overstated its KV cache fourfold, claiming 8GB at 32K context where the measured figure is 2GB. Sizing now follows the model's actual attention shape and reproduces published measurements at 8K, 32K and 262K. Ministral 3 8B joins it, sized from Mistral's own GGUF releases. Where nobody has published a per-level quality loss, the column now shows a dash instead of a number
  136. 2026-09-11Two crawling faults fixed. Every internal link to a model whose name contains a version number — llama-3.1-8b, qwen2.5-7b, phi-3.5-mini — was losing its trailing slash and redirecting: 2,101 links across 46 URLs, and 27 model pages had no direct link to their own canonical address. And the language switcher was a button rather than a link, so the 164 Chinese pages had no crawlable route into them from anywhere on the site. Both are now checked by the build, so neither can come back quietly
  137. 2026-09-08Search and feedback groundwork. Hardware pages now say when a card has real measured runs behind it — four of the 43 do — and name the other cards that share its memory budget, because the model list is decided by VRAM and those pages were otherwise near-copies of each other. Structured data was claiming 73 models on pages that listed 30; it now matches what is on the page, on all 329 of them. And guides and the command generator ask whether the thing actually ran: copying a command is not the same as it working, and the correction email shows you its exact text before your mail app opens
  138. 2026-09-08Two fixes found by running the verification matrix rather than reading the code. Switching models in the VRAM calculator kept the previous model's quant level selected — pick Llama 3.1 8B at EXL2, switch to GPT-OSS 20B, and it confidently sized a file that does not exist; the level now snaps to one the model ships, and any level the index has no build for is labelled as an estimate from the generic table. And the calculator was deleting the card from its own address bar in forward mode, so a shared link lost the hardware the verdict was about
  139. 2026-09-08Guides and legibility. The 8GB starter guide was overstating VRAM by about 2GB against this site’s own calculator and told readers a 14B "needs 36GB+" when it needs 11 — those and the Mac and dual-GPU guides are rewritten from the index, with prerequisites, a way to check the model really ran on the GPU, and what to do when it does not fit. Reading times are now derived from the article instead of typed by hand (22 of 23 were fiction), a guide rewritten since its last real run says "written against" rather than claiming a verification date, and every text colour on the site now clears the WCAG AA contrast floor — 3,175 text nodes checked, none failing. Charts carry a table of the same figures in the static HTML, filter chips announce whether they are selected, and context lengths print the exact token count
  140. 2026-09-08The homepage now starts with your hardware. Pick your card and what you want it for, and it answers with the largest model that fits, one that leaves room for longer context, and the fastest measured — each with the memory maths and a link into the calculator. Popular cards, a sample of the real-hardware benchmark rows, and a place to report a wrong number sit below it; the format heat index and radar moved to the formats page, and the full changelog is still here, collapsed
  141. 2026-09-08The tools now remember what you picked. Choosing a model in the VRAM calculator and moving to the command generator no longer means entering it again — model, quant level and context length carry across, with a shared link always taking precedence over what you have stored. The calculator also links straight to the command for the configuration on screen, and when a model does not fit your card it says what to change and what that would cost
  142. 2026-09-08Numbers now say where they come from. The compare tool had a "Q4_K_M VRAM" row that never moved when you changed the context length, beside copy claiming it did — it now shows an estimated row that tracks the control and a published row that is fixed, each labelled. The 6:1 "8B wins" scoreboard is gone: it counted memory twice, counted how much of each model this site happens to index, and treated fewer parameters as an advantage
  143. 2026-09-08Model cards stopped combining configurations. The stats row showed the smallest VRAM of any quant beside the fastest speed of another, as if both were available at once; it now reports one named configuration (Q4_K_M · RTX 4090 · batch 1). The GPU chips and hardware pages still count differently — 60 versus 51 on a 4060 Ti 16G — but both now share one function and each says which rule it used
  144. 2026-09-08Correctness fixes in the generated commands: the local llama.cpp server now binds 127.0.0.1 instead of publishing an unauthenticated endpoint on every interface, the download step installs the CLI it uses, and the claim that vLLM is CUDA-only was simply wrong — it ships official ROCm builds. The Chinese homepage no longer carries English text in Editor's Picks, and its RSS link points at the Chinese feed the page header already advertised
  145. 2026-09-01New: format comparison pages. GGUF vs AWQ, GGUF vs EXL2 and four more, each comparing hardware support, runtime and adoption — and then listing the models that publish weights in both formats, where the two rows describe the same model and the comparison stops being editorial. Where no model ships both, the page says so rather than implying otherwise
  146. 2026-09-01The calculator answers instead of listing. Its hardware panel showed 43 bars, almost all green — a lot of ink for very little answer. It now leads with the fact you came for ("fits comfortably on 16 of 43 cards — smallest is the Instinct MI100 32G"), gives a verdict for your own card if you have set one, and keeps the full list one click away. The 79-model dropdowns in all three tools are grouped by size instead of listed in data-entry order
  147. 2026-09-01New: a page per GPU. All 43 cards in the database now have one — "RTX 4060 Ti 16G — what LLMs can it run?" answers with 51 of the 79 indexed models, each at the best quant level that still leaves headroom at 4K context, grouped by size. The data always existed; it had only ever been a filter parameter, never a page. 88 new pages across both languages
  148. 2026-09-01The four tool pages now explain themselves. Each carried a single heading and no body text — a bare widget with nothing to calibrate against. They now document how the VRAM estimate is derived, why context length dominates it, where the CLI identifiers come from, and why some commands show a placeholder, plus a FAQ on each, in both languages
  149. 2026-09-01The inference speed chart is readable again: 13 of its 18 bars were all labelled "RTX 4090", so nothing on screen said which model each one measured. Every bar now names its model and hardware, and a key explains what the colours mean (they encode the framework, which was never stated). Tap targets on phones meet the 44px minimum
  150. 2026-09-01The homepage quality figure now names the level it describes: 97.1% retained at Q4_K_M, median across all 79 models, with the 1.4–5.2% spread shown beside it. The old "98.4% avg accuracy" averaged whichever quant level happened to be each model's best, so it moved whenever a level was added to the data. The Chinese benchmarks table is also fully translated — its notes column had been English-only
  151. 2026-09-01The model index is now in the HTML. /quant-hub/ was rendered entirely in the browser, so its static page carried no headings and none of the 79 model names — the site's most valuable page was blank to search engines and to anyone without JavaScript. It now ships all 79 cards and filters on top of them
  152. 2026-09-01VRAM calculator no longer answers a question you did not ask: with no model selected it used to fall through to a generic 7B and print 4.98 GB plus a green verdict on all 43 GPUs. Chinese readers get their own RSS feed at /zh/feed.xml, every page now advertises its feed, and /rss.xml resolves instead of 404ing
  153. 2026-09-01Homepage paints without waiting for JavaScript: the headline was being shipped as opacity:0 and only became visible after the bundle loaded, which put real-user LCP at P75 3.1s on a prerendered site. Entrance animation is now pure CSS and framer-motion is gone — 33 kB less JavaScript on first load
  154. 2026-08-23Format surfaces now agree with the index: the homepage badges, the "formats tracked" stat and the Hub filters all derive from the formats an indexed model actually ships (4). HQQ stays in the format explainer as reference, but no longer advertises a browse path with no results
  155. 2026-08-23Format wizard: quant levels are now per-format — choosing "easiest setup" used to print EXL2 · Q4_K_M and AWQ · Q4_K_M, levels that exist in neither format. The runtime column also follows the format, so an AMD reader no longer sees EXL2 recommended with a ROCm runtime next to the reason explaining EXL2 cannot run on ROCm
  156. 2026-08-23Homepage layout: the stats bar had been painted on top of the job-path cards since those were introduced, covering all three descriptions, and the hero was clipped on phones — the VRAM calculator button and format badges were partly unreachable. Navbar no longer overflows at tablet width
  157. 2026-08-20CLI generator now emits commands that actually run: the real GGUF repo and filename instead of a placeholder, `ollama run hf.co/…` instead of a tag that 404s, and a repo id for vLLM instead of the model's display name. llama.cpp build flags updated to the GGML_* names (the old LLAMA_* ones are ignored, giving a silent CPU-only build)
  158. 2026-08-20VRAM calculator: forward mode now uses each model's own measured bits-per-weight instead of the generic per-level table, matching what reverse mode always did. GPT-OSS 20B at Q8_0 was overstated by 67% (21.1GB → 12.7GB). EXL2 3.5bpw is selectable again
  159. 2026-08-18Chinese edition fixes: every /zh page now declares Chinese in the page itself, the 23 guide links on /zh/cookbook no longer send readers to the English site, and the structured data on 102 Chinese pages describes the Chinese page rather than the English one
  160. 2026-08-18Chinese edition is now indexable: /zh/** mirrors all 113 pages with hreflang pairing, and the Chinese text is baked into the static HTML rather than swapped in after load
  161. 2026-08-08Model index +4 → 79: Qwen3-VL 8B / 30B-A3B, Magistral Small 1.2, Seed-OSS 36B — picked for constrained hardware (multimodal on a 12GB card, small-active MoE for unified memory, 512K context at dual-GPU size). Qwen2-VL 7B marked superseded
  162. 2026-08-08New cookbook: running GPT-OSS 20B/120B locally without re-quantizing (23 guides). VRAM calculator now offers MXFP4 — picking Q4_K_M for GPT-OSS overstated weights by ~14%
  163. 2026-08-07Model index +4 → 75: GPT-OSS 20B/120B (native MXFP4), GLM-4.5-Air 106B-A12B, Devstral Small 1.1 — MoE-heavy batch for 16GB cards and unified-memory Macs
  164. 2026-07-22Polish: re-rendered og.png (71+ models), all 22 cookbook guides have verified stack banners
  165. 2026-07-22Cadence pack: +4 models (Gemma 3 27B, R1-Llama-8B, Phi-4, Qwen3 1.7B), superseded tags, measured/estimated labels, Hub “recent”, weekly updates, RSS, cookbook verified stack (71 models)
  166. 2026-06-26UX for real traffic: job paths, mobile GPU profile, OG/favicon, honest format heat, feedback email
  167. 2026-06-26Model index +4: Qwen3 4B, Qwen3-Coder 30B-A3B, Mistral Large 3, GLM-4-9B (67 total)
  168. 2026-06-26QA fixes: HF stats merge on failure, ≤3B filter, CLI/VRAM tool bugs, i18n polish
  169. 2026-06-26Model index +5: Qwen3 32B, 30B-A3B MoE, 235B-A22B, DeepSeek-V3, DeepSeek-R1 (63 total)
  170. 2026-06-26Model index +7: Qwen3 8B/14B, Gemma 3 4B/12B, Llama 4 Scout/Maverick, Llama 3.1 405B (58 total)
  171. 2026-06-25Cookbook TOC scroll highlight, code block copy, Quant Hub Markdown export
  172. 2026-06-25Cookbook reading progress bar, model HF link copy, Quant Hub shareable filter URLs
  173. 2026-06-25Breadcrumb nav + JSON-LD, cookbook article TOC, Quant Hub GPU quick-filter chips
  174. 2026-06-25Related cookbook guides, similar-model cards on detail pages, hero latest-update badge
  175. 2026-06-25Homepage explore strip, 404 page, multi-model benchmarks (Qwen 7B/32B, DeepSeek-R1 14B), llms.txt for AI crawlers
  176. 2026-06-24Added About page (/about) — maintainer story, update cadence, contribution guide
  177. 2026-06-24Quant Hub: default to all 51 models visible; scale stats bar; clearer GPU filter UX
  178. 2026-06-24SEO: canonical URLs, JSON-LD, per-page metadata, Google/Bing verification env vars
  179. 2026-06-24Quant Hub: show-all toggle when GPU profile active; Cookbook +7 guides (8GB GPU, WSL2, Docker GPU, Nginx, AMD ROCm)
  180. 2026-06-24Privacy Policy + Plausible analytics, cookbook standalone pages (/cookbook/[slug]), model index expanded to 51
  181. 2026-06-24Added Terms & Disclaimer page (/legal) with trademark notice and liability disclaimer
  182. 2026-06-24Phase 3: HF live stats pipeline, model A vs B compare tool, cookbook expanded to 15 guides
  183. 2026-06-24Expanded model index to 30+ entries; added format wizard, hardware profile, ExLlamaV2 CLI, SEO (sitemap/OG), data transparency
  184. 2026-06-24Model detail pages, GPU reverse lookup, shareable VRAM calculator URLs, real homepage stats
  185. 2025-06-10Initial launch: Quant Hub, VRAM calculator, CLI generator, benchmarks, cookbook

All data is manually curated and verified against community sources. Always cross-check with official Hugging Face model cards before deployment.

Hugging Face model cards, community quant releases (bartowski, turboderp, unsloth, city96), WikiText-2 PPL benchmarks

Browse recent models →