Speeds from RAM alone, compared

The short answer: two models on four machines

Both models serve the house's own products: Mistral reads what strangers type at RuleSage, our board-game rules helper, and Gemma 4 speaks for RealKeep, a small game. Here both run from memory alone, at default threads.

This chart and every chart above the prompt-size ladder share one recipe, the frozen prompt: Ollama 0.32.15, Q4_K_M files by digest, one 2,101-byte prompt, a 4,096-token window, 256 tokens written. Three machines on 2026-08-25: writing from five warm runs, prompt reading and the first word from two cold runs. The Ryzen desktop from three fresh loads: gemma4:26b and mistral on 2026-11-04, three dense models on 2026-11-08. Here mistral's first word sits on a 1,023-token prompt, the mixture's on 536. Not a silicon comparison: the laptop and the mini PC run 4 of their 24 and 16 threads. Files: runs/cpu-{server,laptop,mini}-m1…m6.json, cpu-server-x2.json in the battery kit (of Two Hours at 12 tok/s — On Battery, the battery page); two-channel-desktop/summary.json in 105's kit (of Speeds from RAM alone, exhibit 105) and this page's kit.

The machines

T0 · The five machines, as the charts label them; each memory speed says when, or whether, it was read.

Two notes. Exhibit 105 first printed the Ryzen desktop's memory as two 16 GB sticks; the 2026-11-08 dmidecode -t 17 read (the motherboard's own report of each memory slot) found four 8 GB sticks, and that page carries its dated correction; no measured figure changes. The battery page's "server, 128G of ECC RAM" is this EPYC desktop, its "Rig B" this laptop: exhibit 105 did not join them, this page does (the house has named hardware in full since 2026-09-17).

A few words this page leans on

• Writing (decode, token generation, tg): tokens a second as the answer appears; a token is a little under a word.
• Prompt reading (prefill, prompt processing, pp): tokens a second taking in the question.
• First word (time to first token, TTFT): model already loaded, its load subtracted, nothing cached.
• Dense, mixture of experts (MoE): a dense model uses every parameter per token; a mixture wakes a fraction (gemma4:26b about 4 billion of its 26), though all of it must sit in memory.
• Threads: Ollama's num_thread; its default is half the performance-core threads on hybrid Intel parts, the physical cores elsewhere (table T0).
• Q4_K_M, Q8_0, IQ3_S: about four, eight and three bits a weight.
• STREAM triad: a memory-speed test streaming three large arrays, in GB/s. k: writing tokens a second per GB/s of triad; one over k is the GB the rule says moves per written token. Paper peak: transfer rate × 8 bytes × channels, arithmetic, not a reading.
• Fresh, warm, cached: a fresh load puts the model in memory before the run; a warm run follows other runs of that model; a cached prompt was sent before, so its reading is skipped.
• THROTTLED: the laptop's throttle counter rose, or the Ryzen desktop's control temperature reached 95 °C, between request and last token. A label, never a reason to drop the figure.
• NOT WALL: package watts and joules are the processor's own counter, not a wall meter; the whole computer draws more.
• Draft model: gemma4:26b's built-in speculative draft: a small head proposes tokens, the main model keeps those it agrees with. Every bar of the 08ae7ec1744b… build includes it; dense models have none.

How fast does each model write on each machine?

The frozen-prompt bench, writing. The laptop's 2026-11-05 re-read of two models (T8) drifted 2 to 16 % in writing, so a gap under about 16 % between those benches is not a finding. Default threads differ; the next chart shows what they do. Source: the bench's files, above; T1.

Should I raise the thread count?

The same bench at one other setting per machine: 20 threads on the laptop and 12 on the mini PC (warm runs, n = 5), 4 on the Ryzen desktop; T5b prints every ratio. Not a rule for other processors, and nothing for the EPYC (no Ollama thread sweep there). The mini PC's same-session 4-thread controls sit −5.2 % to +3.3 % from its default bars. The laptop's 2026-11-05 pair is in T5. Files: supplement-runs/tuned-cpu-{laptop,mini}-m*.json in the battery kit; two-channel-desktop/summary.json in 105's kit.

How long until the first word of the answer? (time to first token, TTFT)

Client time to the first token minus the model's load; n = 2 on 2026-08-25 (the battery page printed "median of five"; the record holds two), n = 3 on the Ryzen desktop. For a cold start add the load: 9.9 to 10.2 s for gemma4:26b on this laptop in August (page-cache-warm), 14.6 to 16.9 s in November's fresh loads. Threads are the biggest lever (Do more threads shorten the wait?, below). Source: the bench's files, cold_load[] and arms[].first_word_median_ms; T3.

How fast does each machine read the question? (prompt processing)

Nothing cached, and the load subtracted, so disk is not in it; one cold run for the 70B. Not comparable per token between mistral's panel and the others: its prompt is 1,023 tokens under its tokenizer, the same 2,101 bytes. Source: the bench's files, cold_load[] (the battery kit's counting rule 2) and arms[].prefill_median; T2.

Why do some pages claim a 0.2-second first word?

Ollama keeps a prompt's computed prefix: a resent prompt reports its full token count and a near-zero reading time, a cache artifact by the battery kit's counting rule 2. The reading rate reads up to 316 times higher (mistral on the mini PC, 3,308.41 against the cold 10.4745), the first word up to 310 times sooner. Source: runs/cpu-mini-m1…m6.json, derived.ttft_ms.median (warm runs re-sending one prompt) against cold_load[], in the battery kit; T9.

Do more threads shorten the wait?

The Ryzen desktop's fresh loads and the laptop's 2026-11-05 pair (n = 3; THROTTLED: gemma4:26b 3/3 at 4 and 1/3 at 20; mistral 3/3 at both); ratios in T5b. The mixture's trade at 20 threads: a third of gemma4:26b's writing speed (14.63 → 9.80) for a first word at 3.54 s instead of 8.68 s, the biggest lever on the wait the house has measured. Source: laptop/summary.json, two-channel-desktop/summary.json, arms[0..3], in 105's kit; T5.

The tables behind the frozen-prompt charts

T1 · Writing speed, tokens a second, the frozen-prompt bench: the EPYC at 32 threads, the laptop at 4 of 24, the mini PC at 4 of 16, the Ryzen desktop at 8. Q4_K_M by the digest in each row; loaded size is ps_after_load[0].size.

Note to T1, mixture over dense, from the raw fields: 26B over 24B, 3.48 · 4.91 · 3.82 · 5.31 (EPYC, laptop, mini PC, Ryzen); 30B-A3B over 9B, 2.31 · 2.06 · 1.60; the laptop at 20 threads, 8.44 over 5.14 is 1.64 and 8.53 over 13.05 is 0.65.

T2 · Prompt reading, tokens a second, nothing cached; token counts are the frozen prompt under each tokenizer.

T3 · First word, seconds, the model already loaded: the same runs as T2.

T5 · Threads. A dash: not taken (the 2026-08-25 tuned arms were warm runs).

T5b · Thread ratios, from the raw fields.

T8 · Replication: the laptop measured twice, 2026-08-25 (no throttle counter recorded) against 2026-11-05 (fresh loads, n = 3; THROTTLED 3/3 at 4 threads, 1/3 and 3/3 at 20). The record does not say what moved (governors were not recorded alike).

T9 · The cached-prompt trap, on the mini PC.

Is a mixture of experts (MoE) really faster from RAM?

A default-threads lead: at 20 threads on the laptop the 26B mixture leads the 24B dense model by 1.64 times, and the 30B mixture trails the 9B dense model (0.65). Not a quality comparison (none was measured), and not sparsity alone: gemma4:26b writes with its draft model (acceptance 0.60 to 0.67 on the ladder's four texts, mean draft length 2.8 to 3.0; the frozen prompt's acceptance is in no public file), and whether the 30B-A3B mixture drafts was not read. Source: the bench's files and supplement-runs/tuned-cpu-laptop-m1,m4,m5,m6.json in the battery kit; T1's note.

How long is the wait for a long question?

The next three charts are one family: four public prompts of about 500, 2,000, 4,000 and 8,000 tokens (openings of this hub's own articles, each a prefix of the next), a 16,384-token window, 256 tokens written, three fresh loads, two machines at default threads, the same Ollama and digests, 2026-11-08 (UTC). Their 0.5K point is not the frozen prompt or its 4,096 window: a labelled neighbour, never the same bar. Files: fill-in/laptop/summary.json and fill-in/two-channel-desktop/summary.json in this page's kit; T4a.

The whole prompt is read before the first word, so the wait grows with it. At 20 threads this laptop read the frozen prompt 2.46 times faster; the ladder was not run at 20. Not the wait on an already-read prompt (a cache hit). Field: arms[].first_word_median_ms.

Does a longer question slow the writing?

Every gemma4:26b run on the laptop and 6 of the 9 qwen3.5:9b runs are THROTTLED; the Ryzen desktop never reached its 95 °C rule (0/3 on every arm). The mixture's steeper fall is not a property of mixtures: its draft acceptance moves across the texts (0.660 / 0.601 / 0.665 / 0.597 on the laptop) and the dense line stops at 4K. Field: arms[].decode_median.

Does a longer question slow the reading?

From 0.5K to 8K the mixture's reading rate fell 15.3 % on the laptop (64.322 → 54.488) and 11.6 % on the desktop (65.213 → 57.663); the dense model's fell 2.9 % and 3.0 % to 4K (38.337 → 37.244; 47.99 → 46.572). The laptop's hottest sensor rose with length under the mixture (98 to 100 °C at 0.5K, 104 to 105 at 8K, every run THROTTLED), so its decline cannot be separated from heat (T4c). Field: arms[].prefill_median.

The tables behind the prompt-size ladder

T4a · The ladder, the laptop (290HX Plus, 64 GB; 4 of 24 threads; fresh loads, n = 3; 2026-11-08, 02:14:27Z to 03:02:18Z).

T4a · The ladder, the Ryzen desktop (3700X, 32 GB DDR4; 8 threads; fresh loads, n = 3; 2026-11-08, 01:00:20Z to 02:06:09Z).

T4c · The ladder, labels. Draft acceptance is accepted over proposed in each run's log, identical across a text's three runs. The laptop's 105 °C is the processor's limit, under the run's 110 °C stop; its floor was 93 °C.

Where do more threads stop helping?

Warm runs, median of five, 256 tokens written, 2026-08-25; the mini PC has 4 P-cores and 8 E-cores, the laptop 8 and 16. Not the kit's parent sweeps (best of two, 128 tokens, about 3 % high). Files: supplement-runs/sweep-cpu-mini-m6-moe.json, sweep-cpu-laptop-m1.json, sweep-cpu-mini-m1.json, rows[].decode_median, in the battery kit.

T5c · The sweeps, tokens a second while writing, median of five.

What did the STREAM triad read on each machine?

One recipe on every machine (a 100-million-element array, ten reps, the first discarded); the 2026-11 kits' triad.c re-creates August's. The triad scores 24 bytes per element where the hardware moves 32, so traffic can run up to a third above every figure. The EPYC's 2026-11-03 worst rep ran beside live services; the cause is not in the record. The Ryzen desktop's triad read low, its own dense models moving more than this while writing (T6c): not that machine's memory speed. Files: receipts/triad-cpu-{server,laptop,mini}.txt in the battery kit; each machine's triad.json in 105's kit and this page's kit; T6a.

Does writing speed follow the triad?

One over k is the GB the rule says moved per written token: 4.1 GB on the laptop, 1.6 GB on the Ryzen desktop. The band, 0.20 to 0.28, is the August spread widened a tenth each side, registered on exhibit 105 before its runs. Not an explanation: the Ryzen desktop's verdict stands as exhibit 105 printed it, above the band and unexplained. (Its sticks' rated speed, since read at 3,200 MT/s, does not explain it.) Source: the triad files above, runs/cpu-{server,laptop,mini}-m5.json and each 2026-11 summary.json (arms[0].decode_median, bandwidth_rule.k); T6a, T6b.

The tables behind the triad charts

T6a · The triads, GB/s, and the memory's paper peak (configured MT/s × 8 bytes × channels, from the read each row names). Nothing in the record says a BIOS held still between a 2026-08-25 triad and a 2026-11-08 read.

T6b · The rule: gemma4:26b at default threads, writing over the same-day best triad (band 0.20 to 0.28). The last five rows carry no verdict: the default thread-starves the dense model on both machines, and the Ryzen desktop's three dense models were not registered under the rule.

T6c · The dense check, arithmetic from cited fields. Loaded bytes (ps_after_load[0].size, the same digests) × writing tokens a second is the GB/s a dense model would need if it read its whole loaded size once a token; divided by the same-day triad. Two things make that generous: the loaded size also counts the context cache and working buffers (qwen3.5:9b loads 6.07 GB at a 4,096-token window and 6.60 GB at 16,384 in this page's kit), and the triad's 24-of-32-byte scoring lets real traffic run up to 1.33 times its reading. The laptop's dense models at 20 threads sit at 1.33 to 1.42, at that edge; the Ryzen desktop's need 1.83 to 2.09, 38 to 57 % past it, while the no-card verdict there reads PROVEN. So the suspect on that machine is the triad's reading, not the memory; why it reads low is not in the record, and this page guesses no cause.

What does 128 GB of eight-channel memory buy?

About 180 billion parameters by its model card (Qwen3.8-Flash-Next at IQ3_S, about 6 billion awake per token; 54.8 GB of weights and a 28.8 GB lookup table), on the EPYC desktop alone: llama.cpp build 11514, three 4,038-token prompts, an 8,192-token window, 2026-11-03 (UTC), beside its live services. A different engine, model, quantization, prompt, window and writing clock from every Ollama bar: no shared axis, and no thread advice for smaller models. The first request after each load is included; the 19.03 tokens a second ceiling is the triad over 5.159 GB a token. Files: eight-channel-desktop/summary.json, arms[0], arms[2], arms[1], in 105's kit.

T7a · The big model, speeds. The share is of the 19.03 tok/s ceiling. The 32-thread writing figure is 8.325 in the file; this page's round-half-up rule prints 8.33 where exhibit 105 printed 8.32.

What does the laptop's processor draw while writing? (the frozen prompt, 2026-11-05)

RAPL package-0, the processor package's own counter: NOT WALL. A request's energy (T4b-105) includes its 13 to 18 s fresh load. Not beside the EPYC's watts or the ladder's, and not an electricity cost (see Electricity per million tokens, card by card). Files: laptop/summary.json, arms[0..3].decode_package_w_median, idle_package.mean_w, in 105's kit.

And on the long questions? (the prompt-size ladder, 2026-11-08)

The same counter, NOT WALL. Not beside the chart above (a different prompt, window and day); the desktop's package counter is not readable (NOT READ). Files: fill-in/laptop/summary.json, arms[].decode_package_w_median, idle_package.mean_w, in this page's kit; T4b.

And the EPYC's, on the big model?

Model already loaded; the live services' draw is not separated from the package counter; NOT WALL. Not beside either laptop figure. Files: eight-channel-desktop/summary.json, arms[0,2,1].decode_package_w_median, idle_package.mean_w, in 105's kit; T7b.

The tables behind the energy charts

T4b-105 · The frozen prompt, laptop energy (NOT WALL). Joules a token is package watts over writing tokens a second; kJ a request includes the fresh load.

T4b · The ladder, laptop energy (NOT WALL).

T7b · The big model, energy (NOT WALL; the model already loaded).

An older desktop: ten cores, 48 GB of DDR4

Its own figure, joined to nothing above: Ollama 0.32.13 (not 0.32.15), three warm runs, thread count not recorded, 2026-09-10; 47,040 MiB as the system reports it. Its gemma4:26b is an older build (digest 5571076f3d70…, 25.8B), not the 08ae7ec1744b… of every other bar; The 3080 Rig, Priced printed its 12.8 beside the mini PC's 12.7 without saying so. Its reading and first-word fields are cache hits, not printed; no memory speed or triad was read. Two more models it ran, qwen3.6:27b and nemotron3:33b, are not charted: this house has not read their architecture, and their files ship in the kit. Files: older-desktop/gpu-3080-m1…m6-cpu-box.json, -x1, -x2, derived.decode_tok_s.median, in this page's kit.

T10 · The older desktop, tokens a second while writing.

Embeddings on the processor (for search and RAG)

The one non-chat row: nomic-embed-text turning 100 short texts (about 51 words each, one after another) into vectors, the operation behind search and retrieval-augmented generation; 2026-08-25, default threads. The battery page printed "12–26". Files: runs/cpu-{server,laptop,mini}-x1.json, embeddings_per_s, in the battery kit.

T11 · Embeddings a second.

What the numbers do not say

• No quality reading of any model: every reply was hashed, never kept.
• No Ollama thread sweep on the Ryzen desktop, the EPYC or the i9: the matrix compares each engine's default, not silicon.
• No prompt over about 8K tokens, no window above 16,384, no 8K point for the dense model (not run, for time); the ladder ran on two machines only.
• No controlled DDR4-against-DDR5 pair: the machines differ in processor, cores, threads and memory at once.
• No nemotron-3.5-lightning:30b-a3b on the 32 GB desktop: not run under the fill-in kit's 6 GiB headroom rule, so never failed; no 70B except on the EPYC.
• No wall power anywhere, no package power on the Ryzen desktop, and no energy figure comparable across machines or families (the laptop's kJ include a fresh load, the EPYC's exclude it).
• No gemma4:26b writing speed without its draft model: the 2026-11 logs say it drafted, the 2026-08-25 files did not record it.
• The ladder's prompts are one genre: its length effect is a length effect on this text.
• No governor was recorded alike across benches (schedutil and powersave with two EPP settings in August; none in the November summaries).
• Why the Ryzen desktop's triad reads 19.5 to 21.4 GB/s against its 51.2 GB/s paper peak: not in the record; the page guesses no cause.
• The battery page and The 3080 Rig, Priced take dated notes in later cuts for the two statements corrected above.

Not on this page

• Four homes for one reranker, Small open deciders, measured and EmbeddingGemma 2, measured on release day: processor timings of other tasks, the last CONTENDED on every row by its own rule.
• The battery kit's parent thread sweeps (best of two, 128 tokens), and the mini PC's 2026-08-25 memory-fit run of the 30B mixture (15.21 tok/s with 5.35 GiB left free, under a different stop rule).
• The mini PC's 75.6 W at a UPS meter, the house's one wall reading for one of these machines alone: the battery test's different workload.

How to check our work

The data kit beside this page (CC BY 4.0; every file with its size and sha256) holds what the two earlier kits do not: the 2026-11-08 fill-in runs and receipts, the four public prompts, the dated memory slot reads, the twenty chart specs, the older desktop's files and facts/FACTS.md, one row per bar with its raw field, file, rule and gates. The battery kit's counting-rules.md governs the 2026-08-25 columns; its frozen prompt's text is held out, and its README says why. Rounding is done once, round-half-up on the file's own digits: writing to two decimals, prompt reading to one, the first word to two in seconds (so 10.985, 12.165, 8.325 and 6.055 print 10.99, 12.17, 8.33 and 6.06), watts and kJ as the file prints, k to four decimals, ratios and percentages from the raw fields.

The rest of the seminar

• Two Hours at 12 tok/s — On Battery.
• Speeds from RAM alone.
• Mixture of experts, in plain words.
• Why the first word comes sooner: the big mixture with a card helping.
• The 3080 Rig, Priced: the older desktop.
• Electricity per million tokens, card by card.

Who ran this, and thanks

The models ran on Ollama 0.32.15 (0.32.13 on the older desktop) with llama.cpp beneath it, the big mixture on llama.cpp build 11514. They are Alibaba's Qwen3.5 and Qwen3.8-Flash-Next, Google's Gemma 4, Microsoft's Phi-4, Mistral Small 3.2 from Mistral AI, NVIDIA's Nemotron 3.5 Lightning, Meta's Llama 3.3 and Nomic's nomic-embed-text; each earlier page names the licence it found. A small human team pasted the stages, read the memory slots and signed the amendments; AI agents built the kits, drew the charts and wrote this page under its rulings.

Sources

• The three kits: /two-hours-on-battery/data/, /speeds-from-ram-alone/data/ and /ram-speeds-compared/data/.
• Speeds from RAM alone: "Memory speed, and the rule this bench registered" and "The two-channel desktop: AMD Ryzen 7 3700X, 32 GB of DDR4".
• Two Hours at 12 tok/s — On Battery: "The one table to remember", "The wait", "Set the thread count".