DEV Community

Tori Chan
Tori Chan

Posted on

How to Run iOS CI Builds for Capacitor Apps Without Owning a Mac (2026)

Disclosure: I work on Capgo.

You can develop a Capacitor app on Linux or Windows. You can even live-reload the web layer on a physical iPhone from those machines. What you cannot do, if you want a store-signed iOS binary, is pretend that Xcode is optional. Apple still signs and compiles that binary on Apple hardware, with Apple's toolchain.

The useful question in 2026 is not "can I avoid Xcode forever." It is "does a human on the team need a Mac on their desk to get a clean iOS build out of CI." For most Capacitor teams the answer is no. The Mac can live in the cloud, and the developers can stay on the machines they already have.

This is not the same as a one-off "submit without a Mac" walkthrough. This is about the daily path: every pull request or every main branch commit produces an iOS (and usually Android) artifact you can install, and a subset of those artifacts can go to TestFlight or the store.

What CI has to do for a Capacitor app

A Capacitor CI pipeline has two halves.

The first half is ordinary web CI. Install dependencies, run tests, lint, and build the web app into the directory Capacitor uses (often dist or www). This half runs anywhere: GitHub-hosted Linux runners are fine.

The second half is native. npx cap sync copies the web build into the native projects, then Xcode builds the iOS app and Gradle builds the Android app. The Android half can run on Linux. The iOS half needs macOS, signing identities, and a provisioning profile that matches the bundle id.

If your pipeline only builds the web app, you do not have an iOS CI. You have a website CI that happens to live in a mobile repo. The gap shows up when a plugin or a native config change breaks the iOS build, and nobody finds out until someone with a Mac opens Xcode two days later.

Three ways teams close that gap

There are three honest patterns. They all still use Apple hardware. They differ in who operates it.

Self-hosted Macs. You put a Mac mini in a closet or you rent one and attach it to GitHub Actions or GitLab as a runner. This works, and it is predictable if someone on the team is willing to patch macOS, rotate certificates, and babysit disk space. It is also how pipelines rot. The machine gets out of date, Xcode sits a major version behind, and the next OS requirement lands as an emergency.

Hosted macOS runners. GitHub and other CI products sell macOS minutes. You write a workflow that runs on macos-latest, installs tooling, and builds. This is a good fit when you already live in that CI and you are comfortable storing certs in the CI secret store. The costs and queue times are the part to watch. A Capacitor iOS build is not a tiny job once you include CocoaPods or Swift packages, signing, and an archive.

A build service that already has the Mac fleet. You keep web CI where it is, then you hand the native project to a service that compiles and signs on its own machines. That is the product shape of Capgo native builds, which run on Mac Mini M4 hosts and handle certificates, profiles, and store submission. I work on Capgo, so treat that as a disclosed option, not the only option. Codemagic, other mobile CI products, and a well-run self-hosted runner can also be the Mac in this picture.

The pattern I recommend for a Linux or Windows team is: web CI on Linux, native iOS on a cloud Mac you do not maintain by hand, Android on Linux or on the same native service.

A pipeline that stays honest

Here is a shape that holds up.

  1. On pull request, build the web app and run tests on Linux. If you have an Android release flavor that does not need a store key, build that too. Do not pretend to produce a signed iOS app on the PR unless you are willing to spend the Mac minutes.
  2. On main, or on a release tag, run the iOS job. Sync the Capacitor iOS project, build, and sign with a distribution or Ad Hoc profile, depending on whether this artifact is for testers or for the store.
  3. Keep signing material out of the repo. Certificates and profiles belong in a secret store or in a managed signing flow. If a tool offers to handle signing for you, use that rather than checking a .p12 into git.
  4. Publish the artifact. Internal testers get a link or a QR code. Store uploads are a separate, intentional step, not something every CI run should do.
  5. When you also use live updates, do not confuse a web bundle upload with an iOS CI build. A bundle updates the web layer inside an existing binary. The iOS job is for the binary. You need both, and they should not share a "release" button without a human looking at what is being shipped.

If you develop on Linux, the same idea is written up from the developer-laptop side in Build an iOS app from Linux with Capacitor. The CI version is just that flow, unattended.

Signing, the part that usually breaks

Most "we tried cloud iOS builds and gave up" stories are about signing, not about compilers.

Pick one bundle identifier and stay with it. Use an Apple Developer API key or a controlled Apple ID for CI, not a personal login that expires when someone enables 2FA on their phone. Prefer automatic or managed signing if your provider supports it. If you manage profiles yourself, document whether you are building for development, Ad Hoc, or App Store, and do not reuse the wrong profile "just to see if it compiles."

When a build fails, read the log for the signing line before you start changing Capacitor versions. A missing capability, an expired profile, or a team id mismatch looks like a flaky CI problem and is usually not.

What this does not replace

A cloud Mac does not replace TestFlight. It does not replace a real device. It does not replace App Store review. It does not let you skip the Apple Developer Program. It also does not remove the need for a native change when you add a plugin or a permission. For that you still produce a new binary, then you still wait for review.

What it replaces is the bottleneck where only one person can press Product, Archive. When the iOS build lives in CI, a developer on Windows can land a plugin change, see the iOS job fail, and fix it without shipping a laptop around the office.

If you want a single place to start, get a main-branch iOS build producing an installable artifact once a day. After that, hook it to pull requests if the minutes are worth it, and hook store upload to a tag. The Capgo quickstart covers the product-side setup if you use our build and live update tools together. The discipline is the same everywhere: the Mac is an infrastructure detail, not a seat in the office.

Top comments (0)