Runway Solaris Turns Apps Into Live Video. The Buttons Now Improvise.

Somewhere inside Runway’s latest demo, a user clicks a cat and turns the animal’s fur into a paintbrush.

This is not a metaphor for enterprise transformation. It is an actual proposed interface behavior. Select the cat, then click other objects, and their surfaces inherit its color and texture. After forty years of graphical computing, during which humanity carefully standardized menus, buttons, scrollbars, and the sacred little X that rescues us from pop-ups, Runway has looked at the mouse pointer and asked: what if it could briefly become a cat?

I mean that as both a joke and a compliment.

On August 31, Runway introduced Solaris, the first member of what it calls “Interface World Models.” Instead of displaying an app or website assembled from code, fixed components, and predefined behaviors, Solaris generates the interface itself as a continuous stream of images. Every frame is synthesized in real time. Clicks, drags, and typed instructions become inputs to the next frame. A language model decides what should happen; the world model paints that decision onto the screen.

In the demo, this produces interfaces that behave less like forms and more like small responsive universes: assemble a salad by dragging ingredients into a bowl, explore combustion by dropping materials into a generated experiment, or move through a product scene that reshapes itself around what you are trying to do.

The idea is genuinely striking. It is also an aggressive proposal to replace software’s most boring virtue—doing the same thing twice—with a probabilistic movie that accepts mouse input.

Your App Is Now a Very Fast Dream

Traditional software separates the instructions from the picture. Code maintains state, enforces rules, talks to databases, and tells the interface what to show. HTML provides structure. CSS makes the structure presentable. JavaScript makes it move and occasionally consumes the afternoon of a developer who only wanted to center a modal.

Solaris tries to collapse much of the visible layer into generation. Runway says it adapted its Gen-4.5 video model to understand interaction and respond in real time. The system observes clicks and drags as conditioning signals, then predicts the visual result one frame at a time. An LLM interprets intent and supplies instructions to the renderer, separating the application’s reasoning from its appearance.

That matters because ordinary interfaces are finite. A developer must decide in advance what every control does. Solaris can generate responses that nobody explicitly coded, while preserving the visual context of the scene. The company’s broader GWM-1 work already applies real-time world models to explorable environments, interactive characters, and robotics simulation. Solaris points the same machinery at the rectangle where you currently answer email.

The result is not quite vibe coding. In vibe coding, a model writes the conventional code and you hope somebody eventually reads it. Here, the model skips the translation and generates the experience directly. This is vibe interfacing: there may be no button underneath the button. There may only be a convincing sequence of button-shaped pixels and a model predicting what buttonness ought to look like next.

The Benchmark Is a Beauty Contest, Because Of Course It Is

Runway compared Solaris with a coded interface generated by Claude Opus 5. Both started from the same image and received the same interaction instructions. In a study involving 250 people, 30 examples, and nearly 7,500 pairwise judgments, participants preferred Solaris 61% to 24% for following the requested interaction and 71% to 21% for behaving naturally within the scene.

Those are impressive numbers for the question Runway asked. They are not proof that Solaris should run payroll.

The test rewards visual faithfulness and natural motion—precisely the terrain where a video world model should beat code generated from a screenshot. A lighthouse scene that pans smoothly toward the waves is more convincing when rendered by a model trained to produce video than when reconstructed as a hurried web project. The benchmark says Solaris is better at making an image feel alive. It does not tell us whether it can preserve an account balance, submit a tax return once and only once, or remember that “delete” was supposed to require confirmation.

This distinction is not pedantry. It is the product.

Interfaces are not merely pictures that react. They are contracts. A checkbox should have a stable state. A quantity field should contain the quantity the user entered, not an aesthetically adjacent interpretation. A disabled control should remain disabled even if the generated lighting makes enabledness feel emotionally appropriate.

Runway acknowledges the frontier problems: long-session coherence, cost, grounding, accessibility, and integration with the rest of the software stack. Generating every frame remains more expensive than serving a page built once, even after the company says it has reduced costs by orders of magnitude relative to standard video diffusion. Solaris targets 720p and interactive speed, but Runway has not announced public pricing or general availability. It is working with partners and taking early-access requests.

Translation: the future of software is here, provided you fill out the form and do not ask what a million sessions cost.

The Weird Part Is Also the Smart Part

The easy response is to dismiss Solaris as an elaborate demo searching for a product manager. That would be a mistake.

Generated interfaces could be excellent wherever exploration matters more than rigid transactions. Education is the obvious case. A lesson about combustion does not need to be a fixed video or a worksheet wearing a website costume; it can become a manipulable scene that reacts to the learner. Product visualization could let shoppers rearrange rooms, inspect machines, or explore configurations without a team prebuilding every possible animation. Tutorials could render the next step inside the user’s actual context instead of replaying the same cheerful arrow for everybody.

Agent training may be even more important. Today’s computer-use systems often learn against stable screens and then become confused when a hotel site moves the date picker six pixels to the left. As our guide to computer-use agents noted, clicking is easy; recovering from an unfamiliar state is the real work. Solaris can generate endlessly changing layouts and interactions, giving agents a synthetic obstacle course instead of a memorized exam.

That is clever. It turns interface variability from a nuisance into training data. An agent that survives a thousand generated checkout flows may become less brittle on the thousand-and-first human one. Runway is not merely proposing an interface for people. It is proposing a gym for machines that need to understand interfaces.

There is a delicious irony here. The industry has spent years teaching agents to operate the structured web by looking at pixels. SiliconSnark’s guide to AI browsers explained why DOM access and native browser hooks are usually safer and more reliable than screenshot-level guessing. Solaris responds by removing the structure and generating the pixels too. We have invented a harder computer so the computer can practice harder.

Accessibility Cannot Be a Patch Note

The largest practical problem is not whether Solaris can make a salad tumble convincingly. It is whether a generated visual world can remain legible to everyone and interoperable with everything.

Screen readers depend on semantic structure: this is a heading, that is a button, this field has an error. Keyboard navigation depends on predictable focus. Automated testing depends on elements that can be addressed and states that can be asserted. Security systems depend on boundaries that are considerably more specific than “the scene seemed to understand me.”

Runway explicitly lists accessibility and integration as challenges, which is better than pretending the issue will be solved by a sufficiently heartfelt prompt. But the missing intermediate representation it celebrates is also where much of software’s accountability lives. Code can be audited. State can be logged. A transaction can be replayed. A component can expose an accessibility tree. If the interface is a generated audiovisual stream, Solaris will need an equally rigorous machine-readable layer beneath it—or the revolution becomes a gorgeous exclusion zone.

This is where comparisons with AI coding agents moving into the repo become useful. Coding agents produce artifacts humans can inspect: files, tests, diffs, builds. Solaris produces an experience. Experiences are easier to admire and harder to verify. The demo is never the hard part. The hard part is proving that tomorrow’s generated interface still obeys today’s permissions, business rules, and legal obligations when nobody is recording a launch video.

The Verdict: Real Shift, Dangerous Default

Solaris feels like a real technical shift disguised as an argument against the humble button.

Runway has taken the frame-by-frame machinery of generative video, made it interactive, paired it with language-model reasoning, and aimed it at software. The demos suggest that generated interfaces can achieve a fluidity and visual coherence that coded reconstructions struggle to match. The agent-training angle is especially credible. Dynamic environments are useful precisely because the world refuses to keep its menus where the model left them.

But “an app is now generated video” is not yet a general replacement for software. For expressive learning, branded experiences, simulation, prototyping, entertainment, and synthetic training environments, Solaris could open an important category. For banking, healthcare, administration, accessibility-critical workflows, or anything where the same input must reliably produce the same accountable result, determinism is not legacy baggage. It is the feature.

So yes, let the cat become a paintbrush. Let the museum exhibit answer back. Let the tutorial rebuild itself around the learner. Give agents a thousand hostile interfaces and see whether they stop clicking the decorative picture of a button.

Just keep the “transfer money” control boring for a little while longer.