Solaris 将渲染和交互联合处理，消除了我们今天在设计中常见的很多折衷。单一的世界模型生成每一帧以及对用户输入的每一次响应，消除了对中间表示的需求。因为没有转换步骤，就不会有损失，整个帧本身就成为界面。
我们认为 Solaris 开辟了构建网站、应用程序和其他在线界面的新方法。但它同样也是训练代理的新方式，适用于更加动态的环境。即便是当今最先进的大型语言模型（LLM）也难以完成：https://arxiv.org/abs/2606.29537 基础的计算机使用任务，例如预订酒店或购买杂货。由于基于文本的模型被训练以使用编码接口，它们往往会学习训练时所使用的特定布局，无法适应略有不同的界面（比如两个不同的酒店网站）。通过缩短动作与反应之间的空间，Solaris 让代理可以在不断变化的界面和可能从未存在过的布局中进行训练。
实时运行。标准的视频扩散模型需要经过几十步去噪处理整个视频片段，这一过程对于动态用户交互来说过于缓慢。我们将 Solaris 转换为实时引擎，共分三阶段。首先，我们让它以自回归方式生成帧，每一帧只依赖于之前的内容。接着，我们将多步骤去噪过程提炼为仅几步。最后，我们在模型自身输出上进行训练，以确保长时间交互中视觉质量保持稳定。最终生成的帧既能达到交互速度，又保留了原始教师模型的视觉质量。
推理与渲染。Solaris 每次生成界面的一帧，同时语言模型决定该界面如何演变。大语言模型解读用户请求，决定交互何时应修改当前场景或转入新场景，定义让世界栩栩如生的行为，并生成指导 Solaris 渲染每一个状态的提示。语言模型与世界模型协作，将推理与渲染分开：一方决定应用程序接下来应该做什么，另一方生成这些行为的实时外观和反应。
比较。虽然两种系统都对相同的交互请求作出响应，但 Solaris 保持了整个场景的一致性，产生的交互更加自然且具有物理基础。
为了回答这个问题，我们将Solaris与最先进的语言模型（Claude Opus 5）进行了比较。两个系统都从同一幅图像开始，并接收相同的交互请求，我们记录了每个系统的响应情况。然后，我们进行了用户研究，涉及250名参与者和30个交互示例，收集了近7,500条成对评价。在每次比较中，参与者回答了两个问题：“哪个结果更好地遵循了给定的指令？”和“哪个在场景中表现得更自然？”
Solaris 是我们的第一个界面世界模型，我们很高兴继续探索生成式软件可能的发展，从更丰富的交互、更强的基础和更持久的体验，到今天不存在的全新界面类型。我们正在与关键合作伙伴合作，公开发布 Solaris。请填写下面的表格以申请提前访问。
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：https://arxiv.org/abs/2606.29537 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.
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.
Digital interfaces are built on two systems, which until now have lived in different worlds.
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:
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.
Solaris builds on our Gen-4.5：https://runwayml.com/research/introducing-runway-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：https://runwayml.com/research/introducing-runway-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.
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.
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.
Solaris is strongest at ambient motion, click-and-drag interactions and scene transitions. Several important challenges remain:
These challenges reflect the current frontier of real-time generative models, and we expect them to improve alongside the underlying models themselves.
Solaris is an early step toward a new operating layer, and we see several new interaction patterns emerging.
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.
情报判断
Aioga 编辑摘要
Runway 发布 Solaris，称其为 Interface World Models 系列的首个模型。Solaris 可实时逐帧生成应用和网站界面，以图像作为交互层，并可用于训练智能体适应持续变化的界面布局。
扫码直达文章详情