DiffusionGemma: Google's open model writes whole text blocks instead of word by word

What's going on

Google DeepMind has released a new member of the open Gemma 4 family that works fundamentally differently from almost every chatbot out there today: DiffusionGemma. Instead of writing text word by word from left to right, the model generates whole blocks of text at once and refines them over several passes until readable text emerges. The goal is speed: Google promises up to four times faster text output than conventional models of the same size.

The model is explicitly labeled experimental and aimed at developers and researchers, not end users. The weights are available on Hugging Face and GitHub under the permissive Apache 2.0 license, so you can use, modify and redistribute them, including commercially. You can also use DiffusionGemma in the cloud through Google Cloud Model Garden and Nvidia NIM.

How diffusion works for text

Nearly all large language models are autoregressive: they generate one token (a piece of a word) after another, and each new token depends on all the previous ones. It's a bit like typing on a typewriter. Google researchers Brendan O'Donoghue and Sebastian Flennerhag describe the difference in their blog post like this:

It turns model inference from a single, sequential typewriter into a massive printing press that stamps out the entire block of text at once.

DiffusionGemma borrows its approach from AI image generators. Those start with pure image noise and remove it step by step until a picture emerges. With DiffusionGemma, the starting point is a "canvas of random placeholder tokens" – unreadable gibberish. Over several passes, the model works out which tokens it can already predict with confidence and uses them to make better guesses about the rest. The end result is a "denoised" block of up to 256 tokens.

On top of that, it has two properties that conventional models lack:

• Bidirectional attention: every token in the block can "see" all the others, including ones that come later in the text. That gives the model an overview of the whole passage instead of just what's been written so far.
• Self-correction: using a kind of confidence score, the model re-checks tokens in the next pass and can fix contradictions within the same block, instead of just "dragging" an error along the way an autoregressive model does.

Technically, this moves the bottleneck. With autoregressive models, the main brake is memory bandwidth: the GPU keeps waiting for data to load from memory and only computes a single token per step. DiffusionGemma gives the chip much more computational work per pass, which keeps a single GPU busier. According to Computerworld, GPUs and TPUs are often underutilized in local, single-user scenarios.

Numbers and tech

DiffusionGemma builds on Gemma 4 and Google's research project Gemini Diffusion. It's a mixture-of-experts (MoE) model: the network consists of many specialized sub-networks ("experts"), and only a few of them work on each computation step.

According to Ars Technica, that's roughly four times the output of similarly sized autoregressive Gemma models. The sources don't include any independent measurements; the speed figures come from Google.

What the model is for

Google sees its strengths mainly in tasks that aren't strictly linear:

• Code infilling: filling in missing pieces in the middle of existing code while taking into account the code before and after.
• Inline editing: revising text or code right where it is.
• Structured formats like JSON, where brackets and fields have to line up at the end.
• Mathematical graphs, logic problems and, according to Pulse2 and Ars Technica, sequences of amino acids and molecules.

As a showcase, Google fine-tuned the model on Sudoku. That's notoriously hard for conventional models because every number depends on cells that only get "written" later. DiffusionGemma, by contrast, can look at the entire grid at once and keep correcting it. Technology analyst Carmi Levy told Computerworld this shows "quite impressively" that the model can tackle more complex problems too. He also points to a built-in thinking mode that helps with problem solving.

Google also mentions real-time applications, built-in writing and coding assistants, and fast iteration loops. Levy sees potential in customer service, for example, where fast local answers matter, and on cost: per-token billing punishes inefficient solutions, and DiffusionGemma could usher in "a new generation of task-specific, efficient solutions."

The catches

Google doesn't hide the trade-offs:

• Lower quality: The answers are worse than those of regular Gemma 4. If you need maximum accuracy, Google says to stick with autoregressive Gemma 4. DiffusionGemma is explicitly not a replacement for Gemma or Gemini.
• Only an advantage at low loads: The model is optimized for small to medium batch sizes on a single powerful accelerator. In cloud environments with very many requests per second, Google says parallel generation offers "diminishing returns" and can even lead to higher operating costs. GPUs there are already well utilized anyway.
• No cost figures: Google doesn't give concrete operating costs.

Levy believes the lower precision can be partly offset with additional refinement passes, but the sources don't back that up.

What you need to try it

Quantized – that is, shrunk by storing the model's numbers at lower precision – DiffusionGemma needs about 18 GB of VRAM, according to Google. Cards like the RTX 4090 (24 GB) or RTX 5090 (32 GB), which Google and Nvidia optimized the model for, can handle that. Cards with 8, 12 or 16 GB won't cut it. Unquantized, a 26-billion-parameter model needs a lot more (roughly 50 GB and up), which is only realistic on pro hardware like H100s or DGX systems. Plan on about 32 GB of RAM and, depending on the variant, 15 to 55 GB of disk space.

On the software side, Hugging Face Transformers, vLLM and MLX are supported. The latter means Macs with Apple Silicon and enough unified memory (32 GB or more makes sense) are an option too. llama.cpp support has only been announced so far, so tools built on it, like Ollama or LM Studio, probably can't load the model out of the box yet. For fine-tuning, Google lists Hackable Diffusion, Unsloth and Nvidia NeMo. Running on CPU alone makes no sense, since the speed advantage depends on the GPU. In Google Colab, the free T4 GPU (16 GB) isn't enough; an A100 or L4 from the paid tiers is a better bet.

The bigger picture

Diffusion language models aren't entirely new. Google itself has done research with Gemini Diffusion, and startups are working on the approach too. What's new is a major vendor releasing a model like this at this size with open weights and a permissive license. For the first time, developers can broadly test how diffusion holds up for everyday text work – on a single gaming GPU.

That's especially interesting for tools where every second of waiting gets in the way: code completion in the editor, text revision, form and JSON output. The caveats: all speed figures are vendor claims, head-to-head quality benchmarks are missing from the sources, and Google itself rates the quality below Gemma 4. If you just want a good local chatbot, a conventional model is the better choice for now. But if you want to see where language models might go beyond word-by-word writing, DiffusionGemma is one of the most exciting open experiments of the year.