Gemma 4 12B is Google's open-weight, encoder-free multimodal model, released June 3, 2026 under Apache 2.0. Instead of routing images and audio through separate encoder networks, one language model reads raw pixels and sound directly. That makes it light enough to run offline on a mid-range 16GB laptop while handling vision, audio, and text in one pass.

What does encoder-free mean?

A normal multimodal model bolts on separate networks, encoders, to translate images and audio into something the language model can read. Encoder-free deletes them. The image is sliced into tiles and reshaped by a single math step straight into the model, which learned to do the translating inside its own weights instead.

Does Gemma 4 12B really perform like a 26B model?

On Google's own benchmarks, roughly. The 12B lands within a few points of the larger 26B on medium-difficulty tests and beats last year's Gemma 3 27B across the board. But the gap reopens on the hardest reasoning tasks, and the scores were vendor-graded, so treat "near a 26B" as punches-above-its-weight, not a tie.

Can Gemma 4 12B run on a laptop?

Yes. Quantized down, the weights fit in around 8GB, and Google targets a 16GB laptop, the kind a mid-range machine ships with today. On a normal gaming GPU you get about 20 tokens a second. It is great for tinkering and private offline use; serving a thousand users at once is a different sport.

Yes, the weights are released under Apache 2.0, so you can download and run it however you want. Google makes its money on cloud, ads, and devices, not on charging per model call, so giving away a capable model costs them little while pressuring rivals and funneling builders toward Google's paid cloud later.

Gemma 4 12B: The Encoder-Free Model Explained

Google built a model that can look at a photo and tell you what is in it, listen to a voice memo and answer questions about it. Then, right before shipping, they tore out its eyes and ears. No vision network, no audio network, the one piece every multimodal model before it was built around. And the thing still works.

When the announcement went up on June 3, 2026, a developer who builds this stuff for a living left a comment that boiled down to: I have read this three times and still cannot figure out how it is possible. The whole confusion lands on one word, encoder-free. This article walks through what an encoder is, why everyone assumed a model like this could not exist, how Google pulled it off, and the part where the marketing gets ahead of the truth.

What is Gemma 4 12B?

Gemma 4 12B is Google’s open-weight, unified, encoder-free multimodal model, released June 3, 2026 under an Apache 2.0 license. In plain terms: a 12-billion-parameter model that sees, hears, and reasons, with the weights handed to you free to run on your own machine. The headline trick is that it does all of this without the separate encoder networks every other multimodal model leans on.

That one design choice is the whole story. It is why the model is light, why it runs offline, and why a working engineer stared at the release notes in disbelief. To see why deleting the encoder is such a big deal, you first have to know what the encoder was doing in there.

What an encoder is, and why every multimodal model needed one

An encoder is a translator. A language model only reads one kind of thing, text, so when you want it to handle a photo, you hire a separate network to study that image and hand the model back something it can read. The vision encoder is its own full neural network, often hundreds of millions of parameters, trained for the single job of turning pixels into tokens. The audio encoder does the same for sound.

It works, and the whole field treated it as a law of physics. Want a model that sees? Bolt on a vision encoder. Want it to hear? Bolt on an audio one. The problem is that every translator you hire bills you. They eat memory, because now you load three networks instead of one. They add lag, because the language model sits and waits for the translators to finish before it can start thinking. And they are usually frozen, sealed boxes you cannot open, which makes the model a headache to fine-tune for your own use.

The old way3 networks

Image Audio

Vision encoder~400M Audio encoder~300M

Language
model

Two translators to load, and the model waits for both to finish.

Encoder-free1 network

Image Audio

reshape~35M

One modelsees · hears · reasons

A ~35M reshape replaces ~700M of encoders. One brain reads it all.

Fig. 1 The money diagram. The old way bolts two encoder networks onto the language model and makes it wait for both. Encoder-free swaps roughly 700M of encoders for a ~35M reshape and one set of weights.

How Google deleted the encoder

Google fired both translators and taught the executive to read the photo and hear the voice memo herself. The whole thing rests on one bet: that raw pixels and raw sound are not actually a foreign language the model needs translated first. The bet is that the model is already smart enough to handle the raw stuff directly, as long as you reshape it to fit through the same slot the words go through.

Take an image. The model chops it into little squares, 48×48 pixel tiles, like a grid laid over the picture. Each tile is just a list of raw color values, and one dumb math step, a single matrix multiplication, stamps that list into the right shape to ride alongside the text. Nothing studies the picture. There is one wrinkle: a loose pile of tiles does not know where it came from, and in a photo, top-left versus bottom-right matters. So each tile gets tagged with its grid coordinates, like numbering jigsaw pieces. Add it up and the vision side is a reshape plus position tags, about 35 million parameters where the old encoder was hundreds of millions.

1 Raw in
A photo and a sound wave. No network studies them first.
2 Slice
Image into 48×48 tiles, audio into 40ms slivers.
3 One multiply
A single matrix multiply reshapes each piece, plus a position tag so tiles know where they sat.
4 One stream
Tiles, slivers, and words become the same token. One model reads across all of it.

Fig. 2 Firing the encoder, step by step. Raw pixels and sound get sliced, reshaped by a single matrix multiply, tagged with position, then poured into one token stream the model reads end to end.

Audio is even blunter. Take the raw sound wave, slice it into thin slivers a few hundredths of a second each, and run every sliver through one reshaping step into the same stream. There is no audio network at all. Once everything is in, the model stops caring what is what. Tiles of image, slivers of sound, and words all become the same kind of token, poured into one pile, and the model reads across all of it together. The seeing and hearing did not disappear. They moved into the main model, which learned to do the translators’ job inside its own head.

Why an encoder-free model runs on your laptop

Firing the translators is the reason this model lands on hardware you already own. Start with memory: a translator is a whole separate network you load and keep parked next to the language model. Delete it and that weight is just gone, which is the gap between needing a data-center GPU and running on the laptop on your desk. Then speed: in the old setup the language model cannot say a word until the translators finish their reports, and here there is nobody to wait for.

Memory ~8 GB

Quantized, the weights fit in roughly 8GB. Google targets a 16GB laptop, the kind a mid-range machine ships with today.

Speed ~20 tok/s

On a normal gaming GPU. There is no encoder to wait on, so the model starts thinking the moment the image is reshaped.

Fine-tuning 1 pass

Seeing, hearing, and words run through the same weights, so you retrain the whole thing at once. No frozen boxes to work around.

Fig. 3 What firing the encoders buys you: lighter memory, no waiting on a translator, and a single set of weights you can fine-tune in one pass instead of working around frozen boxes.

Fine-tuning gets less miserable too. Because the seeing, the hearing, and the words all run through the same weights, you retrain the whole thing for your own use in one go, with no committee of sealed-shut members to herd. That word “unified” Google keeps using is what this means: one set of weights doing every job. In real numbers, quantization (lowering the precision of each number to save space) squeezes the weights to around 8GB on a 16GB laptop, and on a normal gaming GPU you get about 20 tokens a second. Not blazing, but it is a full multimodal model running start to finish on your own machine, with nothing phoning home.

Gemma 4 12B benchmarks: does a 12B really match a 26B?

On Google’s own test sheet, close enough to be impressive. The headline is that a 12B performs near a 26B, Google’s exact phrasing being “performance nearing our 26B MoE model… at less than half the total memory footprint.” On the published model card the little one lands within a few points of its big sibling on medium-difficulty tests, and against last year’s Gemma 3 27B it is not close, it wins everywhere, often by huge margins.

Benchmark	Gemma 4 12B	Gemma 4 26B	Gemma 3 27B
MMLU Pro (knowledge)	77.2	82.6	67.6
GPQA Diamond (reasoning)	78.8	82.3	42.4
MMMU Pro (vision)	69.1	73.8	49.7
BigBench Extra Hard	53.0	64.8	19.3

Now the asterisks, because vendor benchmarks are marketing until someone independent re-runs them. The scores were graded by Google about a day before anyone outside could check. “Near a 26B” holds on the easy and medium questions and slips on the hard ones, where the gap reopens and parameters start buying real advantage again. And the community jumped on a different result entirely: a smaller Qwen 3.5 9B traded blows with Gemma and won on several shared tests. Both “a 12B nears a 26B” and “a 9B beats the 12B” are true in the same week, because a benchmark score depends enormously on which tests you pick and what each model was fed.

~1 day Graded at home

The scoreboard was Google’s own, posted about a day before anyone outside could re-run it. Vendor benchmarks are marketing until someone independent checks them.

53 vs 65 Hard ≠ tied

On the nastiest reasoning test (BigBench Extra Hard), the 12B trails the 26B by double digits. It punches above its weight, but it does not tie the heavyweight.

9B wins A smaller rival

A Qwen 3.5 9B, smaller still, traded blows with Gemma and won on several shared benchmarks. A score depends enormously on which tests you pick.

Fig. 4 Three asterisks on the headline. The scores were vendor-graded, the 12B trails on the hardest reasoning, and a smaller Qwen still won on several shared benchmarks.

Does encoder-free mean worse vision?

No. The model sees just as well, it just does the seeing in a different place. This is the one myth worth killing, because “they ripped out the vision network” sounds like the vision got worse, and it did not. The translating moved inside the model’s own weights rather than living in a bolted-on box.

But it is no free lunch either. A dedicated encoder can pull richer detail out of an image, and you can read Google’s own verdict in its lineup.

One more reality check on “runs on your laptop.” It does, but feed it a long document and the memory needed to hold that conversation balloons fast, and 16GB gets tight. Great for tinkering and private side projects. Serving it to a thousand users at once is a different sport, and consumer hardware taps out.

Why would Google give Gemma 4 away for free?

Because none of the three reasons are charity. Google spent a fortune training a capable model, then handed it to you free, weights and all. The most-upvoted question on the launch thread was basically: what is the catch? The catch is that giving the model away serves Google better than selling it would.

1 Not their business

OpenAI and Anthropic charge per use of the model. Google’s money is cloud, ads, and devices. A free, good-enough model barely dents Google while it sets fire to the labs whose whole business is the box.

2 Reach

A model small enough for a phone goes where a cloud API never will: inside Android, inside Chrome, on a Pixel, working offline on a plane. Google ships to billions of devices and wants this piece on all of them.

3 The funnel

You tinker, you build something real on the free laptop model, then you need to serve thousands of users around the clock. Google conveniently rents the servers for that. Free model, paid habit.

Fig. 5 Three reasons, none of them charity. A free model barely dents Google's cloud-and-ads business while it pressures the labs that sell model access, reaches devices an API never could, and funnels builders toward Google's paid servers.

Put the three together and you get a loop that feeds itself. Gemma 4 has crossed 150 million downloads, each one a developer building on Google’s tools, in Google’s orbit, getting trained to reach for Google by default. The free model is the first hit. The cloud bill is the habit. Handing the model out is how Google buys the whole world around it.

Is encoder-free actually new?

Not at all, and it is worth knowing so you do not walk away thinking Google invented this. Firing the encoder has been kicking around research labs for years. Fuyu-8B tried it back in 2023, projecting image patches straight into the model with no encoder. A project called EVE then showed in 2024 that a stripped-down model could keep pace with the encoder-based ones using only public data. The idea was already in the water.

2023 Fuyu-8B (Adept)
Image patches projected straight into the model’s first layer, no image encoder. The first widely-noticed proof the trick worked.
2024 EVE (BAAI)
A stripped-down, encoder-free model kept pace with encoder-based ones using only public training data. Proof it could compete, not just run.
2026 Gemma 4 12B (Google)
Shipped at scale: polished, free, audio built in, from a name big enough that the rest of the field now has to pay attention.

Fig. 6 Encoder-free is not new. Fuyu proved the trick worked, EVE showed it could compete, and Gemma 4 12B shipped it at scale with audio built in.

What Google did was ship it at scale, polished, free, with audio built in, from a name big enough that the rest of the field now has to pay attention. The implication is the part to watch. If a model can teach itself to see and hear without a dedicated organ for either, the separate encoder starts to look optional, and it is at its heaviest and most annoying exactly where small, on-device models live. Expect more of these. The honest caveat is that Google itself still trusts encoders on its bigger models, so “this becomes the standard for small models” is a smart bet, not a done deal.

Should you use Gemma 4 12B?

If you want a private, offline assistant that can look at a screenshot, read a messy PDF, or listen to a voice memo, all on your own machine with nothing leaving it, this is one of the smallest things that does the whole job. It owns that niche.

Forget the model for a second. The thing to remember is the move behind it: an AI that grew its own eyes and ears instead of renting them. It is a small trick, and it is quietly working its way into tools you already use.

For the full breakdown, with the translator analogy, the tile-by-tile deletion, and the honest scoreboard on screen, watch the explainer on YouTube.

Watch the explainer