---
title: How Limrun helps agents run iOS simulators in the cloud
description: Add real-Mac Xcode builds and iOS simulators in the cloud to any
  Linux agent sandbox, then build, test, and ship iOS apps.
author: Limrun
date: 2026-11-04
url: https://limrun.com/blog/ios-simulators-in-the-cloud/
---

# How Limrun helps agents run iOS simulators in the cloud

Limrun connects the Linux sandbox an AI agent already uses to real Macs running iOS simulators in the cloud. Agents get Xcode builds and drivable iPhone, iPad, and Apple Watch simulators over a CLI, API, and MCP server. They do not need to buy a Mac. This article explains why the simulator cannot run locally in a Linux sandbox. It also shows how the service adds the macOS layer without displacing your setup.

## Why can't a Linux agent run the iOS simulator locally?

An AI coding agent in a Linux sandbox cannot launch the iOS Simulator locally. Apple ships the simulator, `simctl`, and `xcodebuild` only as part of Xcode on macOS. Cloud agent environments are usually Linux, so the simulator toolchain is absent from the box. That platform split is documented in [Replicas's guide to testing mobile apps with cloud coding agents](https://replicas.dev/resources/test-mobile-apps-with-cloud-coding-agents). Cloud coding agents generally run on Linux while Xcode supplies the simulator tools on macOS.

The real gap is the machine layer. To build or test an iOS app, the agent needs a remote Mac service. That service provides Xcode and simulator access on its behalf. The practical fix is a Mac-backed layer that runs iOS simulators in the cloud. It exposes them through an interface the agent can call.

## How do I add iOS support to an agent sandbox?

Use a platform like Limrun that attaches a cloud Mac to the sandbox the agent already occupies. The `lim` CLI connects the Linux environment to that macOS build host. It synchronizes the project, runs the Xcode steps, and returns build logs to the agent. That pattern is the basis of a [remote iOS development environment](https://limrun.com/blog/remote-ios-development-environment/). The local Linux workspace remains the control plane while macOS-only steps happen on the Mac fleet.

A [Replicas guide to building a native iOS app without a Mac](https://replicas.dev/resources/build-ios-app-without-mac) documents the same path. The `lim` CLI can reach a cloud Mac, and the platform's agent skills support building and driving an iOS Simulator. The remote Mac builder receives only changed source files, so a second run does not re-upload the whole repository. A warm cache keeps repeated builds short. Build logs stream back to the agent, so it can act on a failure without leaving its context.

The same sandbox supports Swift and React Native, with targets for iOS, watchOS, tvOS, and visionOS. A React Native project can therefore use the cloud Mac for `expo prebuild`, CocoaPods, and `xcodebuild`. The rest of the workflow can stay in place. Adding iOS support to an agent sandbox means adding iOS simulators in the cloud rather than trying to containerize Xcode.

## Can an AI agent control iOS simulators in the cloud?

A coding agent controls a cloud iOS simulator through a non-interactive interface. That can be a CLI, API, or MCP server that sends actions and returns evidence. Limrun exposes that interface through its MCP server and simulator outputs. The same agent that wrote the code can operate the simulator. [Expo's guide to cloud mobile simulators](https://expo.dev/articles/cloud-simulators/best-cloud-mobile-simulators) describes the pattern. A cloud iOS simulator lives on a remote Mac and is controlled through a browser, CLI, or API rather than run locally. For an agent, the channel also has to return machine-readable evidence such as accessibility snapshots, screenshots, recordings, or logs.

The platform's MCP server gives that channel. It runs as one remote server at `https://mcp.limrun.com/mcp` with 16 tools that create, drive, stream, and delete devices. Claude Code, Codex CLI, Gemini CLI, and Cursor add it with the Limrun plugin, and Claude Desktop adds it from the connectors directory. The [Xcode MCP server guide](https://limrun.com/blog/xcode-mcp-server/) explains how to connect one of those agents. The agent can open the simulator instead of asking a human to click through a UI. The iOS Simulator covers iPhone, iPad, and Apple Watch, with taps, typing, screenshots, accessibility tree reads, logs, and 30fps screen recordings. Those outputs give the agent checkable evidence rather than a visual stream it cannot parse. For an AI agent iOS simulator workflow, that evidence is what turns a visible simulator into a verifiable test.

## Can I ship to the App Store without a Mac?

Point the agent at a cloud macOS execution target. Run `xcodebuild` and `lim xcode test` there, produce a signed IPA, and push it to TestFlight or App Store Connect. The agent stays in its existing Linux environment while the Mac-only work happens remotely. Replicas's guide to testing mobile apps with cloud coding agents reported a first Limrun Xcode iOS build at 132 seconds. That first run includes installing npm packages and CocoaPods. The same guide measured 15 seconds for an iOS rebuild after a two-line change, which synced 8.4 KB.

The same workflow continues into testing. The `lim xcode test` command builds a scheme's test targets and attaches a simulator when needed. It runs the tests and reports individual test results. The agent sees per-test evidence instead of a single pass or fail line. Cloud iOS builds from the platform preserve the same artifact flow as a local Mac. Signed IPAs download locally or upload directly.

For distribution, the service can upload signed builds to TestFlight and App Store Connect. Store metadata, screenshots, and localizations stay in App Store Connect. The upload turns iOS development without a Mac into a complete path to ship to the App Store without a Mac. The loop from cloud iOS builds to iOS simulators in the cloud gives agents a complete test-and-ship path.

## How do I start without replacing my Linux CI?

Create a free Limrun API key and run the quickstart. It takes about three minutes, which lets a team confirm the connection before changing any pipeline. The GitHub Action can then build each pull request and post a browser preview link that members of your Limrun organization can open. The same approach works on GitLab, CircleCI, Buildkite, and Jenkins.

For teams composing [mobile infrastructure for AI agents](https://limrun.com/blog/mobile-infrastructure-for-ai-agents/), the point is that this capability is additive rather than a migration. The agent gains Xcode and simulator access without the repository or runner moving. Open one pull request through the GitHub Action to validate the whole loop.

## FAQ

### Does Replit support iOS app development?

Yes. Replit Agent builds iOS apps with Expo and React Native, streams a cloud iOS simulator into the Project Editor, and submits builds to TestFlight and the App Store. The workspace itself is Linux, so the Mac-side work runs in the cloud.

### Can OpenAI Codex build iOS apps?

Yes. Codex can build iOS apps when its Linux sandbox has a remote macOS execution layer. Add the Limrun plugin to Codex CLI, or install the `lim` CLI and Limrun skills in its environment, and it can run Xcode builds with `lim xcode build`, inspect logs, and drive an iOS simulator through the CLI or MCP server. Results return as text and screenshots.

### What happens when a cloud dev environment has to build iOS?

Most cloud dev environments run Linux and lack Xcode. They handle iOS builds by calling a remote Mac service for `xcodebuild`, code signing, and simulator tests. Limrun adds that service to existing environments with a CLI, REST API, SDKs, and MCP tools, so the workspace stays unchanged.

### Can I use GitHub Codespaces for iOS development?

Yes, but Codespaces is Linux-based and cannot run Xcode locally. Call a real Mac through Limrun from inside the Codespace to run `xcodebuild` and simulator steps. The `lim` CLI keeps source sync, test results, and simulator control inside the same environment.

### Can I test an iOS app if I only have a PC?

Yes. Limrun runs iOS simulators in the cloud on real Macs. From a PC you control them through a browser preview, CLI, API, or MCP. You can tap, type, read the accessibility tree, capture screenshots, watch logs, and record video.

### What do I need to develop iOS apps as a solo developer?

Without a Mac, you need a remote Mac path for Xcode builds and simulator tests. A free Limrun account with trial credits and the three-minute quickstart give you that path without buying Apple hardware. Shipping to TestFlight and the App Store also needs an Apple Developer Program membership.

### Can React Native be built without a Mac?

React Native still needs CocoaPods, Xcode, and the iOS Simulator for the Apple side. Limrun runs those steps remotely and returns signed IPAs or browser simulator links. A Windows or Linux machine can remain the primary development environment while the platform handles the iOS build.

### Can Hermes agent build an iOS app without a Mac?

Yes, if the agent can call the platform through the `lim` CLI. Hermes Agent can run `lim xcode build` from its terminal tool to trigger remote Xcode builds and stream logs, and it can inspect simulator screenshots or accessibility snapshots through the CLI or MCP tools. It does not need the macOS toolchain inside its own sandbox.

### Can I do iOS development on Linux without a Mac?

Linux cannot install Xcode, so use a cloud Mac service like Limrun. The `lim` CLI syncs changed source files to a real Mac, runs `xcodebuild`, streams logs back, and lets you drive iPhone or iPad simulators from the Linux terminal or an AI agent.

### Can I compile and run an iOS app without owning a Mac?

Yes. A cloud Mac service can host iOS simulators in the cloud, run `xcodebuild`, and install builds for tests. You can compile a Swift or React Native app, run it in a simulator, and run tests. Signed builds can then become an IPA for TestFlight or App Store Connect.

### Can I get my Devin agent to build an iOS app?

If Devin runs in its Linux sandbox, install the `lim` CLI and skills there. The agent can run `lim xcode build`, stream build logs, and act on the returned result. The service supplies the Mac and Xcode steps without moving Devin to Apple hardware.

### Can Devin build and test an iOS app?

Yes. Devin offers macOS sessions with Xcode and the iOS Simulator. In its default Linux sandbox, it needs a remote iOS execution layer, and Limrun provides Xcode builds and simulator controls that return machine-readable results. The agent can run XCTest or Appium, open a simulator, and use screenshots and logs to verify behavior.
