Runway Solaris Generates Software UIs -- No Code Required
Every few months, the AI industry produces a story that quietly rewrites an assumption everyone had stopped questioning
That assumption is: to make software, you need to write code. HTML renders a page, React builds a component, Swift draws a button. It has been the foundation of every digital product for thirty years.
Runway just threw that foundation out the window.
Its new offering, Solaris, is the first model in a category the company calls "Interface World Models." Instead of running code to produce a user interface, Solaris generates the interface itself -- frame by frame, at inference time, in 720p, responding to clicks, drags, and voice commands as if the screen were alive.
This is not a faster way to build apps. It is a fundamentally different idea of what an app even is.
What Solaris actually does
Solaris builds on Runway's video generation lineage -- specifically Gen-4.5 and the earlier General World Model (GWM-1). But where those models generated scenes of the physical world, Solaris generates the interface world: buttons, text fields, scrollable lists, shopping carts, product views, and interactive controls.
The architecture splits the work. A language model decides how the interface should change in response to user input. The world model renders each resulting frame. Together, they produce a responsive environment that does not know it is an environment -- because there is no underlying codebase to know.
Runway demonstrates several use cases:
Online shopping. The store itself becomes the interface. A user drags a shirt onto a picture of themselves to try it on. The shop is no longer a fixed layout that everyone sees the same way -- it is a generated environment that adapts to each shopper.
Product visualization. You say "move the table" or "change the color of the couch," and the scene reacts instantly. The model understands spatial relationships and object properties.
Interactive tutorials. Instead of a chatbot delivering a wall of text, Solaris shows the next step visually in its own context. A combustion demo, for instance, animates the piston stroke as the student clicks through.
The "app" as a fixed unit is the thing being killed
Runway's larger claim is pointed: the app as a fixed, pre-built unit should disappear.
Today, getting something done means opening the right app for the job -- one for shopping, one for messaging, one for reservations. Each app is a static snapshot of decisions a designer and developer made months ago. Every user sees the same layout. Every session starts from the same homepage.
Solaris inverts this. If the interface is generated, there is no homepage. There is no fixed layout. There is no "build" step between the idea and the interaction. The interface becomes a conversation, not a destination.
Whether users actually want interfaces that keep changing -- that never settle into a familiar layout -- is a separate question. But the technical possibility alone reshapes the landscape.
Where it breaks down
Runway is clear about what Solaris cannot do yet.
Stable, readable text in generated interfaces remains a hard problem. Interfaces depend heavily on labels, prices, error messages, and navigation text, all of which must be legible and consistent. The current generation of world models struggles with this.
Long sessions are another open challenge. An interface that remembers what you did five minutes ago and maintains coherent state across dozens of interactions requires a memory model that world models do not natively provide. The language model component helps, but the joint system is still rough.
Reliability is the third gap. A traditional app fails in predictable ways -- a null pointer, a missing dependency, a network timeout. A generated interface can fail in unpredictable ones: the model misinterprets a click, generates a button that does not look clickable, or produces text that is nearly but not quite readable.
These are the reasons Runway is positioning Solaris as a research effort, looking for launch partners through an early access form rather than a public release.
The structural threat to software engineering
This is where the story stops being about Runway and starts being about the industry.
The global software engineering labor market is valued at roughly $300 billion. A significant fraction of that work is frontend and full-stack development: translating designs and product requirements into code that renders interfaces. Solaris proposes a world where that translation step is unnecessary.
This does not mean developers disappear overnight. The technology is early, the text problem is hard, and enterprise-grade reliability is years away. But the direction is clear. The value chain of software -- design, code, render -- is being compressed from code and render into generation. The middle link, which employs millions of people, is the one under pressure.
The irony is that the same companies investing billions in AI infrastructure are also the ones whose developer workforce stands to be disrupted. Microsoft, Google, Amazon, and Meta all employ tens of thousands of engineers writing the code that makes their interfaces work. Solaris-style generation would, in its mature form, replace much of that work.
What comes next
Runway is not the only company exploring this direction. Several labs are working on what might be called "generative UIs," and the underlying trend -- AI that produces interactive experiences rather than text answers -- is broad across the industry. But Solaris is the first concrete product in the category, and it sets the terms of the debate.
The coming questions are not technical. They are economic and organizational. If an app can be generated rather than coded, who owns the user? If the interface is different for every person, who tests it? If there is no codebase, who is liable when something breaks?
The answers to these questions will define the next era of software. Solaris did not provide them. It only made them impossible to ignore.