DiffusionGemma: How Google's Open Text Diffusion Model Writes in Parallel and Gives Autoregression Its First Real Rival - June 26, 2026

DiffusionGemma: How Google's Open Text Diffusion Model Writes in Parallel and Gives Autoregression Its First Real Rival Chris and Laura dig into Google DeepMind's DiffusionGemma, an open weights, twenty six billion parameter mixture of experts model that abandons token by token generation and instead denoises whole blocks of text in parallel for up to four times faster output. They unpack how text diffusion works, the eye opening speed numbers on consumer hardware, why Google calls it experimental, and the energy versus speed tradeoff hiding behind the headlines. Hosted by Chris and Laura. The DX Today Podcast brings you daily deep dives into the most consequential stories in the AI ecosystem. Send us fan mail: https://dxtoday.com/contact #AI #OpenSource #DiffusionModels #Gemma #GoogleDeepMind

Transcript

SPEAKER_01 0:00

Welcome to the DX Today Podcast, your daily deep dive into the AI ecosystem. I'm Chris, and joining me as always is Laura.

SPEAKER_00 0:07

Thanks, Chris. I am genuinely excited about today's topic because it gets at something we almost never question, which is the basic way these language models actually put words on the page in the first place.

SPEAKER_01 0:18

That's a great hook, and I'll admit I had never really stopped to think about it. Because for years, the assumption has just been that an AI writes the way we read, which is one word after another from left to right.

SPEAKER_00 0:28

Exactly. And that assumption is precisely what Google Deep Mind just challenged in a really concrete way with a new open weights release. They are calling diffusion Gemma, which landed earlier this month and quietly upends the standard recipe.

SPEAKER_01 0:41

Okay, so before we get into why it matters, help me understand the name itself. Because diffusion is a word I mostly associate with image generators that turn random static into a photograph, not with something that writes text.

SPEAKER_00 0:53

You have put your finger on exactly the right connection because the core idea was borrowed directly from image models, where the system starts with pure noise and then gradually denoises that mess into a coherent picture over many steps.

SPEAKER_01 1:06

So they took that same denoising concept, which works on pixels, and somehow applied it to language, which feels much trickier because words are discrete symbols rather than smooth gradients of color and brightness that you can nudge a little at a time.

SPEAKER_00 1:20

That is the whole technical breakthrough in a nutshell, and the version they use here is called discrete text diffusion, where instead of corrupting and restoring colors, the model corrupts and then restores tokens, which are the little chunks of words that language models work with.

SPEAKER_01 1:34

Let me make sure I understand the contrast clearly because the model everyone is used to, the autoregressive model, generates one token, looks at everything so far, then generates the next token, and just keeps marching forward like that the whole time.

SPEAKER_00 1:47

Right. And that left-to-right march is both the strength and the bottleneck, because every single token has to wait for the one before it to finish, which means you fundamentally cannot generate the fifth word until you have committed to the fourth.

SPEAKER_01 1:59

And I'm guessing that sequential dependency is exactly the wall that diffusion is trying to knock down. Because if you are not forced to go strictly in order, then in principle, you could be working on many parts of the sentence at the very same moment.

SPEAKER_00 2:11

You just described the entire payoff, and the way Diffusion Gemma does it is something they describe as a canvas, where the model lays down a whole block of tokens at once, all of them rough and noisy, and then refines that entire block together in parallel.

SPEAKER_01 2:25

So rather than painting a sentence one careful letter at a time, it is more like sketching the rough shape of the whole paragraph first and then sharpening every part of that sketch simultaneously until the blur resolves into actual readable words.

SPEAKER_00 2:40

That is a beautiful way to put it. And the specific number here is striking because the model can work on as many as 256 tokens in parallel within a single canvas, which is a dramatically different rhythm from one at a time. It absolutely does. And this is where the headline numbers come in. Because diffusion Gemma can produce text up to four times faster than a comparable traditional model, clocking over a thousand tokens per second on a single high-end data center chip.

SPEAKER_01 3:21

A thousand tokens per second is a number that is honestly hard to picture. So can you ground that for me in terms of what it would feel like for someone actually waiting on a response from a chatbot or a coding assistant?

SPEAKER_00 3:33

Sure, a thousand tokens per second is roughly several hundred words appearing in the blink of an eye. So instead of watching text dribble out word by word the way we all do today, an entire detailed answer would essentially materialize almost instantly on your screen.

SPEAKER_01 3:47

And I noticed you said high-end data centers chip, which made me wonder whether this speed is something locked away inside Google's giant server farms, or whether ordinary developers with the kind of hardware a gamer might own can actually run this thing.

SPEAKER_00 4:02

That is the part that genuinely surprised me, because they reported more than 700 tokens per second on a consumer graphics card, the kind of card a serious gamer or a hobbyist developer might already have sitting under their desk at home.

SPEAKER_01 4:15

This, that is a meaningful detail because so much of the cutting edge in this field feels completely out of reach for individuals. So the idea that this runs on a card you can actually buy at a store changes who gets to experiment with it.

SPEAKER_00 4:27

It really does, and it gets even better on the accessibility front because when the model is quantized, which is a compression technique that shrinks how much memory it needs, it fits comfortably within the memory budget of those same consumer cards rather than demanding a server rack.

SPEAKER_01 4:42

Let's talk about the model itself for a second, because I keep hearing the figure 26 billion thrown around, and I want to understand whether that means this is a genuinely enormous model, or whether there's some clever trick hiding behind that big number.

SPEAKER_00 4:54

There is absolutely a clever trick, and it is called a mixture of experts design, where the model technically contains 26 billion parameters in total, but for any given piece of text, it only switches on a much smaller slice, around 3.8 billion of them.

SPEAKER_01 5:10

So it is a little like having a giant team of specialists on staff, where you do not pay to wake up the entire building for every question. You just summon the handful of experts who actually know about the topic in front of you right now.

SPEAKER_00 5:21

That analogy is spot on, and that selective activation is a huge part of why it can be both knowledgeable and fast at the same time, because you get the breadth of a large model without paying the full computational bill on every single request you send it.

SPEAKER_01 5:35

Now, here is what I think is the most important word in this entire story, and that word is open. Because Google did not just write a paper bragging about this. They actually released the weights under a genuinely permissive license for anyone to download.

SPEAKER_00 5:48

That is arguably the real headline because they put it out under the Apache 2 license on Hugging Face, on Kaggle, and through Google's cloud platform, which means a student, a startup, or a researcher can grab it today and start tinkering without asking permission.

SPEAKER_01 6:04

And the reason that matters so much is that there have been fast diffusion text systems before from a couple of companies, but they were all locked behind closed doors. So nobody on the outside could really study how the speed was actually being achieved.

SPEAKER_00 6:17

Precisely. And that closed nature meant the open source community kept hearing that diffusion text generation was fast and promising, but they could never actually get their hands on the real thing to verify it, build on it, or push the technique forward themselves.

SPEAKER_01 6:31

So, in a sense, the significance here is less about this one specific model being perfect and more about an entire research community suddenly getting a working, inspectable example of a technique that was previously just tantalizing rumors and impressive but unreproducible demonstrations.

SPEAKER_00 6:47

That framing is exactly right. And I think that is why a lot of researchers reacted to this with real enthusiasm. Because handing the community a concrete artifact tends to unlock a wave of follow-on experiments that no single company could ever produce on its own.

SPEAKER_01 7:02

I want to push back a little though and play devil's advocate because whenever a new approach claims to be several times faster than the established way of doing things, my instinct is to ask, what exactly are we giving up to get that speed?

SPEAKER_00 7:14

That is the right instinct to have, and you should absolutely hold on to your skepticism here, because Google themselves were unusually candid about the trade-offs and explicitly labeled this release as experimental rather than something they would recommend for serious production use today.

SPEAKER_01 7:29

That is a striking thing for a company to say about its own launch. So what specifically did they recommend instead? And what does that tell us about how confident they really are in the quality of the text this thing produces?

SPEAKER_00 7:41

They pointed people toward their standard auto-regressive model for any situation where the polish and reliability of the output matters more than raw speed, which is essentially an admission that the diffusion version trades away a bit of quality in exchange for that velocity.

SPEAKER_01 7:55

And there is an even deeper irony lurking underneath the speed claims that I want to make sure our listeners understand, because faster on the clock does not automatically mean cheaper or more efficient in terms of the actual computing work being done.

SPEAKER_00 8:09

You are absolutely right to flag that, because the dirty secret of diffusion is that getting the final answer can require many passes through the network to denoise the canvas, which means it can burn substantially more raw compute than a lean auto-regressive model would.

SPEAKER_01 8:23

So we could end up in a strange situation where a diffusion model finishes the wall clock race first and delivers the answer to the user sooner, while simultaneously consuming more total energy and more chip cycles to cross that finish line.

SPEAKER_00 8:35

That is the tension, exactly. And researchers are openly wrestling with it. Because some studies suggest current diffusion implementations can use anywhere from two to ten times more compute than a well-optimized autoregressive system, despite their theoretical advantage and parallelism.

SPEAKER_01 8:51

That number really reframes the whole conversation for me. Because in an era where everyone is worried about the energy footprint of AI and the strain on the power grid, trading energy for speed is not obviously a win in every context.

SPEAKER_00 9:05

It is genuinely context dependent. And I think that is the mature way to look at it. Because if you are an interactive application where a human is impatiently waiting, shaving seconds off the response is enormously valuable, even at some extra energy cost.

SPEAKER_01 9:19

Whereas if you're running a massive batch job overnight, churning through millions of documents where nobody is sitting there watching, then raw efficiency probably matters far more than how snappy each individual response happens to feel in the moment.

SPEAKER_00 9:33

Exactly. And that is why I do not think diffusion is going to simply replace auto regression across the board, but rather it is going to carve out the niches where its particular profile of strengths and weaknesses lines up best with the actual job.

SPEAKER_01 9:46

There is one more capability I want to touch on before we wrap, because I read that this model is not just a text-in, text-out system, but that it can actually take in images and even video as part of its input.

SPEAKER_00 9:58

Yes, it is multimodal on the input side. So you can feed it text, images, and video, and it produces text as the output, which means you could hand it a video clip and ask it to describe or analyze what is happening inside it.

SPEAKER_01 10:11

That combination feels significant because pairing the speed of diffusion with the ability to digest rich visual information starts to point toward applications like real-time video understanding, where lag has always been the thing that made those experiences feel clunky and frustrating.

SPEAKER_00 10:26

That is a genuinely exciting frontier, and it is exactly the kind of use case where the parallel generation could shine. Because describing a fast-moving scene as it unfolds is precisely the situation where waiting for slow sequential text generation breaks the whole illusion.

SPEAKER_01 10:41

So if I try to zoom all the way out and summarize where this leaves us, it sounds like the big story is not that auto regression is dead, but that the field is finally getting a serious open second option for how machines generate language.

SPEAKER_00 10:55

I think that is the perfect summary because for years there has been essentially one dominant paradigm. And now an entire community has a credible, downloadable alternative to study, which historically is how a quiet research curiosity eventually matures into a real production technology.

SPEAKER_01 11:12

And what I love about that framing is that it puts the power in the hands of thousands of independent researchers rather than a single lab. So the next breakthrough in making diffusion practical could come from absolutely anywhere, including someone working alone at home.

SPEAKER_00 11:26

That democratization is the part that gives me the most optimism because the history of open releases shows that when you hand a powerful tool to a huge and curious crowd, the collective creativity almost always outpaces what any one organization could have planned alone.

SPEAKER_01 11:41

It is a great reminder that sometimes the most important releases are not the flashiest or the most polished, but the ones that quietly hand the broader community a new set of building blocks and then simply step back to see what gets built.

SPEAKER_00 11:53

Couldn't agree more, and my honest advice to anyone listening who has even a passing interest in this is to go read the technical details for yourself. Because watching a fundamental assumption get questioned in real time is one of the joys of following this field.

SPEAKER_01 12:06

That's all for today's episode of the DX Today Podcast. Thanks for listening, and we'll see you next time.