Runway Solaris does not generate a mockup and then turn it into code. It generates the interface itself, frame by frame, and reacts to clicks, drags, and language as a visual world. That removes the normal source-code layer, which is also why builders should treat Solaris as a research preview rather than a website replacement.
Runway calls Solaris the first Interface World Model. It is available through an early-access request, not as a generally available product with public pricing, an API contract, or a production service-level agreement. The accompanying paper was submitted to arXiv on September 1, 2026.
How Runway Solaris differs from generated code
A conventional AI website workflow translates intent into HTML, CSS, JavaScript, components, and assets. The browser then executes those deterministic instructions. Solaris keeps generation in the runtime loop. A world model synthesizes the next visual state based on earlier frames and the user’s action.
Runway says the approach is entirely visual, continuously alive, and open-ended. An object in the scene can become an interaction target even if a developer did not pre-program that exact behavior. A virtual room can respond when a user drags furniture, changes a surface, or asks for a new arrangement.
| Layer | Conventional web app | Solaris preview |
|---|---|---|
| Source of behavior | Code and stored application state | World-model generation conditioned on interaction |
| Visual output | Browser renders declared assets and layout | Model synthesizes each frame |
| Unexpected action | Usually ignored or rejected | May produce an open-ended visual response |
| Inspection | DOM, source, logs, tests, accessibility tree | Public preview does not define equivalent controls |
| Availability | Mature production stack | Early access with no public price or API guarantee |
Why this model was difficult to build
Runway identifies three constraints. Interaction stops feeling immediate around half a second of delay. The generated scene must remain coherent across a session. Generating every frame costs more than serving code that was built once.
Solaris builds on Runway’s Gen-4.5 video model. The company says it adapted the model for interaction and real-time response, then used autoregressive generation, distillation, and training on its own outputs to improve speed and stability. The target is visual quality that holds at 720p.
Runway says the system is orders of magnitude cheaper than a standard video diffusion model, while also acknowledging that it remains more expensive than serving a conventional page. Without a public rate card and workload definition, those statements cannot yet support a cost comparison.
The source-code gap is a product constraint
When an interface is generated as pixels, familiar engineering controls become less direct. A team cannot assume it has stable selectors, semantic HTML, deterministic navigation, or a diff that explains why one state changed. Search indexing, accessibility, analytics, localization, and automated testing all depend on structure that pixels do not automatically provide.
The model may still maintain an internal state or connect to conventional services, but Runway’s public material does not specify a DOM equivalent, event schema, data-binding contract, or deterministic replay format. Those missing details matter more to production than another polished demo.
Accessibility needs an explicit second channel
A generated visual can look clear while remaining opaque to a screen reader, keyboard user, or automated accessibility test. Builders should ask whether every interactive object exposes a stable name, role, value, focus order, and action outside the pixels. Captions and alt text are not enough for a continuously changing application.
A strong deployment design would generate or maintain a parallel semantic interaction tree and keep it synchronized with the visual state. The tree should survive style changes, support keyboard control, and let a reviewer compare the accessible and visible outcomes.
Security changes when the screen is probabilistic
Traditional interface security already fails when authorization lives only in a hidden button or client-side check. A generated interface increases the need for server-side policy because the model may render an action that was not anticipated. The backend must decide what is allowed independently of what appears on screen.
- Bind every consequential action to an authenticated server-side capability.
- Require confirmation for payments, external messages, deletion, and account changes.
- Log the input, generated state, requested action, policy decision, and resulting side effect.
- Provide a deterministic recovery path when the visual state drifts or becomes confusing.
Our AI agent containment guide explains why environmental enforcement must agree with the prompt. The same principle applies when the interface itself is generated.
Where Solaris could be useful first
The early fit is likely a bounded interactive experience where visual adaptation matters more than deterministic form handling. Training simulations, spatial product exploration, creative prototypes, educational demonstrations, and agent-training environments are better candidates than banking, healthcare consent, or a public checkout.
Runway also positions changing interfaces as a way to train computer-use agents that cannot memorize one layout. That is a promising evaluation use. A generator can vary placement, appearance, and interaction while preserving the task goal, forcing the agent to respond to meaning instead of a fixed screenshot.
For creative teams comparing current production tools, our AI video generator cost guide covers available systems with published prices. Solaris belongs in a different bucket until access and runtime economics are public.
A serious early-access evaluation
- Choose one bounded experience with no irreversible action.
- Define a conventional coded baseline with the same user goal.
- Measure response latency, session drift, visual quality, completion rate, and cost per session.
- Test keyboard use, screen-reader semantics, localization, and reduced motion.
- Replay the same interaction sequence and measure how often the outcome changes.
- Disconnect the model and verify that users can recover, save, or exit safely.
My verdict: treat Solaris as a new runtime, not a design tool
Solaris is interesting because it moves generation from creation time to interaction time. That can produce interfaces that feel less like menus and more like responsive visual environments. It also moves uncertainty into the live product, where accessibility, security, state, cost, and recovery are harder.
Do not ask whether Solaris can replace your frontend from a demo. Ask whether a generated runtime can expose the contracts your product needs. Early access should prove semantic structure, deterministic policy, auditability, and session economics. Until then, it is a strong research direction with a deliberately unfinished production story.
Read the primary research
- Read Runway’s Solaris introduction and early-access page.
- Review the Solaris research paper.
Checked September 4, 2026. Architecture, training approach, target resolution, and early-access status come from Runway and the project paper. Deployment tests and product guidance are Musthave.ai analysis.
