Runway Solaris: Why Generated Interfaces Need Designers

Runway has introduced Solaris, an early research system that generates interactive interfaces frame by frame as people use them. That sounds like a product demo designed to make a product designer stare at the ceiling for a while. It is also a serious shift in how interface work might be imagined. Instead of producing code that a browser turns into a page, Solaris renders the interface itself and treats clicks, drags, and typed requests as signals for what should appear next.

Runway announced Solaris on August 31, 2026, describing it as the first in a category called Interface World Models. The company says the system is built on its Gen-4.5 video model, adapted to understand interaction and respond in real time. Its announcement of Solaris is unusually clear about both the ambition and the unfinished bits, which is refreshing. The unfinished bits are substantial. Designers should pay attention to both.

What Solaris actually changes

Most digital products use an intermediate layer. A designer makes decisions about layout and behavior, a developer expresses those decisions in code, and a browser renders the result. That chain has its irritations, but it gives teams something inspectable, testable, and repeatable. Solaris takes a different route. A language model decides how the experience should respond, while the world model generates the visual result one frame at a time.

The result is closer to a live visual environment than a conventional website. A person might drag a shirt from a virtual rack onto a reference image of themselves, move a table in a room, or add ingredients to a bowl. These actions aren't selecting a predefined screen so much as conditioning the next generated state. Runway's research overview describes the approach as autoregressive frame generation, with mouse interactions used as inputs for the visual state that follows.

Independent coverage from CMSWire reports that Solaris has no HTML, CSS, or JavaScript underneath the generated view. That detail matters. It means the interface isn't a skin placed over a familiar application model. The visual output is the application, at least in the research system being shown today.

Why designers should care

Solaris points to three changes in the designer's job, even if it never becomes a shippable product in its current form.

• Interaction becomes a material. Art direction traditionally controls color, type, composition, image treatment, and motion. In a generated environment, the response to a gesture becomes part of the visual language. A drag can feel elastic, physical, theatrical, or simply like the software has misplaced its keys.
• Prototypes become closer to experiences. A static flow can show what a product does under expected conditions. A generative scene can explore what happens when a person acts in an unplanned way. That could be useful for early concept work, spatial commerce, interactive storytelling, and product visualization.
• Brand systems gain a behavioral layer. A brand guide may eventually need to describe not only how a button looks, but how a room rearranges itself, how a product responds to touch, and how much surprise the experience is allowed to contain. The last point is important. “Delightful” is often one unexpected transition away from “why is the sofa melting?”

Runway's own examples are deliberately physical: clothing try-ons, room layouts, and objects that respond to direct manipulation. That direction is useful because it gives the model something to anchor to. The more an experience depends on dense navigation, precise copy, or regulated flows, the less forgiving the approach becomes.

The useful bit is the constraint, not the magic

Solaris is strongest in the areas where generated video already has a reasonable chance of looking convincing: ambient movement, scene transitions, and click-and-drag interactions. It is a compelling fit for a concept showroom, an installation, an interactive campaign prototype, or a product story where the atmosphere carries as much weight as the task.

That doesn't mean every interface should become a simulated room. A checkout flow still needs a clear price, a reliable cart, and a way to recover when a payment fails. A design tool still needs predictable controls. A product team still needs to know whether a user completed the task, not merely whether the interface looked persuasive while doing something adjacent.

The important design question is therefore not “Can an AI make an interface?” It can make something that resembles one. The better question is “Which parts of this experience benefit from being generated continuously?” A designer's answer might be the visual layer, the behavior of a scene, or the exploratory stage of a concept. It probably shouldn't be the source of truth for inventory, permissions, pricing, or a user's accessible route through a task.

Where Solaris falls over today

Runway lists several open problems in its technical discussion of Solaris. Stable, legible text remains difficult, which is inconvenient because interfaces are unusually dependent on stable, legible text. Long sessions can lose visual and semantic coherence. A convincing wrong answer can be more dangerous than an obvious failure, especially in commercial or instructional experiences.

Accessibility is the larger professional concern. A generated view doesn't automatically provide the semantic structure that screen readers, keyboard navigation, browser tools, analytics, and quality checks expect. CMSWire's report also highlights the absence of a DOM and the resulting integration challenge. These aren't minor polish issues for a later sprint. They're part of the product's basic contract with its users.

Speed is another practical question. Runway says Solaris is designed for interactive response and visual quality at 720p. That may be enough for a concept, a guided experience, or an installation. It raises harder questions for a global product: latency, compute cost, device support, privacy, repeatability, and what happens when two people need the same interaction to produce the same answer.

A sensible studio workflow

1. Start with one scene, not an entire product. Pick an experience where direct manipulation adds value, such as exploring a product, rearranging a space, or demonstrating a process.
2. Write the behavior before the prompt. Define the starting state, allowed actions, expected responses, failure states, and the moments where a human needs clarity. A prompt is not a product requirement, however many glossy demos suggest otherwise.
3. Build a reference kit. Include approved product imagery, brand rules, type guidance, motion references, and examples of what the system must not invent. pixelbrief.ai can help turn an early idea into an AI-powered design brief and visual starting point, which gives the experiment something more useful than a heroic sentence about “the future of interaction.”
4. Keep a coded fallback. Treat the generated layer as an experiment until it can meet requirements for content, accessibility, analytics, security, and repeatable behavior. For many teams, the best result will be a visual prototype that informs a conventional build.
5. Test the awkward moments. Try keyboard-only navigation, zoom, long sessions, missing data, ambiguous requests, and users who do not follow the intended path. The awkward moments are where an interface stops being a mood board and starts being a service.

What this means for design teams

Solaris is less a replacement for interface design than a proposal for a new medium. It treats software as something that can be staged, animated, and regenerated in response to a person, rather than as a fixed collection of screens. That opens interesting territory for art directors and interaction designers, especially in experiences where atmosphere, spatial logic, and physical metaphor matter.

It also makes the designer's judgment more important, not less. Someone still has to decide what the interface is for, what it must preserve, where it should surprise people, and when surprise becomes a support ticket. Solaris is an intriguing research preview. For now, the smart move is to use it to explore behavior and visual possibility, then bring the parts that need trust, access, and accountability back into tools and systems that can explain themselves.