8 billion on disk, under a gigabyte of context at 32K

What it is for

The rule is unchanged: the largest seven-day Heat Score gain among models that fit a 24 GB card with margin and were not picked in the last four weeks; ties break by the higher score. Between the readings of 24 and 30 October, both at 18:15 UTC, Gemma 4 E4B rose from 59 to 76. Qwen3 4B gained 14 and is the runner-up. Three models gained as much or nearly as much and were out on the rule: Qwen3.8 2.4T-A95B gained 15 and fits no 24 GB card; Llama 3.1 8B gained 15, but its config is gated, so the engine has no attention shape and gives no verdict, and a model without a verdict is not a fit; Gemma 4 31B gained 13 and barely fits a 24 GB card at 8K, which the rule does not count.

The signals behind the gain are modest, and the report should say so. The model's 30-day downloads went from 3.94 million on 23 October to 4.17 million on 30 October, up 6 percent; its Hub trending score went from 25 to 27, ninth among the 53 models we track today. The Heat Score ranks every component against the other tracked models, so a model can climb by holding steady while the field falls: of the 46 models with readings on both 24 and 30 October, 23 lost 30-day downloads over the window, and Gemma 4 E4B's 4 percent gain ranked fourteenth. It is the third Gemma 4 in eight picks, after the 12B in week 37 and the 26B-A4B in week 38, and the smallest of the three.

What we measure is the file and the shape. The E in the name is Google's label for an effective parameter count; the file carries 8.0 billion parameters, and the Q4_K_M weights, read from the published GGUF, weigh 4.6 GB. The config publishes 42 layers, of which 7 cache the full context with two KV heads of 512 dimensions, and 35 are sliding-window layers capped at 512 tokens. That shape is why the cache stays small: 0.25 GB at 8K, 0.9 GB at 32K, 3.5 GB at the full 131,072-token window. At 8K the engine computes 5.8 GB in total: it runs on the 8 GB cards (5.8 of 7.0 usable) and runs easily from the RTX 3080 upward. At 32K the total is 7.2 GB: the 8 GB cards miss it by 0.2 GB and spill into RAM, the RTX 3080 and RTX 2080 Ti run it, and everything from 12 GB runs it easily, the RTX 3060 12GB included. At the full 128K window the total is 12.9 GB, of which 4.7 GB is our assumed runtime overhead at that length: it spills into RAM on 12 GB, barely fits on 16 GB and runs easily on 24 GB. Last week's pick, Qwen3 8B, is a file of the same size, 4.7 GB, whose 36 layers all cache the full context; it needs 4.5 GB of cache at 32K where this one needs 0.9.

Renting a 24 GB card for a model that needs 7.2 GB at 32K is the wrong tool. The pick card froze an RTX 4090 hour on the Vast marketplace at $0.49, the 18:00 UTC hourly median across 64 offers; this week's median for the class was $0.53 and last week's $0.60. A 12 GB card that is already in your machine runs it at 32K with room to spare, and a 10 GB card runs it at 8K. If you do rent, and the job is the full 128K window, the RTX 3090 class has the same 24 GB: at 18:00 UTC the Vast marketplace median was $0.27 across 56 offers, and RunPod's posted price was $0.22 at its last reading of the day, 10:00 UTC.

Watch out

• The rent figure on this card is the 18:00 UTC hourly Vast marketplace median for the RTX 4090 (64 offers); this week's median for the class was $0.53 and last week's $0.60. Hourly medians move with which offers happen to be listed.
• This week's rise is a rank effect as much as a signal: downloads rose 6 percent and the trending score by two points while 23 of 46 tracked models lost downloads. The Heat Score is percentile-based by design, and a quiet week for the field lifts the models that merely held.
• Heat Score measures attention on the Hub (downloads, trending, likes), not quality. We publish no benchmarks and no speed figures for this or any model.
• The 128K figures include 4.7 GB of runtime overhead, which is an assumption of our engine for that context length, not a measurement; the weights are measured, the cache is computed from the config.
• Fit verdicts assume llama.cpp-style inference with the measured Q4_K_M GGUF and an f16 cache; other runtimes, quantized caches and other quantizations change the numbers.