The release that nobody saw coming

Google dropped this model at 2AM UTC on June 4th. No blog post. No press release. No keynote. Just three new entries appeared on Hugging Face, and ten minutes later /r/LocalLLaMA melted down.

This is not how major model launches work. Every other release this year has had three weeks of leaks, preview benchmarks, influencer embargoes, and carefully crafted marketing. Google just uploaded the weights and walked away.

By the time most people woke up, Unsloth had already published GGUF quantizations. People were running it on laptops. Working code was being posted. Nobody had time to form a hot take before everyone already had the model running locally.

What actually shipped first

Three base variants landed within one hour:

1. google/gemma-4-12B raw base model
2. google/gemma-4-12B-it instruction tuned variant
3. unsloth/gemma-4-12b-it-GGUF community quantized builds from q2_k up to q8_0

This is the first 12B parameter model ever released with native, encoder-free multimodal support. There is no separate vision transformer. There is no extra projection layer. The same weights process text and images. You do not pay any VRAM penalty to use vision.

It has an advertised 256,000 token context window. Unlike every model released before this one, that number is not a lie.

The 3090 test that broke the subreddit

Twelve hours after release, a user posted the first real world long form test. This is the report that convinced everyone this was different.

They loaded the q4_K_M quantized build on a stock RTX 3090. It used 9.2GB of VRAM. It generated 15 tokens per second.

They fed it 117,000 tokens of raw source code from a full git repository. They asked it to diagram the dependency graph and explain three open bugs. It did it correctly. It referenced line numbers from files 90,000 tokens apart in the context window. It did not hallucinate. It did not forget the original question.

No Llama 3 variant will do this past 32k. No Qwen 2 variant will do this reliably past 64k. This model did it at 117k on the first try, no fine tuning, no special prompt tricks.

The same user then pasted a screenshot of their IDE. The model correctly identified the syntax error on line 412, explained the race condition, and wrote the fixed function.

This is performance people were only getting from 70B class models three weeks ago. It runs on a five year old consumer graphics card.

Benchmark head to head: 12B vs 26B A4B

Independent side by side testing was posted 18 hours after release, run on a single RTX 4090. Both models were given an identical task: write a complete working HTML5 canvas implementation of three separate physics demos, no external libraries, no placeholders.

Model	VRAM Used	Output tokens	Generation speed	Task completion rate
Gemma 4 26B A4B	15.1 GB	6912	138 tok/s	100%
Gemma 4 12B	9.0 GB	8971	80 tok/s	94%

The 26B MoE won every test. It ran 1.7x faster. But the 12B came within 6% of output quality on half the VRAM. That is not a small gap. That is the difference between requiring a high end desktop GPU and running acceptably on every 16GB laptop sold in the last four years.

Nobody has ever delivered that ratio before.

Context window performance: not marketing bullshit

Every model for the last 18 months has advertised absurd context window sizes. Every single one falls off a cliff once you pass ~20% of the advertised number. Attention decays. References get lost. The model starts hallucinating answers that sound correct but have no relation to the input.

Gemma 4 does not do this.

One user ran a full 45,000 token code generation task on the 8 bit quantized build. Speed stayed flat between 18.4 and 18.9 tokens per second for the entire generation. There was no measurable slowdown as context depth increased.

Prompt processing started at 228 tok/s on an empty cache. It was still running at 157 tok/s at 23,000 tokens of active context. Llama.cpp reported 96.4% cache reuse across conversation turns, a number no previous model has ever hit above 32k.

This is the first model you can actually dump an entire code repository into. You do not have to chunk. You do not have to run RAG. You just paste the whole thing and ask questions.

Quantization, community builds and the Heretic fork

Official Gemma weights are noticeably more sensitive to quantization than Qwen models. Q4_K_M is the minimum recommended quantization right now. Anything lower introduces measurable reasoning degradation.

Unsloth published optimized GGUF builds 90 minutes after the base weights went live. These are not just standard quantizations. They include fixed KV cache scaling and removed alignment layers that were causing unnecessary refusals.

Within 24 hours the Heretic alignment stripped fork was published. This build removes all refusal guardrails entirely. It was used to generate a complete 467 line brick breaker game in one single generation. No corrections. No follow up prompts. Just one prompt, 4 minutes of generation, working code that ran on first open.

The exact command used for that test is public:

./llama.cpp/build/bin/llama-server \
  -m H-gemma-4-12B-heretic-Q8.gguf \
  -c 256000 \
  --jinja \
  --cache-type-k q8_0 \
  --cache-type-v q8_0

This works. You can run this right now.

License: the thing nobody is talking about enough

All Gemma 4 models are released under Apache 2.0.

There are no usage restrictions. There are no revenue caps. There is no fine print. You can run it. You can fine tune it. You can ship it in commercial products. You can wrap it in an API and sell access. Google will not come after you.

This is the single most important detail of the entire release. Almost every other good open model has restrictive non commercial or revenue capped licenses. This one does not.

You can build a product on this today. You do not need to ask permission.

What this changes for local practitioners

Before this release, the standard tradeoff was simple:

• Run a 7B model fast, get mediocre output
• Run a 34B model slow, get good output
• Run a 70B model, need multiple GPUs

That tradeoff no longer exists.

Gemma 4 12B sits exactly on the threshold that changes everything. It is good enough that you will not reach for a cloud model for 90% of daily development work. It is small enough that it will run on hardware almost everyone already owns.

People have already swapped this into their local coding pipelines. People have already replaced their Copilot proxies. People are already building voice interfaces on top of the native audio input support that nobody even knew this model had until 12 hours after release.

Upcoming variants: QAT, 120B MoE and what's next

Google confirmed Quantization Aware Training variants will be published within the next week. These will fix the quantization sensitivity, and will almost certainly deliver near fp16 performance at q4. That will bring usable VRAM usage down to ~7GB.

This model will run on a Steam Deck.

Multiple sources have confirmed a 120B MoE variant of Gemma 4 is complete and will be released soon. Early leaked benchmarks put it at GPT-4o parity. It will run on two 3090s.

Nobody is talking about what that means.

The end of the cloud default

For the last five years the default assumption was that any useful model would run in the cloud. Any model good enough for real work would be too big to run locally. Any model you could run locally would be a toy.

That assumption died on June 4th.

This is not a gimmick. This is not a demo. This is a production grade model that you can run on your laptop right now. No API keys. No rate limits. No bills. No one can turn it off. No one can read your prompts.

This is what everyone was promised open AI would be. It just arrived quietly, at 2AM, with no announcement.

Most people still have not realized what just happened. They will.