Gemma 4: Every Size in Google's Open-Weight Family Explained

There is no single Gemma 4 to look up. DeepMind's current open-weight line is five separate models — Gemma 4 E2B, Gemma 4 E4B, Gemma 4 12B, Gemma 4 26B A4B and Gemma 4 31B — stretched across two architectures and two context-window tiers, and they disagree with each other on the question most readers arrive with. Three of the five accept audio. Two do not. Two of the five are the kind of model you call through an API; the 12B is the kind you download. Getting the size wrong is the most common way to waste a weekend on this family, and nothing on the vendor's own hub makes the split obvious at a glance.

That gap is measurable, and it is why this page exists. Across our own Search Console data for 2026-09-15 to 2026-10-12, the Gemma 4 facet drew 499 impressions and 5 clicks across 47 queries. The bare term — someone typing just "gemma 4" — accounted for 24 impressions and zero clicks on two queries. The six largest queries in the whole neighbourhood are comparisons, and every one of them is against a Qwen 3.8 model: gemma 4 vs qwen 3.8 (99 impressions), gemma 4 vs qwen3.8 (40), gemma 4 vs qwen 3.8 27b (29). And the live blog already answers the 12B's matchups at length — three gemma-4-12b-vs-* comparisons lead with that model, and forty more carry it on the other side of the versus. Every one of them pitches the same encoder-free Gemma 4 12B against a different opponent. Readers are not asking what Gemma 4 is. They are asking whether it beats something. That question belongs on the comparison pages. What the comparisons need — and what has not been written — is a single place that says precisely what Gemma 4 is and which sizes exist.

What Gemma 4 actually is

Gemma 4 is DeepMind's open-weight model family, published in both pre-trained and instruction-tuned form, with the instruction-tuned checkpoints carrying the -it suffix. The family spans dense and mixture-of-experts designs, five sizes, and a shared set of architectural choices: hybrid attention that interleaves local sliding-window attention with full global attention, with the final layer always global; unified keys and values in the global layers plus proportional RoPE to keep long-context memory in check; a 262,000-token vocabulary; configurable thinking modes; native function calling; and native support for the system role. The model cards say the models were pre-trained on more than 140 languages, with 35-plus supported out of the box.

Two things about the family decide most readers before performance enters the conversation.

The first is the licence. Every Gemma 4 size in the family ships under Apache 2.0. That is a change in posture: the Gemma 2 and Gemma 3 releases carried the custom Gemma Terms of Use, and their model cards on Hugging Face still read license: gemma. The Gemma 4 cards point at an Apache 2.0 licence text instead, and the launch post describes the family as "released under a commercially permissive Apache 2.0 license." For anyone who has had to reason about the Gemma Terms of Use before, that is the headline fact on this page. It applies per size, and it is stated on each size's own model card — not inferred from a family-level claim.

The second is that "Gemma 4" is not one model, and the sizes are not scaled copies of each other. E2B and E4B use a trick called Per-Layer Embeddings, where each decoder layer gets its own small embedding table per token; those tables are large but only ever read by lookup, which is why the card quotes effective parameter counts (2.3B and 4.5B) that sit far below the totals including embeddings (5.1B and 8B). The 12B is the odd one out architecturally — it is encoder-free, projecting raw image patches and audio waveforms straight into the transformer through lightweight linear layers rather than through dedicated vision and audio encoders. The 31B is a conventional dense model. The 26B A4B is sparse. Four different machine profiles, one family name.

The size map

Here is the family as its own model cards describe it. Parameters, layer counts and context windows below are read off the dense and MoE spec tables on the Gemma 4 model cards.

Gemma 4 E2B. The smallest member: 2.3B effective parameters, 5.1B including embeddings, 35 layers, a 512-token sliding window and a 128K context. It handles text, image and audio, with roughly 150M vision encoder parameters and around 300M for audio. It is built for phones and IoT devices, and it is not one of the three sizes the vendor shipped a separate page for in this batch — if you are here for E2B specifically, this section is the whole of it.

Gemma 4 E4B. The same design one step up: 4.5B effective parameters, 8B including embeddings, 42 layers, 512-token sliding window, 128K context, and the same text, image and audio coverage with the same encoder sizes. Also an edge model, also without a dedicated page here.

Gemma 4 12B. The unified, encoder-free middle of the family: 11.95B parameters, 48 layers, a 1,024-token sliding window, 256K context, and native audio alongside text and image — which the June 3, 2026 launch post calls the first mid-sized Gemma to take audio. The vendor's own framing for local deployment is 16GB of VRAM or unified memory. It has its own page in this batch, and the family's entire live search presence today is three gemma-4-12b-vs-* comparisons, so that page carries a lot of weight.

Gemma 4 26B A4B. The sparse model, and the one this page's notation section below is about: 25.2B total parameters, 30 layers, a 1,024-token sliding window, 256K context, text and image only — no audio — and 8 active experts out of 128 plus one shared expert. It has its own page in this batch.

Gemma 4 31B. The dense top of the line: 30.7B parameters, 60 layers, 1,024-token sliding window, 256K context, text and image with a ~550M vision encoder and no audio at all. It has its own page in this batch.

Set the five side by side and the tiering is clean in one respect and messy in another. Context window tracks size exactly — 128K below 12B, 256K at and above it. Audio does not: it is available on the two smallest sizes and on the 12B, and absent from the two largest. If you need speech input, the 31B is the wrong choice no matter how much you are willing to spend on hardware.

The "A4B" in 26B A4B, decoded

The name carries two numbers and only one of them is a parameter count you would use for memory planning. The 26B is the total: 25.2B parameters live in the checkpoint. The A4B is the active count — roughly 3.8B parameters are touched per token during inference, because the mixture-of-experts router selects 8 of 128 experts (plus one shared expert) for each token. The model card states the "A" explicitly: "The 'A' in 26B A4B stands for 'active parameters' in contrast to the total number of parameters the model contains."

What that buys you is inference speed closer to a 4B model than a 26B one, while the quality sits nearer the dense 31B — the card's own description, and the reason the 26B A4B exists as a tier at all. What it does not buy you is a small download. You load all 25.2B parameters; you just do not multiply against all of them.

Open weights, per size, and what the licence permits

All five sizes are open-weights releases, and all five model cards declare Apache 2.0 — E2B, E4B, 12B, 26B A4B and 31B alike. The launch post describes the family as "released under a commercially permissive Apache 2.0 license" that gives developers control over their data, infrastructure and models, and the 12B post repeats the Apache 2.0 line for that size.

Apache 2.0 is the whole of the licence story here, but it is worth being precise about what that means, because it is the question the licence answers rather than a statement about any hosted service. Apache 2.0 grants a perpetual, worldwide, non-exclusive, royalty-free copyright licence and a matching patent grant, permits redistribution and modification, and requires that the licence text travel with the work and that changed files be flagged. The patent grant terminates if you file patent litigation over the work. It grants no trademark rights beyond customary descriptive use, and it disclaims warranties. Read against the Gemma 2 and 3 Terms of Use, the practical difference is that Apache 2.0 is a standard permissive licence with no separate acceptable-use schedule attached to the weights.

So the licence permits redistribution, commercial use, modification and fine-tunes of these weights, and the weights themselves are published. That is the full extent of what the licence text says. What any particular service generates with a model in production is a separate question, governed by that service's own terms and not by the Apache 2.0 grant.

Download formats: what "QAT" and the GGUF repos mean for you

This is a reader question with real traffic behind it, so it gets an answer here rather than a pointer elsewhere. The vendor ships quantisation-aware-trained (QAT) checkpoints for the whole family, and they are the reason a size that looks too big for your machine often is not.

• QAT checkpoints are published for every size and in more than one format: qat-q4_0-gguf for llama.cpp-style local runtimes, qat-w4a16-ct for 4-bit weight / 16-bit activation serving, and qat-q4_0-unquantized variants that carry the QAT-trained weights without the packing, so you can quantise them yourself.

• The Gemma page describes QAT as "Model compression for mobile and laptop efficiency," dated to June 2026 — the same month the 12B arrived.

• Pair the format to the size deliberately. E2B, E4B and 12B have qat-q4_0-gguf builds that target phones, laptops and single consumer GPUs; the 26B A4B and 31B also have 4-bit builds, but they are serving-side quantisation for a machine with real memory, not a phone target.

There are also -assistant variants across the family, which are the multi-token prediction drafters the vendor ships alongside the models; the deepmind.com Gemma page dates the drafter work to May 2026. These are a speed technique for speculative decoding, not a different model — you still need the main checkpoint.

Where the sizes sit on hardware, and what they cost

The launch post for the family describes the two larger models as unquantized bfloat16 weights that "fit efficiently on a single 80GB NVIDIA H100 GPU." At 30.7B parameters, the 31B is a little over 60GB in bfloat16, which is a fair reading of that sentence. The 26B A4B, at 25.2B total parameters, lands around 50GB in bfloat16 but runs at the speed its 3.8B active count suggests.

The 12B is the size the vendor explicitly pitches for local use — "Small enough to run locally with just 16GB of VRAM or unified memory," per the June 2026 launch post, with a 4-bit QAT GGUF build as the obvious route into that budget. That is a vendor claim about a specific configuration, not a general promise about every quantisation level.

On price, the honest framing is that this family splits across two cost models at once. If you self-host, your cost is the GPU and the electricity. If you call a hosted endpoint, the per-token price is set by whoever is serving it, and for most of this family that number moves with the provider. Artificial Analysis, an independent evaluator, lists Gemma 4 12B (Reasoning) at $0.10 per million input tokens and $0.30 per million output tokens — and flags the same page with the note that there is "No publicly available API" for that variant, which is a useful independent signal about which sizes in this family actually have hosted endpoints in the wild.

Vendor benchmarks, with the labels attached

The numbers below are the vendor's own, published on the Gemma 4 model cards, and they are unreproduced here. They compare the instruction-tuned models, with Gemma 3 27B (no think) as the previous-generation baseline.

• Reasoning — MMLU Pro: 31B 85.2%, 26B A4B 82.6%, 12B 77.2%, E4B 69.4%, E2B 60.0%, against Gemma 3 27B at 67.6%.

• Competition maths — AIME 2026 without tools: 89.2% / 88.3% / 77.5% / 42.5% / 37.5%, baseline 20.8%.

• Code — LiveCodeBench v6: 80.0% / 77.1% / 72.0% / 52.0% / 44.0%, baseline 29.1%. Codeforces ELO: 2150 / 1718 / 1659 / 940 / 633, baseline 110.

• Science — GPQA Diamond: 84.3% / 82.3% / 78.8% / 58.6% / 43.4%, baseline 42.4%.

• Agentic tasks — Tau2, averaged over three runs: 76.9% / 68.2% / 69.0% / 42.2% / 24.5%, baseline 16.2%.

• Long context — MRCR v2, 8-needle at 128k: 66.4% / 44.1% / 43.4% / 25.4% / 19.1%, baseline 13.5%. This row is the one that separates the 31B from its siblings most sharply.

• Vision — MMMU Pro: 76.9% / 73.8% / 69.1% / 52.6% / 44.2%. MATH-Vision: 85.6% / 82.4% / 79.7% / 59.5% / 52.4%.

• Document parsing — OmniDocBench 1.5 on average edit distance, where lower is better: 0.131 / 0.149 / 0.164 / 0.181 / 0.290.

Two vendor claims from the launch post are worth keeping separate from the table, because they are rankings rather than measurements: the vendor describes the 31B as the "#3 open model in the world" and the 26B A4B as taking the "#6 spot." Those are the vendor's placements against a set of models it chose. The model card also records that the 12B's audio scores exclude Chinese. And one figure that is neither a benchmark nor a price: the June 2026 12B post says Gemma 4 models have "crossed 150 million downloads." That is a vendor-reported number with no independent audit attached.

Only one independent score turned up for this family. Artificial Analysis lists Gemma 4 12B (Reasoning) at 14 on its Intelligence Index — flagged explicitly as an estimate, with independent evaluation still to come, and ranked #20 of 141 — alongside 110.9 output tokens per second and 2.49 seconds to first token. Its index page carries no measured Gemma 4 score for the larger sizes. Treat the entire table above as a vendor's own, and the 12B's 14 as the single measured data point in the family so far, itself provisional.

Which Gemma 4 members we serve

OrcaRouter serves three Gemma 4 entries, and they are on the live list today:

• google/gemma-4-26b-a4b-it — the instruction-tuned sparse 26B A4B, described on our catalogue as 25.2B total parameters with 3.8B activated per token and a 262,144-token context, accepting text, image and video input. List price $0.06 per million input tokens and $0.33 per million output tokens, with cached input reads at $0.0075 per million.

• google/gemma-4-31b-it — the instruction-tuned dense 31B, 30.7B parameters. List price $0.13 per million input tokens and $0.38 per million output tokens.

• obsidian/gemma-4-26B-A4B — an Obsidian-hosted build of the same sparse 26B A4B, with a 262K-token context and text plus image input, positioned by its provider for creative writing, roleplay and long-context assistant work. List price $0.25 per million input tokens and $2.90 per million output tokens.

Two of the three are the same base model served by different providers, which is the useful case for a routing layer rather than a curiosity. If a provider degrades, the same request fails over to the other id without a code change, and because we pass provider list prices through at 0% markup, a hosted price cut on any of these three reaches you the day it lands rather than after a repricing cycle. The two 26B A4B entries are also the clearest illustration of why the price difference is worth looking at before you default to one: a 4× gap on input and an 8.8× gap on output between two entries running the same architecture is a routing decision, not a model decision.

One thing is absent and it is worth stating plainly rather than implying. There is no 12B id in our list under any spelling. The size with the most live pages and the most comparison demand in this family is precisely the one we do not serve, so if you want the 12B through a hosted endpoint, this is not the place to get it — and if you want the encoder-free, audio-capable, 16GB-class member of this family, self-hosting the open weights is the route to plan for.

What is not settled

Three things a reader should not treat as closed. First, the benchmark table is entirely vendor-reported; the only independent number available for this family is a single estimated Intelligence Index score for one size. Second, the demand for this family is almost entirely comparative rather than standalone — 73% of Gemma 4's family impressions in our data come from qualified queries, and the six biggest are all Qwen comparisons — which means the answers readers actually want depend on matchups that are still being measured. Third, the vendor's own hub has since sprouted neighbours with names that sit close to this family: a DiffusionGemma built on Gemma 4, multi-token prediction drafters, and EmbeddingGemma 2. Those are separate models, not Gemma 4 sizes, and mixing them into a size comparison will produce nonsense.

Availability

Weights for all five sizes — E2B, E4B, 12B, 26B A4B and 31B — are published openly under Apache 2.0, in pre-trained and instruction-tuned form, with QAT and GGUF builds alongside them, through the vendor's own distribution and the usual model repositories. On hosted endpoints, the line-up varies by platform, and for this family that variation is wider than usual: three of the five sizes appear on our live list, the 12B does not appear on ours, and at least one independent evaluator records no publicly available API for it at all. Check the live catalogue of whichever platform you use for the specific size you need rather than assuming the family name covers it.