Limrun for iOS development setup: remote Xcode without local installs
Limrun runs the parts of iOS development that require a Mac, and gives you a CLI, a TypeScript SDK, and MCP endpoints to drive them from anywhere. Real-time remote Xcode builds, cloud iOS simulators, cloud Android emulators, asset storage for builds, and live browser streams you can send to anyone.
The practical effect: no Xcode install, no local simulator, no Mac. Your source stays where it is, builds happen on a cloud Mac, and the running app is a browser tab.
This guide is the setup path from nothing to a running app you can share, plus the extra steps for running it inside a coding agent. Expect about ten minutes if your project builds cleanly today.
Before you start
You need three things.
Node.js 20 LTS or newer. The CLI is distributed through npm. That is the only runtime dependency.
A Limrun account. Sign up at console.limrun.com.
A project that builds. Limrun runs xcodebuild on a remote Mac, so a project with local build errors will have the same errors remotely. If your .xcodeproj is gitignored and a project.yml sits at the repository root or one directory down, XcodeGen runs in the sandbox automatically.
You do not need Xcode, macOS, an Apple Silicon machine, or a simulator installed locally. Shipping to the App Store still needs an Apple Developer Program membership, but that comes later and not during setup.
Step 1: Install and authenticate
npm install --global lim
# or: pnpm add --global lim
# or: bun add --global lim
Then, on any machine with a browser:
lim login
That opens the Limrun console, finishes authentication in the browser, and writes the API key to ~/.lim/config.yaml.
On anything headless, a CI runner, a devcontainer, or an agent sandbox, skip the browser flow. Create a token at console.limrun.com/settings under API Keys and export it:
export LIM_API_KEY=lim_...
The CLI also picks up a .env file in the working directory.
If you would rather see a device before installing anything, the console has a Playground that creates and streams an instance from a dropdown.
Step 2: Build on remote Xcode
Run this from your project root:
lim xcode build .
The first run provisions a Mac sandbox, syncs your working directory, and runs xcodebuild remotely. Build logs stream back as they happen, so you are reading the same output you would see locally.
Later builds sync changed bytes only, which is what keeps the loop fast enough to iterate in.
For a project with multiple schemes, name one and point at the workspace or project file:
lim xcode build . --scheme MyApp --workspace MyApp.xcworkspace
Two flags worth knowing on day one:
--sdk iphonesimulatorbuilds for the simulator,--sdk iphoneosbuilds for a device or for distribution.--include '^ios/GeneratedKit/'force-includes a path that sync would otherwise skip, since sync honors your.gitignoreand generated sources are often in it.
Gradle has the same shape through lim gradle. See Build with Xcode and Build with Gradle.
Step 3: Launch a simulator and attach it
lim ios create --attach --reuse-if-exists --label project=checkout
Three things happen. A simulator boots in the cloud, the build you just made installs and launches on it, and the instance is tagged so you can find it again. From then on, every successful build reinstalls automatically, which means lim xcode build . alone is your whole iteration loop.
Useful flags at create time:
--model iphone|ipad|watchpicks the device. Defaults toiphone.--install-asset <name>preinstalls a build from asset storage, so the app is ready at boot with no Mac sandbox involved.--inactivity-timeout 10mreaps the instance after idle time. Accepts values like1m,10m,3h.--label key=valueis repeatable, and drives both reuse and cleanup.--jurisdiction us|eu|asconstrains where the instance runs when geography is a requirement.
Scope reuse with a label. Reuse needs at least one label and returns an instance whose labels match exactly; without one, every call creates a new instance.
To drive the app from the terminal, read the screen first and work from what it returns:
lim ios element-tree
lim ios tap-element --ax-label "Continue" # whatever your first screen actually shows
lim ios set-text "hello" --ax-unique-id <field-id>
lim ios screenshot ./screen.png
The element tree is the source of truth for what is on screen: labels, accessibility identifiers, types, and frames. Substitute selectors that match your own UI for the examples above. lim ios type sends real keystrokes and needs a focused field.
When you are done:
lim ios delete
lim xcode delete
Without an ID, each delete removes the last instance of that type the CLI created for you.
Step 4: The live preview workflow
Every running instance exposes a Signed Stream URL, with its token carried in the URL fragment. Open it in any browser and you are looking at the live device, and you can drive it with your mouse and keyboard.
This is the part that changes how non-engineers participate. A designer checking spacing, a product manager walking a flow, a support engineer reproducing a customer report: none of them install anything or hold a Limrun account. They open a link.
Anyone with the link can control the simulator, so share it only with people who should have access, and let one person drive at a time.
For a recorded walkthrough instead of a live session:
lim ios record start
# drive the flow
lim ios record stop -o /tmp/demo.mp4
Quality accepts integers 5 through 10 and defaults to 5. Pass --presigned-url instead of -o to push the file straight to your own bucket, which is what you want when the recording is going onto a ticket.
To put a live device inside your own product rather than a Limrun URL, <RemoteControl /> from @limrun/ui renders an iOS or Android device in a web app. Your backend holds the API key and the browser only ever sees a per-instance URL and token. See Embed a simulator.
Step 5: Share a build
Two ways, depending on whether the recipient needs to tap the app themselves.
Preview link on a pull request. Build, upload the artifact, and post the URL:
lim xcode build . --scheme MyApp --upload my-app-pr-482.zip
A reviewer signed in to your Limrun organization opens https://console.limrun.com/stream?asset=<name>&platform=ios, selects Start device, and taps through that branch. Build products expire 14 days after the last upload by default, and each new upload pushes the expiry out again. Full walkthrough in PR previews.
Asset storage for reuse. Push a build once and install it on any instance later, without rebuilding:
lim asset push ./build/MyApp.app.tar.gz -n checkout/my-app-v1.2.3.tar.gz
lim ios create --install-asset checkout/my-app-v1.2.3.tar.gz
Asset names are global to your organization, so prefix them by team or project. Direct uploads do not expire unless you set --ttl. See Asset storage.
Setting it up inside a coding agent
Most cloud coding agents run Linux, which is the reason they stop short on iOS. They can write Swift and cannot compile it. Adding Limrun gives the agent a build command and a device it can see.
The setup is two lines, run from the project root:
npm install --global lim
lim skills install
lim skills install fetches the latest skills from limrun-inc/skills and installs them without prompting. By default it targets every agent that already has a skills directory, installs all skills, and uses project scope. Narrow it with --agents claude|cursor|codex, --skills <name>, or --scope global. Set LIM_API_KEY in the shell the agent uses.
If your agent discovers tools rather than commands, add the MCP endpoint as well. It covers device control; builds and uploads stay on the CLI.
claude mcp add --transport http limrun https://mcp.limrun.com/mcp
One safety note. LIM_API_KEY can create, list, and delete every instance you own, which is more authority than an agent in a shared sandbox should hold. Create the instance outside the sandbox and hand the agent only that instance's credentials:
lim ios create --json > instance.json
export LIM_IOS_INSTANCE_URL=$(jq -r .status.apiUrl instance.json)
export LIM_IOS_INSTANCE_TOKEN=$(jq -r .status.token instance.json)
lim ios element-tree # works with no LIM_API_KEY
Without LIM_API_KEY, create, list, and delete calls fail, so lifecycle stays with whoever holds the key.
Does Claude Code web support iOS development?
Not on its own. Claude Code web runs in a hosted Linux sandbox, and Xcode and the iOS Simulator are macOS-only, so there is no local path to compiling or running an iOS app there.
With Limrun, the loop closes. Install the CLI in the sandbox, set LIM_API_KEY or per-instance credentials for both the simulator and the Xcode sandbox (LIM_XCODE_INSTANCE_URL and LIM_XCODE_INSTANCE_TOKEN), and the agent can run lim xcode build ., attach a simulator, read the accessibility tree, drive the app, and hand you a preview link (per-instance credentials need asset permissions granted when the Xcode sandbox is created). The Mac is on Limrun's side and the sandbox never needs Apple software.
One thing to check for your own environment: hosted agent sandboxes often restrict outbound network access, so confirm yours can reach *.limrun.com and *.limrun.net, plus npm and GitHub for the install, before you debug anything else. A sandbox that cannot make the call will look like an authentication problem and is not one. Claude Code on the web has the exact setup.
OpenClaw
OpenClaw is a self-hosted gateway that connects chat apps to coding agents, so it is the routing layer rather than the thing that builds your app. The iOS question lands on whatever agent sits behind it and whatever machine that agent runs on.
Since both OpenClaw and the lim CLI are Node-based, the setup is the same as any other agent environment: install lim where the agent's shell runs, set LIM_API_KEY, and run lim skills install so the agent has the workflow rather than reasoning its way through the CLI surface. If the host is Linux, Windows, or WSL2, Limrun is what makes iOS work there at all. If the host is a Mac, Limrun is still worth it for the per-session simulators and the shareable previews, but it is a preference rather than a requirement.
FAQ
How long does setup take?
Ten minutes or so from nothing to a running app, most of it the first build and sync. Later builds are much faster, since only changed bytes go over the wire.
Do I need to install Xcode?
No. Xcode runs in the Mac sandbox on Limrun's side. Your machine needs Node and the CLI.
Can I use this from Windows or a Chromebook?
Yes. The base setup is identical. On Windows, the commands run unchanged in PowerShell; if you already use WSL, keep the project on the Linux filesystem, since sync reads your working directory and crossing the /mnt/c boundary adds overhead. On ChromeOS, enable the Linux development environment and install Node there.
Does it work with React Native or Expo?
Yes. For React Native and Expo projects, run Metro locally, open a tunnel for its port, and point Expo at it with EXPO_PACKAGER_PROXY_URL so manifest and bundle URLs resolve. Exact commands are in Connect to local services.
Can I run my test suite on this?
Yes. Maestro flows run against a remote simulator with your flows and the Maestro CLI unmodified, aside from a few commands that do not apply remotely. Appium works through @limrun/appium-xcuitest-driver. XCTest runs through lim xcode test, which streams one line per test case and exits non-zero when anything fails.
Can I ship to the App Store from here?
Yes. Signing and upload both run in the Mac sandbox, either with your own .p12 and provisioning profile or through Apple cloud signing straight to App Store Connect. You still need an Apple Developer Program membership, and the app record has to exist in App Store Connect first, because Apple's API cannot create one. See Build with Xcode.
What does the CLI not cover?
Very little. The CLI is the complete surface: builds, instance lifecycle, asset uploads, device control, and testing. MCP covers devices only: it creates, drives, streams, and deletes them. It exists for agents that discover tools rather than commands.
What still needs a real device?
Release testing. Simulators do not reproduce GPU behavior, thermal throttling, cellular conditions, or battery drain, and NFC, Bluetooth, and LiDAR need hardware. Limrun can feed a video file to the camera, which covers QR scanning and similar flows.
Next: Quickstart · CLI for coding agents · Build with Xcode · Run an iOS simulator · MCP server · PR previews