OUI-1: The First Open-Weights Model for Generative UI

On September 8, 2026, Rabi Shanker Guha — CEO of Thesys (thesys.dev), previously the founder of a payments startup acquired by Google, IIT Kanpur — announced OUI-1 on X: what he called "the first open-weights model for Generative UI." The pitch: 71.7% on a benchmark called Generative UI Bench, at 4B active parameters, beating Gemma 4 31B with 8x fewer active params, and scoring 5.5x the base model it was fine-tuned from.

"We can finally make AI that's not a chatbot" — Rabi Shanker Guha, on X, framing generative UI as a distinct product category from chat.

That base model is DiffusionGemma, Google's experimental diffusion-based text model. A reply on the thread asked about hosting OUI-1 on Cerebras — the wafer-scale inference company already running Gemma 4 31B at 1,851 tokens/sec — and Guha confirmed Cerebras hasn't shipped a diffusion-based model yet, but he'd like to make that happen. That confirms OUI-1's diffusion architecture, and it's a real technical hook: diffusion language models denoise a fixed-size block in parallel rather than committing one token at a time, which fits structured, templated output — like a UI component tree — better than it fits open-ended prose.

We went and read Thesys's actual OUI-1 launch post and its published benchmark methodology rather than taking the compressed tweet numbers at face value. Here's what holds up, what needs a caveat, and what's still an open question.

TL;DR

What OUI-1 actually is

OUI-1 is a fine-tune of DiffusionGemma — 26B total parameters, roughly 4B active — trained to write UI in openui-lang, Thesys's own compact, streaming-friendly format for describing component trees (as opposed to raw HTML/CSS/JS or verbose JSON). It targets consumer hardware: Thesys states it runs on an RTX 5090 at FP8.

This is the same generative-UI category Google's Gemini 3 "dynamic view" and Antigravity's Interactive Generative UI Artifacts occupy — a model producing an interactive interface in response to a prompt, not text a chat window renders as markdown. Where those are proprietary systems bolted onto closed frontier models, OUI-1 is the first attempt at a small, open, purpose-built model for the same job. Runway's Solaris, announced the week before, takes a completely different approach to the same broad problem — generating UI as video frames instead of structured code or markup — worth knowing about as a contrast, not a competitor on the same axis.

Training pipeline (per Thesys's own writeup)

Thesys describes three phases:

1. Supervised fine-tuning on roughly 700 hand-built examples spanning seven component libraries.
2. Self-distillation — rejection-sampled self-training with repair, using parser feedback (does the output actually parse, resolve, and validate as valid openui-lang?) as the training signal.
3. Generalization to 27 component libraries beyond the original seven.

Thesys is candid about one wrinkle worth repeating rather than glossing over: after the initial SFT pass, latency regressed from DiffusionGemma's base 1.6 seconds to 4.3 seconds, before the self-distillation phase recovered it to roughly 1.9 seconds — still with about 28% more output tokens than the base model. That's a real, reported cost of specialization, and it means OUI-1 today is slightly slower than the model it's built on, not faster.

Why a diffusion base model is a genuinely interesting choice here

This is the part of the story worth more than a tweet's compression. DiffusionGemma generates text by denoising a fixed-size block — 256 tokens — in parallel, using bidirectional attention within the block, rather than committing one token at a time the way autoregressive models do. Google's own framing of that trade-off: DiffusionGemma trails standard Gemma 4 on most open-ended benchmarks (MMLU Pro, AIME) but edges ahead on structured tasks like code infilling, where the output has a known shape and self-correction inside a block matters more than long-range reasoning.

A UI component tree is exactly that kind of structured, shape-constrained output — a fixed grammar of allowed component types, prop schemas, and reference resolution rules, not free-form prose. That's a plausible reason a diffusion base transfers well to generative UI specifically: the model can revise a masked token mid-block instead of being stuck with a wrong component name it already autoregressively committed to. It's a coherent technical bet, not just a "we had DiffusionGemma lying around" choice — even if Thesys's own benchmark is the only evidence for it so far.

The benchmark numbers, in full — not just the ones in the tweet

Guha's thread cited 71.7% and "5.5x the base." The full table from Thesys's own benchmark page tells a more complete story:

Two things are both true here. OUI-1's efficiency claim checks out: at 4B active parameters it beats a 31B dense model by 25 points, and beats the 4B base it was fine-tuned from by 5.5x — that's the headline, and it's real, sourced from Thesys's own published table. OUI-1 is not the top scorer overall: Qwen3.8 27B, a 27B general-purpose model with no generative-UI-specific fine-tuning mentioned, scores higher. Guha's tweet leads with the comparisons OUI-1 wins (Gemma 4, its own base) and doesn't mention the one it loses. That's normal launch-thread framing, not a fabrication — but a reader deciding whether to actually deploy OUI-1 should know Qwen3.8 27B is sitting above it on the same chart.

Thesys also reports a second, more product-shaped data point: on 60 previously unseen prompts from an "AppLess" prompt library, OUI-1 produced 55 valid outputs versus DiffusionGemma's 23. That's closer to a real-world reliability metric than a percentage score, and the gap is large enough to be meaningful even accounting for small-sample noise.

Is "Generative UI Bench" independent? No — and that matters

Thesys built Generative UI Bench, hosts it at openui.com/benchmarks, and states the benchmark draws in part from "real production data: OpenUI Cloud traffic." There is no third-party research group, academic lab, or independent leaderboard behind the 71.7% figure — it's Thesys grading its own model against a small set of comparison models, on a test Thesys wrote, using data from Thesys's own product.

This is the same caution this blog has flagged before with other vendor-created evals: a self-reported score on a self-built benchmark isn't evidence of fraud, but it isn't independent verification either. The methodology page does document real, checkable criteria — does output parse, does every reference resolve, are there orphaned or invented components, are props missing or out of range — which is more rigorous than a black-box "we scored X%" claim with no rubric at all. That's a point in Thesys's favor. What it doesn't have is anyone outside Thesys running the eval and confirming the number independently, which is a different and lower bar than what "benchmark" usually implies when the phrase gets used in a launch tweet without qualification.

The unanswered system-prompt question

A reply on Guha's thread raised a specific, fair methodology concern: what did the eval look like against the base model with a decent system prompt? In other words — was Gemma 4 31B and base DiffusionGemma given a well-crafted, generative-UI-optimized system prompt in the comparison, or an out-of-the-box one? That distinction matters enormously for a benchmark like this, since a competently prompted general model can often close much of the gap against a narrow fine-tune.

We checked Thesys's published methodology page directly for an answer. It documents scoring criteria (parsing, reference resolution, prop validation) in detail, and notes each competing format "uses the prompt generated by its own SDK," receiving "the same two worked examples" — but it does not specifically address whether the base-model comparisons (Gemma 4 31B, DiffusionGemma) were run with a deliberately optimized system prompt or a default one. The question went unanswered in the thread as of this writing. We're flagging it as open, not resolving it in either direction — don't read the 71.7% vs 46.7% gap as settled until Thesys clarifies this.

Latency: the streaming claim vs the published numbers

Guha's thread described OUI-1's streaming as feeling "instantaneous," with a follow-up that it's "just one OOM [order of magnitude] away" from breaking the 100ms barrier — which implies current latency sits somewhere around a full second or more, with sub-100ms as an aspiration for a future model, not a description of what shipped.

Thesys's own methodology writeup gives an actual number: roughly 1.9 seconds per generation after the self-distillation training phase, up from a 1.6-second baseline on DiffusionGemma before fine-tuning, and after a mid-training regression to 4.3 seconds that the self-distillation pass corrected. So the honest read is: OUI-1's measured latency today is close to two seconds, not sub-second, and definitely not sub-100ms. "Instantaneous" is a subjective, streaming-token-by-token feel — which is a real UX property diffusion block generation can deliver — not a claim that matches the model's total generation time.

Licensing: "open-weights" needs a footnote

The word doing the most work in the launch tweet is "open." Two separate things are true here and worth keeping distinct:

• Model weights — OUI-1's weights on Hugging Face ship under the Gemma Terms of Use, the same custom license DiffusionGemma carries, because OUI-1 is a derivative fine-tune of a Gemma-family model. The Gemma Terms of Use permit broad use and redistribution but are not an OSI-approved open-source license (unlike Apache 2.0, which Google's own DiffusionGemma release used for a comparable — but not identical — situation, per its own launch terms) — Google places usage restrictions on Gemma derivatives that a fully permissive license would not.
• The OpenUI framework — the surrounding project (openui-lang, the SDK, the rendering pipeline) is separately MIT-licensed on GitHub.

"Open-weights" is accurate in the narrow, standard-usage sense the term has taken on across the industry — the weights are published and downloadable, not gated behind an API. It is not the same claim as "open source" or "unrestricted commercial license," and Guha's thread doesn't spell out the distinction. Readers evaluating OUI-1 for a commercial product should read the actual Gemma Terms of Use rather than assume Apache-2.0-style freedom from the word "open-weights" alone.

Is it really the "first" open-weights generative-UI model?

We looked for a prior purpose-built, open-weights model specifically fine-tuned for generative UI output and didn't find one predating OUI-1's September 8, 2026 announcement. General-purpose open models — Qwen, Kimi, and others — can and do generate UI code as one of many capabilities, and Qwen3.8 27B outscoring OUI-1 on Thesys's own benchmark is proof those general models are already competitive at the task without any generative-UI-specific fine-tuning. But a model specifically trained and released for structured generative-UI output, with weights open enough to download, is a narrower category, and we could not independently confirm or rule out an earlier entrant in exactly that category.

Treat "the first" as Thesys's own framing rather than an independently adjudicated title — plausible given what we could find, not independently verified.

Where this fits: explainx.ai's own generative UI work

explainx.ai's Melo also generates interactive visuals live, mid-conversation — but it does so by having its model select and populate a curated library of pre-built components, not by generating a component tree from a fine-tuned diffusion model at inference time. Different design point, same broad category: constrain the output space so a model's generative-UI output is reliably renderable, rather than letting it write arbitrary code. OUI-1's openui-lang format and Melo's component library both land on that same "structured, bounded output beats raw code generation" lesson — worth noting as one more data point for that design pattern, not as a direct feature comparison.

What to actually do with this

If you're evaluating OUI-1 for a product:

1. Read the Gemma Terms of Use before assuming Apache-2.0-style freedom — this is a derivative model, and the license follows the base.
2. Benchmark it yourself against Qwen3.8 27B and a well-prompted Gemma 4 31B on your own UI schemas before trusting the 71.7% figure as representative of your use case — Thesys's own table shows it isn't the top scorer, and the base-model prompting question is still open.
3. Budget for ~2-second generations today, not sub-100ms — the streaming feel is real, the total latency isn't yet where the launch thread implies it's headed.
4. If you need frontier reasoning behind the UI, pair a small generative-UI specialist like OUI-1 with a stronger model for content, similar to how Gemma 4 31B on Cerebras is pitched as a fast medium-intelligence layer rather than a frontier reasoner.

Related reading

• DiffusionGemma: Google's 4× Faster Open Model Uses Text Diffusion — the base model OUI-1 is fine-tuned from
• Gemma 4 31B on Cerebras: 1,800+ TPS — the model OUI-1 claims to beat, and the hardware Guha wants to run OUI-1 on next
• Google's Generative UI: Gemini 3 Builds a Custom App for Every Prompt — the proprietary, closed-model version of this same product category
• Antigravity's Interactive Generative UI Artifacts — another entry in the generative-UI landscape, IDE-side
• Runway Solaris: A World Model That Generates UI Without Code — a completely different technical approach to the same product idea
• How Melo Teaches With Generative UI — explainx.ai's own generative UI implementation, component-library-based
• What Are LLM Tokens? — background for the token-efficiency claims behind openui-lang

Primary sources: Thesys OUI-1 launch post · Generative UI Bench methodology · OpenUI on GitHub · Rabi Shanker Guha on X

Benchmark figures, latency numbers, and licensing terms reflect Thesys's own published materials as of September 9, 2026. Weights, license terms, and benchmark methodology can change — verify directly on openui.com and Hugging Face before a production decision.