Runway has announced a system called Solaris and describes it as the first model in a new category that the company calls Interface World Models.The approach differs fundamentally from everything that is usual in frontend development: no code is executed that builds a user interface.Instead, the model generates the user interface frame by frame while it is being operated.

In other words: what appears on the screen is not a rendered application with buttons, state management and data binding, but a continuously generated sequence of images that reacts to input.A click is then not an event that triggers a function, but a signal from which the model derives the next plausible screen content.

Why the term World Model appears here

The expression World Model originates from AI research and describes systems that build an internal representation of how an environment changes in response to actions.The principle became known through models that generate playable video sequences: you control, and the model calculates the next frame without a classic game engine running behind it.

Solaris transfers this idea to software interfaces.The "world" that the model simulates is an application: menus, forms, lists, detail views.That is consistent thinking, but it also shifts the problem.A game scene may deviate without anything breaking.An invoice overview may not.

What is interesting about this for projects

The most obvious benefit lies in prototyping.Clickable mockups – that is, clickable dummies of an application without real functionality – are today either static image sequences in a design tool or already hand-built code.Both cost time, and both are touched again with every change.

A model that generates interfaces at runtime could shorten this step: concepts would be walkable before a component library exists.For workshops, for alignment with business departments and for early user tests, this is a real advantage, because discussions about copy and wireframes often fail due to differing ideas.

The approach is also interesting as an exploration tool.Anyone who wants to compare several interaction ideas against each other can make variants visible faster than through built interfaces.The value lies in discarding, not in keeping.

Where the limits lie

Runway has presented Solaris; reliable statements about quality, latency, resolution or costs in continuous operation cannot be derived from that.Independently of this, the principle itself gives rise to several limitations that should be considered when assessing it.

  • Determinism. Business applications must react the same way to the same input.A generative model delivers plausible, not guaranteed results.For an approval or booking process, that is not a viable basis.
  • Data truth. A generated table shows numbers that look like data.Without a connection to systems of record, they are invented.That is harmless in a prototype and a liability issue in production operation.
  • Maintainability. A stream of frames leaves behind no artifact that a team can develop further, version and test.Yet that is precisely the purpose of code.
  • Accessibility. Screen readers and keyboard navigation require semantic structure – labels, roles, focus order.An image has none of that.
  • Traceability. Auditability, logging and error analysis require defined states.A generated interface does not offer them by itself.

How to use this sensibly today

The pragmatic way is a clear separation: generative interfaces where something is to be shown and discussed – built code where something must work reliably.In practice, that means drawing the boundary deliberately.

  1. Early phase: play through ideas and interaction patterns generatively, document decisions, record results as requirements.
  2. Transition: derive real components from what was convincing – with a design system, states, error cases and test coverage.
  3. Implementation: solve data binding, permissions, logging and accessibility in code, not in the image.

Managing expectations in the project is important.A smoothly operable generated prototype looks more finished than it is.If clients conclude from it that the application is ninety percent built, conflicts arise over budget and deadlines that have nothing to do with the technology.Prototypes should therefore be labelled as such and their scope stated explicitly.

A shift, not a replacement

What is emerging is a shift in the toolbox, not an end to frontend development.Effort moves from producing the first visible results to refining requirements, architecture and quality assurance.Anyone who can produce interfaces cheaply must decide all the more precisely which of them should be built – and why.

For web and software projects, this means concretely: generative interfaces are, in the short term, above all an accelerator in the concept phase and for alignment, not a replacement for implementation.Anyone who uses them should plan the transition from prototype to maintainable code from the outset, so that a convincing image does not become a technical promise that no one can keep.

Watching pays off – the decision about production systems is still made on code, data and responsibilities.

Sources