Skip to content

CI review: GitHub Actions and Xcode Cloud (2026-11-20)

Scope set by the owner on 2026-11-20: Xcode Cloud is for the Swift side only (the app build, the Swift unit and UI tests, and the Mac and iOS archives for TestFlight). Python tests and checks stay on GitHub Actions and on our Macs. This is an assessment; nothing here sets Xcode Cloud up.

What is decided and built

  • GitHub Actions, CodeQL, secret scanning and Dependabot are free for this public repository. docs/contributor_manual/specs/harness/github-ci.md holds the lines: .github/dependabot.yml, security.yml (the builder’s own scanners plus CodeQL), tests.yml (engine unit suite and spec guards, Swift build and tests, report-only) and the opt-in rule for builder check to read a green run.
  • The Python side (engine unit suite, spec guards, scanners) is not a candidate for Xcode Cloud: it has no Xcode project to build and its checks are scripts.

Xcode Cloud, Swift side only

Free allowance. An Apple Developer Program membership includes 25 compute hours a month. A workflow that builds and tests the macOS and iOS targets, plus two archives, has to fit in that. The numbers to measure before any move: the wall time of one build and unit-test run of the Fichero (Dev Local) scheme, and of one Release archive for each platform. Those are measured by running the same scheme on GitHub’s macos-15 runner through tests.yml, which is free and shows how long the Swift build takes; Xcode Cloud’s own runners are not the same machines, so the figure is a first bound, not a quote.

The embedded engine. The Mac archive embeds the engine: scripts/build-release.sh builds it with Briefcase (scripts/preflight-embedded-engine.sh --rebuild), cleans it (scripts/clean-embedded-engine.sh), and an Xcode run-script phase copies it into the host app. Xcode Cloud can run ci_scripts/ci_post_clone.sh before the build, so the engine step could move there, but the Briefcase build is Python packaging with a large dependency set (the models and the platform wheels), and it is the slowest and least predictable part of a release. Two ways, in order of preference:

  1. Build the engine on our Macs (as now), publish it as a versioned artifact, and have ci_post_clone.sh download it and verify its checksum before the Xcode build. Xcode Cloud then only does Swift work, as the owner scoped it. The cost is one more thing to publish and a place that must hold the artifact (GitHub release assets fit).
  2. Build the engine inside ci_post_clone.sh. Not recommended: it spends the free hours on Python packaging and puts the Python toolchain on a runner we do not control.

The iOS archive has no embedded engine (the engine is remote-only there, see release-and-versioning.md), so it is the cleanest first candidate.

Signing. Xcode Cloud signs with cloud-managed certificates, so the Developer ID and notarisation path that scripts/release-all.sh runs for the DMG (notarize, staple, Sparkle-sign) is not replaced by it; only the App Store distribution archives are. The DMG release stays on our Macs.

TestFlight. An Xcode Cloud workflow can archive and post a build to TestFlight on a tag or a branch push, which is what the Mac and iOS TestFlight parts of release-all.sh do today. Moving them would take the two longest uploads (and the upload watchdog logic) off the release Mac. What would be lost: the release lane’s own preflight, the smoke of the optimised artifact before the verdict (release-and-versioning.md step 5), and its text alerts to the owner; Xcode Cloud reports through App Store Connect and email, so those would need a replacement before the move.

What it does not do for us. It cannot run the engine’s Python tests, the spec guards or the security scanners, it has no hook for the builder’s rungs, and the builder cannot read its results the way it reads a GitHub run (App Store Connect API only). So the builder’s ladder is unchanged by it.

Recommendation

  1. Let tests.yml run for a few weeks and read the Swift job’s time and failures; that decides whether the Swift unit tests are better on GitHub (free, readable by builder check) or on Xcode Cloud (needed only for the archives).
  2. If the 25 hours are enough, the first and smallest move is the iOS TestFlight archive on Xcode Cloud: no embedded engine, no Developer ID. The Mac archive follows only with option 1 above (engine as a downloaded, checksummed artifact).
  3. Keep the DMG release, notarisation and Sparkle on our Macs.
  4. Nothing is set up until the owner approves the first workflow; setting one up needs the owner’s App Store Connect access, which a worker does not have.