Introducing Solaris

Introducing Solaris: the first model in a new family of AI systems we call Interface World Models.

Today, we're sharing Solaris: the first model in a new family of AI systems we call Interface World Models. Solaris starts with a question: what happens when an operating system generates apps and websites as you use them?

Every operating system, from early terminals to Linux and macOS, has dictated what's rendered on screen and what happens when a person or program acts on it. Applications get built on top, and stay fixed until someone pushes an update. Solaris instead renders that layer directly. It's a real-time interactive model that generates the interface itself, frame by frame. Every frame is synthesized as you interact, allowing the interface to respond continuously to your actions.

Design is more visual than ever, with pixel-perfect mockups and image models that can generate entire screens that are nearly indistinguishable from finished products. But images don’t run like a website or app. Every piece of software built today still requires a translation: the visual design must first be converted into an intermediate representation (e.g. code) before it can do anything.

That intermediate representation limits what an interface can be, and how it responds to human and agent interaction. Every behavior has to be explicitly defined and implemented ahead of time, so software ships as a lossy compression of the space of possible interactions, frozen before any user arrives. The same translation process also sacrifices visual fidelity. Once a design is reduced to a simplified representation, the interface can respond quickly, but only by giving up much of the richness of the original design.

Solaris handles rendering and interactions jointly, removing many of the tradeoffs we associate with design today. A single world model generates every frame and every response to user input, eliminating the need for an intermediate representation. Because there’s no conversion step, there’s no loss, and the entire frame becomes the interface.

We think Solaris opens up new ways of building websites, apps and other online interfaces. But it’s also a new way to train agents, in much more dynamic environments. Even the best LLMs today struggle to complete basic computer use tasks, like booking a hotel or ordering groceries. Because text-based models are being trained to use coded interfaces, they tend to learn the specific layout they were trained on, and can’t adapt to a slightly different interface (say, two different hotel websites). By collapsing the space between action and response, Solaris lets agents train against interfaces that are constantly changing, and layouts that may never have existed before.

What’s New

Solaris brings three new capabilities to software.

First, Solaris is entirely visual. When an image becomes the application itself, there is no need for a second implementation step hidden beneath the visuals that a user sees. Imagine browsing a virtual clothing store where the showroom itself is the interface. Using a single image of yourself as a reference, you can pick up a shirt from a rack, drag it onto yourself to try it on or rearrange the display as naturally as you would in a physical store.

Second, it is alive. Because the application is continuously rendered, it is always evolving rather than waiting for the next user action. Reflections shift with the lighting, and objects respond naturally as they're manipulated. A user can say something as simple as: "Move the table so I can see how it looks" or “Change the color of the couch.” The result is software that feels less like navigating through scripted pages and more like interacting with a living environment.

Finally, it is open-ended. Traditional interfaces are limited to the interactions developers anticipated during development, but Solaris can support entirely different behaviors in the same scene, reacting to user interactions in real-time. This flexibility decouples the interface from predefined workflows, instead leaving the capabilities of the driving world model to determine what is possible.

Solaris turns an interface into an interactive experience rather than a sequence of pages. Instead of selecting options from menus, users interact directly with the scene itself. Building a salad is as simple as dragging ingredients into a bowl, with the interface responding naturally as each ingredient is added.

Why Hasn't This Existed Until Now?

Digital interfaces are built on two systems, which until now have lived in different worlds.

• The systems that know things (e.g., search engines and AI assistants) answer with static content: text, an image, maybe an embedded video.
• The systems that respond in real time (e.g., JavaScript/CSS, game engines and more recently, interactive world models) create rich, interactive experiences, but they know nothing about your products, your task or what you're trying to accomplish.

We've traditionally thought of software interfaces as deterministic programs and world models as generators of visual content. An Interface World Model has to be both at once: a system that understands your intent while continuously rendering an interactive world around it.

Once you try to build one, three engineering challenges immediately appear:

• Speed. Interactions stop feeling interactive somewhere around half a second of delay. Video diffusion models take seconds or minutes to produce a clip, which is acceptable for content creation but too slow for an interface. To cross that threshold, the model has to generate frames sequentially, with each frame depending only on what came before, cheaply enough to keep up with the user.
• Staying coherent. An interface has to remain consistent across an entire session, not just a single clip. The things it needs to preserve (e.g., text, layout, the identity of objects) are the same things generated video has historically struggled to maintain, and small errors compound the longer generation continues.
• Cost. Generating every frame is still more expensive than serving a page that was built once. The same work that made Solaris real time also made it orders of magnitude cheaper to run than a standard video diffusion model, and the cost curve continues to improve.

Solaris is our bet that these conceptual and technical barriers can be overcome. We built it with three focuses: real-time interaction, coherence over an entire session and visual quality that holds at 720p.

How Solaris Works

Solaris builds on our Gen-4.5 video generation model, which we adapted to (1) understand interaction and (2) respond in real time. It follows the path we opened with GWM-1, our general world model.

Learning interaction. Solaris treats user input as conditioning for the next frame, the same way it treats text or images. The model observes clicks, drags and other interactions as it generates, using them as signals for what comes next. Because the model only ever sees interactions that have already happened (never future ones), it learns the relationship between user actions and visual outcomes. This means that it knows what should happen when something is clicked, dragged or modified, without requiring those interactions to be explicitly programmed.

Running in real time. Standard video diffusion models refine an entire clip over dozens of denoising steps, a process that is far too slow for dynamic user interaction. We converted Solaris into a real-time engine in three stages. First, we taught it to generate frames autoregressively, with each frame depending only on what came before. Next, we distilled the many-step denoising process into just a few steps. Finally, we trained the fast model on its own outputs so visual quality remains stable over long interactions. The result generates frames at interactive speeds while preserving the visual quality of the original teacher model.

Reasoning and rendering. Solaris generates the interface one frame at a time, while a language model determines how that interface evolves. The LLM interprets user requests, decides when interactions should modify the current scene versus transition to a new one, defines the behaviors that make the world feel alive and produces the prompts that guide Solaris as it renders each state. Together, the language model and world model separate reasoning from rendering: one decides what the application should do next, while the other generates how that behavior appears and responds in real time.

Continuous generation. You provide a starting state (e.g. a brand environment or product scene) and the model streams frames in real time. As the user clicks, drags or types, those interactions are incorporated into the next generated frames, and the scene responds in place. There are no predefined screens and no templates to fall back on. Instead, text prompts specify what clicks, drags and other interactions mean in a particular scene.

Redefining the mouse. Once interactions are described in natural language instead of programmed, they no longer have to be fixed in advance. Every object in the scene can become a new kind of tool. Click on a cat, and your next clicks apply its fur color and texture to whatever you touch. Click on a painting, and you might begin drawing in its style.

Evaluating Solaris

The Cost of Translation

Earlier, we argued that translating interfaces into an intermediate representation inevitably degrades information. To measure that loss, we tested how faithfully today's multimodal language models can recreate an interface from a screenshot.

To measure this, we evaluated state-of-the-art multimodal language models, including Claude Fable 5, on the task of recreating website interfaces from a single screenshot. We evaluate across a diverse collection of 30 interfaces, ranging from simpler plain webpages to image-heavy webpages and natural images, which evaluate different aspects of visual understanding.

We measure information preservation in two complementary ways. First, structural similarity (SSIM) compares the reconstructed interface to the original in place, capturing how faithfully the visual appearance is reproduced. Second, we compare each region of the original with its most similar region anywhere in the reconstruction using DINOv3 features, measuring whether the underlying visual content survives even when elements move or the layout changes.

Reconstruction fidelity across increasing visual complexity. Even as multimodal language models continue to improve, reconstruction quality consistently degrades as visual complexity increases, revealing the information lost when interfaces are translated through language.

Despite rapid progress in recent years, every language model loses information during reconstruction. Natural images are affected most because rich visual detail cannot be represented accurately in language. As interfaces become more complex, even small changes to text, layout or structure can fundamentally alter how the interface behaves.

Rather than translating an interface into language and reconstructing it again, Solaris operates directly on the visual interface itself. By eliminating the intermediate representation, it preserves the complete visual and semantic state of the interface from the very first frame.

Solaris vs. Coded Interfaces

Our reconstruction benchmark measures how much information is lost when an interface is translated into code. We next ask: given the same interface and the same user interaction, which approach produces the better result? Can a coded interface recreate the same sense of a living, responsive environment as an interface generated by an interface world model?

Comparisons. While both systems respond to the same interaction request, Solaris preserves the coherence of the entire scene, producing interactions that feel more natural and physically grounded.

To answer this, we compared Solaris against a state-of-the-art language model (Claude Opus 5). Both systems started from the same image and received the same interaction requests, and we recorded how each responded. We then conducted a user study with 250 participants across 30 interaction examples, collecting nearly 7,500 pairwise judgments. For each comparison, participants answered two questions: “Which result better follows the given instruction?” and “Which behaves more naturally within the scene?”

Participants preferred Solaris on both measures. For following the requested interaction, Solaris was preferred in 61% of comparisons compared to 24% for the coded result, while 13% were rated as equivalent. The difference was even larger for natural behavior, where Solaris was preferred in 71% of comparisons compared to 21% for the coded website, with 6% rated as equivalent.

The second result highlights the broader difference between the two approaches. A coded interface can often reproduce the requested change, but it treats the interaction as an isolated update to the interface. With Interface World Models, because the model already understands how objects, materials and environments behave, it can generate interactions that feel coherent within the scene rather than treating each UI action as an isolated element.

What It Can't Do Yet

Solaris is strongest at ambient motion, click-and-drag interactions and scene transitions. Several important challenges remain:

• Text. Stable, legible text remains one of the hardest problems in video generation, yet interfaces depend on it more than almost any other visual domain. One practical path is a hybrid system in which image models render text-heavy views whenever a brief pause is acceptable, while video models handle continuous interaction. Fully real-time generated text remains an open challenge.
• Trust. For instructional or commercial experiences, a convincing wrong answer is worse than no answer. Today, Solaris stays anchored through what you give it. The starting frame can be composed from real product imagery and reference material, which grounds the scene in things that actually exist. Conditioning generation on richer verified context as the session unfolds (reference images, product data, documents) is an active research focus.
• Long sessions. Maintaining visual and semantic coherence over extended, open-ended interactions remains an active area of research.
• Accessibility and integration. A generated interface still needs to work inside the rest of the software stack, including assistive technologies such as screen readers and accessibility APIs, so that flexibility doesn't come at the expense of usability.

These challenges reflect the current frontier of real-time generative models, and we expect them to improve alongside the underlying models themselves.

New Kinds of Interfaces

Solaris is an early step toward a new operating layer, and we see several new interaction patterns emerging.

• The app stops being the unit you interact with. Today, getting something done means opening the pre-built app made for it – one for shopping, another for news, another for restaurant reservations. If the operating system can generate useful interfaces, no matter what the user wants to do, there's less reason to sort software into a fixed catalog of apps. What you need simply shows up, customized to you.
• Interface World Models remove the need to translate between a visual idea and an intermediate representation. Instead of working through UI frameworks, components and code, any visual concept can become an interactive interface.
• A storefront is no longer a fixed layout that every visitor sees. It becomes a generated environment that preserves the brand's identity while adapting to each individual. Products, layouts, colors, materials and recommendations reshape around your intent in real time, allowing your brand and products to remain recognizable within hyper-personalized experiences.
• Tutorials no longer replay the same sequence for everyone. Instead, they render the next step in your own context, adapt as you make progress and recover naturally when you go off script.

We expect interface generation to follow the same trajectory as image and video generation: every model generation will become faster, more coherent, more controllable and more capable. The challenges that once made generated interfaces seem impractical now look increasingly like solvable engineering problems.

Solaris is our first Interface World Model, and we're excited to continue exploring what generated software can become, from richer interactions, stronger grounding and longer-lived experiences to entirely new kinds of interfaces that don't exist today. We’re working with key partners to launch Solaris publicly. Fill out the form below to request early access.