Runway Solaris generates working interfaces without code, and it questions what software even is

A natural consequence is that the interface is not deterministic. Open the same app twice and you may not get identical pixels. Disqualifying for a banking app, entirely acceptable for a game or a creative tool.

The study numbers are strong

Runway ran a pairwise comparison with 250 participants across 30 examples, collecting nearly 7,500 judgments. Two headline results:

On instruction following, Solaris was preferred 61 percent of the time against 24 percent for coded interfaces. On what the study called natural behavior, the gap widens to 71 percent versus 21 percent.

The company also published a reconstruction test. Hand a multimodal language model an existing interface and ask it to express that interface as text or code, and a large share of the visual information disappears in transit. That is the core of Solaris's argument: converting an interface to text is lossy, so stop converting.

These numbers deserve caution. Runway ran the study, no independent evaluation exists yet, and a preference metric can quietly blend aesthetics with function. Even so, 71 to 21 is too wide to be measurement noise.

Why the bet might be right

The story of the last three years in software has been models getting better at writing code. Solaris bets differently: maybe code is the wrong target for interfaces.

Writing a React component to describe what a button does is a bit like writing pixel coordinates to describe a face. It works, but there is a translation layer between the tool and the goal that earns nothing. Video models learn physics and motion without routing through code; they learn the image. Applying the same approach to interfaces is not an unreasonable move.

The real gain is not speed, it is flexibility. A coded interface covers the states its developer anticipated. In an interface produced by a world model, there is no such thing as an unanticipated state, because the model decides again on every frame. A user doing something nobody planned for produces a new frame rather than an error screen.

Generating code versus generating the screen

Put the two approaches side by side and the distinction sharpens.

Ask a language model for an interface and it translates your intent into text, the text into code, and the browser translates code into pixels. Three translations, three places to lose information. The code a model produces from the phrase "a thin navigation bar on top" reflects the most common pattern in its training data rather than the visual meaning of that phrase. It is why AI-generated interfaces all look like each other.

Solaris has one translation: intent to pixels. The model learned directly, from millions of screens, how things look and move. How a menu slides open, how a button darkens under a press, how a list behaves mid-scroll; those are represented as observed motion rather than as CSS rules.

The reconstruction test Runway published is offered as evidence for this argument, and it is reasonable evidence. Hand an existing interface to a multimodal model and ask it to rebuild the thing in code, and the result resembles the original without matching it. The loss comes from the carrying capacity of the target format, not from any weakness in the model.

Where it would actually work today

Saying Solaris cannot ship to production is not the same as saying it is useless. Three areas where non-determinism is not a problem are already visible.

Prototyping first. Seeing how a product idea feels currently takes a designer, a prototype tool and a few days. An interface that is fuzzy but fluid tells you more than a static mockup does.

Games second. Game interfaces were never obliged to be deterministic, and players tolerate visual inconsistency far better. Procedural generation has been ordinary in that industry for thirty years.

Third, long-tail software. The single-user, single-use tools nobody thinks are worth writing. No one spends two weeks on a three-screen app to run a warehouse count, so that work happens in a spreadsheet instead. That gap is the most realistic target for the no-code, real-time claim Runway made in its announcement post.

Where it hits a wall

Solaris is early access. There is no generally available app, no API, no open weights; Runway says it is working with key partners toward a public launch and has published a request form. Trade coverage read the announcement as a preview of the no-code internet, a description that captures both the ambition and the distance still to cover.

Three obstacles look serious. Cost first: generating every frame through a diffusion model is orders of magnitude more expensive than letting a browser draw the same interface. The 720p ceiling and limited frame rate follow from that.

Reliability second. No task that requires correctness can tolerate an interface capable of hallucinating. From the user's side there is no difference between your balance being calculated wrong and your balance being drawn wrong.

Accessibility third. Screen readers, keyboard navigation and automated test tooling all work through the DOM. An interface generated as a pixel stream has no DOM to read. That problem has to be solved before this becomes a product.

What it means if you write software

In the short term, nothing. Solaris cannot go into production today and will not within the next year.

The medium term is where it gets interesting. Every time producing interfaces got cheaper, the center of gravity moved from presentation toward logic. Site templates ended hand-written static HTML, low-code tools ended bespoke CRUD panels. Solaris aims at the next layer: the screen itself. The work that survives is where data lives, which rules apply, and who can access what. That work already sat underneath the interface.

The long-term question is bigger. App stores, browsers and operating systems are all built on the assumption that there is a fixed interface layer. Remove that assumption and the distribution model changes with it. Runway calling Solaris an operating system is not marketing decoration; it shows exactly how far the claim reaches.

For now what exists is an early-access research project running at 720p. The direction is clear, and it points less at how software gets built than at what software is.