Plan and build from your phone

The mobile workspace now puts planning beside building, with live activity and conversations that stay close to the app. Notifications and visual feedback give you more ways to follow a project and respond to what you see. For developers and agents, rnx adds a typed scripting API that can drive an interaction and collect the resulting screen, tree, route, and errors together.

#Platform

#Keep the plan beside the build

Plans now have their own presentation inside the mobile Build workspace. The workspace header carries a live strip of activity, while the app preview and conversation remain accessible from the surrounding controls. Agent conversations can open in a floating card, with an identity footer that keeps the speaker clear when the card is minimized.

The layout is designed to hold its place as the work changes. Floating cards share a dock position, scrolling rows reserve space for the presence stack, and opening the keyboard does not force the whole workspace to rearrange. Crew activity and speech have their own animated presence, and chat bubbles use the speaker’s identity color. You can follow a conversation, inspect the plan, and return to the app without losing track of who is doing what.

#Follow updates from an inbox

Contrast gains a notification inbox with preferences and a delivery policy. Notifications have a destination in the product, giving you a place to return to an update after the moment it arrived. Preferences let the inbox and delivery behavior reflect what you want to hear about.

Starter apps also gain notification settings and unread badges, providing a working pattern for apps that need to keep their own users informed. The native integration includes foreground notification behavior through Expo Notifications. This covers both the visible inbox and the app-side pieces needed to make notifications part of an actual workflow.

#Report what you see inside the app

Apps using contrast-native can open an in-app visual feedback overlay. A person testing the app can report from the interface they are looking at, and the report is routed to the project’s handlers. Feedback can stay connected to the app instead of starting as an unrelated message elsewhere.

Production views on mobile also show analytics highlights above the deployment list. Those figures belong to the current project, making the deployment surface useful after an app is published. You can see activity for the app you are managing and keep its releases nearby while deciding what to work on next.

#Script a simulator session

rnx now offers a typed connection and client API for driving a running simulator. A script can perform a sequence of actions, inspect the resulting state, reset the app, and control its camera fixture. A single state request can collect a screenshot, the app tree, the current route, and errors together, reducing the amount of coordination a test or agent has to do itself.

The same work reaches the command line. Action batches can be written inline and chained with --then, and semantic queries resolve controls through the engine. Local video fixtures can feed the simulated camera, letting you repeat a camera-based flow with the same input. Film-format viewports are also available for sessions intended for capture and presentation.

#Tech

#One command contract for scripts and gestures

The rnx client uses a shared typed bridge for perform, state, reset, and camera control. SimClient exposes a promise-based API over that contract, while the Node connection entry discovers the running simulator. The client core remains browser-safe, allowing an in-browser agent to use the same commands without pulling Node-only discovery into its bundle.

Gesture batches execute as ordered steps inside the simulator. They return per-step results, wait for work already in flight, and cancel an unmatched touch when a batch ends on its deadline. Tap-by-text resolves to a target before the batch is sent. Keeping a drag or pinch inside one operation preserves its continuity and removes the old need to assemble gesture source strings for evaluation.

#The workspace gives scrolling priority

During a workspace row scroll, preview painting pauses and pane visibility changes wait until the scroll settles. A fling therefore does not mount a transcript or switch a pane body in the middle of a frame. Offscreen web guests also pause animation callbacks and batch short timers while they are inactive, rather than continuing at full speed simply because their browser tab is visible.

Held callbacks are queued and resume when the guest becomes active again. This preserves waiting work while reducing competition between the editor, its previews, and the gesture the person is performing. The media pane applies the same principle to downloads: full-resolution images load when the pane becomes visible, instead of spending bandwidth and decode time while it is offscreen.

#Native controls share the screen’s actual geometry

rnx expands its native rendering path for Expo UI forms, sheet presentation, LayoutAnimation, text measurement, and input. Control colors composite over the surface that really hosts them, including React Native’s alpha behavior, inherited foreground colors, masks, and layout modifiers. The compact color picker uses a conical hue sweep around the selected color, with transparency preserved against the host background.

SVG work carries masks, clip paths, images, and radial-gradient geometry through transforms. Text baselines follow iOS metrics inside explicit line heights, and captures use the simulated device’s scale. These are changes to how an app’s declarations reach pixels and input, so the same behavior applies across apps that use those controls.

#Hosted delivery keeps the app and its assets together

Hosted app delivery moves to contrast.run. Router changes wait for the dynamic loader to deploy and become ready, while the loader retains migration history and the routed app protocol. Runtime artifacts are required before a dynamic deployment is accepted, and mismatched versions produce an explicit error instead of an ambiguous serving result.

Asset retention is budgeted per deployment target. An asset that is temporarily unreadable during a retry is kept distinct from an absent asset, and rnx Pages retains the generations a live page may still reference through a cutover. Project deletion follows the other end of that lifecycle: the hosted app is unpublished before the project is removed.

#Mobile workspace

• Plans can occupy a standalone stage as well as the Build card, and the live stage strip becomes part of the workspace header.
• Preview surfaces have an explicit closed state and one active presentation path. Floating preview cards retain their dock position as cards join or become active.
• Agent transcript cards include an identity footer, while speech bubbles and presence components make current activity visible within the mobile workspace.
• Workspace tabs, headers, bands, plans, and floating cards receive a coordinated layout pass. The crew strip, stage heading, and preview bar retain their separate roles.
• The Design canvas has softer shadows, the composer returns to its glass treatment, and preview navigation, fonts, source identity, and route parameters receive targeted refinements.
• Cached chat can paint before an authentication refresh finishes. Switching projects no longer flashes a transient connection indicator in the composer.
• Design capture shows a stable “Capturing screens” label, with the current stage and elapsed time beneath it, so progress is understandable while a cloud capture runs.
• Completed capture status clears from the project surface, and hidden Design capture sessions remain alive while their work is still needed.
• Project pickers close before navigation begins, signed-out routes wait for access to resolve, and project transitions retain the intended preview rather than showing an empty intermediate surface.
• The mobile organization header keeps its account context available at phone widths. Billing and usage are also visible from organization administration.
• Native release builds explicitly use production service origins, keeping local development addresses out of the installed app’s connection settings.
• Mobile presence connections authenticate the active user, keeping collaborative activity associated with the signed-in session.

#Chat, accounts, and billing

• Package installation has its own tool card in chat, giving dependency work a visible result separate from the surrounding assistant messages.
• Assistant failure rows keep provider diagnostics out of the user-facing conversation, while telemetry retains the information needed to investigate a failed turn.
• Account names are provisioned for people lists, so collaborators see a usable identity instead of an internal identifier.
• Email sign-in returns directly to the workspace. Magic links retain their intended destination, and a newly enrolled passkey becomes the remembered sign-in method.
• Accepted beta invitations grant three months of Pro. Checkout and the pricing page complete the Pro reprice, including the first-month offer.
• A public charge table brings the listed charges together, while organization billing surfaces expose usage in the account context that owns it.
• Managed model routing adds DeepSeek Flash and Pro through Workers AI credits, extending the available service path without changing the Factory workspace.

#Editor, previews, and templates

• Creating a root document places it inside the document area where it can be opened, and an empty document pane offers a direct create action.
• Expanding a pane preserves the file tree’s list and open-directory state, keeping the surrounding project context intact.
• Platform dependencies and reviewed framework ranges become explicit parts of project setup. Preview aliases resolve against that project’s installed dependencies.
• Preview documents receive each build once and share a single delivery revision. Document replacement clears the preceding delivery’s state before accepting new work.
• Hosts receive a restart signal when the app actually restarts, avoiding unrelated reload notifications during ordinary delivery changes.
• Closed preview branch sessions do not retain runtime leases, and a signed-out native reset clears the app’s authentication storage.
• Hosted previews no longer attempt to connect to development-only Metro WebSocket routes, keeping production preview traffic on its serving path.
• Template authentication starts when it is needed, while preview startup preserves the template’s declared auth-user fields.
• Public example demos are read-only and return to their seed state on publication, providing visitors with a stable starting point to explore.
• The local-agent path retains the selected stack’s origin and daemon port and can open the hosted editor as the chosen signed-in user.
• Preview crash telemetry and terminal model errors include project context, helping distinguish a failed app from the surrounding editor session.
• Project file reads share a content cache across browser and server access. Its key includes project, path, and content hash, and writes reconcile the cache only after their bytes match that hash.

#rnx scripting and desktop

• The public command is rnx, and integrations use rnxPlugin. The branded macOS installation and update guidance follow the same product identity.
• A development server can open a named desktop app. Ambiguous same-name matches are rejected so the command cannot silently select another app.
• Local discovery checks IPv4 and IPv6 loopback paths and accepts IPv6 proxy targets, covering development servers bound to either address family.
• Left-bezel swipes reach the app as native back gestures in the desktop simulator, extending interaction beyond the visible screen content.
• The SDK can collect screen, tree, route, and errors in one state response. Reset reports intentionally skipped stores and whether it restarted the guest worker.
• Camera commands use fixtures staged by the daemon, including local video input, so scripts can reproduce the same camera-based interaction.
• Long presses and other write commands hold the simulator’s write lease. Batch execution waits for running steps and rejects malformed action input before acting on it.
• Inline action batches and repeatable --then separators reach the same command implementation as the typed API. Semantic targets and waits resolve in the engine.
• Agent-driven keyboard interactions stay silent, and an explicit viewport option supports sessions prepared for film-format captures.
• Install and update handling accounts for incomplete desktop installations, pins a newly installed standalone runtime, and bounds checks that would otherwise remain pending.
• Build errors expose Metro’s reason, incomplete multipart bundles are rejected before further streaming, and a crashed guest cannot report itself ready.
• RedBox error text is selectable and can be tapped to copy, making a useful error report easier to carry into the next debugging step.
• Inspect respects React Native pointer transparency, letting you select content beneath decorative overlays that would also let a finger pass through.
• Shell dialogs stay centered over the simulated phone, and the Record dialog explains its account and plan state. Alternate-port demos retain their own checkout’s runtime configuration.

#rnx rendering and input

• Graphite admission follows actual WebGPU capability, while row-raster defaults remain limited to their supported browser path.
• LayoutAnimation covers geometry changes, replacement direction, interrupted creation, and the retirement of settled presentation state.
• Reanimated CSS transitions and keyframes run through the native interaction path, alongside keyboard gesture areas and long-press handling.
• Gesture-handler hit slop, cancellation, and local hit regions follow the actionable subtree. Delayed replay after blocked JavaScript preserves the active scroll’s position.
• Semantic taps resolve through deeper ancestors to the intended child, and native overlays keep their touchable child layout when they open.
• Initial ScrollView offsets apply after content layout. VirtualizedList retains its anchor when content is prepended, including through small subpixel changes.
• TextInput semantic identity, React Native node tags, and detached ScrollView handles remain stable through focus and cleanup transitions.
• Keyboard-controller preload leaves focus and visibility alone. Semantic focus, pending accessibility focus, and native input focus retain their distinct behavior.
• Expo UI forms use measured row heights, section spacing, footers, color wells, tints, sliders, and steppers. ContentUnavailableView follows SwiftUI spacing and symbol treatment.
• Switch tracks, segmented controls, masks, and hierarchical colors composite against their actual host surface, with the intended inherited foreground and alpha.
• True sheets use native presentation insets and detents. Stacked modals retain their separate presentation instead of becoming ordinary nested views.
• SVG opacity, luminance masks, clip paths, transformed images, and radial gradients preserve their geometry, with circular references rejected before recursive rendering.
• Custom-font leading and baselines align more closely with iOS. Native text measurement is available to components that ask the platform to size their text.
• Root and deep Image imports share Metro asset resolution. Expo Image honors content position, Android images honor fade duration, and image rectangles receive the required device pixels.
• Live texture uploads pause while their surface is moving, SVGs rasterize at their own aspect ratio, and screen capture reads the presented canvas.
• Graphite memory and completed recordings are reclaimed within the appropriate GPU lifetime. Ordinary nodes avoid unnecessary transform-bound and culling work.
• Recorder flush and replay ordering remain lossless, while WebSocket one-shot listeners retain the information needed to remove the original listener correctly.
• iOS status-bar visibility follows the app, and heading dimensions receive native measurements. Brightness and volume settings persist through app activity.
• Wireframe can omit the home wallpaper for a cleaner structural capture while keeping foreground controls visible.
• Yoga rounds layout at the selected device’s density rather than the host canvas density. Captures retain straight alpha and the intended canvas bounds.

#rnx native libraries

• Expo passkeys use browser WebAuthn, with credentials carried through the simulator bridge. Authorization code paths use Web Crypto for PKCE randomness.
• Calendar APIs retain EventKit-shaped data, and Expo Calendar can query daily recurrence instead of treating every event as a one-off entry.
• Hardware key events reach native app handlers and Expo key hooks. Clipboard paste follows the React Native text-input event path.
• Safari view integrations open through browser tabs and host URLs. WebView delivers open-window events so the app can handle its own new-window behavior.
• Nitro sound can record and play, queued audio uses browser media controls, and video responses are cached for subsequent playback.
• dotLottie archives render through Skottie, alongside liquid-glass effects, audio waveforms, and signature capture.
• BlurHash placeholders and Nitro images run through the image pipeline, supporting both loading presentation and the final image content.
• Expo Maps gains simulator support. Browser geolocation, foreground and background location interfaces, and Expo quick actions expand the device behaviors apps can exercise.
• Month and year pickers render in the simulator, DateTimePicker accepts named time zones, and orientation and segmented-control packages use their native interfaces.
• The emoji picker is interactive, retail barcode output is valid, and native context menus render in the canvas interface.
• PDF documents, document viewers, file downloads, and printing receive supported browser-backed paths. Cloud storage and cloud-store data persist through the shared virtual filesystem.
• Speech recognition, Ometria, AppCenter, file logging, cookie utilities, pull-to-refresh, SF Symbols, and shared splash-screen interfaces gain additional native adapters.
• Enriched text uses native hosts, while interactive snackbars and Expo picture-in-picture can present through the simulator’s browser environment.
• Linking listeners, Android intent extras, send-intent content, and React Native Settings preserve their platform-shaped behavior, including settings observers and persistence.
• Wake locks no longer require an unrelated permission path, and live appearance changes propagate across rendering contexts to the running app.
• Compatibility inventory broadens across Expo and third-party packages. Entries describe supported subsets and evidence, so an inventory listing does not imply that every feature of the package has been verified.
• React Native 0.87 Metro bundles use the expected asset-registry paths and version exports. Compatibility checks distinguish framework constraints from native-package support.

#Site and product information

• rnx compatibility results account for declared package versions and separate core React Native coverage from other capability groups.
• The public conformance meter distinguishes strict coverage from practical, usage-weighted coverage and makes both values visible in its home and detail views.
• Compatibility credit follows the capability’s required evidence, tying the displayed result to the behavior that has actually been checked.
• The rnx homepage uses production demo bundles, and a mobile navigation menu brings the public site to smaller screens.
• The boot treatment introduces the two-chip mark before revealing its surrounding rings. Native boot and macOS menubar artwork follow the same identity.
• Isometric wireframe highlight art shares a lighting model, and the rnx social card uses a centered lockup rendered at higher resolution for sharper sharing previews.
• Sticky headers use their page’s background and stay above hero content. Guided tours, dark surfaces, hover movement, and simulator reveal transitions receive a coordinated polish pass.
• Contrast’s social card moves to monochrome artwork, and homepage glass interaction stays anchored to the pointer and active appearance.
• Safari’s browser theme color follows the Contrast background before the browser chrome paints, keeping appearance changes consistent across the page and its surrounding controls.
• Toasts use a borderless treatment, a lifted close control, and matching hover and pressed feedback, making transient messages quieter without hiding their actions.

#Fixes and polish

1,112 fixes and 85 performance improvements landed this week. Package installation is easier to follow in chat, mobile captures explain their progress, and offscreen previews yield work while the workspace is scrolling. The totals cover the full commit window, including internal work omitted from the public update.