Live updates on your iPhone

You can now keep an installed iPhone development build current as you edit, without rebuilding the native app for every JavaScript change. The mobile workspace gives Factory its own tab and adapts its controls to your project’s platforms. Our browser-native React Native simulator also has a new public name, rnx, alongside a new renderer, wireframe presentation, and layered screen captures.

#Platform

#Keep editing the app on your phone

An iPhone development build installed through Contrast can now receive compatible JavaScript updates. Install the build once, keep working in the editor, and try the updated app on the same phone. The development build checks for updates belonging to its deployment. When a change needs a different native build, the update flow says so and sends you back through the build process.

The distinction matters when working on a real device. A screen, interaction, or JavaScript change can travel through the live-update path. Adding a native dependency still needs a build that contains it. Contrast checks that boundary before delivering the update, so the installed app receives a bundle it can run. Production views also open the canonical iOS artifact and distinguish a published standalone preview from work that has not been published yet.

#A mobile workspace that fits the project

Factory now has its own project tab on mobile. You can move between the conversation, the work being carried out, and the app preview without managing an overlay. The conversation opens at its newest messages and loads older history as you scroll back. The Factory transcript loads separately from the live team view, keeping the initial screen focused on what you came to read.

Preview, Design, sharing, and deployment controls now follow the platforms your project actually supports. A web project gets web actions, while a native project exposes its available iOS and Android surfaces. Controls wait until the project is known before choosing a preview. Invitation onboarding and native sharing controls also make it easier to bring someone into a project or pass along a production build from your phone.

#Pull a real screen into a 3D shot

rnx can export a screenshot as separate layers. Choose named parts of the app and receive a base image with those parts hidden, individual transparent images, and the positions needed to put them back together. The images come from the running app, so a product shot can use the interface you built.

Three Mode can attach those layers directly to the phone’s display. They begin over their original pixels and can then lift away from the glass into a three-dimensional composition. The phone provides the coordinate system, removing the need to line up every shot by eye. A new glass-lift film demonstrates how the captured interface and the phone stage work together.

#Meet rnx, and look inside a screen

The simulator is now presented publicly as rnx, with rnxsim as its package name. Its new site includes a live simulator, an app and settings tour, compatibility and benchmark information, and clearer explanations of plans and cloud workflows. Existing public links continue through redirects.

The simulator also gains a wireframe mode that shows the structure of a live screen. Text, icons, shapes, and surfaces become a consistent drawing, with fine lines, silhouettes, and hatching that distinguish different materials. Switch it from the rail while exploring an app, or use it as a presentation style. It follows the running interface, including transitions, rather than showing a separate static mockup.

#Tech

#Graphite moves rendering onto WebGPU

rnx can select Skia’s Graphite backend on supported Chromium hosts. Backend selection happens at boot while the engine retains a common scene and rendering model. Safari and Linux use their supported graphics paths. Workers share the selected CanvasKit WebAssembly body and its Blob URL, avoiding separate copies of the same download and keeping backend assets consistent across the runtime.

The work includes partial-repaint clipping, parking surfaces that have no presentation target, limits for live-image and idle-cache memory, and preparing GPU programs before revealing app content. Raster caching now admits expensive pictures even when their recorded byte size is small. On the recorded air-32 Graphite home benchmark, full home paint fell from 9.4 ms to 2.7 ms after cache and repaint-boundary changes. That is a measurement of this home scene, not a claim about every app or device.

#Live updates check the native boundary

The iOS development shell reads a deployment-scoped update endpoint. The update contract includes the native fingerprint, allowing a compatible JavaScript payload to reach the installed app while a fingerprint change requires a new native build. Dependency identity participates in update detection, so a lockfile change can produce a new delivery even when application source has not changed.

Crash reporting composes Hermes and Metro source maps to recover useful frames from an updated bundle. Source bodies stay out of the public update asset path, and shipped production artifacts exclude source maps. This separates the information needed to diagnose a crash from the files a browser or phone downloads to run the app.

#Preview interactions belong to a delivered revision

Automated preview actions now wait for the exact committed web bundle and retain that delivery’s identity through the interaction. A new build, a retry, or activity in another pane cannot silently move an action onto a different preview revision. Routed web apps retain their own shell document, and concurrent preview runtimes keep their app state and delivery ownership separate.

Source inspection begins earlier in compilation. Development JSX receives the authored file, line, and column before the JSX transform erases that structure. Inspect can then connect a rendered element to its source in the editor. Explicit locations supplied by the app are preserved, and the development stamp is omitted from production bundles.

#Dynamic apps retain their serving contract

The dynamic Workers hosting path gained managed upload serving and Cloudflare Pages redirect behavior. A version-addressed configuration travels with the application, while the active app pointer provides the rollback boundary. Publishing validates that the module catalog is complete and that the worker’s imports and source outputs match before switching a deployment.

Storage and sync work reinforce the same ownership rule. Dynamic apps retain their own data storage, namespace reconciliation checks copied columns and unique indexes, and hot reads avoid serialized write turns. Project file writes put content into blob storage before a database row can name its hash. These changes extend the versioned deployment and content-addressed storage work introduced in the previous entry.

#Editor and Design

• Focused preview panes hide their window chrome, leaving more space for the app itself. Native panes also offer a screen-jump picker without requiring the full preview frame.
• Preview file discovery includes MDX and resolves platform-specific siblings by the requested module name, keeping the selected platform’s file in the build.
• Editor warmup follows the preview document’s declared boot graph at low priority, leaving optional 3D, developer-tool, billing, and marketing code until it is needed.
• Safari receives its supported preview isolation policy, and preview document delivery avoids an extra redirect before the app can start loading.
• A remounted native preview returns to the reusable pool. Reloads retain a populated preview, and an errored web preview can restart through its pinned shell document.
• Entering Design refreshes stale captures with ownership tied to that project. Capture work remains isolated when adjacent projects are open or refreshes overlap.
• Paid design capture uses the established project-creation path, keeping its provisioning and ownership consistent with other projects.
• Editor hydration keeps the current tab state, and local editing state survives replacement of the sync client without replaying an older copy over the user’s work.
• Compact tabs have clearer selected-state contrast and tighter spacing. Focus stays inside the workspace without scrolling the surrounding page away.
• The Design zoom readout updates at a bounded rate, and the developer-tools drawer stays clipped inside the editor shell.
• Imported projects receive the workspace session structure they need on first open. Invited members can enter their workspace without a separate setup action.
• The homepage carries a typed starting prompt through sign-in and the first app boot, preserving the request that brought someone into the editor.

#Mobile and collaboration

• Mobile chat owns its transcript by thread, opens at the synced tail, and loads older messages in bounded pages rather than fetching the entire history at startup.
• The composer stays stable while project content changes, Design actions follow the active surface, and Factory controls keep independent touch targets.
• Mobile preview actions wait for their live callbacks to be ready and offer a retry when the preview cannot load.
• A shared project link retains its project identity through the marketing redirect, carrying the recipient toward the app that was shared.
• Native production-sharing controls and invitation onboarding are available from the mobile workspace, alongside account-level referral sharing.
• A newer sign-in takes precedence over an older authentication response. Logout propagates across tabs, and mobile account switching follows the active login callbacks.
• Cached native data can paint from the persisted session on a cold start, while preview sign-in state remains separate from schema-driven app-data changes.
• OTA and TestFlight update screens keep their urgency visible and fit required update titles on phone-sized layouts.
• Factory progress on mobile follows the live work state. A pending handoff is visible in web chat, and repeated delivery does not create duplicate conversation entries.
• Conversation timestamps are more compact, internal execution rationale stays out of the transcript, and empty activity labels no longer take up chat space.
• Lux waits for the active conversation turn before starting its tour, and its eye tracking updates with movement while avoiding repeated geometry work for unchanged input.

#rnx rendering and interaction

• ScrollView supports sticky headers and snapping to intervals or explicit offsets. Virtualized lists size their spacers along the correct axis and retain input behavior when inverted.
• Active slider gestures stay with the slider instead of scrolling its parent. Native screen transitions and transparent modals retain their motion through compositor updates.
• TextInput delivers key and end-editing events, preserves multiline caret insertion, and refreshes keyboard-aware layout when focus moves between fields.
• Keyboard rows, password autofill, and native picker wheels use more faithful device geometry, including the standard native back chevron.
• SVG text carries its content and typography through the workers. Inline SVG wrapped in a view can render inside text without losing its intended presentation.
• SVG gradients retain their stops, transforms, and paint inheritance. Shape-level hit testing delivers a press to the intended child rather than flattening the whole SVG into one target.
• Project fonts are discovered from React Native font declarations and react-native.config.js. Custom-font line boxes follow Core Text metrics more closely.
• Yoga auto margins work through the supported shorthands, and nested stack headers measure within their own layout instead of borrowing unrelated dimensions.
• Reanimated support includes retained host instances, derived animation graphs, and mapper presentation. Settled spring graphs stop requesting frames that no longer change the screen.
• Graphite readback and layer-isolation capture use fresh frames, while an active composite survives source refreshes and live transition capture.
• Wireframe uses a consistent device-pixel line, tonal dither, structural fills, and material hatching. Its rail control changes with the mode so the selected presentation remains clear.
• Three Mode reduces multisample antialiasing during camera movement while retaining supersampling, and device-frame presentation changes crossfade cleanly.
• The haptic indicator lives on the Home rail button. Erasing simulator content also resets accessibility settings, keeping a fresh simulator consistent with its reset state.
• Splash selection respects react-native-bootsplash and updates when app configuration changes. Native-linked icon fonts load without requiring a fabricated Expo module.
• External app reloads recreate their guest worker, bundled demo assets remain available across app switches, and worker errors can include React owner stacks.
• Embedded demo interactions follow the selected simulator session. App activation and hosted-editor input remain associated with their owning runtime.
• Offscreen home and marketing content can stop painting when settled, and ambient glow resamples after a visible screen change rather than continuously.

#rnx compatibility

• Expo coverage expands across assets, clipboard, crypto, haptics, linking, browser opening, widgets, age range, Spotlight, hardware buttons, navigation bar, and Play Core interfaces.
• Expo Location follows the SDK 57 contract, shared screen wake locks coordinate their lifetime, and Expo System UI can set the app’s root background.
• Native WebSocket support reaches guest apps, while WebView can materialize local file sources and initialize its bridge from a data URI.
• React Navigation support includes the core and legacy packages, native stack animation state, and local header sizing. Screens and gesture-handler DrawerLayout gain additional supported behavior.
• Clipboard, quick actions, Notifee, Turbo Haptics, OS constants, masked views, and imperative native references receive additional adapters and compatibility coverage.
• Rainbow-related support includes image and tooltip contracts, palette colors, inline LaTeX, and the native interfaces used by its app screens.
• Maintained WebView and Nitro packages resolve through the guest runtime, with cached Nitro methods and animated host references following their live owners.
• Pulsar, Nano Icons, Lucide, and native-linked vector icons gain supported paths. Shiki can load through guest bundles, and Expo UI tokens resolve iOS semantic colors.
• Storage, cookies, axios, state-management, internationalization, and React Native Web integrations gain validated subsets for the data paths used by real apps.
• Victory Native chart support broadens alongside BlueCrypto scrypt and legacy AES access. Compatibility reports distinguish proven behavior from unsupported native work.
• Upstream date and value picker packages run through their native interfaces, with matching wheel geometry and build handling for Flow-authored sources.
• Compatibility work exercises app paths from Bluesky, Rocket.Chat, Mattermost, Joplin, Rainbow, Uniswap, Expensify, BlueWallet, Artsy, and Takeout. These are targeted integration improvements, not a blanket claim that every feature of those apps is supported.
• Pure JavaScript packages are classified separately from packages that need native integration, making compatibility scores describe the work an app actually requires.

#CLI, delivery, and data

• rnx setup and upgrade output make runtime selection clearer, print engine release notes, and report installed-runtime crashes with more useful context.
• The simulator CLI reuses isolated launches, discovers workspaces deterministically, and finds its built-in shell and demo registry from the installed runtime.
• Explicit bridge ports remain authoritative, and simulator shells stay attached to their runtime generation through reload and cleanup.
• Contrast’s local-agent path resolves the origin and daemon port of the selected local stack. It can open a hosted editor tab as the signed-in user with --login user.
• Deployment upload serving uses the dedicated uploads host and honors trailing-slash behavior. Dynamic apps can carry their existing Pages redirect rules into hosting.
• Standalone iOS previews are exposed after publication, production views use canonical artifact links, and web documents can be embedded from the delivery surface.
• Update detection hashes the lockfile, allowing dependency changes to trigger delivery. Native archive signing stays scoped to its signing keychain.
• Compile artifacts follow the project’s installed dependency resolution and revision-specific catalog. Published package bytes determine artifact addresses, and oversized packs receive an explicit rejection.
• Sync queries bound row-scaled parameters and relation windows, preventing growing datasets from turning an ordinary request into an unbounded query.
• AI spend reads use the user’s own ledger with bounded diagnostic retention. Retention scans follow creation-time indexes, and engagement writes keep activity reporting bounded.
• Backup exports account for each queued export separately and retry foreground preemption within their budget. An incomplete control-plane export prevents a backup run from being reported as complete.
• Pro moved to $10 per month this week. Paid plans include more cloud Factory time, and account-level complimentary hosting can be granted durably.

#Site and examples

• Holding the Contrast homepage’s glass lens previews the opposite appearance. Completing the hold changes the site’s color scheme with a fade.
• The rnx landing tour explains app loading as it happens, with a boot-progress indicator, guided settings, and popovers that stay inside their available space.
• The compatibility dropzone has visible hover and drag states plus keyboard activation. Pricing comparisons and documentation tables fit smaller screens.
• Public sheets keep their sheet presentation at each width and close with Escape. Pricing comparisons permit normal page scrolling, and navigation preserves command-click behavior.
• The site shares a consistent visual language across feature cards, adapts mobile cards to their content, and keeps Safari’s theme color aligned with the chosen appearance.
• Pages without a simulator avoid starting one, and offscreen videos and CLI demonstrations pause when they leave view. Download calls to action can use static edge delivery.
• The local-agent explanation and pricing FAQ make the bring-your-own-agent path easier to understand. Local-mode command panels stack on narrow screens.
• The Todo example scrolls as one screen and includes the user fields its authentication flow needs. Pennywise’s spending aggregates and examples using WebGPU receive targeted integration updates.

#Fixes and polish

917 fixes and 73 performance improvements landed this week. Among the visible refinements: focused previews give the app more room, SVG presses reach their intended shapes, and mobile chat loads older history incrementally. The counts cover the full commit window; the sections above select the product changes and engineering work behind them.