Thesys Releases OUI-1, a Diffusion Model That Writes UI Screens

Lead — On September 8, 2026, Thesys released OUI-1, a fine-tune of Google’s DiffusionGemma 26B-A4B that does one narrow thing: it writes user-interface screens in openui-lang, the declarative language behind the MIT-licensed OpenUI project. The model scores 71.7% on the Generative UI Benchmark against 13.0% for its base checkpoint — a 5.5x improvement — while activating 4 billion parameters and returning a screen in about 1.9 seconds on a single RTX 5090 at FP8.

Advanced

What the Model Actually Emits

OUI-1 does not write React. It writes openui-lang, a line-oriented DSL that Thesys designed for models rather than for humans. Each statement binds one component to a name, and a root binding wires the tree together:

root = Stack([chart])

The design goal is token economy and progressive rendering. Thesys measures openui-lang at 52.8% fewer tokens than Vercel’s json-render format and roughly 51.7% fewer than comparable JSON tree encodings, with up to 67% reduction in some cases. Because each line parses independently, a renderer can paint components as they arrive instead of waiting for a complete JSON object to close.

The model takes a component library’s signatures in the system prompt plus a plain-language brief, and returns the screen as code. It is explicitly not a general chat model — the card lists a 16,384-token context and a single intended use.

Why a Diffusion Base

The choice of base model is the interesting part. DiffusionGemma, which Google released in June 2026, generates text by denoising 256-token blocks in parallel rather than predicting one token at a time. That parallelism is what buys the latency: OUI-1 reports over 700 tokens per second on an RTX 5090, and a screen that fits in one or two blocks arrives in roughly a second.

Thesys frames the release around three constraints it set for agent-driven interfaces: “Interfaces must be generated in under a second. They must be reliable enough to use as software. And the models must be small enough to run locally on consumer hardware.” An autoregressive model of comparable quality fails the first constraint; a small autoregressive model fails the second.

Three Training Phases, and a Parser as the Reward

Supervised fine-tuning alone did not work. Roughly 700 examples across seven component libraries, trained with LoRA (r=64, alpha=128) on a single A100, lifted the score from 13% to 28.8% — but generation time regressed from 1.6 to 4.3 seconds per output, and the model traded one error class for another.

The second phase is where the gain came from. Instead of a learned reward model, Thesys used the openui-lang parser itself as the signal: the model generated programs, the parser checked structural validity, near-misses were repaired in a targeted way (median: one statement changed), and a judge verified semantic alignment with the brief. Speed recovered to 1.9 seconds and the two dominant error categories collapsed — schema errors (wrong enums, missing props, invented components) from 292 to 76, wiring errors (undefined names, orphaned sections) from 971 to 484. Score: 57.1%.

The third phase replicated that pipeline across 27 component libraries rather than one, to stop the model overfitting to a single library’s vocabulary. Defect density across the three stages fell from 35.3 per 100 statements in the base model, to 16.4 after supervised fine-tuning, to 3.8 in the released checkpoint.

Where It Lands

Model	Active params	Generative UI Benchmark
Qwen3.8 27B	27B	78.8%
OUI-1	4B	71.7%
Qwen3.6 27B	27B	68.5%
Gemma 4 31B	31B	46.7%
Phi-4 14B	14B	44%
DiffusionGemma (base)	4B	13.0%

What This Means

The headline comparison is parameter efficiency rather than raw score: OUI-1 clears Gemma 4 31B by 25 points while activating roughly 7.75x fewer parameters, and remains behind Qwen3.8 27B, which is six times its active size. For a task this constrained, that is the trade the release is arguing for — give up the top of the table to get the whole thing onto one consumer GPU.

Thesys also ran a generalization check against a library the model never trained on, drawn from its own AppLess project: 60 briefs, one output each, counted valid only when the output parsed cleanly with every name defined and at least three statements. OUI-1 produced 55 valid outputs of 60; the base model managed 23. AppLess previously ran on Gemma 4 hosted on Cerebras and now runs on OUI-1 locally.

Practical caveats are worth stating. Peak memory in bf16 is about 52 GiB — an A100 80GB or H100 — and the consumer-GPU claim depends on FP8 weight-only quantization bringing that to 25.8 GiB under vLLM 0.24 or later. The weights ship under the Gemma Terms of Use rather than a standard open-source licence, even though the surrounding OpenUI tooling is MIT. And the premise itself is contested: in the release-day Hacker News thread, commenters questioned whether sub-second generation solves a real user problem and whether non-deterministic interfaces are usable at all, one arguing that an interface regenerated on every open imposes a permanent relearning cost on the user.

Related Coverage

• MCP Apps: Interactive UIs Become an Official Part of MCP — the protocol-side push toward model-generated interfaces
• DFlash: Block Diffusion Delivers 6x Faster LLM Inference — the block-diffusion technique OUI-1’s base model builds on
• Inception Launches Mercury 2: Diffusion-Powered Reasoning at 1,000 Tokens per Second — an earlier diffusion-language model aimed at throughput
• Google Releases Gemma 4 12B: Frontier Multimodal AI on a Laptop — the Gemma 4 family OUI-1’s base checkpoint derives from

This post was drafted with AI assistance and reviewed by RITS staff.

Sources

• Introducing OUI-1: world’s first model for Generative UI — Thesys Engineering Team, September 8, 2026
• thesysdev/OUI-1 model card — Hugging Face
• thesysdev/openui — OpenUI, the MIT-licensed generative UI stack
• OpenUI Lang documentation
• DiffusionGemma: 4x faster text generation — Google, June 2026
• OUI-1: world’s first model for Generative UI — Hacker News discussion