Gemma 4 12B ships encoder-free multimodal local model with 16GB target and 256K context

• Google shipped Gemma 4 12B as an Apache 2.0 open model that targets local multimodal work on 16GB-class laptops, according to Google's launch thread and the official announcement.
• The architectural move is simple and consequential: Google's architecture thread says vision and audio now project directly into the LLM backbone, and the developer guide fills in the numbers behind that change.
• Google positioned the 12B against its larger 26B MoE sibling, while lmsysorg's day-zero SGLang post attached concrete scores including 77.5% on AIME 2026, 72.0% on LiveCodeBench v6, and 78.8% on GPQA Diamond.
• Day-one runtime support landed unusually fast: osanseviero's ecosystem post listed Hugging Face, llama.cpp, Ollama, vLLM, SGLang, Unsloth, MLX, and LM Studio, with ollama's launch post already wiring it into agent-style local commands.
• The launch also came with a local app and local server story, because osanseviero's demo post showed a new macOS desktop app and Google's AI Edge post added an OpenAI-compatible litert-lm serve path.

You can read the official announcement, then jump straight to the denser developer guide for the 35M vision embedder and raw audio projection details. Maarten Grootendorst also published a handy visual guide, while Google's separate AI Edge post is where the local app and local API server details actually live.

Gemma 4 12B sits between the edge-oriented E4B models and Google's larger 26B MoE, with Google's launch thread pitching it as the first mid-sized Gemma with native audio and the official announcement framing it as a laptop-class multimodal model.

The day-one package is broader than just weights:

• Apache 2.0 licensing, per Google's launch links post
• pre-trained and instruction-tuned checkpoints on Hugging Face and Kaggle, via Google's download post
• text, image, audio, and video inputs in the Gemma 4 stack, as summarized in the model card
• 256K context, function calling, and thinking mode, according to lmsysorg's SGLang post and vllm_project's day-zero post

The core trick is that Google removed the separate multimodal towers. Google's architecture thread says image inputs now go through a lightweight embedding module, while raw audio is projected into the same space as text tokens.

The developer guide adds the concrete implementation details:

• Vision: a 35M-parameter embedder replaces the 550M vision stack used in other medium Gemma 4 variants.
• Image patches: raw 48x48 patches get one linear projection into the LLM hidden dimension.
• Spatial information: X and Y coordinate lookup tables are attached directly to the input.
• Audio: the separate 300M encoder disappears.
• Audio frames: raw 16 kHz audio is sliced into 40 ms frames, 640 floats each, then projected into the LLM input space.
• Fine-tuning: one shared weight space means LoRA or full tuning updates vision, audio, and text together in one pass.

That last point is easy to miss in the launch copy. Google's own guide makes the bigger claim here: encoder-free is not only a deployment story, it also collapses multimodal fine-tuning into the same token loop.

Google's headline comparison is that the 12B gets near the larger 26B MoE while using less than half the memory, per the official announcement and _philschmid's launch summary.

The most concrete public benchmark bundle in the evidence pool came from lmsysorg's SGLang post:

• AIME 2026: 77.5%
• LiveCodeBench v6: 72.0%
• GPQA Diamond: 78.8%
• context window: 256K
• multilingual pretraining: 140+ languages

Hardware claims already split into two tiers. Google kept the official target at 16GB VRAM or unified memory in the developer guide, while UnslothAI's quantized release post said Dynamic GGUFs can push local runs down to 8GB RAM. Later, UnslothAI's follow-up said GGUF vision and audio support had been added after users updated Unsloth and llama.cpp.

Google and ecosystem partners made day-zero support part of the launch itself. osanseviero's ecosystem post listed Hugging Face, llama.cpp, Ollama, vLLM, SGLang, Unsloth, MLX, and LM Studio, and the developer guide adds Google AI Edge Gallery, Google AI Edge Eloquent, and LiteRT-LM.

A few concrete integration notes surfaced immediately:

• vllm_project's day-zero post said reasoning, tool parsers, vision, and audio all route through an OpenAI-compatible API.
• ollama's launch post exposed ollama run gemma4:12b-mlx, plus local agent commands for Hermes and Claude Code through MLX.
• lmsysorg's SGLang post shipped a cookbook the same day.
• ai_for_success's local run demo reported 28 tokens per second for text generation in LM Studio, while noting vision issues in that setup.

That last caveat matters because the launch story was polished, but the early local reports were still exactly what you would expect from a day-one multimodal stack: text first, then the modality edges get sanded down.

Google quietly attached a fuller local product surface to this release than to most open-weight drops. The AI Edge post says Google AI Edge Gallery expanded to macOS with offline execution on Apple Silicon GPUs, a sandboxed Python execution loop, and support for the Google AI Edge Eloquent app's voice editing flow.

The same post also introduced litert-lm serve, which runs Gemma 4 12B as a local OpenAI-compatible API server with stateless prefix caching in memory. Google's example wiring explicitly names Continue, Aider, OpenClaw, Hermes, and OpenCode as drop-in clients.

That means the launch was not only a model-card event. It also shipped a reference local stack: native Mac app, local API server, and an official skills repository in the developer guide for agent workflows built around Gemma itself.