Native previews move to the cloud

Phone previews now receive a finished app bundle instead of compiling the app on the phone. New users begin with a prepared welcome project, and Design can hold a row of variants that you refine and carry into a conversation. rnx also adds Remote Simulators, while a new Contrast homepage gives the product and the editor their own surfaces.

#Platform

#Give the phone less work

Native previews on your phone now fetch a cloud-built bundle. The app still appears in the preview, and editing still brings in updated code, but the phone no longer needs to compile the project before it can display it. Reopening an unchanged version can reuse the prepared bundle, leaving more of the phone’s memory available for the app itself.

For work that also needs the simulator to run remotely, rnx provides Remote Simulators through rnx ios --remote. A remote session can be viewed in the browser and controlled through the CLI, with access covered by the account’s plan and credits. Idle sessions close and stop their meter. Customer-created Boxes, which add a remote workspace and terminal, remain a separate early-access feature.

#Start with a project that is ready

Signup and anonymous entry now claim a fully prepared welcome project. The files and workspace are already seeded before the person opens it, reducing the amount of setup placed between a new visitor and the first usable screen. Signing in retains the welcome project’s identity as ownership transfers to the account.

The creation flow also handles delayed provisioning without discarding the current workspace. It keeps the optimistic project visible while setup is in progress and retries a temporary “not ready” response. A failed attempt clears only its own pending state. The aim is to make the first project feel like opening something that is ready to use, rather than watching its supporting pieces assemble.

#Compare and refine Design variants

Design variants now form a horizontal row on one canvas, with a glass dock for the controls. Each result fills an iPhone-sized surface, including artwork that extends to the screen edges. You can refine a variant, revisit its history, and hand the selected image to chat as an attached draft.

Panning remains direct when drawing is inactive, and circle annotations retain their frame while you inspect a screen. Double-tap provides an explicit zoom-in action. Captures preserve native scale, fonts, gradients, and color emoji, while recapture can focus on routes whose source changed. Together, these changes make the canvas useful for comparing actual screens and deciding which direction to continue.

#Get into the iOS beta

Every iOS beta call to action now opens the same two-step installation flow: install TestFlight, then follow the beta invitation. On a phone it opens as a sheet, with both steps available together. The download and invitation pages share the same instructions, so the path stays consistent wherever you start.

Production web cards also offer a copyable iOS test-drive link. You can pass the native preview along from the deployment surface without asking the recipient to find the right installation page first.

#Tech

#Build once, deliver a prepared native bundle

The phone preview requests an artifact keyed by project, route, and version. Concurrent requests for the same cold version share one build, and a request for an unchanged version can return without another bundle body. Production builds happen in the build service; the phone receives the finished Metro bundle through the existing preview transport.

Artifacts are stored with a placeholder asset token, then receive a fresh token for each response. Authentication therefore does not determine the cache key or force identical code to be rebuilt. File-change notifications still trigger a refresh, and the client applies a replacement when the code hash changes. In the recorded same-machine, same-project comparison, the preview renderer’s footprint fell from 1,278.3 MB to 801.4 MB, with no bundler worker remaining in the phone-preview document.

#Remote execution keeps presentation close

rnx can run the guest engine remotely while a local compositor presents its scene updates. Display sessions retain a single owner, wake for tree, layout, and scroll changes, and keep native animation graphs on the shell clock. Viewing and driving have separate authority: a display grant permits watching, while typed input requires the controlling lease.

The headless engine can also present into a live canvas, receive pointer and wheel input, and return to an offscreen surface without remounting the guest. Its dirty regions limit the framebuffer area copied for a change. Recording samples the presentation clock, keeping captured motion tied to the frames the viewer actually saw.

#Welcome projects are prepared before the request

A maintained pool holds seeded welcome projects with their workspace and session structure. Signup claims one through a conditional ownership transfer, keeping competing requests from taking the same project. A repeated claim after a lost response does not consume another project. The pool refills separately from the request that needs it.

Welcome identity is stored as a project pointer rather than encoded in a special project name. Moving an anonymous project to an account changes ownership while preserving the project id. Sign-in also removes profile synchronization from its critical path, batches anonymous-account transfer, and uses one-hop autocommit operations where a multi-request transaction is unnecessary.

#Rendering work follows visible changes

rnx bounds Graphite frame production when the GPU falls behind and drains submitted work before releasing a context. Once a scene is quiet, it frees purgeable resources instead of retaining them just because the cache has not reached its limit. Transformed app bundles live in Blobs and are read when needed, reducing retained JavaScript heap pressure.

Dense scrolling reuses unchanged text-input and boundary checks. LayoutAnimation skips paints that round to the same device pixels, overlay fades use the compositor clock, and the first pointer move can be dispatched on receipt. Retained backgrounds preserve their pixel alignment, and interrupted scrolling keeps one owner for momentum integration, avoiding competing updates during a finger catch or pager handoff.

#Design and capture

• Fluid variants share the canvas, dock, refinement controls, native history, and image-to-chat handoff instead of opening as disconnected results.
• Browser guest canvases use the Graphite GPU path at Retina density. Headless canvases keep their CPU presentation path for the environments that need it.
• Expo File uploads serialize actual multipart bytes, allowing a selected file to arrive as file content rather than an object description.
• Native capture graphs persist as a complete result, with progress tied to the capture lifecycle and rasters drawn at the simulated device’s scale.
• Design captures preserve color emoji, custom fonts, gradients, and paint beneath semantic overlays, retaining visual information that a structural tree alone cannot represent.
• Panning uses the animated workspace transform and remains available when drawing is inactive. The drawing surface stays bounded to the capture it is editing.
• Circle annotations keep their frame through zoom changes, and double-tap consistently zooms in on the screen being inspected.
• Warm capture passes retain completed screens. Recapture is scoped to routes with changed source, avoiding repeated work on unchanged parts of an app.
• Reused capture environments clear stale seed state before a new run, and capture failures preserve their actual rejection details.
• Browser capture opens on the canonical project origin and can start before a web deployment exists. The browser producer remains the default capture path.
• Capture outcomes distinguish a completed flat image, surviving captured paint, and a pass that did not start, giving callers a usable result for each case.

#Mobile and chat

• Mobile has one preview action that opens picture-in-picture first. Fullscreen web previews keep their controls visible, and path-only navigation preserves the requested destination.
• Native sheets share one portal root, keeping their presentation attached to the intended mobile surface.
• When a chat send fails, the draft returns to the composer with a toast. A landing-page prompt also remains visible until its send is accepted.
• Mobile explains the actual reason Design is unavailable, rather than borrowing a generic preview message that leaves the next step unclear.
• A live driver for the same project can take a request from the phone, keeping an already-connected project session useful across its surfaces.
• The Factory feed reads as an overview of active work. Browser-hosted Factory state makes clear when the work lives in the open tab.
• Dark chat cards recover their lifted surface treatment, and preview navigation and source identity stay consistent while the active project changes.
• A preview whose content process repeatedly exits stops the reload loop, giving the user a stable failure state instead of continuously restarting the same screen.
• Selecting a model that requires Pro opens pricing at the point of selection. Cloud Factory overage uses the shared usage balance.
• Mobile build identity follows the native runtime’s reachable inputs, keeping live updates on a matching installed build.

#Projects, editor, and templates

• A new App Empty starter includes the required project setup while leaving the product screens open for the app you want to build.
• General project settings now include Delete project, with project pointers cleaned up as part of the deletion lifecycle.
• Project creation retains optimistic state through route bootstrap, retries temporary filesystem provisioning responses, and clears only the failed request belonging to the current user.
• Project bootstrap can answer “not ready” with a retry interval while setup continues, giving the client an explicit next action.
• Anonymous visitors receive a signed sync identity for their welcome project. That identity remains usable through subsequent queries and transfer into an account.
• Project feeds, thread lists, session pickers, and decision reads gain indexes, while bootstrap and projection synchronization batch related work.
• Imported project slug reservation and main workspace creation happen in one transaction, avoiding a partially created identity between those steps.
• File reads reuse a content-scoped cache, and larger project searches remain bounded instead of scanning and materializing every file unnecessarily.
• Workspace preview separates the manifest listing from blob materialization, allowing discovery without reading all file bodies at once.
• Hot reload preserves callable component refresh families in both web and native builds, allowing a component update to keep its refresh behavior.
• Web preview replacement and reload resume the active app route. Theme and Tamagui configuration changes restart the preview document once the rebuilt configuration is available.
• Native previews keep signed asset reads on the Contrast backend, and relative signed assets bypass the app proxy. Hosted previews restore sync and app fonts together.
• Bundling rereads changed files in parallel, loads package artifacts in batches, and avoids decoding downloaded source text twice.
• Catalog and workspace package specifiers are separated for on-demand compilation, and template navigation uses one canonical application-home destination.
• Templates gain a shared adaptive control kit covering dialogs, confirmation, toast, select, tabs, menus, text inputs, and text areas. Touch-web dialogs adapt their presentation, and fields share focus-ring behavior.

#Remote Simulators and Box early access

• Remote Simulators have their own public name and CLI spelling, rnx ios --remote, with plan and credit checks separate from customer-created Box access.
• Remote simulator time is priced at $0.05 per hour in the billing contract. Idle cleanup closes the session and stops its meter.
• A simulator page can display a remote session through an account-bound display grant. Watch-only viewers and the input controller have separate permissions.
• Remote display frames and scene changes retain their session owner, and native animation timing follows the shell clock through remote execution.
• A headless session can move between an interactive canvas and offscreen execution without losing guest state, scroll position, or the running app.
• Remote session reuse follows cross-origin and flow-runner reloads. A settle response explains what is still pending when the operation cannot complete.
• Cloud artifacts include their required app assets, and guest asynchronous work can continue across individual commands without losing the runtime that owns it.
• For accounts with Box early access, the CLI can attach to a named Box from another machine and select a default target for later commands.
• Early-access Box pages combine a terminal and simulator at one URL. A shared session streams to its viewers, including the agent cursor, rather than starting a private simulator for each person.
• The early-access Box agent pane can edit its checkout and hot-reload the attached app. It uses the hosted model route or a supplied key and directs commands to that Box’s simulator.
• Boxes can open prebuilt apps, serve bundle parts directly, and compile a missing catalog package on demand. Snapshot paging follows deterministic file order and verifies each reported page.
• The desktop rail adds Send to box for accounts with Box access, carrying the app’s route and supported storage. It can carry the signed-in session when that option is selected.

#rnx startup and tooling

• Engine workers bundle into one file, and the shell preloads its dependency closure from the initial document to reduce serial import waves during a cold start.
• Built-in app components can mount from a warm cache, with their chunk bytes prefetched in parallel while the home screen is open.
• The immutable graphics-pipeline corpus loads before the first surface, and glass materials prewarm before their first visible frame.
• The standalone CLI owns its bridge and child processes. Installation groups shell-profile changes into an attributed block that can be removed cleanly.
• Tap-by-id and tap-by-text resolve directly through semantic commands. Covered-target diagnostics explain when another surface prevents the action.
• Selector tap results distinguish malformed input, a missing control, and reaching the wrong subtree without inventing a more specific failure reason.
• Readiness accounts for pending guest fetches, recursive timers yield to other work, and headless remounts retain the correct request and cleanup boundary.
• Metro entry failures report the actual build reason. Bundle fingerprint identity survives minification, and asset destinations and scale variants resolve from the destination graph.
• Rolldown apps load through explicit bridge selection, Expo apps can boot in the CPU guest, and Hermes preserves the Metro class syntax those bundles require.
• Debug events are recorded and read in the selected guest worker, keeping diagnostics attached to the app being inspected.
• Home and Back stay visible on the desktop rail, the developer-tools popout remains aligned with the phone, and a dismissing app reveals Home behind its rounded screen.

#rnx native fidelity

• Scroll momentum survives interrupted touch handoffs and pager rebases. A snap settles on its intended target while the compositor retains ownership of the active scroll.
• Embedded taps and drags stay at the pointer position, and transparent views with raw touch handlers remain part of hit testing.
• Nested tabs remain interactive after returning from a native stack screen. Stack replacement and redirected navigation retire the preceding transition before it can compete with the new screen.
• Visible-frame calculations account for frontward overlays and occluding siblings, making the effective visible region follow what the person can actually see.
• Keyboard-controller gesture areas include iOS accessory offsets and avoid redundant updates. Keyboard height follows the selected device, including its compact prediction row.
• Hidden keyboards stay outside resized canvases, and focus changes between input families use the intended keyboard geometry.
• Text clipping preserves centered content, handles whitespace beside ellipses, and can clip through part of a glyph instead of erasing the whole label.
• Custom-font baselines use iOS hhea metrics, WOFF2 fonts retain their own line height, and system-text alignment receives measured native adjustments.
• Text shadows, angled gradients, thin borders, and outlines render more faithfully. Shadow layers stay bounded to the work needed for the text.
• TextInput reports content size from its backing text view, and the caret uses measured native color and width.
• SearchBar supports placement and imperative commands, with cancel and clear delivering the expected blur and change events. Integrated search toolbars follow native presentation.
• SVG Symbol and Use retain their viewport, opacity, masks, clipping, transforms, and presentation context. MaskedView can retain mask ink outside its own box.
• Images with an open dimension use the asset’s corresponding size. Native font imports resolve catalog dependencies, keeping the intended font with the preview.
• Reanimated transparent color endpoints fade correctly, dormant mappers retain their presentation, and native text updates preserve animated and platform-owned values.
• Glass controls lift into their held state, moving crops reuse blur scratch buffers, and the regular material uses a softer rim. The tab bubble magnifies the page through the frosted bar.
• A host-backed Audio global is available to render-worker apps. Bridge disposal and errors share the same lifecycle as the audio operation.
• React Native Gesture Handler web toggles and Swipeable exports have supported paths. Expo FetchResponse listeners work through SharedObject, and Expo Winter fetch avoids recursively allocating its own request wrapper.
• Expo FormData initializes once per realm before guest modules run. Additional manifest-backed support covers fast-image, PDF, blob-util, UI text views, and Skia offscreen surfaces and image encoding.
• Unknown SF Symbols produce a warning while the app continues, and Settings preserves existing native keys when a null value crosses the bridge.

#Site, delivery, and reliability

• Contrast’s new homepage has its own marketing surface, while opening a project moves into the editor through a staged handoff.
• The homepage uses a layered dither hero, a split live phone, a glass loupe, and real rnx captures. Mobile layouts stack the hero and omit desktop-only layers.
• Light and dark treatments refine shadows, brand accents, floating-app depth, and alternating feature cards. Navigation and copy remain interactive when the loupe is parked.
• Contrast typography is coordinated across headings, body text, and mobile cuts. The generic control kit uses a shared heading and body font contract.
• The logged-in rnx site shares its shell with the public product. Recording, repository, run, pull-request, and build pages use consistent rows, toolbars, identity, and sharing areas.
• Simulator and Box organization pages include cloud usage, while pricing and proof-memory information receive clearer separation on the rnx site.
• Compatibility ratings separate strict coverage from assessed app API usage and identify their platform-specific evidence source. Stale proof no longer silently becomes a fresh verified claim.
• Worker and sync-host uploads can be skipped when their bundle bytes already match production, and dynamic deployment waits for a usable slug registry entry.
• Retryable sync-authorization reads remain distinct from a final denial. Pulls stay isolated through schema changes, and schema reconciliation has a bounded lifetime.
• Safe static reads and session reads use the database read path, preserving serialized transactions for work that changes state.
• Production failures carry a request identity, cause, and owner, with bounded exception messages so upstream response bodies cannot turn into unbounded diagnostics.
• Compile artifacts remain addressable by catalog hash, and native asset tokens can be refreshed without changing the underlying app artifact.

#Fixes and polish

906 fixes and 73 performance improvements landed this week. Failed chat sends preserve the draft, preview reloads return to the current route, and scroll handoffs retain their momentum. The counts cover the full commit window, with internal testing, deployment operations, and maintenance left out of the product sections.