Runway Solaris: How Interface World Models Could Change the Way We Build Software

Today, August 31st, 2026, I read an exciting development from Runway, introducing their brand new Solaris model. What makes this announcement so interesting to me, is that it brings to market a whole new class of AI models - what Runway is calling the world's first Interface World Model.

While we'll have to wait and see how an Interface World Model like Solaris actually performs in the real world, it's hard not to see the many possibilities it presents as a designer, design engineer, and creative director:

What if the apps we use in our daily lives did not require a traditional interface underneath them? What if developers didn't have to try to plan for every actions that a user might take in their app?

What if there were no HTML, CSS, component libraries, or predefined screens to render when you clicked a button? What if interfaces could generate in real-time, responding to your unique actions as you used it?

That's the idea behind Solaris, Runway's freshly announced Interface World Model.

Announced on August 31, 2026, Solaris is the world's first attempt at something that could eventually fundementally change how software is designed, built, and used. Instead of translating a visual design into code and then rendering it on a user's screen, Solaris generates the visual interface directly as it's being used.

The implications are significant for designers, developers, marketers, and anyone building digital experiences.

They're also easy to overstate - as is the case with many developments in the AI industry and tech in general.

With that said, it's worth prefacing that Solaris is still an early research product with substantial limitations (in particular, constraints related to text, accessibility, trust, long sessions, and integration with existing software.) Runway itself acknowledges these limitations.

Still, the underlying concept is worth paying attention to. Which is why I wanted to write this article to give my thoughts in the moment.

What Exactly Is Runway's Solaris?

Solaris is the world's first Interface World Model, developed by Runway. As described by Runway themselves, an Interface World Model is a real-time AI system designed to generate interactive interfaces frame by frame instead of relying on a traditional coded interface.

And it's this "real-time generation" distinction that truly matters.

Most software follows a standard pipeline:

Design → Code → Render → User Interaction

A designer creates the visual side of things. A developer translates that into an intermediate representation, such as HTML, CSS, JavaScript, native application code, or a game engine. The end user's operating system and browser then render the final result.

Solaris takes a fundamentally different approach: the visual environment becomes the interface itself.

Runway describes this as removing the intermediate representation between the visual idea and the experience the user interacts with. Instead of defining every possible behavior ahead of time as is typically done, the system continuously generates what happens next based on the current visual state and the user's actions.

That makes Solaris much closer to a dynamic, user-generated environment than a traditional application.

And that aspect is what is most interesting to me.

How Does an Interface World Model Work?

The separation of reasoning and rendering

Solaris is not simply a video model responding to mouse movements.

Runway describes it as a split between reasoning and rendering.

A language model interprets what the user wants and determines how the interface should evolve. Solaris then generates the visual result, producing the next frame based on the current state and interaction.

Put in simple terms:

The language model decides what should happen. Solaris decides what that looks like.

That architecture allows a natural-language instruction to directly guide the interface itself, without requiring a developer to explicitly program every possible interaction.

For example, Runway presents the idea of turning objects inside an interface into tools. Clicking on a cat could make subsequent clicks apply the cat's fur color and texture to another object. Clicking on a painting could turn its visual style into a drawing tool.

That is a very different interaction model from clicking through a toolbar full of predetermined buttons and functions.

How did Runway solve the speed problem?

Real-time interaction creates a major technical problem. And in my opinion, this is where we'll have to see how Solaris actually handles real-world use cases and gets stress tested.

Traditional video diffusion models can take seconds or minutes to generate a clip. That is perfectly acceptable when generating a finished video, but completely impractical for software that needs to respond while someone is dragging a cursor.

Runway identifies three core engineering challenges: speed, coherence, and cost.

For speed, Solaris generates frames "autoregressively", meaning each frame depends on what came immediately before it. Runway then distilled the original multi-step denoising process down to just a few steps, substantially reducing the compute required to generate the next frame.

This is an crucial shift in architecture.

Instead of creating a complete video and then playing it back, the model effectively generates the interface as you're using it.

How does Solaris maintain visual consistency?

As you're likely familiar with, AI tends to really struggle with consistency, in particular with longer form video.

People and objects warp and change appearance. Text becomes nonsensical. Small errors stack over time, leading to an end result that looks visibly different than the start or the reference material.

Those problems are especially dangerous in software, where users expect an object, button, product, or feature to remain the same throughout an interaction.

Runway says it addressed this by training the faster Solaris model on its own outputs, helping preserve visual quality and coherence across longer interactions. The company specifically identifies stable text, layouts, and object identity as major challenges for interface generation.

This does not mean the problem is solved, though.

Runway explicitly lists long-session coherence and legible text among the areas that still need significant improvement. So this alone could hamper Solaris' usability - in the short-term at least.

What about cost?

As you can imagine, generating every individual frame of an interface is inherently much more computationally expensive than serving a webpage that was already built beforehand.

That makes efficiency critical.

Runway says the same architectural work that made Solaris able to operate in real-time also made it orders of magnitude cheaper to run than standard video diffusion, although the company acknowledges that cost remains an important consideration.

For a concept like Interface World Models to work itself into mainstream software infrastructure, the economics will matter every bit as much as the technical capabilities.

Why Is Solaris a Paradigm Shift for UI and UX?

Ultimatley, the most important element of Solaris may have little to do with video.

It's about where software behavior comes from.

Traditional software requires anticipating all possible interactions before the user even arrives.

A developer decides beforehand what happens when a button is clicked. They define how a specific feature will behave. They determine which states are possible and how the interface transitions between them.

That creates reliable software, but it also creates boundaries, and an inherent scalability limitation.

Solaris gives us a model where those behaviors may able to be generated dynamically, and scalability may no longer as much of an issue.

Interfaces can respond directly to the user's intent, rather than simply executing a predefined set of behaviors and forcing the user to try to work within the boundaries of the app or website.

Runway describes this as making interfaces "open-ended." The same visual environment can support interactions that were not explicitly designed into it ahead of time.

From my perspective, this legitamately could fundamentally change the role of the interface.

Instead of selecting an application and learning how its interface works, users could interact directly with whatever they are trying to accomplish.

That could mean dragging ingredients into a virtual bowl to build a salad. It could mean manipulating objects in a virtual showroom. It could mean changing the environment itself with natural language.

The interface behaves less like a collection of predetermined actions, and more like a dynamic environment.

What Happens When the App Stops Being the Unit of Interaction?

This is one of the most interesting ideas presented in Runway's announcement.

Today, software is organized around applications.

You open Amazon to buy something. You open Google to look something up. You open Figma to create something (or increasingly nowadays, Claude Code.)

Runway argues that Interface World Models could eventually make that application-centric structure less important. Instead of opening a predefined application, the operating system could generate the interface required for the task at hand.

Imagine asking your computer:

"Help me compare these three couches in my living room."

Rather than opening a furniture website, navigating product pages, uploading a photo, and using a separate visualization tool, the system could potentially generate an interactive environment around the task.

The software itself would assemble around your intent - forming itself to the goal you're triyng to achieve..

That is a much bigger and more useful idea than AI-generated websites.

It suggests a future where software becomes disposable, contextual, and personalized.

What Can We Build With Solaris?

We can only really speculate on the practical applications, but Runway's demonstrations point toward some compelling directions:

Immersive commerce

A static product page could eventually become a generated environment. Less one-size-fits-all, more tailored to your tastes and needs.

Imagine starting with a photograph of a clothing store. The system could transform that image into an interactive showroom where users move through the space, manipulate products, try on clothing, and change the environment dynamically.

Runway specifically demonstrates a virtual clothing store where users can interact directly with garments and the surrounding environment.

For brands, this opens a very different approach to digital commerce.

The storefront itself becomes part of the shopping experience, enhancing the product.

Generative design tools

Design software could become far more contextual.

Instead of opening Photoshop, Illustrator, Figma, or another application and selecting from a fixed set of tools, an interface could generate the tools required for the task.

Working on a painting could produce brushes based on the artwork.

Editing a photograph could generate controls specific to that image.

Building a brand identity could create an interface around the particular visual system being developed.

The software would adapt to the work rather than forcing the work into the software.

AI agent training

This may become one of the more important applications of Interface World Models.

AI agents currently interact with software through interfaces that were designed for humans. Runway argues that this creates a problem because agents can become overly dependent on the specific layouts and patterns they were trained on.

A generated environment could create much more varied training scenarios.

An agent could encounter interfaces that constantly change while still behaving logically within the environment.

That could make training digital workers more robust and closer to the unpredictable nature of real-world interaction.

Disposable interfaces

Perhaps the simplest use case is also one of the most practical.

Sometimes you only need software for five minutes.

Today, that usually means finding an existing application, learning its interface, performing the task, and closing it.

With generated interfaces, the software itself could be temporary.

Describe the task. Generate the environment. Complete the task. Move on.

That could eliminate entire categories of small, specialized applications.

Is Runway Solaris Replacing Software Developers?

No, not immediately. Solaris is a research-stage system with substantial technical limitations. Its more realistic near-term impact is shifting some development work from explicitly programming interfaces toward defining environments, behaviors, data, and natural-language logic.

There will still be a need for engineering, infrastructure, security, data systems, APIs, accessibility, and integration with existing software.

The bigger question is what developers spend their time building.

Does Solaris Use HTML or CSS?

Solaris does not use HTML or CSS as the underlying representation of the generated interface. It renders the interface directly as a continuously generated visual environment.

That is one of the central ideas behind the Interface World Model concept.

However, this does not mean HTML, CSS, or conventional software development disappear. Solaris still needs to integrate with the rest of the software stack, and Runway specifically identifies accessibility and integration as unresolved challenges.

What Is the Difference Between a World Model and a Video Generator?

A video generator primarily creates video content. A world model is designed to represent an environment and respond to actions within it. Solaris extends that concept to interfaces, generating visual states based on ongoing user interaction.

That distinction is important.

Runway's GWM-1, announced in December 2025, was designed as a General World Model capable of simulating interactive environments, avatars, and robotic scenarios. Solaris applies a related concept specifically to software interfaces.

What Can Solaris Not Do Yet?

This is where the hype surrounding technologies like Solaris needs some restraint.

Runway openly identifies several major limitations.

Text is still a problem. Stable, readable text is one of the hardest challenges in generative video, and software relies heavily on text. Runway suggests that hybrid systems may be necessary, combining generated video for continuous interaction with other rendering approaches when text-heavy views require precision.

Trust is another major issue. A convincing visual interface that generates incorrect information could be dangerous in commercial or instructional contexts. Runway says it is exploring stronger grounding through verified product data, documents, reference images, and other contextual inputs.

Long sessions remain difficult. Maintaining both visual and semantic consistency during extended open-ended interaction is still an active research problem.

Accessibility is unresolved. A generated interface still needs to work with screen readers, accessibility APIs, and the broader software ecosystem. Generative flexibility cannot come at the expense of basic usability.

These limitations are important because they reveal what Solaris actually represents today.

It is not a finished replacement for the modern web.

It is a demonstration that an entirely different computing model may be possible.

What Does Solaris Mean for Designers?

For designers, the implications could eventually be profound.

The traditional relationship between design and development has always involved translation.

Designers think visually.

Developers convert that visual idea into a system of rules and components.

Browsers and operating systems turn those rules back into pixels.

Interface World Models attempt to shorten that chain dramatically.

That does not make designers into programmers, nor does it eliminate the need for engineering. It does suggest that visual thinking could become a much more direct input into software itself.

The designer's role could increasingly involve defining environments, interaction logic, behavior, systems, and intent rather than simply producing static screens.

That direction aligns with a broader shift already happening across design and technology.

AI is increasingly capable of producing the first version of the artifact.

The next challenge is making the artifact useful, reliable, coherent, and controllable.

Solaris is taking that idea one step further by asking whether the artifact needs to be pre-built at all.

The Beginning of a Visual-First Web

Solaris is an early experiment, but the direction is difficult to ignore.

Runway is betting that the next generation of software interfaces will become more visual, more dynamic, and less dependent on predefined workflows. The company describes Solaris as the first step toward a new operating layer where interfaces can be generated around what a person is trying to accomplish.

That future is likely still far away from production-ready.

Text needs to become more reliable. Sessions need to remain coherent for much longer. Generated interfaces need strong grounding. Accessibility needs to work by default. The economics need to make sense at scale.

And those are significant problems.

They're also engineering problems, rather than purely conceptual ones - and that may be the most important takeaway from Solaris.

The idea of generating software visually would have sounded impractical only a short time ago. Runway is now demonstrating an early version of it working in real time.

We may be witnessing the interface becoming less like a document that software renders and more like a dynamic environment that software continuously creates in real-time.

That is a change worth watching, and I for one am genuinely excited for it.

‍