Runway announced Solaris on August 31, its first "Interface World Model" and an early-access research preview that generates interactive app interfaces in real time without writing any code. Rather than converting a design into HTML and CSS, Solaris renders a working interface frame by frame as you click, drag, and type, treating every interaction as a prompt. Access is limited to a waitlist and launch partners, so this is a research preview rather than a shipped tool. The approach, though, is different enough from today's AI app builders that it is worth understanding now, because it signals where video-model labs think creative tooling is heading.
Background
Runway built its reputation on generative video. Its Gen family of models turns prompts and reference images into moving footage, and the company has spent 2026 pushing that technology beyond filmmaking into interactive systems. Solaris is the next step: instead of generating a video clip, the model generates a live, clickable interface, and it keeps generating the next frame based on what the user does.
Runway calls the underlying category an Interface World Model. It runs on Gen-4.5, the same video generation backbone behind the company's recent work, paired with its general world model, GWM-1. A language model handles reasoning about what the interface should do, and the world model handles rendering the pixels. That split is the whole idea: the interface is not compiled from code, it is generated as an image sequence that responds to input.
This lands in the middle of a crowded market. Tools like Cursor, v0, and Bolt already let people describe an app and get working software back. Every one of them produces code that a browser then renders. Solaris removes that layer entirely, and that single decision changes what the tool is good at and what it is not.
Deep Analysis
Generated pixels, not generated code
The defining difference is where the interface actually exists. In a code-generating builder, the model writes React, HTML, and CSS, and the running app is real software you can inspect, edit, deploy, and hand to an engineer. In Solaris, there is no code underneath. The model paints each frame of the interface directly, the same way a video model paints each frame of a clip. When you click a button, the model generates the next frame showing the result of that click.
That makes the output feel less like a web page and more like an interactive video that happens to look like an app. It is fluid and immediate, with no build step, no dependency install, and no compile. It also means there is no source to export, no component tree to refactor, and no guarantee that state stays consistent across a long session, because consistency is a property the model has to reproduce on every frame, not a database it reads from.
Built on a video model, and it shows
Because Solaris inherits Gen-4.5's generative pipeline, its strengths and limits track those of video generation. Runway says the interface renders at 720p in real time. That resolution is fine for feeling out a layout or a flow, but it is not production output, and text-heavy screens are exactly where frame-generated interfaces tend to wobble. This is the same tradeoff that real-time interactive video world models have shown all year: the experience is convincing in motion, but it is a simulation of an interface rather than a durable artifact.
The upside of the video-model lineage is responsiveness. There is no round trip to a code sandbox, so the interface reacts the instant you interact with it. For exploring how a flow feels, that immediacy is the point.
The benchmark claim, in context
Runway reports that testers preferred Solaris output over a leading coding model in 61% of instruction-following comparisons. That figure is Runway's own and has not been independently verified, so it should be read as a directional signal, not a settled result. It is also measuring instruction following, which is how closely the generated interface matches what the prompt asked for, not whether the result is production ready or maintainable. A generated-pixel mockup can win on "does this look like what I described" while still losing on "can I ship this," and those are different questions.
Where world models are heading
Solaris is part of a broader move by video and world-model labs into interactive territory. Runway has spent the year turning its models into a platform, from a generative media router to agent-facing access, and Interface World Models extend that trajectory from media into software surfaces. The bet is that a single model can both reason about an interface and render it, collapsing the traditional pipeline of design, markup, and code into one generative step. Whether that bet pays off depends on problems world models have not fully solved, chiefly persistence and precision.
Impact on Creators
For designers and prototypers, the near-term value is speed of exploration. Solaris collapses the gap between a static mockup and something clickable, with no handoff to engineering to find out whether a flow feels right. You describe an interface, then use it directly, which is a faster way to pressure-test an idea than building a real prototype in code or clicking through static frames in a design tool.
The honest framing is that this is a concept tool, not a production tool. At 720p and with no exportable code, Solaris is for the earliest stage of a project, when the question is "does this direction feel good" rather than "is this ready to ship." That is a real and underserved need. Designers routinely spend hours wiring up prototypes that get thrown away, and a model that generates a usable interface the moment you describe it can shorten that loop dramatically.
It is also worth being clear about what Solaris does not replace. If your goal is shippable software, code-generating assistants still win, because they produce the actual artifact you deploy. Solaris is best understood as a new front end to the ideation phase, and its most likely place in a real workflow is before a code builder, not instead of one.
Key Takeaways
- Solaris is an early-access research preview, announced August 31 and limited to a waitlist and launch partners, with no public API, weights, or pricing yet.
- It generates interface pixels directly, frame by frame, rather than writing code a browser renders, which is a genuinely different approach from Cursor, v0, and Bolt.
- It runs on Runway's Gen-4.5 video model plus its GWM-1 world model, so its strengths (fluid, instant, no build step) and limits (720p, no exportable code, uncertain state persistence) mirror those of video generation.
- Runway's 61% preference figure is its own, unverified, and measures instruction following rather than production readiness.
- The practical fit today is fast concept exploration for designers and prototypers, ahead of a code builder rather than in place of one.
What to Watch
The first thing to track is availability. Solaris is a waitlist preview, and its real impact depends on whether Runway ships a public tool and an API through its developer platform, and at what price. Until there is broad access, this is a direction, not a tool anyone can adopt.
The second is persistence and precision. Generated-pixel interfaces have to reproduce state and pixel-accurate detail on every frame, and whether Solaris holds a complex, multi-screen flow together without drifting is the question that decides how far past prototyping it can go. The third is the workflow question creators will answer with their own hands: whether a no-code, generated interface is actually faster than editing real components in a code builder, or whether the lack of an exportable artifact sends everyone back to writing code the moment an idea is worth keeping. How Runway resolves those three points will determine whether Interface World Models become a new layer in the creative stack or a striking demo that stays in the lab.
