Point, ask, and preview the change

Contrast now carries one edit through web, native, agent review, design capture, and production with fewer seams. SootSim’s Android range expanded sharply, inactive simulators release nearly all rendering state, and the mobile app can take you from account setup to a live agent edit.

#Platform

#Point at a mobile screen and ask for a change

Inspect an element in the running app from your phone, describe the change, and follow the agent in the same conversation. The selected element stays attached to the request, and the standalone preview refreshes after the edit so you can review the result without returning to a desktop.

#Preview Android and iOS with device-level behavior

SootSim opens substantially more real Android apps in the browser, including those with broad community-native dependencies. It carries Android behavior through keyboards, hardware keys, accessibility, right-to-left layouts, nested scrolling, predictive back, modals, system bars, Material controls, and app-window transitions. On iOS, browser previews and design-map captures preserve app fonts, text metrics, symbols, layered glass, overlays, tint, and rounded stage corners more faithfully, helping visual decisions survive the move to a phone.

A single-app preview opens directly into the app. If rendering fails, a clear Reload action rebuilds it in place. Android demos also use the same authenticated public sharing flow as iOS demos, enabling native review without local project setup.

#Capture stable designs and photographic product shots

Design-map recaptures use a hidden, isolated project branch with seeded data. They wait for real content and reuse unchanged work. The live preview can change without leaking temporary state into the capture, while fonts, masks, shadows, opacity, dark appearance, rounded corners, and glass survive into the result. An unchanged second pass finished in 0.03 seconds, and 29 screens across three apps replayed without the targeted dark bands.

The 3D device stage adds an iPhone 17 Pro with selectable finishes and one focus-strength control for continuous foreground and background blur. It can produce more photographic stills and films, with a translucent finish that reveals fitted frosted internals instead of an empty shell.

#Add subscriptions, test the paywall, and prepare to ship

Connect a billing provider, view revenue, and preview the actual monthly and annual plans in your catalog. A running native preview reloads when the catalog changes, while projects without billing omit the irrelevant revenue panel. The finance example covers monthly and annual purchases, restoration, and a shared entitlement that unlocks the same signed-in account on phone and web.

When the app is ready, run one shared App Store readiness review and see its verdicts beside the iOS deployment controls on desktop and mobile. Submission includes a preflight for account, payment, and store requirements, keeping the checklist with the project from agent review through release preparation.

#Follow the work without surrendering your workspace

Use Follow active agent to keep chat on whichever working agent acted most recently without moving the rest of your workspace. To watch the work itself, press the footsteps beside a person or agent in the presence popover. The viewer shifts to that participant’s branch and follows their editor and stage activity only after that explicit press. Measured branch changes reached the editor in 183 milliseconds and settled web and native previews in about 2.2 seconds.

Viewer follow is session-local. Press the lit footsteps to stop and return to the exact route you left, while presence badges show who is typing, driving, or following. Scrolling and typing do not stop a follow; clicking into a preview deliberately takes control.

#Tech

#One graph now builds web and native previews

Web and native previews share one Metro-compatible transform, dependency graph, serializer, hot-update format, and asset boundary. Dependency collection and refresh signatures reuse the transform’s token stream, parsing each file once instead of twice. Incremental chunks key to the virtual entry, web Fast Refresh preserves component state, and retiring CDN interpretation removed about 2,700 lines.

Packages outside the compiled catalog are fetched from the registry, compiled on demand, and published by content address with their dependency and asset closure. Version ranges, optional peers, workspace references, deep imports, and package stylesheets all resolve through the graph.

#Agent runs move less data and stop on better evidence

Model streaming sends deltas instead of the accumulated assistant message on every event, changing transport growth from quadratic to linear. A 20,000-character response that produced 1,671 events and 17.4 MB on the wire now costs about 20 KB. Oversized prose is capped before storage, and project events share a 250-millisecond batch of at most 100 events, with authorization and agent lookup once per batch. One measured run moved 0.7 to 1.1 GB for 1.19 MB of visible text, and replay bursts reached 1,682 queued mutations. Standing telemetry records bytes, queue depth, pull traffic, replay amplification, and main-thread lateness before the evidence disappears.

Supervision distinguishes a large healthy document from sustained node growth, a missing required preview, a preview stuck on its boot placeholder, and repeated waits for the same target. In recorded evidence, growth fired on sample 16 of 32, fifteen ticks before a renderer crash, while a replay of 28 futile waits stopped at call 13. Tool activity counts as progress, follow-up work remains open through its quality pass, and resuming the same failure requires a changed plan.

#Design agents finish a coherent set before review

The orchestrator waits for the complete merged design set, retains finished screens when the board changes, and sends design work through one dedicated sequence before review. Grading rebuilds the declared screen registry, preserves the intended capture target, records interaction states, resolves literal layout names against screens the project contains, and can release scores blind. It catches boot failures invisible to parsing, types, imports, and source ownership, while computed screen names remain valid instead of being guessed statically.

Model routing defines six complexity tiers, from inexpensive mechanical work to the hardest design and debugging. Every role selects its route instead of inheriting a creation-time default. Private deliberation, including partially arrived markers, is stripped before streaming and storage, while diagnostics travel separately. A prior compact-model run stored 426 KB across 584 text parts in 26.8 minutes; that material no longer enters synchronized history.

#SootSim parks the renderer and keeps motion off the page thread

SootSim is demand-driven through the engine, compositor, and GPU. A still screen stops worker frames, paint requests, compositor ticks, and GPU submissions while retained layers stay ready to wake. After five seconds, an exact-generation snapshot lets an inactive surface release its mirror, layout tree, retained pictures, CanvasKit and GPU contexts, and shrink its backing store to 1 by 1. Three sequential WebKit captures settled at zero engine demand, zero compositor ticks, and zero GPU flushes. Removing the retired painting path deleted about 2,180 lines while adding 262 across 26 files.

Cold work starts after the home screen’s first painted frame, records content up to one screen beyond the viewport in slices capped at 4 milliseconds, prepares one surface’s GPU programs every 1.5 seconds, and decodes images once at draw size. Launch-window tenant chunks fell from 54 to zero, requests from 62 to 8, and loopback first paint from 160 to 175 milliseconds down to 122 milliseconds. Closed-form timing and spring graphs, keyboard motion, system chrome, transitions, and overlays run on the compositor clock. It delivered ten keyboard frames during a 1.5-second page-thread stall while the shell published four updates.

#Native parity is enforced at boundaries and proved against devices

iOS and Android differences enter the engine through one typed platform adapter, and a build-time analyzer rejects new platform branches elsewhere. Window state and shell events are validated before publication, preventing malformed platform data from reaching shared rendering state. Gesture velocity uses the touch-stream clock, keyboard updates batch into one presentation pass, iOS retains full window bounds while Android uses its resized visible area, and nested gesture handoffs preserve native release direction. This resolved 13 conformance failures, including an iOS window that collapsed from 852 points to 485 points with the keyboard visible.

A paced compatibility pipeline walks repository cohorts and published package metadata, detects native-code evidence, ranks candidates, and replaces its corpus only after a complete refresh. It covers 1,000 native-package candidates against a 2,000-package top list, then exercises prioritized libraries in source-only capsules and compares browser output, real devices, and frozen design captures. Android device pairs join the same authenticated proof pipeline as iOS, with manifests validated before publication and generated pages swept at runtime.

#Site and marketing

• The home page restores your exact scroll position after an editor visit, mounts its embedded workspace during a quiet moment so it cannot steal focus, and uses compositor-friendly scroll effects while keeping the phone hero visible.
• Public pages use the correct navigation, branding, and metadata for the site being viewed, with hero and legal layouts that fit phone widths cleanly.
• The developer overview adds a compact foundations grid and closes with seven concrete capability groups, helping visitors scan the product beyond its main chapters.
• Public navigation stays closed after a link is followed, large section titles retain their responsive scale, and catalog listings use real details instead of invented marketing sections.
• Showcase publishing validates every baked render before upload, so a malformed result fails without replacing the last known-good image.

#SootSim

• Mouse, trackpad, and press-drag scrolling derive momentum from the fastest sustained part of the final motion; one trackpad release improved from no coast to a velocity of 1,618 and 759 pixels of travel.
• Home and app-switcher gestures fan cards, ramp blur under your finger, cancel cleanly, preserve animation ownership, and settle tab or submenu highlights without a stale value reclaiming the surface.
• Keyboard-aware focus carries input geometry with the request and settles the field at 482 points with 20 points of clearance instead of leaving it at 653 behind the keyboard.
• Drawers, pinned scroll views, menus, sliders, segmented controls, swipeables, image pickers, scheduled callbacks, and accessibility announcements exercise more React Native behavior directly in the browser.
• Images retain their encoded dimensions inside larger frames and report that intrinsic size consistently across PNG, JPEG, GIF, BMP, WebP, HEIC, and AVIF.
• Liquid glass adapts through scrolling and screen transitions, then closes its heightened sampling window when motion ends; daily conformance scores eight stored iOS reference rows and fails when registration or proof coverage is missing.
• Automation sends swipes through the real interaction bridge, requires complete text matches, and reports faded text as a device would, turning former bridge gaps into useful app failures.
• Point inspection follows visible surface ownership through sheets, menus, and system transitions. Startup screenshots queue until the worker is ready, and command-line inspection requires an explicit target when several simulators are connected.

#Collaboration

• Mobile project chat shows participants, identity pills, avatars, and active typers beside the thread, making conversations with several people and agents easier to attribute.
• Shared author pills, exact model and effort labels, tighter branch treatments, and a parent-task timeline capped at four rows make dense multi-agent conversations easier to scan.
• Factory handoffs survive interruption, automated nudges identify the Manager as their author, and dependency or task failures appear in the transcript instead of resembling a user’s words or a silent stop.

#AI Factory

• Attach a reference screenshot when starting an agent build so the visual target arrives with the brief instead of being reconstructed from prose.
• Stock-image search returns a typed result agents can use and removes a failed fallback that consumed 18 minutes in one measured run without producing an image.
• Text-field assertions read the actual value, layout analysis understands an open sheet, malformed selectors fail only their own batch item, and refused writes are checked before success is reported.
• Seed data is distinguished from executable queries before validation, so valid starter data is no longer rejected by rules for query code.
• Agent chat keeps detail bodies collapsed and loads them on demand, clears discarded streaming turns from the thread, and accepts the formatting variants models emit in reasoning or tool sections.

#Mobile

• Complete onboarding, choose and pay for a plan, return to the app with the purchase applied, and recover a pending upgrade after an interrupted checkout.
• A new project opens directly into chat while files and the agent environment prepare in the background, shortening the wait before you can describe what to build.
• The first synced message sends as soon as project data is ready, one-word requests after a day away start a fresh conversation, and exhausted credits produce an immediate plain-language upgrade path instead of a misleading 90-second wait.
• Preview actions respond where you touch them because dragging starts from a dedicated handle; return swipes keep the deck visible, and picture-in-picture controls share one size-aware chrome treatment.
• When an update needs native capabilities missing from the installed app, mobile distinguishes that state from being current and explains that a new build is required.

#Design and UX

• Template selection uses the same stacked squircle cards and real cropped artwork on web and mobile, making starter choices recognizable across devices.
• Enabled switches tint their full track, while shared squircle cards and a horizontally scrollable row give compact visual collections one reusable treatment.
• Dialogs, sheets, popovers, selects, and tooltips share one public overlay host across the app, simulator shell, and previews, preserving close animation while removing duplicate open state.
• Web sheets repeat the same roughly 465-millisecond spring on later opens and unmount hidden content between uses, keeping animation consistent without offscreen work.
• Changing a project icon no longer makes the project look newly edited, so recency ordering reflects substantive work.

#Editor

• One command palette searches files, panes, and quick actions; file results stay inside the open project, pane labels include their section, and rankings remain stable as you type.
• Minimize and restore preview or docs panes with state intact, then move backward or forward through recent workspace arrangements.
• Pane layout and measurement commit together during minimize, expand, and resize animations; handles follow the column spring, the trailing gutter works again, and opening chat keeps neighboring pane bodies mounted.
• Chat stops auto-following when you choose an agent or start typing, shows elapsed time for running tools and the actual effort level in the composer, and opens compact task cards into the matching conversation.
• Choose a starter inside assistant chat and carry it into project creation; the resulting Docs area exposes one canonical project spec to people and agents.
• Web preview bundles receive the project’s build environment values through the normal browser build data flow.

#Reliability

• Preview capacity uses the browser heap limit as a device-class signal, and the tighter cap wins; a typical machine mounts four native previews instead of eight after measurements showed about 585 MB per preview and roughly 4.7 GB resident for eight.
• Each branch has separate sign-in storage, and each preview bundle is bound to one document, preventing identity and code state from crossing previews while pinned reviews survive handoff.
• Unwatched agent previews record pending edits and perform one catch-up rebuild when opened; visible or captured previews stay pinned, hidden canvases stop painting, and capture sizing restores correctly.
• Request-scoped asynchronous state clears on normal, nested, and abnormal exits, so finished requests stop retaining context that could leak into later work.
• New sessions persist their workspace before binding, teardown wakes event readers, status broadcasts precede durable writes, and the desktop simulator owns its window lifecycle through close.

#Platform and accounts

• Ready anonymous identities are leased only when someone enters the product. Signed-in visitors skip that work, and public-site readers create nothing; pooled startup measured 0.61 seconds against three earlier runs near six seconds.
• Slow project startup records accumulated phase durations and emits one ready summary, distinguishing a slow step from a stalled project.
• Project deletion records enough state for the promised 30-day recovery window, and restored state is represented separately from a project still awaiting deletion.
• Account operations validate the active session and current membership, and losing project access clears the stored active-project choice at the same boundary.
• Sign-in retries are no longer swallowed by a three-requests-per-ten-seconds limiter, and failed delivery raises a visible alert immediately.
• Chat, generation, image understanding, icon preparation, and repository-preview agents record their usage debit before releasing output, while automated Factory work remains excluded from customer billing.

#Examples

• Starters and examples share one native runtime setup, animation root, build configuration, and toolbar convention across four examples, six templates, and conformance packages.
• The travel example has simpler glass navigation, clearer cards and forms, image fades contained within their cards, and back buttons that preserve real navigation history.
• The finance example keeps its dashboard visible beneath the add-expense sheet and has stable navigation and subscription setup, making it a cleaner source for reusable native patterns.
• The pet game renders its animated creature with ordinary native views when WebGPU is unavailable, while other games explain the missing browser capability instead of showing an empty screen.
• Links across seven starters and examples keep framework styling props out of browser markup, removing invalid attributes and related console noise.
• Generated apps install stream support before multipart uploads, consume authentication through guarded source exports, and share the complete typography scale across templates and synchronized examples.

#Deploy and infrastructure

• Production and native builds install the project’s declared dependencies in isolation, keep build credentials outside project-controlled code, and invalidate warm native workspaces when merged dependencies change.
• Mobile updates lock native dependencies and use the actual native fingerprint for compatibility, while download naming and current Expo and React Native types follow one publishing contract.
• Values marked secret use the deployment platform’s secret mechanism across project, staging, example, build, and tools deployments instead of readable configuration.
• Live backups run in bounded cycles that prioritize control data and namespaces never backed up before; scheduled coverage reports stale live namespaces while excluding disposable anonymous projects.
• Build and tools probes use one temporary-storage owner and tear it down after success, failure, or early termination, preventing verification from accumulating abandoned resources.
• Pull-request hosts provision the exact browser revision SootSim launches, keeping preview runners on the tested runtime.
• Production builds retain the native runtime, validate public readiness and sync wake-up before shipping, and synchronize public examples and downloadable starters after a successful deploy, with freshness checks against drift.

#Data and sync

• Preview queries keep syncing after a screen unmounts, so returning reads current data; authenticated writes preserve request identity, serialize before local execution, and maintain derived totals through preview-database triggers.
• Changed sync queries must declare an explicit read policy, native apps persist local state and pending writes across restarts, and schema field rebuilds recreate the indexes required for query performance.
• Session workspace creation runs in the service that owns the data; preconditions throw, client failures reject, and redundant binding work is gone, preventing a missing session from stalling later synchronized work.
• Transient sync-auth failures preserve their status and server-selected retry delay across the service boundary, preventing an aggressive retry from turning recoverable pressure into a permanent error.
• The iOS test-drive surface can use a deployed app’s authenticated sync backend across origins because the browser permission check reaches the sync host before authentication is enforced.
• The schema generator cleanly removes a retired data namespace during regeneration, with behavior-level coverage for the removal path.

#Fixes & polish

781 fixes and 57 performance improvements landed this week. Design-map captures now wait for settled glass and invalidate cached frames when the rasterizer changes, so improved rendering reaches phones. A packed sync ledger left in capture mode can be repaired only on its owning instance and only when no writes are pending, allowing later deploys to proceed. An overscrolled list now springs back from its real offset while preserving nested Android consumption, making the release look like a return instead of a forward fling.