Runway's Solaris Generates Apps as Live Video: What Interface World Models Mean for Developers

On August 31, 2026, Runway introduced Solaris, the first model in a category the company calls Interface World Models. Past AI programming tools made models write HTML, CSS, and JavaScript that a browser then rendered; Solaris skips code entirely. The model generates the application interface itself, frame by frame, in real time, and every click, drag, or text input simply conditions the next frame. Software no longer runs; it is generated, existing only as a continuous image stream. Coverage from The New Stack and CMSWire in early September both landed on the same counterintuitive point: there is no code underneath this application. This guide explains how Solaris works, what it means for the developer role, and what to prepare as interface generation follows the same trajectory toward speed and coherence that image and video generation did.

1. What Solaris Actually Is

Runway defines Solaris as an Interface World Model: a system that folds rendering and interaction into a single world model that outputs dynamic interactive interfaces frame by frame, rather than producing an intermediate code layer first. In the demo, a shopper browses a virtual clothing store and drags garments from a rack onto their own photo to try them on, and the system responds with coherent frames in real time. CEO Anastasis Germanidis argued in the announcement that this bypasses the constraints of HTML and CSS, because there is no longer a document object model; the interface is simply a stream of frames the model imagines. The New Stack and CMSWire both stressed the key distinction: this is not "AI writes code faster," it is "interaction itself becomes the input to a generation process."

# Concept: an Interface World Model maps (state, action) -> next frame.
# No DOM, no CSS, no code: the frame IS the software.
def next_frame(model, current_frame, user_action):
    return model.generate(current_frame, user_action)

frame = load_frame("checkout.png")
action = {"type": "click", "x": 420, "y": 310}   # "Pay now" button
frame = next_frame(model, frame, action)          # frame changes

2. The Architectural Difference From AI Coding Tools

Mainstream AI coding, whether Claude Code, Codex, or Cursor, follows this paradigm: the model generates code, a build tool compiles it, a runtime executes it, and the user sees an interface. Solaris follows a different paradigm: the model receives interface state plus a user action and directly generates the next frame. In the first paradigm, code is an auditable, testable, version-controlled intermediate artifact. In the second, the intermediate artifact disappears, and what remains is a sequence of frames and an interaction stream. That is a double-edged sword: on the plus side, visual coherence can be pixel-perfect because the model inherits image and video generation's fluency; on the minus side, you lose the traditional notion of source code, so testing, review, and rollback must be designed around action streams and frame hashes instead of code diffs.

# The prompt that drives a Solaris-style interface session.
PROMPT = {
    "task": "Build an e-commerce checkout flow",
    "constraints": {
        "style": "minimal, high contrast",
        "locale": "en-US",
        "payment": ["card", "wallet"],
    },
    "state": {"cart": ["item-1", "item-2"], "total": 89.90},
}

# Every user action becomes conditioning for the next generated frame.

3. Do Developers Still Need to Write Code?

The short-term answer is yes, and arguably more than ever. Systems like Solaris excel at interface appearance and interaction feel, but software is not just an interface: carts must add prices, orders must persist, inventory must decrement, payments must clear a gateway. All of that business logic still runs on traditional code and APIs. A generated interface is best understood as a front-end shell over the architecture you already know: backend services, databases, and third-party integrations. What changes is the front-end skill stack: instead of hand-writing responsive layouts, engineers design prompts, constraints, and state contracts, then verify that model-generated interfaces do not corrupt business state. AI image generation did not eliminate designers, and interface generation will not eliminate front-end engineers; it will rewrite what front-end work is.

# Latency is the make-or-break metric for frame-based UIs.
# Human perception wants <100ms per interaction -> frame.
def is_responsive(frame_ms, threshold_ms=100):
    return frame_ms < threshold_ms

print(is_responsive(45))    # feels instant
print(is_responsive(320))   # feels laggy, unusable for input

4. Testing and Reliability: How to Verify Without a DOM

Traditional UI tests assert on DOM elements, class names, and events. Without a DOM, the assertion targets become frames and action streams: after clicking at these coordinates does the frame change as expected, does the total match the line items, does payment success move the user to confirmation? Screenshot comparison, frame hashes, and action replay become the primary regression toolkit, while business-state consistency, such as cart total equaling the sum of item prices, still needs API-layer tests as the safety net. In other words, end-to-end testing shifts from browser automation to action-stream plus frame verification. Accessibility testing gets harder too: screen readers depend on a semantic tree, and a generated visual stream may not have one, which is the biggest risk the accessibility community should be watching.

5. Latency, Cost, and Content Safety: Three Hurdles

Before generated interfaces reach production, three hurdles must be cleared. First, latency: humans perceive interaction lag at around 100ms, so frame-by-frame generation must approach real time, which puts enormous pressure on inference infrastructure and explains why such models will run in the cloud rather than on-device for a long time. Second, cost: every frame is an inference, and long sessions accumulate token or per-frame charges quickly, so sessions need cost budgets. Third, content safety and consistency: a generative system can render incorrect information beautifully, and it can slowly drift away from business state over a long session; you need frame-level audit logs and state-consistency checks to separate looking right from actually being right.

# In a code-free interface, testability moves to the action stream.
def log_interaction(session_id, action, frame_hash, ok):
    entry = {
        "session": session_id,
        "action": action,
        "frame_hash": frame_hash,
        "ok": ok,
    }
    # persist entry for replay and regression checks
    return entry

print(log_interaction("s-42", {"type": "drag", "dx": 120}, "a1b2c3", True))

6. What to Do Now

The practical advice splits into three layers. Layer one, doable today: make your front-end/back-end JSON contracts and API tests rock solid, because whatever generates the interface, the business boundary must hold; JSON Formatter and API Tester are your friends here. Layer two, over the next 6-12 months: start treating interfaces as frame streams plus state contracts, and build action-recording and replay capability so regression testing is ready when generated UIs arrive. Layer three, keep watching: track the latency and cost curves, because once the per-frame cost crosses a threshold, interactive generated interfaces will move from demos to real products, exactly as video generation did. Do not rush to rewrite your front end, but do rewrite your mental model: software may stop being written and start being generated, and the value of engineers will increasingly live in defining constraints and guarding state.

# Classic reliability concerns still apply to generated apps.
def check_state_consistency(cart_total, line_items):
    expected = sum(i["price"] for i in line_items)
    if abs(cart_total - expected) > 0.001:
        return "BUG: total does not match line items"
    return "OK"

print(check_state_consistency(89.90, [{"price": 49.95}, {"price": 39.95}]))