今天,我们分享 Solaris:这是我们称之为 Interface World Models 的全新 AI 系统家族中的首个模型。Solaris 始于一个问题:当一个操作系统在你使用它的过程中实时生成应用和网站时,会发生什么?
从早期的终端到 Linux 和 macOS,每一个操作系统都决定了屏幕上渲染什么,以及当人或程序对其操作时会发生什么。应用程序构建在其之上,并保持固定不变,直到有人推送更新。而 Solaris 则直接渲染这一层。它是一个实时交互模型,逐帧生成界面本身。每一帧都在你交互时被合成,使界面能够持续响应你的操作。
设计比以往任何时候都更加注重视觉,像素级精确的模型图和图像模型能够生成几乎与成品难以区分的完整界面。但图像并不像网站或应用那样运行。如今构建的每一款软件仍然需要一次转换:视觉设计必须先被转换为一种中间表示(例如代码),然后才能做任何事情。
这种中间表示限制了界面可以是什么样子,以及它如何响应人类和智能体的交互。每一种行为都必须事先被明确定义并实现,因此软件在发布时,只是对可能交互空间的一种有损压缩,在任何用户到来之前就已经被冻结。同样的转换过程也牺牲了视觉保真度。一旦设计被简化为一种简化表示,界面就能快速响应,但代价是放弃了原始设计的大量丰富性。
Solaris 将渲染与交互统一处理,消除了我们今天在设计中所关联的许多权衡。单一世界模型生成每一帧以及对用户输入的每一个响应,无需中间表示。由于没有转换步骤,也就没有损失,整个画面本身即成为界面。
我们认为 Solaris 开辟了构建网站、应用及其他在线界面的新方式。但它也是一种在更加动态的环境中训练智能体的新方法。即便是当今最好的 LLM,也难以完成基本的计算机使用任务,比如预订酒店或订购杂货。由于基于文本的模型被训练来使用编码界面,它们往往学到的是训练时所针对的特定布局,无法适应稍有差异的界面(比如两个不同的酒店网站)。通过压缩动作与响应之间的空间,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)进行了对比。两个系统都从同一张图像出发,并接收相同的交互请求,我们记录了各自的响应方式。随后,我们开展了一项用户研究,涵盖 30 个交互示例、共 250 名参与者,收集了近 7,500 组两两对比判断。在每次对比中,参与者需回答两个问题:“哪个结果更好地遵循了给定指令?”以及“哪个在场景中的表现更自然?”
参与者在两项指标上都更偏好 Solaris。在遵循所请求的交互方面,Solaris 在 61% 的对比中更受偏好,而编码结果仅为 24%,另有 13% 被评为相当。在行为自然度方面差距更大,Solaris 在 71% 的对比中更受偏好,而编码网站仅为 21%,另有 6% 被评为相当。
第二个结果凸显了两种方法之间更广泛的差异。编码界面通常能够复现所请求的更改,但它将交互视为对界面的一次孤立更新。而在 Interface World Models 中,由于模型已经理解了物体、材质和环境的行为方式,它能够生成在场景中感觉连贯一致的交互,而不是将每个 UI 操作当作孤立元素来处理。
它目前还做不到什么
Solaris 最擅长环境运动、点击拖拽交互和场景过渡。但仍存在若干重要挑战:
- 文本。 稳定、清晰的文本始终是视频生成中最棘手的问题之一,而界面对其依赖程度几乎超过任何其他视觉领域。一条切实可行的路径是采用混合系统:当可以接受短暂停顿时,由图像模型渲染文本密集的视图;而视频模型则负责处理连续交互。完全实时生成的文本仍是一个尚未解决的挑战。
- 可信度。 对于教学或商业体验而言,一个令人信服的错误答案比没有答案更糟糕。如今,Solaris 通过你提供给它的内容来保持锚定。起始帧可以由真实的产品图像和参考素材构成,从而将场景扎根于实际存在的事物之上。随着会话的推进,基于更丰富的已验证上下文(参考图像、产品数据、文档)来条件化生成,是一个活跃的研究重点。
- 长会话。 在长时间、开放式的交互中保持视觉和语义的一致性,仍然是一个活跃的研究领域。
- 可访问性与集成。 生成的界面仍然需要能在软件栈的其他部分中正常工作,包括屏幕阅读器和无障碍 API 等辅助技术,这样灵活性才不会以牺牲可用性为代价。
这些挑战反映了实时生成模型当前的前沿水平,我们预计它们将随着底层模型本身的进步而改善。
新型界面
Solaris 是迈向全新操作层的第一步,我们看到了多种新的交互模式正在涌现。
- 应用不再是与你交互的基本单元。如今,要完成一件事意味着打开为此预先构建的应用——一个用于购物,另一个用于看新闻,还有一个用于餐厅预订。如果操作系统能够生成有用的界面,那么无论用户想做什么,都无需再将软件归入固定的应用目录。你所需的一切会直接出现,并为你量身定制。
- 界面世界模型消除了在视觉构想与中间表示之间进行转换的需要。无需通过 UI 框架、组件和代码来实现,任何视觉概念都可以变成可交互的界面。
- 店面不再是每位访客看到的固定布局。它变成了一个生成式环境,在保持品牌识别度的同时适应每一个个体。产品、布局、颜色、材质和推荐会围绕你的意图实时重塑,让你的品牌和产品在超个性化体验中依然保持可辨识度。
- 教程不再为每个人重放相同的流程。相反,它们会在你自己的情境中呈现下一步,随着你的进展而调整,并在你偏离脚本时自然地恢复。
我们预计界面生成会沿着与图像和视频生成相同的轨迹发展:每一代模型都会变得更快、更连贯、更可控、能力更强。那些曾让生成式界面显得不切实际的挑战,如今越来越像是可解决的工程问题。
Solaris 是我们的首个 Interface World Model,我们很期待继续探索生成式软件能够成为什么样子——从更丰富的交互、更强的落地能力、更持久的体验,到如今尚不存在的全新界面形态。我们正与重要合作伙伴携手,将 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.