今天,我们发布 Solaris:这是我们称之为“界面世界模型”的全新 AI 系统家族中的首个模型。Solaris 从一个问题出发:当操作系统在你使用过程中实时生成应用和网站时,会发生什么?
从早期的终端到 Linux 和 macOS,每一个操作系统都决定了屏幕上渲染什么内容,以及当人或程序对其操作时会发生什么。应用构建在这些系统之上,并且一直保持不变,直到有人推送更新。而 Solaris 则直接渲染这一层。它是一个实时交互模型,逐帧生成界面本身。每一帧都在你交互的过程中被合成,使界面能够持续响应你的操作。
设计比以往任何时候都更加注重视觉呈现,像素级完美的设计稿和图像模型可以生成几乎与成品难以区分的完整屏幕画面。但图像并不能像网站或应用那样运行。今天构建的每一款软件仍然需要一次转换:视觉设计必须先被转化为一种中间表示(例如代码),然后才能发挥任何作用。
这种中间表示限制了界面的可能性,也限制了它如何响应人类和智能体的交互。每一种行为都必须事先被明确地定义和实现,因此软件交付时就像是对可能交互空间的一次有损压缩,在任何用户到来之前就已经被冻结。同样的转换过程也牺牲了视觉保真度。一旦设计被简化为一种简化表示,界面虽然可以快速响应,但代价是放弃了原始设计中的大量丰富性。
Solaris 将渲染和交互联合处理,消除了我们今天与设计相关的许多权衡取舍。一个单一的世界模型生成每一帧画面和对用户输入的每一次响应,从而无需中间表示。由于没有转换步骤,也就没有损失,整个帧本身就成为了界面。
我们认为 Solaris 开辟了构建网站、应用和其他在线界面的新方式。但它也是一种在更具动态性的环境中训练智能体的新方法。即便是当今最优秀的大语言模型,在完成基本的计算机使用任务时(比如预订酒店或订购 groceries)仍会遇到困难。由于基于文本的模型被训练用于使用编码接口,它们往往只会学习训练时所见的具体布局,而无法适应略有不同的界面(比如两个不同的酒店网站)。通过压缩动作与响应之间的空间,Solaris 让智能体能够在不断变化的界面、以及可能从未存在过的布局上进行训练。
新功能
Solaris 为软件带来了三项新能力。
首先,Solaris 是完全视觉化的。当图像本身成为应用时,就不再需要隐藏在用户所见视觉层之下的第二套实现步骤。想象一下浏览一家虚拟服装店,展厅本身就是界面。以你自己的一张照片作为参考,你可以从衣架上拿起一件衬衫,拖到自己身上试穿,或者像在实体店里一样自然地重新布置陈列。
其次,它是“活”的。由于应用是持续渲染的,它始终在演变,而不是等待用户的下一个操作。倒影会随光线变化而变化,物体在被操作时也会自然地做出响应。用户只需简单地说一句:“把桌子移一下,我想看看效果”,或者“把沙发的颜色换一下”。最终的结果是,软件不再像在脚本化的页面中导航,而更像是在与一个鲜活的场景进行互动。
最后,它是开放式的。传统界面仅限于开发者在开发期间预设的交互方式,但 Solaris 可以在同一场景中支持完全不同的行为,实时响应用户的交互。这种灵活性将界面与预定义的工作流程解耦,转而由驱动它的世界模型的能力来决定什么是可能的。
Solaris 将界面转变为一种交互式体验,而非一系列页面的堆叠。用户无需从菜单中选择选项,而是直接与场景本身进行互动。制作沙拉就像把食材拖入碗中一样简单,每添加一种食材,界面都会自然地做出响应。
为什么此前从未出现过这样的产品?
数字界面建立在两套系统之上,而这两套系统至今一直存在于不同的世界中。
- 那些“知晓事物”的系统(如搜索引擎和 AI 助手)以静态内容作答:文本、图片,或许还有一段嵌入式视频。
- 那些“实时响应”的系统(如 JavaScript/CSS、游戏引擎,以及近来的交互式世界模型)能创造丰富的交互式体验,但它们对你的产品、你的任务或你试图达成的目标一无所知。
我们传统上把软件界面视为确定性程序,把世界模型视为视觉内容的生成器。而一个“界面世界模型”必须同时兼具两者:它既是一个理解你意图的系统,同时又在持续渲染一个围绕该意图的交互式世界。
一旦你尝试构建这样的系统,三个工程挑战便会立刻浮现:
- 速度。当延迟达到半秒左右时,交互就不再具有交互感。视频扩散模型生成一段片段需要数秒甚至数分钟,这对内容创作来说可以接受,但对界面而言则过于缓慢。要跨越这一门槛,模型必须按顺序逐帧生成,每一帧仅依赖于之前的内容,并且成本足够低,以跟上用户的操作节奏。
- 保持连贯性。界面必须在整个会话过程中保持一致,而不仅仅是在单个片段内。它需要保留的内容(例如文本、布局、物体身份)恰恰是生成视频历来难以维持的东西,而且生成时间越长,小错误就越会累积放大。
- 成本。逐帧生成仍然比提供一次构建好的页面更昂贵。让 Solaris 实现实时运行的那项工作,同时也使其运行成本比标准视频扩散模型低了数个数量级,而且成本曲线还在持续改善。
Solaris 是我们押注这些概念性和技术性障碍可以被克服的赌注。我们以三个重点来构建它:实时交互、整个会话过程中的连贯性,以及在 720p 分辨率下依然成立的视觉质量。
Solaris 的工作原理
Solaris 构建在我们的 Gen-4.5 视频生成模型之上,我们对其进行了改造,使其(1)理解交互并(2)实时响应。它沿循了我们通过通用世界模型 GWM-1 开辟的道路。
学习交互。Solaris 将用户输入视为下一帧的条件输入,就像它对待文本或图像一样。模型在生成过程中观察点击、拖拽和其他交互,将它们作为接下来会发生什么的信号。由于模型只会看到已经发生的交互(绝不会看到未来的交互),它便学会了用户行为与视觉结果之间的关系。这意味着它知道当某个东西被点击、拖拽或修改时应该发生什么,而无需显式编写这些交互逻辑。
实时运行。标准视频扩散模型需要经过数十步去噪步骤来精修整段片段,这一过程对于动态用户交互而言过于缓慢。我们分三个阶段将 Solaris 转化为实时引擎。首先,我们教会它自回归地生成帧,每一帧仅依赖于之前的内容。其次,我们将多步去噪过程蒸馏为仅几步。最后,我们让快速模型在自己的输出上进行训练,以确保视觉质量在长时间交互中保持稳定。最终结果是以交互速度生成帧,同时保留原始教师模型的视觉质量。
推理与渲染。Solaris 逐帧生成界面,而语言模型决定该界面如何演变。大语言模型解读用户请求,判断交互何时应修改当前场景、何时应过渡到新场景,定义让世界显得鲜活的行为,并生成引导 Solaris 渲染每个状态的提示词。语言模型与世界模型共同将推理与渲染分离:一个决定应用下一步该做什么,另一个生成该行为如何呈现并在实时中做出响应。
持续生成。你提供一个起始状态(例如品牌环境或产品场景),模型便实时流式生成帧。当用户点击、拖拽或输入时,这些交互会被纳入接下来生成的帧中,场景就地做出响应。没有预定义的屏幕,也没有可依赖的模板。相反,文本提示词规定了点击、拖拽及其他交互在特定场景中的含义。
重新定义鼠标。一旦交互用自然语言描述而非编程实现,它们就不再需要预先固定。场景中的每个物体都可以成为一种新型工具。点击一只猫,你接下来的点击就会将它的毛色和纹理应用到你所触碰的任何物体上。点击一幅画,你或许就能开始以它的风格进行绘制。
评估 Solaris
翻译的成本
此前我们曾论证,将界面翻译为中间表示形式必然会造成信息损耗。为量化这一损耗,我们测试了当今多模态大语言模型能否仅凭一张截图就忠实地重建出界面。
为衡量这一点,我们评估了包括 Claude Fable 5 在内的最先进多模态大语言模型,测试其仅凭单张截图重建网站界面的能力。我们选取了 30 个风格各异的界面进行评测,涵盖从较简单的纯文本网页,到图片密集的网页以及自然图像,以全面考察模型在视觉理解不同维度上的表现。
我们通过两种互补的方式来衡量信息保留程度。其一,结构相似性(SSIM)将重建界面与原始界面进行逐位对比,以衡量视觉外观被复现的忠实程度。其二,我们利用 DINOv3 特征,将原始界面的每个区域与重建结果中任意位置最相似的区域进行比对,从而判断即便元素发生移动或布局有所改变,底层视觉内容是否依然得以保留。
重建保真度随视觉复杂度提升而变化。即便多模态大语言模型持续进步,重建质量仍会随着视觉复杂度的增加而稳定下降,这揭示了界面经由语言转译时所损失的信息。
尽管近年来进展迅速,但每个大语言模型在重建过程中都会丢失信息。自然图像受影响最为严重,因为丰富的视觉细节无法用语言精确表达。随着界面日趋复杂,文本、布局或结构上的细微变化都可能从根本上改变界面的行为方式。
Solaris 并非将界面转译为语言后再进行重建,而是直接作用于视觉界面本身。通过消除中间表示形式,它从第一帧起便完整保留了界面的视觉与语义状态。
Solaris 与编码界面
我们的重建基准测试衡量的是,当一个界面被翻译成代码时,会丢失多少信息。接下来我们要问:在给定相同界面和相同用户交互的情况下,哪种方法能产生更好的结果?一个编码界面能否像界面世界模型生成的界面那样,重现那种生动、响应式环境的感觉?
对比。虽然两个系统都对相同的交互请求做出响应,但 Solaris 保持了整个场景的连贯性,产生的交互感觉更自然、更符合物理规律。
为了回答这个问题,我们将 Solaris 与最先进的语言模型(Claude Opus 5)进行了比较。两个系统都从相同的图像开始,并收到相同的交互请求,我们记录了各自的响应方式。随后,我们开展了一项包含 250 名参与者的用户研究,覆盖 30 个交互示例,收集了近 7,500 个成对比较判断。对于每次比较,参与者需要回答两个问题:“哪个结果更好地遵循了给定指令?”以及“哪个在场景中的行为更自然?”
参与者在两项指标上都更偏好 Solaris。在遵循所请求的交互方面,Solaris 在 61% 的比较中被选中,而编码结果仅为 24%,另有 13% 被评为不相上下。在自然行为方面的差异更大,Solaris 在 71% 的比较中被选中,而编码网站仅为 21%,另有 6% 被评为不相上下。
第二个结果凸显了这两种方法之间更广泛的差异。编码界面通常可以复现所请求的更改,但它将交互视为对界面的孤立更新。而借助界面世界模型,由于模型已经理解物体、材质和环境的行为方式,它能够生成在场景中感觉连贯的交互,而不是将每个 UI 操作视为孤立元素。
它目前还做不到的事
Solaris 在环境动态、点击拖拽交互和场景切换方面表现最为出色。但仍存在几个重要挑战:
- 文本。稳定、清晰的文本仍是视频生成中最棘手的问题之一,而界面几乎比任何其他视觉领域都更依赖文本。一条可行的路径是采用混合系统:在允许短暂停顿的场景下,由图像模型渲染以文本为主的视图,而视频模型则负责处理连续交互。完全实时的文本生成仍是一个未解决的挑战。
- 信任。对于教学或商业类体验,一个看似可信的错误答案比没有答案更糟糕。目前,Solaris 依靠你提供的内容来保持锚定。起始帧可以由真实产品图像和参考资料构成,从而将场景锚定在真实存在的事物上。在会话进行过程中,基于更丰富的已验证上下文(参考图像、产品数据、文档)进行条件生成,是一个活跃的研究方向。
- 长会话。在长时间、开放式的交互中保持视觉和语义一致性,仍是一个活跃的研究领域。
- 无障碍与集成。生成的界面仍然需要能在整个软件技术栈中正常工作,包括屏幕阅读器和无障碍 API 等辅助技术,以确保灵活性不会以牺牲可用性为代价。
这些挑战反映了实时生成模型当前的前沿水平,我们预计它们将随着底层模型本身的进步而不断改善。
新型界面
Solaris 是迈向新操作系统层级的早期一步,我们看到了几种新的交互模式正在浮现。
- 应用不再是交互的基本单位。如今,完成某件事意味着打开为此专门预建的应用——购物用一个,看新闻用一个,订餐厅再用一个。如果操作系统能够生成有用的界面,无论用户想做什么,都没有必要再把软件归类到固定的应用目录中。你需要的东西会直接出现,并为你量身定制。
- 界面世界模型消除了在视觉构想与中间表示之间进行转换的需求。无需再通过 UI 框架、组件和代码来工作,任何视觉概念都可以直接成为交互式界面。
- 店面不再是一个每位访客都看到的固定布局,而是变成一个既保留品牌调性、又为每个个体量身适配的生成式环境。产品、布局、色彩、材质和推荐都会围绕你的意图实时重塑,让你的品牌和产品在超个性化体验中依然保持可辨识度。
- 教程不再为所有人重复播放同一套流程。相反,它们会在你自己的上下文中渲染下一步操作,随着你的进度实时调整,并在你偏离既定流程时自然恢复。
我们预计界面生成将沿着与图像和视频生成相同的轨迹发展:每一次模型生成都会变得更快、更连贯、更可控、更强大。那些曾让生成式界面显得不切实际的挑战,如今越来越像是可以解决的工程问题。
Solaris 是我们的第一个界面世界模型,我们很高兴能继续探索生成式软件的可能性——从更丰富的交互、更强的落地能力和更长久的体验,到如今尚不存在、全新类型的界面。我们正在与核心合作伙伴携手,推动 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 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.