You've built something in Rork and the simulator looks fine — but you want to see how it actually feels in your hand before sharing it with anyone.
That's exactly what the Rork Companion app is for. It lets you preview your Rork project on a real iPhone or iPad without needing a paid Apple Developer account, Xcode, or a TestFlight build. Here's how to set it up, and how to think about the gap between the in-browser simulator and a real device.
What the Companion App Does
Rork Companion is an official app available on the App Store. You open it on your device, scan a QR code from your Rork project, and the app loads directly on your phone — no certificates, no build configuration.
The key idea: Companion is the shortest path to running on your actual iPhone. That's a different job from the in-browser live simulator described below.
Between the Simulator and the Device — the Cloud-Mac Live Simulator
It helps to think of Rork's testing setup as three layers: the local simulator, the cloud-Mac live simulator, and the real device via Companion.
Rork compiles your app on a fleet of cloud-hosted Macs and streams the result to your browser as a 60fps live simulator. Because it responds to touch input in real time, you can verify behavior right inside Chrome or Safari without ever launching Xcode. Even if you don't own a Mac, the whole loop from compile to preview happens in the browser.
But the in-browser live simulator is showing you the result of a cloud Mac — it isn't running on your iPhone. The feel under your finger, real chip performance, actual sensor values, the way permission dialogs appear — those "only-this-device-knows" things are what Companion confirms as the final step.
| Environment | Where it runs | What it reveals | What it can't |
|---|---|---|---|
| Local simulator | Your own Mac | Appearance, basic behavior | Real performance, sensors, camera |
| Cloud-Mac live simulator | Rork's cloud Macs (streamed to the browser at 60fps) | Fast iteration without a Mac; touch response | Device-specific performance, permission dialogs |
| Companion (real device) | Your iPhone / iPad | Finger feel, real chip performance, true sensor data, permissions | Submission-grade rigorous testing |
A two-step rhythm works best: iterate quickly in the browser's live simulator, then drop to a real device with Companion at key milestones. You get both speed and accuracy.
Simulator vs. Real Device: The Real Differences
Even with the live simulator, a few things are only honest on a real device:
- Camera: Doesn't work in the simulator (a placeholder image appears instead). On a real device, you can test access and the actual permission prompt
- Touch feel: Tap accuracy and swipe friction only reveal themselves under your fingers
- Performance: Animations can feel different between your Mac's chip and an actual A-series chip
- Push notifications: Limited in the simulator, fully functional on device
- Sensors: Accelerometer, gyroscope, and GPS are simulated values in the simulator and real data on device
Setup: Three Steps
Step 1: Install Rork Companion on your iPhone or iPad
Search "Rork Companion" in the App Store and install it. You can also find the link on Rork's official website.
Step 2: Open your project in Rork and get the QR code
In Rork (desktop app or web), open your project and look for the preview or share options. Find "Open on device" or "Companion" — this displays a QR code.
Step 3: Scan the QR code in the Companion app
Open Companion on your phone, tap "Scan QR Code," and point it at your screen. Your app should load within a few seconds. No accounts, no certificates, no build configurations.
Why Making Device Testing a Habit Pays Off
For a solo developer, real-device testing is the step you keep meaning to "do all at once later." I once felt an app was finished in the simulator, then loaded it onto my own iPhone and realized — right before launch — that one-handed, my thumb couldn't reach the bottom tab. An obvious thing I'd missed entirely.
Since I started touching the real device often through Companion, I catch those "only-obvious-when-you-use-your-finger" problems much earlier. Build in the browser's live simulator, and every time a feature wraps up, scan the QR code and spend thirty seconds on device. That alone cut down a lot of rework downstream.
What to Check on the Real Device
Tap target sizes
You click with a mouse in the simulator; you tap with a finger on device. Apple recommends a minimum tap target of 44×44 points. If something feels hard to tap, that's a real usability problem worth fixing before launch.
Scroll and swipe behavior
Momentum scrolling on a real device differs from the simulator's approximation. Test lists, carousels, and swipe interactions on device before finalizing them.
Notch and Dynamic Island layout
Different iPhone models have different notch sizes or Dynamic Island shapes. Content that looks fine in the simulator can end up obscured on device. Check the top of the screen on whichever models you have.
Permission dialogs
If your app requests camera, location, or microphone access, the dialog only fully appears on a real device. Confirm the wording makes sense in context — it's often the first thing a new user reads.
Common Issues and Fixes
QR code scans but nothing loads
- Make sure your project is saved and the build has completed in Rork
- Confirm your iPhone and Mac are on the same Wi-Fi network
- Force-close Companion and try again
Layout looks different from the simulator
The simulator is an approximation. If real-device rendering differs, treat the real device as the source of truth and adjust your layout to match.
App crashes on a specific device
Memory and CPU constraints differ across iPhone generations. If older devices crash, first check whether any images or animations are particularly heavy. Rork's community forums are a good place to report device-specific issues.
What Companion Catches, and What It Quietly Misses
Once Companion is working, it is tempting to think "it ran on a real device, so we're fine." But what you can verify through Companion is not the same as what you can verify in a store build.
Companion loads the JavaScript bundle from your host machine, so it reproduces JS-layer problems very well: broken layouts, tap targets that are too small, scrolling that catches, fonts that render differently than expected. Companion will surface all of that.
What it will not show you:
- The real transition speed from the splash screen (the bundle loads through a different path)
- Native module initialization failures (Companion already bundles them, so they succeed)
- Permission dialog copy that only appears after submission (
Info.plisttiming)
I once had a camera feature that behaved perfectly in Companion and then crashed in the TestFlight build because I had never filled in the permission usage description. The safe mental model is to treat Companion as the final UI check and TestFlight as the final native check.
If the connection itself is unreliable, see "Rork Companion Not Connecting or Showing Preview?", and if you want to test on a device before enrolling in the Apple Developer Program, "Rork Companion: Test Your iPhone App on a Real Device" covers that route.
Where Companion Fits in the Path to Launch
Rork's workflow runs in one line — design, code, and test in the browser, all the way to a two-click App Store submission. Within that flow, Companion's job is the final real-device check before you press publish.
That said, Companion is a preview tool, not a substitute for full testing. Before submitting to the App Store, you'll want more thorough checks, including TestFlight builds across multiple devices. But for the "does this actually feel good to use?" question, Companion is the fastest answer.
If you haven't tried it on a real device yet, scan a QR code now — before you take the design any further.