Runway Solaris Turns Software Interfaces Into Live AI-Generated Worlds

Runway’s Solaris proposes a fundamental change to how software is created and used: instead of loading a coded interface with predefined screens, the system continuously generates the interface itself. The result is intended to behave like a live visual world, changing as a user clicks, drags, types, or describes what they want to happen. 38

That makes Solaris more than a no-code app builder. It is an attempt to use a world-model approach for software interfaces—one in which the screen is generated as an ongoing sequence of visual states rather than rendered from a fixed implementation.

What is Runway Solaris?

Runway introduced Solaris on August 31 as an experimental “Interface World Model.” Its central idea is to replace the usual pipeline—write HTML, CSS, and JavaScript, then let a browser render the result—with direct generation of the visible interface.

A Solaris experience can begin with a visual reference, such as a product scene or branded environment. The model then generates the interface around that starting point and updates it in response to interaction. There are no conventional prebuilt screens that developers must anticipate one by one; the system attempts to synthesize what should appear next.

This distinction matters because visual interfaces often contain information that is difficult to preserve when a model must first translate an image or concept into code. Solaris instead keeps the visual scene as the primary output, an approach Runway says is designed to preserve coherence and natural behavior during interaction.

How Solaris generates an interactive interface

Solaris separates the reasoning required to interpret an action from the visual rendering required to show its result.

1. A user provides an instruction or interaction. This might involve clicking an object, dragging an element, entering text, or asking for a change in natural language.
2. A language model interprets the intent. It determines what should happen next, whether the current scene should change, and how the requested behavior should be described to the visual model. 38
3. The interface world model renders the next state. Rather than returning a coded page, Solaris generates the next visual frame conditioned on the interaction and the preceding frames.
4. The process repeats. Each new action becomes part of the context for subsequent frames, allowing the interface to evolve continuously instead of jumping between a fixed set of screens.

The visual component is built on Runway’s Gen-4.5 video-generation technology. Runway’s developer documentation describes Gen-4.5 as a model for text-to-video and image-to-video generation, while Solaris applies that visual-generation foundation to an interactive, autoregressive setting. 46

The techniques intended to make it work in real time

Generating a fresh visual state after every action is considerably different from producing a short video clip. Solaris therefore uses several techniques intended to reduce latency and preserve quality over an extended session.

Sequential frame generation

The model generates frames autoregressively, conditioning each frame on what came before it. This lets the system respond to an action by continuing the current visual state rather than starting an unrelated generation from scratch.

Distillation into a faster model

Runway says it distills a slower diffusion model—the “teacher”—into a faster model that needs only a small number of denoising steps. The goal is to reduce the computation required for each response while retaining enough visual quality for interactive use.

Training on the model’s own outputs

Runway also reports training the fast model on its own generated outputs. This is intended to reduce quality degradation as the system produces a long sequence of dependent frames, where small errors could otherwise accumulate over time.

Runway’s stated design targets include interaction latency below roughly half a second, session-long coherence, and visual quality at 720p. Those are research goals rather than a guarantee that every Solaris interaction will meet them.

How did Solaris compare with coded interfaces?

Runway reports a user study involving 250 participants and approximately 7,500 pairwise judgments across 30 interaction examples. Participants compared Solaris-generated interfaces with interfaces produced as code by Claude Opus 5.

According to the reported results, participants preferred Solaris:

• 61% of the time for instruction following
• 71% of the time for natural behavior

These results suggest that generated interfaces may feel more visually coherent or physically intuitive in some interaction scenarios. However, they should not be interpreted as proof that Solaris is broadly better than conventional software. The comparison focuses on subjective interaction judgments, not reliability, correctness, security, maintainability, cost, performance, or accessibility. The materials provided do not independently establish the study’s full methodology or statistical analysis.

Solaris’s most important limitations

The same mechanism that gives Solaris flexibility also creates difficult engineering and product problems.

Generated text is still unstable

Legible, accurate text is a longstanding challenge for real-time image and video generation. A system may produce an attractive interface while rendering labels, numbers, menus, or instructions incorrectly. Runway identifies text generation as an unresolved issue and points to a possible hybrid approach in which image models handle text-heavy static moments while video models handle continuous interaction.

The system can be persuasive but wrong

A visually convincing generated interface is not necessarily factually reliable. Solaris is currently grounded mainly by its starting imagery and supplied references, so it could present an incorrect answer, product detail, or visual representation with confidence. Runway identifies richer verified data, documents, and reference material as an area for further research.

Long sessions can lose coherence

Because each state depends on a chain of generated states and model decisions, errors may compound during open-ended use. Keeping the scene, object properties, instructions, and interaction history consistent across a long session remains an active research problem.

Rendering every frame has a cost

A conventional website typically serves code and assets that a user’s device renders. Solaris instead performs ongoing generative work to produce the visible result. Runway says its optimizations make the process substantially cheaper than standard video diffusion, but frame-by-frame generation is still a more demanding approach than serving a fixed coded page. The prototype’s stated visual-quality target is 720p.

Accessibility and software integration are unfinished

A rendered image does not automatically expose the structured semantics that screen readers and other assistive technologies rely on. It also does not inherently provide the inspectable state, event structure, and predictable interfaces that many software systems need. Analysts have identified the absence of a conventional DOM and accessibility layer as a major obstacle to deploying this approach in accessibility-sensitive or highly auditable settings.

Is Solaris available?

Solaris was presented as experimental research rather than a broadly available production platform. Reports describe it as a research preview with early-access availability or access by request, rather than a generally released app-building product.

That means its current importance is primarily conceptual and research-oriented. It demonstrates a possible direction for software interfaces, but it does not yet offer evidence that teams can use it as a drop-in replacement for coded applications.

How Solaris relates to Runway’s GWM-1

Solaris is related to Runway’s broader world-model research but serves a different purpose. Runway describes GWM-1 as a general-purpose, real-time simulator covering environments, avatars, and robotic manipulation. Solaris narrows that world-model idea to software interfaces: the “world” being simulated is an app or website and the user’s actions drive its evolution. 12

In that sense, Solaris extends Runway’s focus from generating media to generating interactive visual environments. The interface is not merely a video to watch; it is a scene that responds to actions and is regenerated as the interaction continues.

Why Runway believes Solaris could matter

A different path to software creation

If the approach becomes reliable, creators could describe a visual environment, products, goals, and behaviors in natural language rather than implementing every possible state in code. That could be especially useful for exploratory, spatial, or highly visual experiences where conventional UI layouts are restrictive.

The trade-off is that flexibility would come from generation rather than explicit program logic. For production software, teams would still need predictable behavior, testability, data integrity, accessibility, and integration with other systems—areas Solaris has not yet demonstrated it can replace conventional engineering practices in.

A new interface layer for AI agents

Solaris also points toward a way for AI agents to operate in unfamiliar visual environments. Instead of depending entirely on fixed APIs or hard-coded workflows, an agent could interpret an interface as a dynamic world, take an action, observe the resulting state, and continue from there.

That ambition is significant for agents that must navigate interfaces not designed around a known automation schema. But it remains a research direction. Reliable structured APIs and conventional accessible software still offer important advantages for tasks that require auditability, precision, and repeatable execution.

The practical takeaway

Solaris is best understood as a research preview of generative software interfaces, not as the end of application code. Its distinctive idea is to make the interface itself the model’s output: a sequence of AI-generated frames guided by a language model and shaped by user actions.

Runway’s reported study indicates that people sometimes prefer this approach for natural interaction and instruction following. Yet the unresolved problems—text accuracy, factual grounding, long-session coherence, generation cost, accessibility, and integration—are central product requirements, not minor polish issues. Solaris shows what an interface world model might become, while also making clear why conventional code remains difficult to replace.