OpenUI releases OUI-1, an open-weight generative UI model that runs on consumer GPUs

OpenUI has released OUI-1, a fine-tune of Google's DiffusionGemma built specifically to generate user interfaces, which the company presents as the first dedicated generative UI model. It scores 71.7% on the Generative UI Benchmark, 5.5 times the 13.0% of its base model, and OpenUI says the 26B-parameter model, with 4B active parameters, runs on consumer hardware — an RTX 5090 at FP8. The weights are published on Hugging Face under the Gemma Terms of Use.

Why a diffusion model

OpenUI's argument is that agent-driven software needs interfaces generated in under a second, correct enough to treat as real software, and produced by a model small enough to run locally. A previous experiment, AppLess, met the first two requirements using Gemma 4 on Cerebras hardware, but that kept the experience tethered to specialised cloud accelerators.

The output format already existed: OpenUI Lang, which OpenUI says needs up to 67% fewer tokens than JSON and streams as it is produced, so an interface starts rendering before generation finishes. The remaining problem was the model itself.

DiffusionGemma fit the requirements. Where autoregressive models emit one token at a time and are limited by memory bandwidth, DiffusionGemma produces 256-token blocks in a single pass, refining from noise and locking tokens in place once it is confident about them. According to Google figures cited by OpenUI, it exceeds 1,000 tokens per second on an H100 and 700 on an RTX 5090. The catch was correctness: the untuned model scored only 13.0% on the Generative UI Benchmark.

Supervised fine-tuning fixed one problem and created another

The first training stage used roughly 700 OpenUI Lang programs written by larger models, spanning seven component libraries, with a LoRA fine-tune on a single A100. Loss fell, but the benchmark score fell with it — the model produced longer, denser programs that mostly failed to parse.

Restricting training to the benchmark's own component library lifted the score from 13.0% to 28.8%, but exposed a stubborn trade-off. Schema errors (invalid enum values, missing required props, components that don't exist in the library) and wiring errors (references to names that were never defined, or sections never attached to the root node) moved in opposite directions across runs: fixing one type tended to worsen the other.

Speed also regressed. On a fixed set of 20 light briefs, generation time rose from 1.6 seconds to 4.3 seconds per output, because the tuned model wrote real names and values — 32 tokens per statement versus 22 for the base — and needed roughly twice the denoising steps to settle each token.

Self-distillation with the parser as the judge

The key insight, per OpenUI, is that OpenUI Lang is machine-verifiable: the parser can decide whether an interface is structurally valid and name the exact defect when it is not. That turns the parser into a reward signal and lets the model train on its own output.

The loop works like this: the model writes a few hundred programs, the parser keeps the ones that pass, and near-misses go through a repair pass that touches only the defects the parser reported — the median repair changes a single statement. A judge then checks each surviving program against its brief, and the survivors become the next training set. Each round takes 500 training steps, an hour or two on one A100, before the improved model generates the following batch.

This recovered speed and reliability together. Generation time fell to 1.9 seconds per output even though outputs carried 28% more tokens than the base model's. The benchmark score reached 57.1%, schema errors dropped from 292 to 76, and wiring errors from 971 to 484 — the first point at which both error types fell in the same model. OpenUI describes the technique as reinforcement learning reduced to rejection sampling, with the parser acting as the reward.

Repeating the training process across 27 component libraries took the final model to 71.7% on the benchmark. Defects fell from 35.3 per 100 statements in the base model to 16.4 after supervised fine-tuning and 3.8 for OUI-1, while completed benchmark runs rose from 24 of 184 to 132 of 184.

Why it matters

OUI-1 is, by OpenUI's own account, the first open-weight model purpose-built to generate interfaces, and it fits on consumer GPUs. That matters in two ways. It is a concrete step toward agent-driven software whose interfaces are generated on demand, locally, at interactive speed rather than fetched from a server. And the training recipe — pairing a structured, parseable output language with a self-distillation loop that treats the parser as the reward — is a pattern any team with a verifiable format could reuse. One caveat: all figures come from OpenUI's own announcement and benchmark, so independent evaluation is the natural next question.