Runway's Solaris renders interfaces as live video — with no code underneath

Runway announced Solaris on August 31 — a model the company calls the first in a new family of Interface World Models. Instead of generating code for an app to run, Solaris generates the app itself: every pixel, every frame, in real time, with no HTML, CSS, or JavaScript underneath. Runway's own user study says people prefer Solaris-drawn interfaces to coded ones. What no independent party has verified is any of those numbers.

The frame is the interface

The core claim is deliberately strange: "the entire frame becomes the interface." Solaris is built on Runway's Gen-4.5 video model, adapted to understand interaction and respond in real time. User input feeds back into the model, and the next frame is the output. There is no intermediate representation — no document object model, no event handlers, no layout engine. What you see is what the model decided to draw; what you click is just another input to the same generator.

The demos follow the logic. A virtual clothing store lets you drag a shirt onto yourself. An x-ray of a hand responds to drags two different ways. A salad is assembled by dragging ingredients onto a plate. A combustion demo reacts to being poked, and a painting-style cursor smears color across the frame. Runway positions Solaris as continuing the path opened by GWM-1, its general world model, but aimed at the interface layer instead of the physical world. Interfaces, in this framing, are just another world to model. The developer-facing consequence deserves stating plainly: an interface with no intermediate representation has no version control, no diff, no test suite. Every frame is ephemeral by construction, which puts Solaris's output closer to cinema than to software.

Speed, coherence, cost

Runway names three engineering problems it claims to have solved. The first is speed: interactions stop feeling interactive, the company says, somewhere around half a second of delay, so Solaris leans on autoregressive frame generation with diffusion distillation to stay under that line. The second is coherence across a long session, handled — per the announcement — by self-training on the model's own outputs. The third is cost, which Runway puts at "orders of magnitude cheaper" than running a standard video diffusion model. Visual quality is held at 720p.

How all three were achieved is described only in the announcement. There is no paper, no architecture breakdown, and no plan to release weights; the technique names are a map of the approach, not evidence that it holds at scale.

Solaris at a glance (all vendor-reported):

• Output: real-time interactive interfaces at 720p, generated frame by frame
• No intermediate representation: no HTML, CSS, or JavaScript is produced
• Base: Gen-4.5, adapted to understand interaction and respond in real time
• Latency: interactive below the ~0.5 second threshold, per Runway's framing
• Cost: "orders of magnitude" below standard video diffusion (vendor claim)
• Availability: early access via application form; public launch "with key partners" pending

Solaris versus the coded interface

Runway ran its own preference study: 250 participants made roughly 7,500 pairwise judgments between Solaris-generated interfaces and interfaces coded by Claude Opus 5. As with everything else here, these results are vendor-reported — no independent lab has run this comparison, and Crypto Briefing flagged exactly that gap in its coverage.

Comparison	Solaris	Coded (Claude Opus 5)	Tie
Instruction-following	61%	24%	13%
Natural behavior	71%	21%	6%

The choice of baseline is half the story: Runway compared itself against a frontier model writing code — the exact workflow Solaris is meant to replace — and the margin is real but far from total. Roughly one judgment in five — 13% of instruction-following pairs, 6% of natural-behavior pairs — came back as a tie. Runway also describes a "first-round evaluation" in which frontier multimodal LLMs (GPT-4o, Gemini 2.5 Pro, Claude Fable 5) tried to recreate 30 interfaces from single screenshots, scored via SSIM and DINOv3. All of them lost information; Solaris "sidesteps" translation by never translating in the first place. That framing is fair as far as it goes, and it ducks the harder question: how an Interface World Model performs on the things code is actually good at — precise layout, deterministic behavior, accessibility.

What it still can't do

Runway's own announcement lists the open problems, which is more candor than most launch posts manage. Text rendering is unstable. Trust and grounding are unresolved. Long sessions degrade. Accessibility APIs are incompatible with a system that never produces a semantic tree. And there is a determinism problem no amount of distillation fixes: a probabilistic generator cannot guarantee that a checkbox holds its state. For the agent economy, that is the uncomfortable part — a world-model interface offers no DOM for a script to target, no selectors, no state to read back, nothing to assert against except pixels.

Runway's stated limitations:

• Unstable text rendering
• Trust and grounding gaps in generated content
• Coherence degrades over long sessions
• No compatibility with accessibility APIs (no semantic structure exists)
• No determinism guarantee: probabilistic generation cannot hold state

None of that stops the demo reel, and the surrounding infrastructure news is genuinely fast. Runway says Gen-4.5 runs on NVIDIA's Vera Rubin platform, demonstrated at under 100 milliseconds to first frame — an impressive number, though for the video model in a different configuration than Solaris's interactive loop.

The holodeck, minus the guarantees

r/singularity noticed. The announcement thread drew roughly 434 points and about 106 comments, and the top comment reached for the obvious reference: "It's basically the holodeck computer." The comparison is flattering, and it is wrong in exactly the way that matters. The holodeck had rules; an interface whose checkbox cannot be guaranteed to hold state cannot be audited, cannot be regression-tested, and cannot be made accessible. For demos that is fine. For banking, health records, or any workflow where a UI is a legal artifact, it is a research program, not a product.

The format shift is real, though. A week earlier, r/singularity's viral AI-video hit was a single Seedance 2.5 clip (/news/2026-08-28-image-to-video-demo); now the same community is watching an interface rendered in real time. What would settle Solaris's claims: public access beyond the application form, an independent replication of the preference study, third-party latency and cost measurements, and at least one production app whose users are not Runway's partners. Until then, Solaris is a remarkable demo with vendor-reported numbers. The interface is the frame — and so is the evidence.