CanRun

Updates: new models, features and fixes

CanRun changes often. New models arrive, the calculator gains features, and now and then we find part of the calculation was wrong and fix it. This page lists the changes you would notice, newest first, followed by the date each model joined the catalog. How the calculation works today is explained on How we calculate.

Changes to the site

DGX Spark: two and four linked units

The DGX Spark page and each model's DGX Spark page now also show verdicts for two and four units linked over ConnectX-7, and the calculator lets you pick one to four units and shows the llama.cpp command to start on each one. These verdicts are worked out for llama.cpp RPC, which splits the layers across the units: memory adds up, but each token still passes through every unit, and every hop between units adds time to each token, a cost measured on two units linked over TCP. So linked units are never faster than CanRun's one-unit estimate, and fast, smaller models slow down the most. They are theoretical estimates, and vLLM tensor parallelism, which NVIDIA's own guides use, can be faster. That day at an 8k context, gpt-oss-120b, which does not load on one 64GB unit, came out as Runs great on two of them, and GLM-5.3-Flash at Q4_K_M, too big for one 128GB unit, as Runs well on two.

DGX Spark: a 64GB configuration, partner models and the memory its GPU can use

The DGX Spark is now calculated in two configurations, 64GB and 128GB, and typing a partner maker's name for the same GB10 machine, such as the ASUS Ascent GX10 or the Lenovo ThinkStation PGX, now finds it in the calculator search. Instead of the 70% CanRun counts for Macs and the Strix Halo, its GPU share is now what Linux and the desktop leave free, starting from the lowest figure in owners' public boot logs, and the same limit applies when a model falls back to the CPU. That day at an 8k context, the Q2_K file of Solar Open 2 250B on the 128GB model moved from Runs slowly on the CPU to Runs well on the GPU, while the Q2_K file of DeepSeek V4 Flash 0731 went from Runs slowly on the CPU to not fitting at all. On the 64GB model, Llama 3.3 70B at Q4_K_M was calculated to fit fully on the GPU at an 8k context. Where the 64GB configuration gets the same verdict as the 128GB one, the model pages and each model's DGX Spark page now use 64GB.

A hybrid of sparse and linear attention is now calculated

CanRun now calculates GLM-5.3 Flash, which mixes linear-attention layers with sparse-attention layers. CanRun counts KV cache only for the sparse ones, so a long context adds little memory; that day at an 8k context its Q4_K_M file was calculated to fit fully on the GPU of an M3 Ultra with 512GB, and with 256GB only the Q2_K file fit on the GPU. Its GGUF files call the Q4_K_M quantization Q4_K, a short name the llama.cpp quantizer accepts for the same format, so a file without Q4_K_M in its name is read as the Q4_K_M row after its header confirms the format, and the commands use the tag written in the file name. The llama.cpp commands for this model add -np 1, because llama.cpp sets aside memory for the model's sparse-attention indexer in proportion to the number of request slots, so the four slots llama-server opens by default would need more memory than the estimate counts. The speed formula does not count the extra work this model does in every layer, and public results from recent llama.cpp builds were all slower than the estimate, so every combination for it carries the theoretical label and its rating is based on a speed about 8% below the estimate shown.

Models with compressed attention are now calculated

CanRun now calculates DeepSeek V4 Flash 0731, whose layers keep their KV cache in compressed blocks of several tokens each, and its model page lists the attention type as compressed. The cache is counted the way llama.cpp allocates it for one request slot, so a long context adds little memory on top of the weights; that day its MXFP4 file was calculated to fit fully on the GPU of an M3 Ultra with 256GB at an 8k context. llama.cpp keeps a separate cache for every slot, so the llama.cpp commands for this model add -np 1 in place of the four slots llama-server opens by default. GGUF repositories without a Q4_K_M file now use MXFP4 as the baseline, for this model and when the calculator loads a model from Hugging Face. The speed formula does not count the extra work this model does in every layer, and the one public result from a current llama.cpp build was slower than the estimate, so every combination for it carries the theoretical label.

Models that run their layers more than once are now calculated

CanRun now calculates Nanbeige4.2 3B, whose 22 layers run twice for every token on the same weights. llama.cpp keeps a separate KV cache for each pass, so at long contexts this small model needs as much memory for that cache as a much larger one; that cache is why Q4_K_M with a 32k context on an 8GB RTX 4060 was calculated as partial offload. llama.cpp also counts each pass as its own layer, so when part of the model stays on the CPU, the -ngl value in its command is higher than its layer count. The speed estimate reads the repeated layers twice for every token. Only one public measurement backs it, so every combination for this model carries the theoretical label.

K2-Horizon and its Mixture-of-Values attention are now calculated

Now that llama.cpp supports K2-Horizon, CanRun calculates K2-Horizon 7B and K2-Horizon MoVA 36B-A4B. In its MoE layers, all but the first three, the MoVA model builds the attention values from a few of many value experts, and llama.cpp keeps those value experts on the graphics card even when it moves the MoE experts to system RAM. CanRun places them the same way, so when we checked, Q4_K_M with an 8k context did not fit an 8GB RTX 4060 even with the experts in RAM and was calculated as CPU only, while a 16GB RTX 5060 Ti came out as Runs well with the experts in RAM. When the model runs on the graphics card, the speed estimate counts only the value experts each token picks, but there are no public benchmarks yet and the small cost of picking them is not counted, so every combination for this model carries the theoretical label.

Gemma 4 E2B and E4B are now calculated

Gemma 4's two edge models give each layer its own embedding table, and many of their layers reuse the KV cache of earlier layers, so CanRun had left them out. It now reads the size of that per-layer table from each GGUF file's header, keeps the table in system RAM instead of on the graphics card as llama.cpp does, and counts KV cache only for the layers that store their own. When we checked, Gemma 4 E4B, which ollama run gemma4 downloads, and Gemma 4 E2B both fit fully at Q4_K_M on an 8GB RTX 4060 with an 8k context. Their speed estimates add a small fixed delay per token that public benchmarks showed, and they carry the theoretical label except where a benchmark matches, as on the RTX 5090. The Gemma 4 guide now covers both.

Apple M6 added

The Apple M6 in the new Mac mini is now in the catalog with its 16, 24 and 32 GB configurations. The 16 GB version has less memory bandwidth than the 24 and 32 GB versions, so CanRun now uses each configuration's own bandwidth for its verdicts and speeds. A public llama.cpp benchmark on the 32 GB Mac mini is included.

CanRun in Simplified Chinese

The language menu at the top of every page now has 中文 next to English and Korean. The Chinese version covers the calculator, the model and GPU lists, and every GPU, model, combo and comparison page; its menus, tables and verdicts were translated by machine. Guides and pages such as this one stay in English and Korean because we write them by hand, so the links at the bottom of Chinese pages lead to the English versions.

Four new guides and GPU comparison pages

Four new guides answer questions people search for: how the Gemma 4 sizes differ, Qwen3.6 versus Qwen3.8, which DeepSeek R1 models run on a home PC and what Ollama and LM Studio need. We also added GPU comparison pages for twelve pairs people often weigh against each other, such as the RTX 5060 Ti 16GB and the RTX 5070. Each one puts the two cards side by side for every model in the catalog and explains where their verdicts split. Two DeepSeek models joined the catalog so the guide covers what ollama run deepseek-r1 actually downloads.

A calculator box on GPU, model and combo pages

GPU, model and combo pages now have a small calculator box near the top, under the page heading. It starts with that page's GPU and model already filled in, so one click opens the calculator, where you can change the RAM and context length or try a different GPU or model. On a model page, leave the GPU box empty to see how every GPU handles that model. Try it on the RTX 4060 or Qwen3 14B page.

A short description at the top of each model page

Model pages now open with a few sentences on what the model is: who released it and when, what it was built for, whether it thinks before answering by default, and what its license allows. Every fact comes from the model card or the maker's release post, linked right under the description. Qwen3 8B and EXAONE 4.5 33B are two examples. New models usually get theirs on the day they join the catalog.

Lists of every model and every GPU

Two new pages show everything CanRun covers, and both are linked from the menu at the top of every page. All models puts every model in one table with its size, the memory it needs, release date, thinking mode, license, max context and Hugging Face downloads. You can sort it, or narrow it by the memory it needs, to Korean models, MoE models or models with a thinking mode. All GPUs, Macs and PCs groups every graphics card, Mac chip and CPU setup by type with its memory, bandwidth and price. It counts how many models run great and how many run well on each, and picks the cheapest graphics card for each memory size.

Prompt speed estimates now depend on the model

The prompt-processing estimate on combo pages was one figure per graphics card, fitted to a 7B model, so a 1B model and a 70B model showed the same prompt speed on the same card. It is now divided by the model's size, and mixture-of-experts (MoE) models count as more than their active parameters, because each expert gets only a slice of every batch of prompt tokens. We fitted it to 91 public benchmarks from recent llama.cpp builds and refitted the NVIDIA, AMD and Strix Halo factors with it; Radeon cards now use AMD's FP16 matrix figure, which is twice the usual FP16 figure on the RX 9000 series. On an RTX 4090, Qwen3 32B now shows a little under a quarter of the old figure and Llama 3.2 1B about five times as much, and the DGX Spark now gets a prompt estimate too. Generation speeds and verdicts did not change.

Faster estimates for the Strix Halo

Our efficiency factor for the Ryzen AI Max+ 395 (Strix Halo) was an older value without a clear source, and it ran low for dense models on current llama.cpp builds. We refitted it to public Vulkan results from current builds, and refitted the fixed per-expert cost for MoE models with it. Dense models now come out about a quarter faster, and 8B models such as Qwen3 8B moved from Runs well to Runs great. MoE estimates moved both ways, by up to about a fifth: gpt-oss-20b rose, and Qwen3 30B-A3B fell a little. The factors follow the Vulkan backend; in public comparisons on the same machine, ROCm ran about 3% to 12% slower.

More accurate speeds for MoE models

Our speed estimate for mixture-of-experts (MoE) models used a separate efficiency factor for each class of hardware and a rough count of the bytes each token reads, which left out most of the shared layers. We now count those bytes from each file's header and add a fixed cost that each token pays for every expert it runs in every layer, fitted to public benchmarks from recent llama.cpp builds. Small MoE models on top-end NVIDIA cards are no longer held under a fixed ceiling, and large MoE models on Macs came out faster than before. At Q4_K_M, gpt-oss-20b on a 24GB Apple M4 moved from Runs well to Runs great. A few 8GB-card combinations that keep MoE experts in system RAM moved from Runs slowly to Runs well.

Corrected compute figures for Apple chips

Apple does not publish its chips' GPU compute, and the figures we showed were double the theoretical FP32 compute, on the assumption that the GPU runs FP16 at twice that speed. Apple GPUs run FP16 at the same rate as FP32, so GPU and model pages now show the theoretical figures from Wikipedia's Apple silicon table as they are, about half the old ones. The prompt-processing factors were refitted to the same public benchmark with these figures, so prompt estimates moved by 7% or less, and the Apple M5 Ultra, which had no figure, now gets a prompt-processing estimate too. Generation speeds and verdicts did not change.

Prompt speed estimates for Macs

We had estimated prompt processing on every Apple chip with one factor per unit of GPU compute. M5-series chips have a matrix accelerator in each GPU core, and in llama.cpp's public Apple benchmark they read prompts about three times as fast for their compute as earlier chips, so one factor ran too low for the M5 series and too high for the rest. M5-series chips now get their own factor, which raised their prompt estimates by about 70%; for M4-series and Ultra chips the estimates fell by about 40%. On an Apple M5 Max (40-core GPU) the estimate is now close to that benchmark's result. Generation speeds and verdicts did not change.

Apple M5 Ultra added

The Apple M5 Ultra from the new Mac Studio is now in the calculator and the GPU list, in the 96GB and 256GB configurations on sale now. Apple does not publish its FP16 compute, so its model pages show no prompt-processing estimate. Its GPU page also lists a public Llama 2 7B result from the llama.cpp discussion on Apple silicon.

Twelve new guides

We turned the questions we hear most into twelve new guides: choosing a GPU for your budget, running MoE models bigger than your GPU with system RAM, laptop GPUs and two-GPU setups, comparing 128GB unified-memory machines, and running on the CPU alone. GPUs by budget and MoE models with system RAM are two of them; the full list is on Guides. Every number in them comes from the same data as the GPU and model pages, and each verdict they give for a named model and card is checked against that data every time the site is rebuilt.

Higher speed estimates for Macs

Our speed estimates for dense models on Apple chips had been fitted to public benchmarks from an old llama.cpp build, which generates noticeably slower than current builds. They now follow results measured with current builds on M5-series and Ultra chips, so dense-model estimates rose by about a quarter on base, Pro and Max chips and by nearly a third on Ultra chips. At Q4_K_M, Llama 3.3 70B on a 128GB Apple M4 Max (40-core GPU) moved from Runs slowly to Runs well, and so did Qwen3 8B on a 16GB M4. Estimates for MoE models on Macs did not change.

Written introductions on popular GPU and model pages

Ten popular GPU pages and ten popular model pages, such as GeForce RTX 4060 and gpt-oss-20b, now open with a short introduction we wrote by hand. It points out what the tables alone don't say: which quant makes a model fit, when a mixture-of-experts model can keep its experts in system RAM, and how a laptop or 8GB version of a card differs. Every number in it comes from the same data as the tables, and each verdict it gives for a named model and card is checked against that data every time the site is rebuilt.

Example results on the calculator page

The calculator page now shows example results before you pick any hardware. For six common setups, from an 8 GB graphics card to a 128 GB unified-memory PC, it lists the model the calculator puts first in each size class with its verdict and estimated speed range, plus the largest model that fits entirely on the GPU. Below that, a short guide explains the main lines of a result card. Both are part of the page itself, so you can read them even with JavaScript turned off.

We look for new models every day

Every day we check Hugging Face for open models released in the last two weeks. A model goes into the catalog when it comes from a major publisher or is already widely downloaded, uses a design our calculation supports, and has a Q4_K_M GGUF file. Whether it has a thinking mode is estimated from its chat template and model card, and every addition has to pass our data checks, tests and a full build before it goes live. MiniCPM-V 4.7 35B-A3B was the first model added this way. We add models with a design we can't calculate yet once llama.cpp and our calculation support them.

Three new ways to sort calculator results

After you pick a GPU, the calculator used to list models by verdict and then speed, so the smallest models always came first. The new default, Recommended, starts with the models that run great or well, puts larger size groups first and, within a group, the more popular model first. Most popular uses a five-level score we give each model. Most downloaded uses the original model's Hugging Face downloads over the last 30 days, which don't include GGUF downloads. The old order is still available as "Verdict, then speed".

Cookie-free visitor statistics

We started using Cloudflare Web Analytics to see which pages people read and where visitors come from. It sets no cookies, and we only see totals. The privacy policy lists exactly what your browser sends.

Pick a model, see which GPUs run it

The calculator now works in both directions. Choose "Find GPUs for a model", pick a model, and you get every GPU, Mac and CPU setup in the catalog with its verdict, speed range and price. You can filter by type, budget and minimum verdict, and your own setup stays pinned at the top. Every model page links straight to this view.

Mix different graphics cards

"Add a different GPU" combines desktop cards from the same maker, up to four in total, such as an RTX 3090 with an RTX 3060 12GB. Memory adds up across the cards, but each token passes through them one after another, so the slower card holds the whole run back. If the model would fit on the faster card alone, the result tells you. Results for mixed cards are always labeled theoretical (±30%).

Calculate a model from its numbers

For a model you can't load from Hugging Face, you can type the numbers from its model card or config.json: total parameters, layers, KV heads and head dimension, plus active parameters and expert counts for MoE models. The file size is estimated from the parameter count, so these results are labeled theoretical. The calculation stays in your browser, and nothing is requested from Hugging Face.

System RAM on model-and-GPU pages

When a model doesn't fit entirely on the graphics card, the verdict depends on how much system RAM you have. Those pages now list the verdict for 16GB to 128GB of RAM. Pick an amount and the verdict sentence and the llama.cpp and Ollama commands change to match. Pages where RAM makes no difference say so instead. If you come from the calculator, the page keeps the RAM you chose there.

Graphics card memory counts only what goes on the card

llama.cpp keeps a model's input embedding table in system RAM. It also leaves out the multi-token prediction (MTP) block some newer models carry unless you turn MTP on. We used to count both against graphics card memory; now we read their sizes from each GGUF file's header and leave them out. Some models now fit on the card with longer contexts, and a few verdicts went up: HyperCLOVA X SEED Think 14B on the GeForce RTX 2080 Ti, for example, moved from Runs well to Runs great. On a Mac, the whole file still counts.

Models with Mamba and other hybrid layers

Some newer models mix ordinary attention layers with Mamba2, short convolution or KDA layers. Those layers keep a small state of fixed size instead of a KV cache that grows with the context. The calculation now handles them, for models in our list and for models loaded from a Hugging Face link. Nemotron 3.5 Lightning 30B-A3B, LFM2.5 2.6B and the two Ling-3.0 models joined the catalog the same day.

Stricter speed thresholds for every model with a thinking mode

A model that thinks before it answers makes you wait for many more tokens, so its speed thresholds are 1.5 times higher. This used to apply only to models we had tagged as reasoning models. Now it follows each model's official card and chat template: every model with a thinking mode gets the higher thresholds, including models where you can switch thinking off, while models without one, such as Phi-4, keep the normal thresholds. Some verdicts dropped a level as a result: Qwen3 14B on the GeForce RTX 3060 12GB, for example, went from Runs great to Runs well.

Won prices on the Korean pages

On the Korean GPU, model and model-and-GPU pages and in the Korean calculator, US dollar prices now come with an amount in Korean won. It is a plain conversion at the European Central Bank reference rate, updated weekly, so it can differ from what a card actually costs in Korea. Guides and the English pages show dollars only.

Two to four of the same GPU

A "Number of GPUs" setting in the calculator covers two to four identical cards, and memory adds up across them. With llama.cpp's default layer split the cards take turns on each token, so our calculation doesn't make generation faster. When the setting arrived, our calculation at 8k context fit Llama 3.3 70B at Q4_K_M entirely on two GeForce RTX 3090 cards, while at 16k part of it spilled into system RAM. Multi-card results aren't matched to public benchmarks, so they are labeled theoretical (±30%). GPU, model and model-and-GPU pages still assume one card.

Models that aren't in our list

Paste a Hugging Face model link or id, such as Qwen/Qwen3-4B, under "A model that isn't listed", and the calculator runs the same calculation for it. Your browser reads the model's configuration and file list from Hugging Face directly. For some models, MoE models among them, it also reads the start of a GGUF file to measure its parts. If the model is already in our list, you are pointed to its card instead. Loaded models are labeled theoretical (±30%).

MoE models: experts on the GPU when there is room

When a mixture-of-experts (MoE) model is too big for the graphics card, llama.cpp can keep its expert weights in system RAM. We now put as many experts on the GPU as fit and only the rest in RAM, the same direction current llama.cpp and Ollama take on their own. The --n-cpu-moe value in our commands follows the same split, using expert sizes read from each GGUF file's header. gpt-oss-20b on 8GB to 12GB cards such as the GeForce RTX 4060, for example, moved from Runs slowly to Runs well. These results are still labeled theoretical (±30%).

MoE speed estimates corrected

For MoE models with their experts in system RAM, our speed estimates had been about two and a half times too low. The old formula read the shared weights at system RAM speed as well. Now only the experts each token is routed to are read from RAM, and the new estimate was checked against public benchmarks. Common setups such as Qwen3 30B-A3B on 8GB to 16GB cards moved from Runs slowly to Runs well.

Gemma 4 KV cache sizes corrected

We had been sizing the KV cache of Gemma 4 12B four times too large, and that of Gemma 4 26B-A4B twice too large. In these models the layers that attend to the whole context have their own KV head count and head size in the configuration file, and we had used the values of the sliding-window layers instead. With the right values their KV cache shrank to a quarter and a half of the old size, so both models need less memory at long contexts.

CanRun opens at canrunllm.com

The site opened with the calculator, a page for every GPU, every model and every model-and-GPU pair, and six guides. Every page was available in English and Korean from the first day.

How the data stays current

  • Every week, model data is compared with Hugging Face: the file size of each quant, each model's configuration and its download count. Changes are checked before they go live.
  • Every day, we look for new models, as described above.
  • The exchange rate behind the won amounts on the Korean pages is updated weekly.
  • Every page shows its data date at the bottom. It is currently October 23, 2026.

Models added to the catalog

Each model below links to its own page, with the memory it needs by quant and context and the GPUs that can run it. The date is when the model joined CanRun, not when it was released. The earliest dates are from before the site opened to the public, while the catalog was first being put together.

58 models are in the catalog now. The newest additions come first.

· 1 model added

· 6 models added

· 4 models added

· 2 models added

· 1 model added

· 1 model added

· 6 models added

· 8 models added

· 9 models added

· 20 models added