---
title: "Limrun for iOS development setup: remote Xcode without local installs"
description: "Set up iOS development without a Mac: install the lim CLI, build
  on remote Xcode, run a cloud iOS simulator, and share it as a live browser
  stream."
author: Limrun
date: 2026-11-03
url: https://limrun.com/blog/limrun-ios-development-setup/
---

# 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](https://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

```sh
npm install --global lim
# or: pnpm add --global lim
# or: bun add --global lim
```

Then, on any machine with a browser:

```sh
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](https://console.limrun.com/settings) under **API Keys** and export it:

```sh
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:

```sh
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:

```sh
lim xcode build . --scheme MyApp --workspace MyApp.xcworkspace
```

Two flags worth knowing on day one:

* `--sdk iphonesimulator` builds for the simulator, `--sdk iphoneos` builds for a device or for distribution.
* `--include '^ios/GeneratedKit/'` force-includes a path that sync would otherwise skip, since sync honors your `.gitignore` and generated sources are often in it.

Gradle has the same shape through `lim gradle`. See [Build with Xcode](https://docs.limrun.com/docs/ios/build-with-xcode) and [Build with Gradle](https://docs.limrun.com/docs/android/build-with-gradle).

## Step 3: Launch a simulator and attach it

```sh
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|watch` picks the device. Defaults to `iphone`.
* `--install-asset <name>` preinstalls a build from asset storage, so the app is ready at boot with no Mac sandbox involved.
* `--inactivity-timeout 10m` reaps the instance after idle time. Accepts values like `1m`, `10m`, `3h`.
* `--label key=value` is repeatable, and drives both reuse and cleanup.
* `--jurisdiction us|eu|as` constrains 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:

```sh
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:

```sh
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:

```sh
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](https://docs.limrun.com/docs/platform/embed-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:

```sh
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](https://docs.limrun.com/docs/ci/pr-previews).

**Asset storage for reuse.** Push a build once and install it on any instance later, without rebuilding:

```sh
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](https://docs.limrun.com/docs/platform/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:

```sh
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.

```sh
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:

```sh
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](https://docs.limrun.com/docs/agents/claude-code-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](https://docs.limrun.com/docs/ios/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](https://docs.limrun.com/docs/ios/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](https://docs.limrun.com/docs/quickstart) · [CLI for coding agents](https://docs.limrun.com/docs/agents/cli) · [Build with Xcode](https://docs.limrun.com/docs/ios/build-with-xcode) · [Run an iOS simulator](https://docs.limrun.com/docs/ios/run-simulator) · [MCP server](https://docs.limrun.com/docs/agents/remote-mcp) · [PR previews](https://docs.limrun.com/docs/ci/pr-previews)
