Google DeepMind just dropped something that changes how we think about text generation. DiffusionGemma, released June 10, 2026 under Apache 2.0, is the first major open-source text diffusion model — and it generates text 4x faster than traditional autoregressive models. We’re talking 1,000+ tokens per second on consumer NVIDIA RTX GPUs.

If you’ve been following the local AI space, you know speed has always been the bottleneck. Autoregressive models generate one token at a time, sequentially. DiffusionGemma throws that entire paradigm out the window. Let me walk you through everything you need to know.

What is DiffusionGemma?

DiffusionGemma is a Mixture-of-Experts (MoE) language model with 26 billion total parameters, but only 3.8 billion active per token. It uses a completely different generation method called Uniform State Diffusion — instead of predicting one token at a time left-to-right like GPT or Gemma 4, it starts with random placeholder tokens and iteratively refines ALL of them in parallel across multiple denoising passes.

Think of it like image diffusion models (Stable Diffusion, DALL-E), but for text. You start with noise, and through several refinement steps, coherent text emerges — all at once, not word by word.

This is a collaboration between Google DeepMind and NVIDIA, optimized specifically for local inference on RTX hardware. You can read the official announcement at deepmind.google/blog/diffusiongemma-4x-faster-text-generation/ and the developer guide at developers.googleblog.com/en/diffusiongemma-the-developer-guide/.

Architecture and Specifications

Here’s what’s under the hood:

Spec	Value
Total Parameters	26B
Active Parameters/Token	3.8B
Architecture	Mixture-of-Experts (MoE)
Generation Method	Uniform State Diffusion
VRAM Requirement	18GB
Data Format	NVFP4
License	Apache 2.0
Optimized Hardware	NVIDIA RTX PRO, DGX Spark, GeForce RTX

The MoE architecture is key here. With only 3.8B parameters active per token, you get the knowledge capacity of a 26B model with the computational cost closer to a 4B model. Combined with the parallel generation approach, this is why the speed numbers are so dramatic.

If you want to understand how VRAM requirements work for models like this, check out our guide on how much VRAM AI models need.

How Uniform State Diffusion Works

Traditional autoregressive models (Gemma, Llama, Qwen, GPT) generate text like typing on a keyboard — one token after another, each dependent on all previous tokens. This creates an inherent sequential bottleneck. No matter how fast your GPU is, you’re limited by this chain of dependencies.

DiffusionGemma works differently:

1. Initialization: Start with a sequence of random placeholder tokens (the “noisy” state)
2. Parallel Refinement: In each denoising pass, ALL tokens are updated simultaneously
3. Iterative Convergence: After multiple passes (typically 10-20), the random noise converges into coherent, high-quality text

Because every token is refined in parallel, you can leverage GPU parallelism far more effectively than autoregressive generation. GPUs are designed for massively parallel computation — autoregressive decoding barely scratches that capability.

For a deeper dive into how this differs from standard LLM inference, read our LLM inference explained article.

Speed Benchmarks and Claims

Google claims 4x faster generation compared to autoregressive models of equivalent quality, with throughput exceeding 1,000 tokens per second on NVIDIA RTX GPUs. Let’s put that in perspective:

• A typical 7B autoregressive model on RTX 4090: ~80-120 tokens/sec
• A 27B autoregressive model on RTX 4090: ~30-50 tokens/sec
• DiffusionGemma (26B total, 3.8B active) on RTX hardware: 1,000+ tokens/sec

That’s not a small improvement — it’s an order of magnitude faster. The combination of MoE (fewer active parameters) and parallel diffusion (all tokens generated simultaneously) creates a multiplicative speedup.

The NVFP4 data format keeps memory usage at 18GB, making it accessible on cards like the RTX 4090 (24GB), RTX 5090 (32GB), and the new RTX PRO series. For context on GPU selection for local AI, see our GPU vs CPU AI inference guide.

How to Use DiffusionGemma

Since this is optimized for NVIDIA’s ecosystem, the primary path is through the RTX AI Garage. Here’s the general workflow:

# Install dependencies (NVIDIA toolkit required)
pip install diffusiongemma

# Basic generation
from diffusiongemma import DiffusionGemmaModel

model = DiffusionGemmaModel.from_pretrained("google/diffusiongemma-26b-nvfp4")
output = model.generate(
    prompt="Explain quantum computing in simple terms",
    num_diffusion_steps=16,
    max_tokens=512
)
print(output)

The num_diffusion_steps parameter controls quality vs speed. More steps = better quality but slower. Fewer steps = faster but potentially less coherent. The sweet spot seems to be 12-20 steps for most use cases.

For a complete local setup walkthrough, see our how to run DiffusionGemma locally guide. If you’re comparing inference backends, our vLLM vs Ollama vs llama.cpp vs TGI comparison covers the landscape.

Limitations and What to Expect

Let me be real with you: DiffusionGemma is experimental. This is the first major open text diffusion model, and Google explicitly notes that quality may not match top autoregressive models on all tasks yet.

Here’s what that means in practice:

• Reasoning tasks: Autoregressive models may still have an edge on complex multi-step reasoning, since they can “think” sequentially
• Instruction following: Early reports suggest slightly less precise instruction following compared to Gemma 4 27B
• Creative writing: Mixed results — sometimes surprisingly good, sometimes repetitive
• Code generation: Viable for boilerplate and simple functions, but may struggle with complex algorithmic problems
• Factual accuracy: On par with autoregressive models of similar effective parameter count

The tradeoff is clear: you get dramatically faster generation at the cost of some quality degradation on complex tasks. For many applications — drafting, summarization, chatbots, content generation — the speed advantage may far outweigh the quality gap.

When Should You Use DiffusionGemma?

DiffusionGemma shines when:

• Latency matters more than peak quality: Real-time chatbots, interactive applications
• Batch generation: Producing many outputs quickly (content pipelines, data augmentation)
• Drafting and iteration: Generate fast drafts, then refine with a slower, higher-quality model
• Local inference with speed requirements: When cloud API latency is unacceptable

It’s less ideal when:

• You need maximum accuracy on reasoning benchmarks
• You’re doing complex code generation that requires careful step-by-step logic
• You need the absolute best quality regardless of speed

For coding-specific tasks, you might want to check our best AI models for coding locally roundup to compare options.

DiffusionGemma vs The Competition

How does DiffusionGemma stack up against other models in a similar size class?

Model	Params (Active)	Speed	Quality	VRAM
DiffusionGemma	26B (3.8B)	★★★★★	★★★☆☆	18GB
Gemma 4 27B	27B (27B)	★★★☆☆	★★★★★	20-24GB
Qwen 3.7 27B	27B (varies)	★★★☆☆	★★★★☆	20-24GB
DeepSeek V4 Flash	Large MoE	★★★★☆	★★★★☆	Cloud

For detailed comparisons, check out our articles on DiffusionGemma vs Gemma 4 27B and DiffusionGemma vs DeepSeek V4 Flash.

The Bigger Picture

DiffusionGemma isn’t just another model release — it’s a signal that the industry is seriously exploring alternatives to autoregressive generation. If text diffusion can reach quality parity with autoregressive models (which many researchers believe is achievable), it would fundamentally change how we deploy LLMs.

Imagine local models running at 1,000+ tokens/second with quality matching GPT-4 class outputs. That future is no longer theoretical — DiffusionGemma is the first concrete step toward it.

The Apache 2.0 license means the community can build on this. Expect quantized variants, fine-tuned versions, and integration into existing inference frameworks in the coming weeks.

Frequently Asked Questions

Is DiffusionGemma better than Gemma 4 27B?

Not “better” — different. DiffusionGemma is dramatically faster (4x) but currently lower quality on complex reasoning tasks. Gemma 4 27B remains the better choice when you need maximum accuracy and don’t mind slower generation. DiffusionGemma is better when speed and throughput are your priority.

Can I run DiffusionGemma on Mac Apple Silicon?

DiffusionGemma is currently optimized for NVIDIA RTX hardware using the NVFP4 data format. While it may be possible to run it on Apple Silicon through community efforts, the speed advantages are specifically tied to NVIDIA GPU parallelism. For Mac-optimized models, see our best AI models for Mac M4 guide.

How does text diffusion differ from image diffusion?

The core concept is the same — start with noise, iteratively denoise to produce output. The difference is the modality: image diffusion works in continuous pixel space, while text diffusion works in discrete token space. DiffusionGemma uses “Uniform State Diffusion” which starts with random placeholder tokens and refines them into coherent text through parallel denoising passes.

Is DiffusionGemma good for coding?

It’s viable for simpler code generation tasks like boilerplate, templates, and straightforward functions. For complex algorithmic problems or precise instruction following, autoregressive models like Gemma 4 27B or Qwen 3.7 still have an edge. The speed advantage makes it interesting for rapid prototyping workflows.

What GPUs can run DiffusionGemma?

Any NVIDIA GPU with 18GB+ VRAM: RTX 4090 (24GB), RTX 5090 (32GB), RTX PRO series, RTX A5000/A6000, and NVIDIA DGX Spark. The model uses NVFP4 quantization to fit in 18GB. Check our NVIDIA RTX Spark complete guide for details on that hardware.

Will DiffusionGemma be available on Ollama?

As of launch day, DiffusionGemma requires specialized inference code due to its non-autoregressive generation method. Standard frameworks like Ollama are designed for autoregressive models. Integration with popular tools will depend on community and framework developers adding diffusion-based generation support.

Final Thoughts

DiffusionGemma is a genuinely exciting release. Not because it’s the best model available today — it’s not — but because it proves text diffusion works at scale with open weights. The 4x speed improvement is real and meaningful for production workloads where latency matters.

If you’re running local AI inference and speed is your constraint, DiffusionGemma deserves a spot in your toolkit. Just go in with appropriate expectations: this is generation one of a new paradigm, and it will only get better from here.