Remote Simulators

Remote Simulators are in early access. Access is switched on per customer while we learn how people use it. Email [email protected] and we will turn it on for your account.

A remote simulator runs your React Native app in a micro Box and lets you watch and drive the authoritative instance from anywhere. You hand rnx a Metro JavaScript bundle and it opens a browser-hosted iOS simulator. There is no Mac in the loop, no Xcode, and no local simulator process.

#Launch one

export RNX_BOX_ENDPOINT=https://rnx-box.contrast.dev

# from a local Metro bundle
rnx ios --remote ./dist/main.js

# from an HTTPS bundle URL
rnx ios --remote https://cdn.example.com/main.js

The command prints and opens the stable Box page. A shell onto the running session is available from the terminal-only rnx box command.

The CLI has no default endpoint: set RNX_BOX_ENDPOINT or pass --endpoint.

#How it actually works

This is the interesting part, and there is no reason to hide it.

rnx ios --remote produces a self-contained artifact, splits it into bounded parts, and creates a prebuilt micro Box. The Box control plane keeps the files, revisions, shell, identity, and lifecycle in Durable Objects and R2. A Cloudflare Browser Run page joins the parts, boots the app in rnx’s headless CPU renderer, and remains the one authoritative simulator.

The Box page exposes that simulator through Remote Viewing. Viewer browsers receive scene commits and compose them locally, while input travels back to the same hosted instance. Browser Run does not expose WebGPU, so the hosted renderer uses the CPU tier.

The separate nano service runs the same CPU renderer in a Dynamic Worker and survives isolate replacement through Durable Object state and journal replay. You reach it from the JS client rather than the CLI.

#What you give it

• +
  A JavaScript bundle. One local .js file or one HTTPS URL. HTTP URLs are refused. Hermes bytecode is refused, so supply the JavaScript bundle produced before Hermes compilation.
• +
  Your assets. rnx finds Metro’s compiled asset directory on its own and embeds the declared scales into the artifact. See bundles and assets below.
• +
  Nothing else. No Xcode project, no native build, no provisioning profile.

Production bundles built through withRNX(config, { productionBundles: true }) from rnxsim/metro carry exact module identity. A plain unannotated Metro production bundle also works; rnx infers its module identity from the published fingerprint registry.

#Bundles and assets

rnx locates the compiled asset directory Metro wrote, rather than asking you to name it. It reads the asset graph out of your bundle first, then checks the handful of places Metro actually writes to and picks the directory that resolves the most declared asset scales. The directory it chose is printed when the simulator starts.

If an image is declared by the bundle but missing from every candidate directory, rnx embeds a magenta checker in its place at every declared scale, and prints one warning naming each substituted asset and every directory it searched. The descriptor keeps Metro’s own width and height, which is what React Native lays an image out from, so the stand-in changes the pixels without moving your layout. A missing image will not stop a session from starting, and you will always be told it happened.

Fonts, video, and audio still refuse, because there is no stand-in a viewer would read as missing.

rnx never recompresses your images. Embedded bytes are the bytes you built.

#Remote viewing

Remote Viewing opens the running simulator in a browser and paints the authoritative hosted instance with the viewer’s local rnx compositor. A person and an agent therefore see the same app state. Pointer, scrolling, keyboard, text editing, and the agent cursor travel over the same leased connection.

The stable /box-host/<id> URL watches a micro Box, while /sim/<id> watches a nano simulator. Both are private to members of the account running them and mint a short-lived display grant without exposing the command credential. The first connected viewer currently receives the input lease.

Remote Viewing is rnx’s simulator-only experience. Cloudflare Live View is a separate vendor feature that exposes a complete Browser Run tab and is used to debug micro Box hosts.

#Session lifecycle and cost

The CLI client heartbeats the Box while it is connected. rnx remote close ends active compute while preserving the durable checkout; the terminal-only rnx box command deletes a Box and its stored state.

Micro simulator density and pricing are still being measured, so the early access product does not publish a final rate yet. The nano service has separate limits and pricing because it runs on a different host.

#What it can and cannot do

The micro remote simulator supports:

• +
  Remote Viewing with live pointer, scrolling, keyboard, and text input
• +
  a Box shell and agent pane that drive the same authoritative simulator
• +
  hot reload from edits made through the Box file plane
• +
  a private local-copy mode with the rnx inspector
• +
  stable member URLs that survive Browser Run generation replacement

The remote product is iOS-only today and Browser Run has no WebGPU adapter, so the hosted renderer uses the CPU tier. A public endpoint, measured density, and final pricing are still open launch work.

The nano typed client has a smaller command vocabulary for bounded inspection, taps, waits, screenshots, captures, logs, and reset. It does not expose the Box shell or continuous gestures.

#Next

• +
  JS Client drives a nano simulator from JavaScript or TypeScript with no CLI child processes.
• +
  Limits & Pricing records the nano service ceilings and rates.