A Galaxy S24 and an iPhone 13 in one Parallax window, running the same test app on one Metro. The agent taps on the S24; the iPhone is
watch only, and a pick on its picture opens src/CompatScreen.tsx:16.
Parallax is a desktop app and an MCP server that give you and your coding agent the same live view of a running React Native app: the
screen, the component tree, logs, network and state. Three releases went out this week. Here is what changed, how one of the changes
works, and what is still missing.
Every agent tap reads the screen twice. Before the tap, the tool needs to find the element and check that the app is in front. After
the tap, it tells the agent what changed. Until beta.7 both reads were the platform's accessibility dump: AXe on iOS, uiautomator on
Android.
Those dumps are slow. On a still screen they took 0.6 to 3 s. On an Android screen with an animation, uiautomator waits for the screen
to go idle, and on our busy test screen it gave up after 11 s. One tap took 14 s.
A React Native app already knows what is on its screen. Parallax reads the app's React tree through Metro, and from it builds the same
list the dump gives: each view with a testID, a label, text, or a text input, with its frame measured by the app itself. That takes 5 to
100 ms. The testIDs are the same, and 33 of 34 frames we compared matched the dump's to within a point.
So when the app is connected and in front, both reads now come from React. A tap is 0.50 to 0.53 s on the iOS simulator and 0.60 to
0.84 s on the S24, measured over 5 taps by id and 5 by point on each. The first tap of a session still takes about 4.9 s, because it opens
the input session and reads the dump once.
The agent's taps on the iOS simulator: count+ three times, then the perf lab opened and closed. The "Last action" line under the picture updates after each tap.
The dump stays for what React can't see: system alerts and permission prompts, the keyboard, another app in front, an app that isn't
connected. If the app loses its connection to Metro, every read falls back to the dump, and taps are as slow as before.
Showing an iPhone and controlling one are different problems.
Showing it is the cheap half. macOS can treat a plugged-in iPhone as a video source. Our capture helper, a small piece of native code of
our own, streams that picture to the window. The app's data comes through Metro as on a simulator, so the Inspector, logs, network and
state work unchanged. Nothing is installed on the phone, and you need no Apple account. macOS asks once for camera access, because that
is how it classes the iPhone's picture.
Pointing works on the iPhone's picture as on a simulator's, because a pick reads React, not input:
On the simulator: Select element, a click on "fetch", and the Inspector opens src/CompatScreen.tsx:16. The pick on the iPhone in the
first clip works the same way.
Controlling it is the expensive half. Sending a tap to a real iPhone needs a signed test runner on the phone. That is the next plan, and
until it lands, the agent's tap, swipe and type tools on an iPhone answer that this needs a later version. You tap on the phone itself.
One setup note. With React Native 0.86 and the prebuilt React Core, an app on a device ignores RCT_METRO_PORT and connects to port 8081.
If your Metro runs on another port, start the app from Xcode with this launch argument:
-RCT_jsLocation <your Mac's IP>:<port>
Parallax doesn't install or launch your app for you.
The desktop app is in closed beta: ask for an invite at https://parallax-rn.dev/download. Corrections to anything above are welcome.