Runway Solaris: The AI Model That Generates Interactive Interfaces

What happens if software interfaces no longer need to be coded before people can interact with them? That question sits at the heart of Runway Solaris, an ambitious new approach to building interactive software that challenges decades of design and development practice.

Introduced on August 31, 2026, Runway Solaris is the first model in a new family of AI systems called Interface World Models. Rather than relying on traditional code to define how an interface looks and behaves, Solaris generates the interface itself, frame by frame, in real time as users interact with it. The result is software that feels less like navigating predefined screens and more like interacting with a dynamic, responsive environment that evolves continuously around your actions.

This represents a fundamental shift in how we think about software architecture. For more than half a century, the pipeline has been straightforward: a designer creates visual mockups, a developer translates those mockups into code, and the code runs in a browser or application. Every behavior must be explicitly programmed. Every interaction is finite and predetermined. Solaris disrupts that workflow entirely. Instead of designing first and coding second, Solaris generates both the visual appearance and the interactive behavior simultaneously in response to user input.

The potential implications extend far beyond traditional software development. Runway sees implications for AI agents learning to adapt in dynamically changing environments, for personalized shopping experiences that reshape themselves around individual customers, and for a future where interfaces become adaptive experiences rather than fixed applications. But the current reality is more measured: Solaris is a research technology demonstrating what becomes possible when visual generation and interaction reasoning combine into a single system.

Key takeaway: Solaris does not simply generate code for an interface. It generates the interface itself as users interact with it, treating each user action as input that conditions the next visual frame.

Runway Solaris: Quick Summary

Runway Solaris is an Interface World Model that generates interactive software interfaces frame by frame in response to user actions, without relying on underlying code.

What is an Interface World Model? A new category of AI systems that combine visual generation with interaction understanding, producing interfaces dynamically rather than implementing them through a fixed intermediate representation like code.

How does Solaris generate interfaces? A language model interprets user intent and determines how interactions should affect the environment. A visual world model then renders that state frame by frame, with each user action (clicks, drags, typing) conditioning the next generated frame.

How do users interact with it? Through natural input like clicking, dragging, typing, and verbal instructions. The model learns from these interactions and responds by generating the next visual state, creating interfaces that evolve based on context.

How is Solaris different from conventional coded interfaces? Traditional software implements interfaces through code that defines predefined states. Solaris generates states dynamically, enabling open-ended interactions that never had to be explicitly programmed in advance.

What are the main use cases? Interactive shopping environments, dynamic design tools, learning simulations, and creating training environments for AI agents that must adapt to continuously changing interfaces.

Is Solaris publicly available? Runway is working with partners toward a public launch and currently accepts early-access requests through an online form.

Bottom line: Solaris is an experimental approach to generating software interfaces dynamically rather than building every possible interaction into fixed code beforehand. It remains a research technology, not yet a production-ready tool for commercial software development.

What Is Runway Solaris?

Runway Solaris is an Interface World Model that treats the entire visual interface as a generated output. This marks a departure from how software has been built for decades. In conventional software development, designers create mockups, developers translate those designs into code, and that code defines what appears on screen and what happens when users interact with it. The interface is essentially locked in place at deployment.

Runway describes this traditional approach as requiring an “intermediate representation” (code) that stands between the original design and the interactive interface. That translation step, they argue, inevitably costs something. Visual fidelity can degrade when a richly detailed design is reduced to simplified code. Interactions become constrained by what developers anticipated and implemented. Behavior must be explicitly programmed.

Solaris removes that intermediate step. Instead of design becoming code becoming interface, Solaris generates the interface directly. A starting image provides context (for example, a photo of a physical room or a product scene). The user interacts with that image. A language model reasons about what that interaction means. A visual world model then synthesizes the next frame, taking the user’s action into account. That frame becomes the interface. The cycle repeats with each new user action.

The distinction is subtle but significant. This is not simply a “no-code app builder.” Those systems still rely on predefined logic and workflows. Solaris is fundamentally different: the interface itself is the output, generated in response to interaction rather than implementing behavior through an intermediate layer.

Key takeaway: The most important distinction is not that Solaris uses less code. It is that Solaris generates the interface directly instead of using code as an intermediate step between design and interaction.

How Does Runway Solaris Work?

User Interactions Become Model Inputs

Traditional software treats user input as a trigger for programmed logic. Click a button, and predefined code executes. Drag an object, and hardcoded physics or animation rules apply. Solaris inverts this model. User interactions become conditioning signals for the next generated frame, much like text prompts condition image generation.

When a user clicks on an object, drags an element, or types text, Solaris treats that action as data informing what should appear next. The model has learned associations between interactions and visual outcomes. It understands that clicking an object often means selecting it, dragging might mean moving it, and typing typically means inputting text. But because the model learned these associations from training data rather than from explicit programming, it can generalize to interactions never explicitly coded.

A Language Model Handles Higher-Level Reasoning

Solaris is not a purely visual system. A language model runs alongside the visual world model, operating at the strategic level while the visual model handles rendering. The language model interprets user intent, determines whether an interaction should modify the current scene or transition to a new one, defines the physical or behavioral rules that make the world feel alive, and generates the natural-language prompts that guide the visual model frame by frame.

This separation of concerns is crucial. High-level reasoning about what the interface should do resides in the language model. Low-level rendering of how that behavior appears visually resides in the visual world model. The language model might decide that a user’s click should rotate an object. The visual model then renders that rotation across multiple frames, handling lighting changes, reflections, and the smooth motion that makes the interaction feel natural.

The Visual World Model Generates the Interface

While the language model reasons about intent and behavior, the visual world model performs the actual frame generation. This is where Solaris builds on Runway’s Gen-4.5 video model. Gen-4.5 was trained to synthesize video clips given text prompts and starting images. Solaris adapts that capability for interactive, real-time generation.

Rather than generating an entire video clip in one pass, Solaris generates frames one at a time, with each frame depending on what came before. This autoregressive approach is essential for interactivity. The model cannot predict future frames until it knows what the user will do next. By generating only the next frame based on prior context, Solaris can incorporate user input at every step.

Autoregressive Generation Enables Real-Time Interaction

“Autoregressive” means each output depends only on previous outputs. In Solaris, each generated frame depends only on the starting image, all previous frames, and the user’s current action. It never attempts to predict multiple frames into the future or refine dozens of possible interpretations. It generates the next frame.

This design choice enables real-time performance. Standard video diffusion models are iterative: they start with noise and refine it through dozens of “denoising” steps to produce a high-quality output. This refinement process works well for pre-recorded video generation but is far too slow for interactive systems. Users expect interfaces to respond in under 500 milliseconds. Solaris meets this threshold by committing to each frame immediately rather than spending seconds perfecting it.

Few-Step Distillation Reduces Generation Latency

Creating a visually coherent frame in interactive time requires significant optimization. Runway addressed this through “distillation,” a technique that compresses a complex multi-step model into a simpler, faster version. Their approach takes the original Gen-4.5 model (which uses many denoising steps) and distills it into a model that requires only a few steps to produce similarly high-quality frames.

The distilled model runs significantly faster while maintaining visual quality, bringing frame generation times into the interactive range. This represents a practical engineering solution to a fundamental tension between quality and speed.

The Model Is Trained on Its Own Outputs

A common challenge with generative models is that errors compound over time. A small inaccuracy in one frame can propagate into the next, degrading quality as generation continues. Solaris addresses this through self-training: after distillation, the fast model is trained on its own generated outputs rather than only on high-quality source data.

This approach helps the model remain stable during extended interactions. By training on frames it generates itself, the model learns to correct for its own patterns and maintain coherence across long sequences of generation.

Simplified workflow:
User action → Language model reasoning → Interaction conditioning → Frame generation → Updated interface → Next user action

What Can Runway Solaris Do?

Interactive Shopping

Runway’s demonstrations showcase Solaris in a virtual clothing store. A user provides a photo of themselves as a reference. They can pick up clothing items from racks, drag them onto themselves to see how they look, arrange the display, or change lighting. The environment responds naturally. Fabric drapes with weight. Lighting reflects off surfaces. The scene feels physically grounded rather than like isolated UI elements responding to clicks.

This moves beyond conventional e-commerce, where product images are static and customers choose from predefined variations. With Solaris, the store itself becomes dynamic. A user could ask the interface to “show me that jacket in the corner” or “make the lighting warmer,” and the visual environment would respond immediately.

Interactive Design Environments

Runway demonstrated users manipulating objects within virtual scenes. Users can drag elements, change their properties through natural language, and observe how those changes propagate through the scene. A user might say “move the table so I can see how it looks in the other room,” and the interface generates that viewpoint and physical rearrangement in real time.

This breaks from conventional design tools that rely on menus, palettes, and parameter inputs. The scene itself becomes the interface.

Interactive Learning and Simulations

Another demo showed an interactive simulation of combustion. Users can drag different materials into the interface, and the model generates physically plausible reactions based on what those materials are. A user experiments by adding different elements and observes how they interact. The interface does not rely on predefined outcomes; instead, it leverages the model’s learned understanding of how materials behave.

This approach could transform education and scientific exploration. Instead of text-based explanations followed by canned demonstrations, learners interact with dynamic simulations that generate their next state based on their actions.

Open-Ended Interfaces

One of Solaris’s defining characteristics is that it does not depend on predefined screens or templated flows. Users can ask for interactions that never existed in the training set. Because the interface is generated rather than selected from a fixed menu, the system can respond to novel requests.

This open-endedness is particularly significant for AI agent training. Current AI agents learn by interacting with coded websites and applications. Those layouts are fixed. If an agent trains on a hotel booking website and that website changes its layout, the agent must relearn. With Solaris, the interface layout never exists in a fixed form. This forces agents to generalize rather than memorize specific layouts.

Runway Solaris vs AI App Builders and Coded Interfaces

A critical misconception is that Solaris is simply another “no-code app builder” or an AI agent that generates code. It is neither. Understanding the distinction is essential for evaluating what Solaris actually represents.

Conventional no-code platforms use AI to generate application code from descriptions. You describe what you want, the AI writes code, and that code defines the interface. The intermediate representation is still there; AI simply automates its creation. Coding agents work similarly: they write or modify software based on your instructions.

Solaris eliminates the intermediate representation entirely. There is no code being generated. The interface output is pixels generated in real time by a world model, not code that a browser interprets.

This distinction matters because it opens possibilities that conventional approaches cannot easily achieve. A coded interface, whether written by human developers or AI agents, must be deterministic. The same input should produce the same output. Solaris can be more fluid. The same starting state and the same user interaction can result in different interface responses because the generative process introduces variation. That flexibility is valuable for adaptive interfaces.

However, this fluidity also introduces challenges. Determinism is often valuable in software. Users expect interfaces to behave consistently. Trust is difficult when responses can vary unpredictably.

Runway Solaris Performance and Research Results

Runway conducted a user study comparing Solaris against coded interfaces to quantify the performance differences. Both systems started from the same image and received the same interaction requests. Participants then compared the results.

The study involved 250 participants evaluating 30 interaction examples, collecting nearly 7,500 pairwise judgments. Participants answered two questions: “Which result better follows the given instruction?” and “Which behaves more naturally within the scene?”

These results demonstrate that participants preferred Solaris responses on both measures. The preference was larger for natural behavior, suggesting that Solaris’s main advantage lies not in following explicit instructions more accurately but in generating interactions that feel physically and contextually grounded.

Runway’s explanation is insightful: a coded interface treats each interaction as an isolated update. If a user asks a coded interface to “lift this object,” the system changes the object’s position. But objects exist within scenes. They cast shadows. They reflect light. They respond to gravity. A coded interface implementing a simple position change ignores those contextual details. Solaris, because it understands how objects and environments behave, generates interactions that preserve physical plausibility.

This is the real strength of the approach: not that Solaris can follow instructions better, but that it generates interactions that feel congruent within the scene rather than treating each action as an isolated manipulation.

These results should be interpreted as findings from Runway’s reported study, not as universal proof that generated interfaces have surpassed coded software. The comparison involved specific scenarios. Results would likely differ in other contexts, particularly those requiring deterministic behavior or complex state management.

Key takeaway: The most important technical challenge is not visual quality alone. It is maintaining speed, coherence, and reliability during continuous interaction while keeping generation costs manageable.

What Are the Limitations of Runway Solaris?

Text Rendering Remains Difficult

Stable, legible text is one of the hardest unsolved problems in video generation. Interfaces depend on text more than almost any other visual domain. Every button needs a label. Forms need field names. Confirmations need messages. Current video models consistently fail at maintaining text across frames. Characters morph, spacing shifts, letters appear and disappear.

Runway acknowledges this as a critical limitation. For text-heavy interfaces like forms, search results, or messaging applications, Solaris faces a fundamental challenge. The company suggests a hybrid approach: deploying image models to render text-heavy views during brief pauses while the world model handles continuous interaction. This workaround preserves interaction fluidity but introduces discontinuity when text needs to be read or edited.

Trust and Grounding

A visually convincing wrong answer is worse than no answer at all. For commercial or instructional applications, trust is paramount. A shopping interface that generates a plausible-looking product description that is factually incorrect undermines customer confidence. An educational interface that generates physically implausible demonstrations misleads learners.

Solaris currently depends on being anchored through starting frames composed of real reference material: actual product photography, verified data, genuine images. As sessions extend and the model generates increasingly removed from those grounded inputs, the risk of hallucination increases. Runway identifies “conditioning generation on richer verified context” as an active research focus, suggesting that future versions might incorporate product databases, document references, or real-time data feeds to maintain grounding throughout a session.

Long-Session Consistency

Maintaining visual and semantic coherence becomes exponentially harder the longer a session continues. Objects that existed early in the interaction might disappear later. Layouts might subtly shift. Colors might gradually desaturate or intensify. These small inconsistencies accumulate, degrading the experience.

The distillation and self-training approaches help but do not solve the problem entirely. Session consistency remains an active research frontier. Users expect interfaces to maintain state across long interactions. A shopping session that gradually forgets items in a cart, or a design environment where previously positioned objects lose their relationships, fails to deliver the consistency users demand.

Accessibility and Integration

Generated interfaces have no DOM (Document Object Model), no semantic HTML, no hooks for accessibility APIs. Screen readers cannot interact with pixels. Keyboard navigation does not apply to generated frames. Users who rely on assistive technologies cannot use Solaris-powered interfaces without significant additional infrastructure.

This is not a technical oversight; it is a fundamental architectural limitation. Making generated interfaces accessible requires either developing entirely new accessibility paradigms designed around frame-by-frame visual generation or designing hybrid systems where generated content coexists with traditional accessible markup. Either path requires substantial research and development.

Integration with existing software stacks presents similar challenges. Databases need to persist state. APIs need to communicate with the interface. Payment processors need to complete transactions. Solaris currently generates visual interfaces. Connecting those interfaces to backend systems, databases, and third-party services remains an open problem.

Generation Cost

Generating every frame is computationally more expensive than serving a prebuilt webpage. A traditional website is built once and served millions of times. Solaris must generate a unique visual sequence for each user, in real time. The work that enabled real-time performance also reduced costs compared to standard video diffusion models, but the cost curve remains higher than static web interfaces.

For consumer applications at scale, this cost differential matters significantly. The economics of generating an interface dynamically for every user interaction are less favorable than the economics of serving cached static pages. Runway expects costs to improve, but currently this represents a practical constraint.

What Could Solaris Mean for the Future of Software?

Personalized Interfaces

Rather than every user seeing the same interface layout, Solaris could generate personalized experiences adapted to individual users in real time. Not just rearranging predefined elements, but generating interfaces that reflect a user’s context, preferences, and immediate intent. A shopping interface could prioritize products based on what the user has browsed, adapt layout based on device and viewing context, and personalize recommendations without relying on predefined recommendation templates.

AI-Native Shopping

Shopping could transform from clicking through product pages to interacting with dynamic environments that preserve brand identity while adapting around individual shoppers. A fashion brand’s website could generate a personalized showroom where product photography, layout, lighting, and recommendations all reshape continuously based on user interaction.

Adaptive Tutorials

Educational content could generate its next step based on the learner’s specific context and progress. Rather than replaying the same tutorial sequence for every user, Solaris could render the next step in the learner’s own environment, adapting as they make progress and recovering naturally when they deviate from the expected path.

AI Agent Environments

For AI agents learning to interact with software, Solaris offers a fundamental advantage: the interface never exists in a fixed form. Current language models trained to complete computer-use tasks like booking hotels or ordering groceries struggle to adapt when interface layouts change. With Solaris, every interaction occurs with a slightly different interface. This forces agents to develop more robust strategies than memorizing layouts.

A Shift From Apps to Generated Experiences

Runway’s broader vision imagines an operating layer that generates interfaces on demand rather than requiring users to navigate a fixed catalog of applications. Instead of choosing which app to use for a task, the system generates the interface needed. This would decouple software design from application distribution and make interfaces truly adaptive around user intent.

This remains speculative and faces significant technical and business hurdles. But it represents the trajectory Runway envisions: moving away from the app as the atomic unit of software toward generated experiences that adapt continuously.

Is Runway Solaris Available to the Public?

Runway introduced Solaris as an early technology and is working with key partners toward a public launch. The company currently provides an early-access request form for interested users. Solaris is not generally available; access requires applying through Runway’s official channels and being selected for the early program.

No pricing has been announced. No public launch date has been confirmed. This is not a finished product ready for commercial deployment. It is a research technology that Runway is selectively sharing with partners and research organizations to gather feedback and demonstrate capabilities.

Who Could Benefit From Interface World Models?

Best for:

AI researchers exploring generative interfaces and how world models can produce interactive experiences.

Product teams experimenting with AI-native experiences and exploring what continuous interface adaptation might enable.

Designers exploring interactive environments and how generative systems might expand creative possibilities.

Developers researching alternatives to fixed UI architectures and considering how visual generation might reshape interface design.

AI-agent researchers working on environments that force agents to generalize rather than memorize specific layouts.

Businesses exploring future customer experiences and how personalized, dynamically generated interfaces might differentiate their offerings.

Not yet ideal for:

Mission-critical software requiring deterministic, predictable behavior and guaranteed state consistency.

Text-heavy interfaces requiring perfect text rendering and content accuracy.

Accessibility-critical applications without additional infrastructure to support assistive technologies.

Systems requiring long-term deterministic state and interaction history.

Teams looking for a conventional, production-ready application builder.

Final Verdict

Runway Solaris is significant because it challenges the assumption that an interface must be translated into conventional code before becoming interactive. This alone is a substantial conceptual contribution. By demonstrating that visual generation and interaction can operate jointly, Solaris opens a different possibility space for how software might be built.

Its most interesting contribution is the combination of visual generation, interaction understanding, language-model reasoning, and dynamic environment rendering. No single piece is novel. Video models generate visual content. Language models reason about behavior. But combining them to produce interactive interfaces that respond to real-time user input represents a new approach.

Current limitations around text rendering, grounding for trust, long-session coherence, accessibility integration, and generation cost mean that Solaris should currently be viewed as an important research direction rather than a replacement for coded software. For many applications, conventional software remains superior. Determinism is valuable. State consistency is often essential. Text readability is non-negotiable. For applications where those constraints are less stringent, or where personalization and adaptation are paramount, Solaris demonstrates genuine promise.

The possibility worth watching is not whether Solaris will replace all software development. It will not. Rather, it is whether interfaces increasingly become generated experiences that adapt continuously to user intent rather than fixed implementations deployed once. That shift, even if partial and selective, would represent a meaningful change in how software evolves. Solaris demonstrates it is technically possible. Whether it becomes practical at scale remains to be seen.

Frequently Asked Questions

What is Runway Solaris?

Runway Solaris is an Interface World Model that generates interactive software interfaces frame by frame in response to user actions. Rather than using code as an intermediate representation, Solaris generates the interface directly as pixels, eliminating information loss during the design-to-implementation translation.

How does Runway Solaris work?

A language model interprets user intent while a visual world model renders frames in real time. User interactions (clicks, drags, typing) condition each generated frame. The system combines autoregressive generation, distillation, and self-training to maintain visual quality and coherence during continuous interaction.

What is an Interface World Model?

An Interface World Model combines visual generation with interaction understanding. It generates interactive interfaces dynamically in response to user input, departing from traditional approaches where interfaces are implemented through intermediate representations like code.

Does Runway Solaris generate code?

No. Solaris generates pixels, not code. The generated interface output is visual frames produced by a world model, not application code that a browser interprets. This eliminates the intermediate step traditional software development requires.

How is Solaris different from an AI app builder?

AI app builders generate code that developers then deploy. Solaris generates the interface directly without an intermediate code layer. The distinction is fundamental: Solaris produces a visual interface; app builders produce code that produces an interface.

Can Runway Solaris create interactive websites and apps?

Solaris can generate interactive visual experiences. Creating production-quality software requires additional capabilities around state management, data persistence, accessibility, and integration with backend systems. These challenges remain areas of active research.

Is Runway Solaris available to the public?

Runway is working with key partners toward a public launch and currently accepts early-access requests. Solaris is not generally available for public use without qualification or selection into the early program.

What are the biggest limitations of Runway Solaris?

Text rendering, grounding for trust in commercial applications, maintaining consistency over long sessions, accessibility integration, and the computational cost of real-time generation remain the primary challenges. These represent the frontier of real-time generative models research.