The roster, as of October 2026

How to read this page

One machine, one model at a time. The desktop has an NVIDIA GeForce RTX 5090 with 32,607 MiB of graphics memory, an Intel Core Ultra 9 285K and 188 GiB of system RAM. MiB and GiB are binary units of memory: mebibytes and gibibytes. One row also ran on an ASUS ROG Flow Z13 laptop with 128 GB of memory, and says so. Every model is served by llama.cpp's llama-server, which loads a model and answers requests, one request at a time.

A few terms, once:

• Speaking is how fast the model writes: generated tokens per second (t/s). A token is roughly three quarters of a word.
• First word is how long a cold prompt takes to read before the reply can start. Cold means the server had not read that text before. It is the server's own prompt time.
• Deep means how many tokens of conversation were already read when the reply was written. Models write slower deep in a long conversation.
• Window (context window) is the most text the server will hold at once, prompt and reply together.
• Quantization is how the weights are compressed: Q4 is about 4 bits a weight, Q8 about 8. Lower is smaller and less exact. The names (UD-Q4_K_XL, IQ1_S, MXFP4) are the file makers'. The cache, the model's memory of the conversation so far, can be compressed the same way. Rows say so where they list a cache setting.
• Experts in RAM. A mixture-of-experts model uses a few of its many expert blocks for each token. When the file is bigger than the card, the experts live in system RAM and the processor runs them. That is why processor settings matter on those rows.
• Thinking models write hidden reasoning before they answer. Their speaking figures count that reasoning.

Every speed below is a measurement from a dated run, and the files for that run are in the data package. The method page defines the label measured. Each cell says what reply it timed. A short answer and a 400-word letter are different measurements, so a row that has only a short answer says so. A draft model is a small second model that guesses the next few tokens. The main model checks the guesses and keeps the ones it agrees with.

The change that helped most of the models we tested

On 29 September we ran 16 models that keep part of their weights in system RAM twice on the same prompt of about 96,000 tokens (48,000 on three rows, 24,000 on two). In the first run, llama.cpp used 24 threads spread over every core. In the second run, we pinned it to the eight performance cores (P-cores) with three settings: the operating system's taskset -c 0-7, llama.cpp's --threads 8 --threads-batch 8 and the OpenMP setting GOMP_SPINCOUNT=10000000. OpenMP is the library llama.cpp uses to run its threads. The bundle: cores 0 to 7 with taskset, 8 threads, and the OpenMP spin setting GOMP_SPINCOUNT=10000000; the spin setting was not run on its own. The 285K has eight performance cores and sixteen efficiency cores. Fifteen of the 16 are mixture-of-experts models with their experts in RAM. The sixteenth, Mistral Medium 3.5, is a dense model. On 15 of the 16 rows both runs read the same prompt and wrote replies with the same token count and the same word count. We call those 15 the clean test pairs.

Measured 2026-09-29, one run per setting. The reply was a letter of 230 to 534 words, written in the same request that read a synthetic ledger (an invented long document), from a cold cache. The percentage is arithmetic on the two speeds. MiniMax M2.7 is the one row that is not a clean pair. Its run with the bundle restored the ledger from a saved copy, so its ledger was already cached, and it wrote a different reply (421 tokens against 381), so it is outside the 13 of 15. Four rows ran a draft model on both runs, so their speeds include its help; each pair is still like for like. Mistral Medium 3.5's letter stopped at the 500-token cap on both runs.

What to do with it. If your model keeps experts in system RAM on a chip with performance and efficiency cores, try the same bundle. The bundle: cores 0 to 7 with taskset, 8 threads, and the OpenMP spin setting GOMP_SPINCOUNT=10000000; the spin setting was not run on its own. Pin the prompt threads too (--threads-batch), because reading a prompt runs on them. Measure your own model both ways, because two of ours got slower. Prompt-reading speed moved by 2 percent or less on 11 of the 15 clean pairs. It rose 5 to 11 percent on the two DeepSeek presets and on GLM-5.3-Flash, and fell 4.4 percent on Mistral Medium 3.5.

Our explanation of why it helps, which we have not proven: for every layer held in RAM, each token sends a short burst of work to the processor. A layer is one stage of the model's computation. A burst ends only when the slowest thread finishes. With 24 threads, the slowest is often on an efficiency core.

Installed since 27 September

Thirteen models, newest first. Every row is on the desktop unless it says laptop. "Letter" means a request for a letter of about 300 to 400 words. The model wrote it after reading a long synthetic ledger (an invented document) for the first time. The length of that ledger in tokens is what "deep" counts.

Card peak is the most graphics memory in use at any sample during the run, in MiB, including the desktop's own use. Window is the default that each start script serves, read on 25 October. A start script is the command file that launches a model. Muse Spark's row, MiMo's row and the 131,072 figures in the notes below were timed on long prompts we do not publish. Only their token counts and the server's timing lines ship.

Row notes

• Ornith-1.5-122B. Two other placements were measured the same day. A placement is how many blocks keep their experts in RAM. Both read the same 239,533-token ledger. With experts of 36 blocks in RAM, the letter came out at 22.15 t/s (349 words) and the ledger read at 868.4 t/s, but the card peaked higher (29,462 MiB against 26,881). With the file's built-in draft head at 40 blocks, the letter came out at 22.69 t/s (345 words), 1,278 of 1,616 drafted tokens were kept, the ledger read slower (779.3 t/s) and the card peaked at 29,919 MiB. A draft head is a small built-in predictor that does the same job as a draft model. At a 131,072 window, after a 111,235-token prompt, its median (middle) speed over 123 replies was 26.15 t/s.
• Hemmingway-1. At a 131,072 window, after a 111,235-token prompt, its median (middle) speed over 119 replies was 41.69 t/s without a draft model and 53.68 over 42 replies with Qwen3.8-27B's draft model, which kept 58,728 of 319,380 guesses (18%). Those medians mix reasoning and visible text.
• Aura 4o Rebirth. Thinking is off by the server's default. At 98,304 with images it spoke 33.12 on a 319-word letter, 90,242 deep, peaking at 29,099 MiB. After a 113,205-token prompt at 131,072 its median speed over 21 replies was 30.86.
• Nemotron 3.5 Bolt. unsloth's larger UD-Q4_K_XL file without a draft model spoke 53.37 on a 215-token answer, 58,935 deep. On the same public text, read as 24 chunks of 4,096 tokens, its perplexity was 3.0970 ± 0.0285 against 3.2931 ± 0.0319 for NVIDIA's 2-bit file. Perplexity measures how surprised a model is by text. Lower is closer to the original weights' behaviour.
• DeepSeek V4.1-Flash-1017. On the same run, with thinking off, a tool call and the model's reply to the tool's result both completed. It also quoted 3 of 3 planted codes (short codes hidden in the prompt to test recall) from the 110,052-token read. The conversion is in the field notes.

Re-measured: the models that changed

Why the Qwen3.8-27B gain depends on what it writes

A draft model guesses the next few tokens. The big model checks the guesses in one pass and keeps the ones it agrees with. On thinking text the draft's guesses were kept 57% of the time (2,838 of 4,957) and the gain was about 3 times. On the two plain letters about 19% were kept: 244 of 1,274 on the letter that gained 44 percent, and 268 of 1,428 on the one that gained 30 percent. We think the share of guesses kept explains the difference, but these runs did not test that on its own. The letter runs with the draft model also used the smaller micro-batch, and their new text after the long read was 314 tokens against 570, so the letter gains cannot be given to the draft model alone. One draft run kept -ub 512, at a 196,608 window. On the same 570 tokens of new text, 100,000 tokens deep, its 3,500 tokens of reasoning ran at 133.92 t/s against 47.30 without the draft model, 2.8 times. The window changed in that pair, so no run here measures the draft model on its own. Our speculation-gate study explains why the shape of the output matters.

The installed window is 229,376 because the card is tight. In a test run at 229,376 the card peaked at 30,647 MiB. The installed speed run kept no peak reading. In test runs at 262,144 it peaked at 32,028 MiB on the thinking-on run and 31,992 on the thinking-off letters, about 600 MiB from full.

What the Qwen3-235B records isolate

Every run here used the UD-Q3_K_XL file and the same 109,712-token ledger on 29 September, one letter each. The expert count was measured on its own. The cache comparison also changed the window. The cache: with all 8 experts, a 16-bit cache wrote at 5.71 t/s, an 8-bit cache at 4.24 and a 4-bit cache at 2.86, and prompt reading ran at 640 to 649 t/s for all three. The 16-bit run used a 118,784 window, the other two 131,072. The experts: at that same 118,784 window and 16-bit cache, running 6 of the model's 8 experts per token raised the letter from 5.71 to 6.77 t/s. The installed 8.89 came from a later server start that also changed the window to 131,072 and the micro-batch to -ub 1024, and its prompt read at 466.7 t/s. How its extra speed over 6.77 splits between those settings was not isolated. Running 6 of 8 experts is a change to the model's computation, and we did not measure what it does to answer quality. The thread-pinning bundle of section 02 came later the same day and was not re-measured on this model.

Retired or removed

Dates come from the notes we keep of changes to this desktop.

What we got wrong

• Muse Spark's reading speed. Our own records listed 191 t/s for "a 106K read". The server log shows the 106,469-token cold read at 155.0 t/s, 686.9 seconds. The 191 belongs to two later reads of about 77,000 tokens (190.52 and 192.92). This page prints the log's figure.
• GLM-5.3-Flash's "reasoning effort none". Our September runs, and the GLM-5.3-Flash card, say the server ran with reasoning effort none. Reasoning effort is how much hidden thinking a model does before it answers. The model's own chat template (the text pattern that turns a conversation into the model's input) accepts only low and high. It turns every other word into max. Those runs were at maximum effort.
• The September roster's "now" sentences. They were true on 26 September. Many of its rows have since changed or left (sections 02, 04 and 05). This page is the current list.

What this does not show

This page does not measure answer quality. The only figures near quality are planted codes read back and one perplexity pair. Rows were measured on different days with different prompts, so compare within a row, not down a column. These are single runs on one desktop, not benchmarks. Some speeds include a draft model's help, and the rows say so. The thread-pinning bundle's gain was measured on one processor, and its cause is unproven.

Related pages on this site

• October field notes: the month's faults and traps, including five GPU timeout faults.
• The roster, as of 26 September 2026: the previous snapshot, kept as a dated record.
• The batch-size study and Silent settings: the September settings work this page builds on.
• Qwen3.8-27B at 256K, GLM-5.3-Flash and DeepSeek V4 Flash: field cards with dated updates for this month.
• Method: the labels used on this page.

Sources and artifacts

The data package holds the result files behind most figures: the probe results, card-memory samples and selected server lines for each run, a listing of the model files with their byte counts, and the served windows read from the start scripts. A few figures come from records that do not ship, or from our earlier published pages, and data/NUMBERS.md names each one. Machine paths, addresses, process numbers and our internal names for each model are removed, and so is every reply's text: only token counts, timings and pass or fail flags ship. For Muse Spark, MiMo and the 131,072-window medians, the prompts are not published, and only the server's timing lines ship.

• data/README.md: every file, where it came from, what was removed, and where the package looks like it argues with itself.
• data/NUMBERS.md: every figure on this page mapped to its file and field.

If a number on this page disagrees with a file in its package, the file is right and the page is wrong. Tell us at hello@graphometer.ai and the correction goes on the page with its date.

This page is dated on purpose. It is a snapshot as of 25 October 2026; a later roster will be a later page.