Google's DiffusionGemma Generates Text in Parallel Blocks

Google DeepMind released DiffusionGemma on June 10, 2026, an experimental open language model that drafts whole blocks of text in parallel rather than word by word. The approach matters because it changes where generation slows down, and it lets the model revisit uncertain passages before settling on a final answer.

According to MachineLearningMastery, DiffusionGemma applies a diffusion process familiar from image generation to language. Instead of committing to each token as soon as it is produced, the model begins with a noisy canvas and gradually refines it. That shift is the central idea in the hands-on walkthrough, and it has practical consequences for speed, hardware use, and the kinds of mistakes a model can correct.

What is DiffusionGemma?

DiffusionGemma is an experimental, open model from Google DeepMind, described by MachineLearningMastery as a research and development preview rather than a finished product. It is built on the architecture of Gemma 4 26B, a mixture-of-experts design with 26 billion total parameters but only 3.8 billion active for each token. The A4B part of the name refers to that active-parameter figure.

The model is released under the Apache 2.0 license, which MachineLearningMastery notes is permissive enough for most commercial and research use. The article also advises readers to check Gemma's prohibited use policy before putting the model in front of customers, since a permissive license and an acceptable-use policy are separate considerations.

On input, DiffusionGemma is multimodal: it accepts text, images at variable aspect ratio and resolution, and video, but not audio. Its output is always text. It also includes a built-in thinking mode that can be configured, allowing the model to work through a problem in a separate reasoning channel before presenting a final answer. For developers, that combination makes it more than a novelty in generation order; it is a model intended for experiments with prompts, images, video, and step-by-step reasoning in the same system.

How does diffusion generation differ from standard generation?

Most major language models, including GPT, Claude, Gemini, and standard Gemma models, generate autoregressively. They produce one token, append it to the sequence, process the sequence again, and produce the next token. MachineLearningMastery explains that, especially for a single user running a model locally, the limiting factor in that loop is usually memory bandwidth rather than compute. The weights must be loaded repeatedly to produce each token, while the compute cores spend much of their time waiting for data.

DiffusionGemma reverses that pattern. It starts with 256 placeholder tokens, described as essentially random noise, and refines the entire block at once over multiple passes. Under Uniform State Diffusion, as Google calls it, tokens the model is more confident about help settle tokens it is less sure about. The result gradually takes shape as a whole, rather than being fixed left to right from the start.

That change moves the bottleneck from memory bandwidth toward compute, because the hardware now has a large parallel task. It also changes the error behaviour of the model. An autoregressive system cannot go back and change a token once it has been written, which can lead it into a corner later in a complex answer. Within a diffusion block, a token whose confidence drops can be re-noised and reconsidered. For writers and developers, that self-correction may be as important as any speed claim.

How does it handle text longer than one block?

A 256-token canvas is not enough for most useful responses, so DiffusionGemma uses block-autoregressive denoising for longer sequences. Once a block has resolved, it is committed to the model's KV cache using causal attention, the same general mechanism used by a standard autoregressive model. A new 256-token canvas then begins, conditioned on everything already committed.

The distinction between the two kinds of attention is important. Committed history is handled causally and sequentially, which helps keep long-form generation stable. Tokens inside the active canvas can attend to each other in both directions, which supports parallel refinement and revision. In practical terms, the model is not abandoning sequential generation altogether. It is combining sequential commitment between blocks with parallel, bidirectional work inside each block.

For users, this hybrid design suggests a different mental model from either a conventional chatbot or an image generator. The output appears in chunks that are internally revisable, while earlier chunks provide the context for later ones. Anyone evaluating the model should therefore look beyond a single speed figure and ask how quality holds up across block boundaries, how often revision helps, and whether the thinking mode changes the final answer.

What hardware and software do you need to run it?

MachineLearningMastery separates the full model from the quantized build. Google's own cookbook notebook specifies a GPU with more than 60GB of memory, such as an A100 or H100-class card, for the unquantized version. For local use, the quantized build is presented as the realistic option, fitting within an 18GB VRAM budget and within reach of a single high-end consumer card such as an RTX 4090 or 5090.

The software requirements are specific. The walkthrough installs PyTorch and Accelerate, and requires transformers 5.11.0 or newer. That version floor is not optional in the article's account, because DiffusionGemma's block-diffusion architecture needs model classes that older versions do not recognise. Loading the model uses a dedicated class, DiffusionGemmaForBlockDiffusion, rather than the standard causal language-model class, along with AutoProcessor instead of a plain tokenizer because image and video inputs must be handled as well as text.

The article also covers serving the model with vLLM and explains what Google's recommended sampling settings do. For teams planning production use, that serving path matters as much as the local experiment. A model that is interesting on a workstation still needs a reliable way to handle requests, memory, and sampling choices when other people depend on it.

How can you explore the idea in Grafy?

There is no direct claim that Grafy offers DiffusionGemma itself, so the most useful Grafy route is comparative and practical. In Grafy Chat, you can put several models side by side on the same prompt and observe how different generation approaches handle revision, length, and reasoning. That makes it easier to judge whether parallel block generation offers a visible advantage for a particular task, rather than relying on a headline claim.

For the hands-on side, Grafy Code is the natural place to work through the technical walkthrough: installing the required libraries, loading the model class described in the source, generating a first response, and using a diffusion streamer to watch the process unfold. You can also use Reader to study the MachineLearningMastery walkthrough and related papers or PDFs, asking questions about block denoising, sampling, and serving while you experiment. Together, those tools let a reader move from understanding the mechanism to testing it against familiar autoregressive models.

Frequently asked questions

Does DiffusionGemma generate text one token at a time like a standard language model?

No. According to MachineLearningMastery, DiffusionGemma starts with a canvas of 256 placeholder tokens and denoises that block in parallel across multiple passes. For longer outputs, it commits one resolved block and starts another, rather than appending a single token and feeding the whole sequence back in for the next step.

Is DiffusionGemma built on Gemma 4 26B?

Yes. MachineLearningMastery reports that DiffusionGemma uses the same architecture as Gemma 4 26B, a mixture-of-experts design with 26 billion total parameters and 3.8 billion active for each token. That active count explains the A4B label attached to the model name, while the total size describes the full parameter set.

Can DiffusionGemma revise a token after it has started forming an answer?

Yes, within an active block. If confidence in a token falls during denoising, the sampler can re-noise it and let the model try again. That self-correction is different from an autoregressive model, where a committed token stays in place and cannot be revisited once generation moves on.

Source: MachineLearningMastery

---

Source: MachineLearningMastery — DiffusionGemma: Hands-On with Google’s Text Model That Writes All at Once