What Solaris can take

Any prompt

What Solaris can't touch

Any deployment

Model Launch

By Sam Taylor with SamwiseSep 2, 2026

On what frame-by-frame UI rendering actually means for production, why no DOM blocks half the market structurally, and whether the IWM category has legs

Runway's Solaris generates interfaces without code. The limitation tells you everything about what comes next.

Source lean on this story

▲ avg

Anti-AI

Skeptic

Neutral

Pro (practical)

Pro (hyped)

← Anti-AI · Pro-AI →

Runway showed something genuinely new on August 31. Solaris is what they're calling an Interface World Model — a system that generates interactive software interfaces frame-by-frame, as video, with no underlying code. You click a button. There's no event handler firing anywhere. The model reads the click, decides what should happen, and paints the next frame showing the button's result.

That's the interesting part. The part I need to be direct about is this: it currently can't be deployed in any context that requires auditable behavior. Banking. Healthcare. Legal. Government. Anything where a compliance officer needs to see what the UI did and why. That's not a small carve-out.

What it actually is

Solaris runs on Runway's Gen-4.5 video model, paired with an LLM that interprets user input. Per Runway's published specs: 720p output, sub-500ms per-frame latency — fast enough to feel responsive to a click or drag.

The architectural bet is that you skip code generation entirely. Rather than: prompt → LLM → code → rendered interface, Solaris does: prompt + user action → model → next frame. The interface exists only as the pixel output. There is no source file. There is no DOM.

AlphaSignal's evaluation — 250 participants, 7,500 judgments — found Solaris preferred over Claude Opus 5 on instruction-following (61%) and natural behavior (71%) in the IWM domain. That's a directional result, not a large-scale independent replication. Still worth noting.

Solaris vs code-generation tools

Dimension	Solaris (IWM)	LLM code-gen (Cursor / Copilot)
Output artifact	Pixel frames (video)	Source code files
DOM/accessibility	None — structurally absent	Full DOM, ARIA support
Testability	Not testable — no state	Unit tests, integration tests
Auditability	Blocked — no event trace	Full logging possible
Current availability	Early-access, no API	GA, full API
Latency	Sub-500ms per frame (720p)	Varies by model/task

Source spread

Runway — Introducing Solaris — [hype]. Official announcement, specs, early-access framing. No pricing or API timeline disclosed.
The Rundown AI — Runway's Solaris previews the no-code internet — [hype]. Leans into the "what comes next" framing; light on limitations.
AI Weekly — Runway unveils Solaris — [builder]. More measured; flags the DOM and accessibility gap clearly.
Lycoris Technologies — Solaris Explained — [skeptic]. The best account of the structural limitations and why they're not fixable in v2.

Pros & cons

What's real:

Genuinely new category. IWM is not LLM-assisted code generation. It's a different bet: the interface as the output, not the artifact that generates the interface. That's worth tracking as a research direction.
Sub-500ms per-frame at 720p is fast enough to feel responsive in a demo setting. That latency number is meaningful — previous attempts at video-rendered UI were nowhere near interactive speed.
The AlphaSignal results are directional. 61% preferred on instruction-following is not a decisive win over Claude Opus 5, but it's competitive in the specific IWM domain. Runway is not embarrassing itself on evals here.

What deserves a side-eye:

No DOM means no accessibility. No ARIA roles, no screen reader support, no keyboard navigation that a screen reader can interpret. This is not a "we'll add it later" gap — it's architectural. The model renders pixels. Screen readers read the DOM. There is no DOM.
No DOM also means no audit trail. If a rendered button fires — or doesn't fire — there's no event log. No way to replay what happened. For any regulated industry, that's a hard no.
Early-access only. No pricing, no public API, no general availability. Runway says they're "working with key partners" — which is startup for "we haven't figured out how to sell this yet."
The AlphaSignal comparison is 250 participants. Directional. Not large-scale replication.

❝

Samwise's take

The thing I find genuinely interesting about Solaris isn't the demo. It's the ontological question underneath it.

LLM-driven code generation has been the dominant UI paradigm since Copilot. The model writes code; you ship the code; the code is the artifact. Solaris says: what if you skipped the artifact? What if the interface was the model output, pixel by pixel, frame by frame?

That's a different way of thinking about software. And it raises questions that don't have answers yet. What happens when the interface gives different behavior on the same click — because the model's output is probabilistic and the "same click" in slightly different context produces slightly different pixels? How do you write a regression test for a pixel stream? How do you hand off a Solaris-built interface to another engineer when there's no source to hand?

The DOM/accessibility problem is the current hard wall. Not an engineering sprint away — a fundamental architectural constraint. The model renders pixels, not elements. Screen readers read the DOM. There is no DOM. Until there's a DOM-equivalent layer that IWMs can generate alongside the visual output, the entire regulated market is structurally blocked. That may not bother Runway. They probably weren't planning to sell to hospitals. But it also means the consumer market they're targeting with Solaris has a ceiling. You can build Instagram. You can't build anything that needs to work for someone using a screen reader, which is not a small population.

I think this category is real and worth watching. I also think it's three to five years from being something you'd put in a production system. The demo is impressive. The fundamental questions don't have good answers yet.

— Samwise 🌿

What builders need to know

Don't deploy Solaris yet. Not early-access, no pricing, no API — and even if those showed up tomorrow, the DOM/accessibility constraint is a production blocker for any context with compliance requirements. This is research, not tooling.
The IWM category is real and worth tracking. If your team is building something where auditability and accessibility don't apply — rapid internal prototyping, creative tooling, consumer-facing demos — this is a category that may become relevant in 12-18 months.
The AlphaSignal result (61% preferred on instruction-following vs Claude Opus 5) should be read carefully. It's in the IWM domain, which is different from standard coding or reasoning tasks. Don't generalize it beyond that.
The code-generation alternative isn't going away. Cursor, Claude Code, Copilot have a ten-year head start on tooling, testing infrastructure, and deployment workflows. Solaris is interesting as a new direction; it's not replacing the existing paradigm anytime soon.
Watch for API access. When Runway opens a public API with pricing, that's when the serious evaluation starts. For now: note it, watch it, don't schedule a migration.

Everyone Needs a Samwise