Gemma – Google's open model family

Google released Gemma in February 2024 as its open-weight counterpart to Meta's Llama and Mistral's models: a family of models you can download, run on your own hardware, fine-tune, and ship inside a product without calling an API. The models descend from the research that produced Gemini, but they are distinct artifacts with their own architecture decisions, their own license, and their own trade-offs. As of this writing the line spans small models sized for a laptop up to a 27B-parameter model aimed at a single accelerator, plus specialised branches for vision, code, and long-sequence efficiency. What follows is a builder's evaluation – where each generation earns its place, what the license actually permits in plain English, and how Gemma stacks up against the open-weight alternatives you would realistically weigh it against.

Gemma in one paragraph

Gemma is Google's family of open-weight language models, first published in February 2024 by Google DeepMind and released under a permissive, Apache-2.0-style grant with a separate Google usage policy attached. The models are derived from the same research lineage as Gemini but are trained and packaged independently for self-hosted inference. The first generation shipped in 2B and 7B sizes; Gemma 2 added 9B and 27B variants with a meaningful capability jump; Gemma 3 introduced multimodal input and longer context windows. Around the core text models sit specialisations – PaliGemma for vision-language tasks, CodeGemma for programming, and RecurrentGemma for memory-efficient long-sequence work. The pitch to builders is simple: Gemini-adjacent quality, weights you control, and hardware requirements that keep the larger model within reach of a single GPU.

If you are new to how Gemma relates to Google's flagship, the distinction matters and is worth reading alongside our explainer on Gemini, Google's model family. Gemini is the closed, API-served frontier line. Gemma is the open, download-and-host line. They share research, not weights.

The Gemma family evolution

Gemma 1 (February 2024)

The first Gemma release met a mixed reception. The 2B and 7B models were competent but not obviously ahead of what Meta and Mistral already offered at similar sizes, and early adopters flagged rough edges: a tokenizer and chat-template setup that tripped up several inference stacks, and instruction-tuned behaviour that felt more constrained than its raw benchmark numbers suggested. Gemma 1 established the brand and the licensing model. It did not, on its own, displace Llama 2 or Mistral 7B in most builders' default stacks.

Gemma 2 (June 2024)

Gemma 2 is where the family became genuinely competitive. The generation introduced the 9B and 27B sizes and rebalanced the architecture, and the 27B model in particular drew attention for punching above its parameter count. On community leaderboards at launch, Gemma 2 27B ranked near models substantially larger than itself – a strong showing for a single-GPU-class model. The instruction tuning improved, the chat template stabilised across tooling, and the smaller 9B became a popular choice for cost-controlled deployments where a 70B model was overkill. If you evaluated Gemma once and dismissed it at generation one, Gemma 2 is the point at which that judgement went stale.

Gemma 3 (current as of publication)

Gemma 3, the current generation as of this writing, extends the family into multimodality and longer context. The generation adds image understanding to several sizes and pushes the context window well beyond the earlier models' limits, which matters for document-heavy and retrieval-augmented workloads. Google has continued to publish technical reports with each generation; the Gemma documentation and model cards on ai.google.dev are the authoritative place to confirm exact sizes, context lengths, and modality support, because these specifics shift between point releases. Treat any figure quoted secondhand – including in this article – as time-sensitive and verify it against the current model card.

A note on the future: Google has signalled continued investment in the line, and builders planning multi-year roadmaps should watch for the next generation rather than assume the current one is terminal. The direction of travel – more modalities, longer context, better small-model efficiency – is consistent across releases.

The specialised branches

Three offshoots are worth knowing. PaliGemma pairs a vision encoder with a Gemma language backbone for image captioning, visual question answering, and document understanding. CodeGemma tunes the base models for code completion and generation, competing in the same space as other open code models. RecurrentGemma swaps the pure-transformer backbone for a recurrent architecture (based on Google's Griffin work) that trades some raw quality for dramatically lower memory growth on long sequences – useful when you need to process long inputs on constrained hardware. These are not marketing variants; each targets a real deployment constraint.

Architecture and what's distinctive

At the core, Gemma is a decoder-only transformer – the same broad family as Llama, Mistral, and most open text models. The interesting choices are in the details.

Gemma uses a GeGLU activation in its feed-forward blocks rather than the plain GELU or the SwiGLU common elsewhere. GeGLU is a gated variant that tends to improve quality per parameter, part of why the models perform well relative to their size. The models also use RMSNorm for normalisation and rotary position embeddings, both now standard in the open-weight world.

The more consequential design decision arrived with Gemma 2: an alternating local and global attention pattern. Instead of every layer attending over the full sequence, Gemma 2 interleaves layers that attend only within a sliding local window with layers that attend globally. This cuts the memory and compute cost of long contexts substantially while preserving the model's ability to integrate information across the whole input. It is a pragmatic answer to the quadratic cost of attention, and it is one reason the 27B model stays tractable on a single accelerator. Gemma 2 also employed knowledge distillation during training – the smaller models learned partly from the outputs of a larger teacher, which helps explain why the 9B model performs better than its size would naively predict.

On training data, Google describes a heavily filtered web-scale corpus with deliberate removal of sensitive and personal content, along with the usual mix of code and mathematics. As with every major lab, the exact composition is not fully disclosed, and builders with strict provenance requirements should read the data section of the relevant technical report rather than assume. The curation approach is more conservative than some competitors', which shows up as strong safety behaviour and, occasionally, as over-refusal on benign prompts.

Capability map

The honest summary: Gemma is very good for its size, and size is the whole point.

Where Gemma 27B is competitive. The 27B model is the family's flagship for open deployment, and it holds its own against considerably larger models on general reasoning, instruction following, and multilingual tasks. For teams that want strong quality from a model that fits on a single high-memory GPU, it is one of the more efficient options in the open landscape. On chat-quality comparisons and standard knowledge benchmarks, Gemma 2 and 3 at 27B land in the same neighbourhood as models with far more parameters – a genuine efficiency story rather than a benchmark artifact.

Where it lags Llama 70B. When you have the hardware and budget to run a 70B-class model, the larger Llama models generally retain an edge on the hardest reasoning tasks, long multi-step problems, and the deepest factual recall. Parameter count still buys capability at the top end, and Gemma's design goal is not to beat a 70B model – it is to get close to one at a fraction of the serving cost. If your workload lives at the frontier of difficulty, the bigger model still wins. Meta's family is covered in depth in our piece on Llama, Meta's open model family.

Versus Mistral. Against Mistral's models of similar size, the comparison is closer and more workload-dependent. Mistral tends to be lean and fast, with strong multilingual performance and, in its Mixtral line, a mixture-of-experts approach that delivers high quality per active parameter. Gemma often edges ahead on English instruction following and on the small-model tier, while Mistral frequently wins on raw inference efficiency and European-language coverage. Neither dominates; the right choice depends on your language mix, latency budget, and whether you value the Apache-2.0 cleanliness of Mistral's licensing (more on licensing below). Mistral's approach is examined in our profile of Mistral AI, the European open model lab.

For any of these comparisons, methodology matters more than the leaderboard rank. A model's score depends heavily on the prompt template, the quantization, the sampling settings, and which benchmark you trust. Our guide to AI benchmarks – MMLU, GPQA and the LMSYS Arena explains why two teams can measure the same model and disagree. Before you commit to Gemma over an alternative, run your own evaluation on your own tasks with identical inference settings across candidates. Published numbers are a starting hypothesis, not a verdict.

Running Gemma

Gemma's practical appeal is how easily it slots into the standard open-weight tooling.

The models are supported in llama.cpp, the inference engine that runs quantized models on CPUs and consumer GPUs, which is the fastest path to running Gemma on a laptop or a modest workstation. GGUF quantizations of every Gemma size circulate widely, and llama.cpp underpins the friendly desktop apps – Ollama and LM Studio – that let you pull a Gemma model and chat with it in minutes. For production serving at scale, vLLM is the more common choice: it delivers high-throughput batched inference with paged attention and supports Gemma directly.

On hardware fit, the rough picture as of this writing: the smallest Gemma models run comfortably on a laptop, quantized, with a few gigabytes of memory. The 9B model fits on a single mainstream consumer GPU at 4-bit quantization. The 27B model is the demanding one – it wants a high-memory GPU (24GB or more) for a comfortable quantized deployment, and full-precision serving needs a data-centre-class card. These thresholds move with each new quantization technique, so validate against your specific accelerator rather than trusting a general rule.

Quantization is where Gemma's economics get interesting. Dropping from 16-bit to 4-bit typically shrinks the memory footprint by roughly four times with modest quality loss on most tasks, which is what makes the 27B model a single-GPU proposition at all. The trade-off is real but usually acceptable for production chat and retrieval workloads; for the most precision-sensitive reasoning, test whether the quality drop matters for your use case. If you are building a chat product on top of Gemma, our overview of AI chatbot development frameworks and tutorials covers the surrounding stack.

The Google license

Gemma's license is the part builders most often misunderstand, so here it is in plain English.

The grant itself is broadly permissive, in the spirit of Apache 2.0: you may use, modify, distribute, and commercialise Gemma and models derived from it, including fine-tunes, without paying Google and without a revenue cap. This is more generous than several proprietary offerings and, importantly, imposes no threshold above which the terms change – a contrast worth noting against some competitors' historical clauses.

The catch is that the grant is conditioned on Google's separate Gemma Prohibited Use Policy, referenced from the official Gemma terms of use. Your permission to use the model is contingent on not using it for the prohibited purposes, and – this is the operative part – you must pass those use restrictions downstream to anyone you distribute the model or your derivatives to. The prohibited categories are the expected ones: generating illegal content, targeted harassment, certain categories of high-risk manipulation, and similar abuses. For most legitimate commercial applications the restrictions are irrelevant. But they are legally binding conditions, not suggestions, and they travel with the weights.

Versus the Llama license. Meta's license is, in some respects, cleaner and in others more restrictive. It is also a bespoke community license with its own acceptable-use policy, and its most-discussed clause historically imposed conditions on very large deployments. Gemma's license has no such scale trigger. Where Gemma is arguably less clean is that its permissions are formally conditioned on an external policy document that Google can reference – so the effective terms are the license text plus the current use policy, both of which you should read together. Mistral, by contrast, ships several of its models under a straight Apache 2.0 license with no attached use policy at all, which is the simplest position of the three for legal review. If your legal team prizes minimal conditions above all else, that difference is worth weighing.

The practical guidance: read the actual Gemma terms with counsel before you ship, confirm nothing has changed since this article, and make sure your own product terms pass the restrictions through to your users. This is a fifteen-minute exercise that avoids a real liability.

Gemma in production

Best fit. Gemma shines in cost-controlled, self-hosted inference where you want strong quality without frontier-model serving costs, and in compliance scenarios where the data cannot leave your infrastructure. A 9B or 27B Gemma running on your own GPUs, behind your own network boundary, is a defensible answer to "we cannot send this to an external API." The efficiency of the 27B model at 4-bit quantization makes per-request economics attractive at volume, and the broad tooling support means you are not betting on an exotic runtime. For teams building agentic systems, Gemma can serve as the local reasoning engine in a pipeline – though for the hardest planning tasks you may still route to a larger model, a pattern our coverage of AI agents news and developments explores.

Anti-patterns. Gemma is the wrong default when your workload sits at the top of the difficulty curve and you have the hardware for a 70B-class Llama, which will generally reason more reliably. It is also worth reconsidering if your task is heavily code-centric or reasoning-heavy and a specialised open model – including DeepSeek's reasoning-tuned releases – measurably outperforms Gemma on your evaluation. And if your legal review cannot accommodate an attached use policy, a straight-Apache-2.0 Mistral model removes that friction entirely. The point is not that Gemma is worse; it is that the open-weight field is deep enough that no single model wins everywhere.

Multi-vendor strategy. The mature approach treats Gemma as one option in a portfolio rather than a monogamous commitment. Build your inference layer to route across models – a small Gemma for cheap high-volume tasks, a larger Llama or a frontier API for the hard cases, a specialised model where it clearly wins – and keep the ability to swap as the leaderboard churns. Because Gemma runs on the same tooling as its rivals, adding it to an existing open-weight stack costs little. The broader competitive picture is mapped in our AI companies landscape for 2026, which situates Google's open-model strategy against the rest of the field.

The through-line across every Gemma generation is efficiency: Google is not trying to own the frontier with its open models – Gemini does that – but to offer the best quality that fits on hardware a builder actually has. Judged on that goal, Gemma from the second generation onward is a serious contender, and the sensible move is to benchmark it on your own tasks against Llama and Mistral, read the license before you commit, and let the numbers you measure yourself – not the ones on a leaderboard – decide.