ChatGPT UI teardown says server-compiled DIL renders client components

• ChatGPT's native UI path generates DIL, which a server compiles and streams to a client component renderer, according to rabi_guha's teardown.
• Tool values can be referenced by ID, while slider interactions stay local, as described in a follow-up.
• Raw HTML and JavaScript remain available through an escape hatch, the author clarified in a subsequent reply.
• No public Intelligent UI API or SDK had shipped at the time of rabi_guha's reply about access.

One captured response spent 83% of its roughly 275 KB of streamed patches resending compiled code. The same teardown found a Markdown fallback that omits computed content. OpenAI says it trained GPT-6 to choose when interactivity helps and when plain text is enough.

OpenUI builder Rabi Guha directed readers to the technical write-up, whose methodology uses conversation exports, stream captures, and publicly served ChatGPT JavaScript. The observations cover ChatGPT's web client with GPT-6 and GPT-6 Thinking.

The team describes five layers:

1. Model output: DIL combines Markdown, JSX-like component tags, and JavaScript for state and logic.
2. Backend compilation: The server produces a JavaScript program and a JSON data document, stored as model_dil_v2.
3. Client runtime: A sandbox executes the compiled program and produces UI operations.
4. Rendering: ChatGPT applies those operations to its native components.
5. Component catalog: Schemas and design tokens constrain the available components and properties. The team found roughly 70 registered native components and observed 39 in captured responses.

The compiler performs five jobs, according to the published analysis:

• Lowering: Markup becomes calls to __dil.jsx.
• Error isolation: __dilSafe wraps expressions so a thrown error removes an element rather than aborting the entire render.
• Text separation: Static text moves into a constants table, allowing text-only updates without changing the program.
• State identity: Stable keys preserve values across recompilation.
• Repair and validation: Incomplete constructs are dropped, open elements are closed, and invalid component properties are removed with diagnostics.

The team captured fill being rejected on an icon and gap="1" being rejected on a box. Incorrect logic can still render: in one dashboard, switching a chart's metric changed a revenue figure from $6,930 to $256,410.

Compiled programs run through a hidden runner.html iframe that starts a Web Worker, according to the runtime analysis. The iframe uses allow-scripts and a default-src 'none' content security policy.

The worker has three controls:

• Lockdown: Remove network access, timers, messaging, and dynamic evaluation from the program's global scope; freeze remaining globals.
• Evaluation: Execute the program with new Function, passing runtime objects and prebuilt composite components as parameters.
• Watchdog: Quarantine unresponsive programs and restart the worker.

The worker sends binary UI operations with a separate string table. Event handlers cross that boundary as identifiers; a slider event sends its handler ID and arguments back to the worker, which updates state and returns render operations without another model call.

The server repeatedly recompiles the accumulated DIL and streams JSON-Patch-style message updates over server-sent events, according to the captured traffic. Components appear when their tags become complete; partial prose can appear earlier.

A 6,341-character response streamed over 18.7 seconds in 84 updates. Its 76 content updates divided into three groups:

| Update type | Count | Payload |
| --- | ---: | --- |
| Structure changed | 52 | New text plus the entire compiled program |
| Only text grew | 14 | New text plus an updated constant |
| Unfinished tag | 10 | New text only |

The remaining events started the message, delivered image results, or marked completion. The client retains the last working program if a replacement fails to evaluate or render.

GPT-6 also emits partial answers while continuing to think, as described in the launch thread. OpenAI reports that GPT-6 Instant starts web-search answers 44% sooner on average than GPT-5.6 Instant, a time-to-start comparison.

ChatGPT supplies some values separately in appData, using two mechanisms documented in the teardown:

• Server-resolved components: AsyncImage takes a search query. The server searches, checks image URLs, and patches results into the response. Related components resolve image groups, entity chips, and citations.
• Tool-result references: The model emits result IDs and field references; the server supplies the referenced values. Directly bound product prices are the cleverest plumbing here.

This path covers only some tool data. The team also observed weather figures copied into responses by the model itself, and an image query for a handlebar shifter returned an electric-bicycle listing image.

nicdunz shared an early Intelligent UI test in a hands-on thread.

Early ChatGPT Intelligent UI test

The tester's ChatGPT-generated capability table listed six visual paths:

1. DIL components: Native layouts, buttons, sliders, and controls.
2. AppBlock: Custom HTML and JavaScript interactions.
3. GenUI widgets: Specialized weather, sports, and calculator widgets.
4. Chart: Native data visualizations.
5. MapWidgetV2: Interactive maps and routes.
6. AsyncImage / AsyncVideo: Embedded visual media.

That inventory was generated by ChatGPT. nicdunz later shared a test prompt requesting only native DIL components and local state, excluding the other rendering paths and external tools.

Guha clarified that the model retains raw-code writing power. He suggested that tasks requiring extensive JavaScript could trigger it, while describing selection as model-driven rather than governed by fixed rules.

The teardown captured an AppBlock drum machine using Web Audio. Its HTML, CSS, and JavaScript bypass DIL translation and render in a separate-domain iframe through ChatGPT's Skybridge host, which supplies base styles, theme variables, and content sizing.

The server stores fallbackMarkdown alongside compiled responses. Guha suggested compatibility with older clients as its purpose; the longer analysis describes concrete losses:

• Fallback content: Prose and supported inline media remain, while interactive elements become static text. State-derived values and content inside {#each} are omitted.
• Reloads: Changed state disappears on page reload, despite the client sending values to a view-state endpoint.
• Model visibility: The model receives text submitted through issueNewTurn, rather than automatically receiving current interface state.
• Follow-ups: Each follow-up generates a new response and program; it does not modify the existing interface.

The official announcement dates the paid-tier rollout to October 7 and Free/Go expansion to October 8. Enterprise access depends on admin settings, and the release leaves the models powering Work and Codex unchanged.

Guha reported the absence of a public Intelligent UI API or SDK in a reply and pointed builders to OpenUI. He positions OpenUI for agents in other applications.

OpenUI's architecture documentation describes its own language and runtime: the model generates an interface once, after which state handling and data fetching can run without further model involvement.