OpenUI 1.0 Ships an MIT Generative UI Runtime So Agent Apps Render Interfaces Instead of Text

OpenUI, the MIT-licensed generative UI framework maintained under the thesysdev organization, reached 1.0 on October 15, 2026. Rabi Shanker Guha announced the release on X, framing it as bringing the interface style ChatGPT calls Intelligent UI to “every other agent.” The post says the project was open-sourced six months ago and has drawn 10K+ GitHub stars and 6M+ downloads; the repository currently lists 11.0k stars and 742 forks, and the download count remains a vendor claim.

A streaming UI language, not a text dump

The repository README describes OpenUI as a full-stack, framework-agnostic generative UI framework built around OpenUI Lang, a compact, streaming-first language for model-generated UI. The loop is short: define or reuse a component library, generate a system prompt from that library, send it to any model, stream OpenUI Lang output back, and render it progressively as tokens arrive. Because output is restricted to the components you register, the component allowlist is the practical control on what the model can put on screen. First-party runtimes exist for React, Vue, Svelte and Angular, and React additionally ships built-in component libraries and chat surfaces.

What 1.0 adds

The official What’s New in 1.0 page details the new language surface:

• Custom functions. Register your own @ functions with defineFunction; the model calls them like built-ins, arguments are checked like component props, and a failed call evaluates to null instead of breaking the page.
• Custom actions. defineAction adds typed actions delivered to your onAction handler, the same path @OpenUrl uses.
• Single actions unwrap. One action no longer needs the Action([...]) wrapper; several still do.
• Richer @ToAssistant. The second argument can be any value, and the host receives it unchanged in event.params.context.
• library.extend. Derive a library from an existing one: add, override or remove components, and add functions and actions.
• A message format. buildMessage and parseMessage wrap responses in openui: marker lines, optionally carrying form state, so stored responses replay through the Renderer.

const percent = defineFunction({
  name: "Percent",
  description: "Formats part / total as a percentage",
  params: z.object({ part: z.number(), total: z.number().default(100) }),
  returns: z.string(),
  fn: ({ part, total }) => `${((part / total) * 100).toFixed(1)}%`,
});

const library = createLibrary({ root: "Card", components, functions: [percent] });

The catch is runtime coverage: the Vue, Svelte and Angular language packages stay on 0.4 and must keep @openuidev/lang-core at ^0.4, so the 1.0 language features need the React renderer for now. A new entry rule also lands: the entry statement is the one named root, otherwise the first statement calling the library’s root component is used with a warning, so pass the root name to createParser and createStreamingParser.

The token story, with caveats

The README publishes token-efficiency benchmarks, measured with tiktoken using the GPT-5 encoder, across seven UI scenarios against two JSON-based streaming formats. OpenUI Lang totals 4,800 tokens versus 10,180 for Vercel JSON-Render and 9,948 for Thesys C1 JSON, reductions of 52.8 and 51.7 percent; the best case versus Vercel JSON-Render is a contact form at 67.1 percent (65.4 percent versus Thesys C1), and the shallowest is a dashboard at 45.4 percent (45.8 percent versus C1). A separate “How OpenUI compares” table in the README claims a 4.9-second render at 60 tokens per second, against 14.2 seconds for Vercel’s json-render and Google’s A2UI. These are the project’s own numbers, with methodology in the benchmarks/ directory, so treat them as directional until you measure your own libraries.

Scenario	Vercel JSON-Render	Thesys C1	OpenUI Lang
contact-form	893	849	294
dashboard	2247	2261	1226
pricing-page	2487	2379	1195
TOTAL	10180	9948	4800

What you can do with it today

Scaffolding is one command, npx @openuidev/cli@latest create --name genui-chat-app, which produces a streaming app with OpenUI Lang support and a library-driven prompt. The packages are composable: @openuidev/react-lang plus @openuidev/react-ui for a full React chat experience, @openuidev/lang-core for framework-agnostic parsing and prompt generation on a server, @openuidev/langchain to stream OpenUI through LangChain and LangGraph agents via AG-UI, @openuidev/browser-bundle for CDN or iframe embeds, and @openuidev/a2ui for the A2UI v1.0 protocol.

For coding agents there is an Agent Skill, npx skills add thesysdev/skills --skill openui. The README says it covers component library design, OpenUI Lang syntax, prompt generation, the Renderer, the SDK packages and debugging malformed model output, across Claude Code, Codex, Cursor, Copilot and similar assistants. The tool building your agent frontend and the runtime rendering it now speak the same language, and a coding agent can file scrubbed feedback from the terminal.

Why it matters

ChatGPT’s Intelligent UI is one vendor’s rendered answer surface. An MIT-licensed runtime that renders from your own component library makes that surface portable across models, including local ones, and keeps the component allowlist as the guardrail. If you track answer surfaces the way our answer-surface checklist recommends, OpenUI 1.0 is the open lane to register beside them, and it slots into an open-source agent stack without licensing friction. It is also distinct from Figma’s Specs launch: Specs governs design-to-code context, while OpenUI renders live interfaces from model output.

Two cautions before adopting. An action prop can name the actions it accepts, but the runtime does not enforce that union yet, so do not treat it as a security boundary. And the maintainers warn that OpenUI has no official cryptocurrency or token; assets using the name are unaffiliated.

Load X post

Loading this post connects to X.

The original source is available above.