Run Gemma 4 locally: Google's open family, now under a plain license

On April 2, 2026, Google shipped the strongest open models it has ever released and, in the same breath, deleted its own license. For two years, every Gemma download came with homework: a custom “Gemma Terms of Use,” a use policy Google could enforce, and a clause letting the company restrict your usage remotely. Gemma 4 threw all of that out for plain Apache 2.0, the same license behind everyday open-source software.

We mapped the family when it launched in Google Gemma, explained. This is the hands-on sibling: which of the five sizes fits the machine you actually own, the one command that runs each, what the new license actually lets you ship, and where a rival family is still the better pick.

Five sizes cover everything from a phone to a rig

The core family is five models, and the split is by hardware, not by marketing tier. At the bottom sit the two edge models, Gemma 4 E2B and E4B. The E stands for “effective,” Google’s naming for models whose resident memory footprint tracks a 2B or 4B model rather than the larger full parameter count. Google’s launch post pitches them at phones, Raspberry Pi boards, and Jetson Orin Nano devices, with a 128K-token context window and, uniquely in the family until June, native audio input.

Don’t read “edge” as “toy.” Audio input means the E-models transcribe a voice memo or take spoken questions on a device with no network connection at all, and every size in the family reads images, so “what does this error screenshot mean” works on the smallest tier. That combination, full multimodal understanding on hardware that costs less than a game console, is the part of the roster that would have read as fiction two years ago.

Above them sit the big three. The 26B is the family’s efficiency play: a mixture-of-experts design that activates only about 3.8 billion of its parameters per token, so it answers at small-model speed while scoring near the top of the family. The 31B is dense, built as the quality ceiling and the base Google recommends for serious fine-tuning; at launch it ranked #3 among all open models on the LMArena text leaderboard, with the 26B at #6. Both read images natively and stretch the context window to 256K tokens. And in the middle sits the 12B, which deserves its own section, because for most readers it is the reason to care.

One family-wide bonus landed two weeks after launch: multi-token prediction drafters, small companion models that draft several tokens ahead while the main model verifies them in one pass. Google reports up to roughly 3x faster generation with identical outputs. On local hardware, where every token fights your memory bandwidth, that is the difference between watching a cursor and reading an answer.

The 12B is the daily driver Google didn’t launch with

The original lineup had a gap in the middle: nothing between the 9.6 GB edge model and an 18 GB workstation pull. On June 3, 2026, Google filled it with Gemma 4 12B, and the result is the most laptop-shaped model in the family. It is a dense 12B that understands text, images, audio, and video in one architecture, carries the full 256K context window, and is sized for machines with 16 GB of VRAM or unified memory. A mid-range MacBook or a gaming laptop clears that bar.

The engineering trick is what Google calls a unified, encoder-free design. Most multimodal models bolt a separate vision encoder onto the language model; the 12B replaces that stage with a 35-million-parameter embedder, about one sixteenth the size of the encoder in comparable models, and feeds raw image patches and audio frames straight into the transformer. Less machinery between your input and the model means lower latency, which matters most on exactly the hardware this model targets. It shows up in the download too: at 7.6 GB, the 12B is a smaller pull than the E4B edge model, while carrying twice the context and adding video input.

For the technically curious, the developer guide publishes the plumbing. Images enter as raw 48-by-48 pixel patches with a coordinate lookup instead of an encoder pass; audio enters as 16 kHz signal chopped into 40-millisecond frames. Google’s demo runs the model over a five-minute video, 313 frames sampled at one per second with synchronized audio, and asks questions about what happened. That is not a party trick; it is meeting-recording and lecture-capture territory, running on a laptop.

If you want one model to leave loaded all day (chat, summarize PDFs, describe screenshots, transcribe a voice memo, answer questions about a lecture recording) this is the one. It is the first mid-sized Gemma with native audio, and the only size in the family that watches video. The model page has the full spec sheet.

Match the command to your memory, not your ambition

Everything below assumes Ollama, the same one-command runner our local-models guide uses throughout. Install it, pick your row, run the command. The pull sizes are Ollama’s default 4-bit quantized builds; if that term is new, quantization is the compression that makes a 12B model fit in 7.6 GB with little visible quality loss.

The honest sizing rule: the pull size approximates the memory the weights occupy, and your operating system, browser, and the model’s working context all compete for the rest. Leave a few gigabytes of headroom, and when in doubt, drop a tier. A model that fits runs; a model that swaps to disk crawls.

Ollama is the shortest path, not the only one. LM Studio pulls the same checkpoints behind a graphical interface with memory-fit hints. On Apple Silicon, the MLX builds in the table’s footnote are the fast path. Tinkerers can go straight to llama.cpp with the GGUF files from Hugging Face, and Google’s own LiteRT-LM runtime will stand up an OpenAI-compatible local server with one litert-lm serve command, which means anything that speaks the standard chat API can point at your laptop instead of a cloud endpoint. Whatever the runtime, it is the same Apache-licensed model underneath.

One warning specific to this family: 256K context is a budget, not a free upgrade. Context costs memory on top of the weights, and filling a quarter-million tokens can add gigabytes to the footprint. Ollama also defaults to a much shorter window than the model supports, so long documents get silently truncated until you raise it. Our RAM and VRAM guide covers the arithmetic; the short version is to raise the context you actually need and no further.

Apache 2.0 changes what you can ship, not how it runs

The license flip is easy to undersell as paperwork. Here is what the Gemma Terms of Use attach to every earlier Gemma, and still attach to Gemma 3: your use is subject to a prohibited-use policy Google can update; Google reserves the right to restrict usage it believes violates the agreement, “remotely or otherwise”; and if you build on the model, you must pass those same restrictions on to your own users. None of that made Gemma 3 unusable, but every product decision carried a small asterisk.

Gemma 4 core has no asterisk. Apache 2.0 is a standard, OSI-approved license: run it, fine-tune it on your own data, embed it in a commercial product, sell that product, and keep the result. There is no use policy attached to the weights, no remote-restriction clause, and nothing of Google’s that your terms of service must carry. It also grants patent rights, which is the quiet reason legal teams prefer it. For a company, that moves Gemma 4 from “ask counsel” to the same bucket as the open-source libraries already in the build.

Apache 2.0 is not zero obligations, so state them honestly: if you redistribute the model or a fine-tune, you keep the license text and copyright notices with it, and you note what you changed. That is bookkeeping, not control; Google keeps no say over what you build. The contrast with the rest of the market is stark. Meta’s Llama license carries a 700-million-user ceiling and branding rules; Gemma 3 carries the terms above. Among big-lab open families, only Gemma 4 core now matches the MIT-licensed Phi line for “read it once and move on.”

The seam to keep straight: Apache 2.0 covers the Gemma 4 core models only. The specialist Gemmas (ShieldGemma, PaliGemma, CodeGemma, EmbeddingGemma, FunctionGemma, and the rest of the specialist roster) remain listed in the Gemma Terms’ appendix, and Gemma 3 itself never changed. If your product touches a specialist model, the old rules still apply to that piece. Check the license on the exact checkpoint you pull, not the family name on the blog post.

Where Gemma 4 loses, honestly

A #3 open ranking means something still sits above it, and the pattern is worth knowing before you commit. Gemma 4 is a generalist. The reasoning-first lines, like DeepSeek’s R series, are built to spend far more inference-time tokens thinking, and that design keeps them ahead on the hardest math and code. If competition-grade problem solving is the job, a dedicated reasoner remains the better tool.

Breadth is the other flank. Qwen ships more sizes and more specialist variants than Google does, so if your constraint is unusual (a 0.6B for a microcontroller-class device, a dedicated coder model) the everything-family likely has a closer fit. At the smallest end, Phi’s reasoning-tuned minis still punch above the Gemma edge models on math. And note what Gemma 4 doesn’t do at all: it understands images, audio, and video, but outputs only text. It will describe your photo, never generate one.

There is also a quirk inside the family itself: hearing does not scale up. Only the edge models and the 12B accept audio; the 26B and 31B are text-and-image only. Upgrade your hardware, move up a tier, and the voice-memo workflow you built on the 12B stops working. If audio input is core to your use, the 12B is not the budget pick, it is the ceiling.

The one to install tonight

The decision compresses well. On an ordinary 16 GB machine, pull gemma4:12b and stop reading; it is the best capability-per-gigabyte in the family and the only tier that hears and watches. On an 8 GB laptop or a single-board computer, take gemma4:e2b. With a workstation or a 24 GB GPU, take gemma4:31b and get within sight of the frontier without a subscription. Still torn between families? The local-model flowchart exists for exactly that.

The larger point is the one in the hero. Open-model capability improves every quarter; open-model terms almost never do. In April, Google’s open family quietly improved on the one axis that usually only gets worse, and whatever you build on it this weekend is yours in a way it wouldn’t have been a year ago. That is worth one command and eight gigabytes to find out what it means for you.

Disclaimer: The license descriptions in this post are plain-English summaries, not legal advice. Model licenses change between releases, and what counts as permitted use depends on your situation. Read the license text that ships with the model, and consult counsel before relying on it in a product. Details reflect sources available as of August 2026.