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.
What shipped
- beta.8: a real iPhone in the window, watch only. Plug the phone in with a data cable, and the window shows its live screen next to the app's component tree, logs, network requests and state. You can point at an element on the picture and see its component in the Inspector. The agent can take screenshots of the phone. It can't tap on it yet. Together with beta.7's Android phones, this means an Android phone and an iPhone can run side by side in one window, as in the clip above.
- beta.7: agent taps 6 to 20 times faster. A tap went from 3.3 s to 0.5 s on the iOS simulator, and from 14 s to 0.6–0.8 s on a Galaxy S24. The same release added physical Android phones, and in strict approval mode a third button on input cards, "Always allow taps, swipes and typing". Reloads, launches and other commands still ask.
- beta.6: faster taps with the window closed. When the app isn't open, the agent's iOS taps now go through the screen helper: 5.1 s to 3.3 s on the simulator.
Reading the screen from React instead of the system
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.
Why the iPhone is watch only, and what is next
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 limits
- macOS 26 or later, on Apple silicon only.
- The iPhone is watch only: the agent gets screenshots, not taps. You need a data cable (over Wi-Fi there is no picture), the phone must trust the Mac, and Developer Mode must be on.
- The faster taps need the React Native app connected through Metro and in front. Otherwise the system dump is used, as before.
- Our numbers come from one test app, on one iPhone simulator and one Galaxy S24.
- It's a beta and free while it lasts. Things will break.
The desktop app is in closed beta: ask for an invite at https://parallax-rn.dev/download. Corrections to anything above are welcome.
