Learn Swift - Modern Tooling & Build Automation

#Introduction

A healthy project isn't only about code — it's also about how that code is built, tested, and released consistently. Episode 18 covers modern tooling and build automation: managing Xcode projects, building CI/CD pipelines with Xcode Cloud, GitHub Actions, and Bitrise, handling code signing, and automating distribution with Fastlane.

A build that anyone can run, at any time, with identical results is the foundation of a trustworthy release. This episode turns fragile manual processes into repeatable automation.

#Xcode Project and Build Settings

#Understanding Build Settings

Xcode build settings are hundreds of variables that control compilation. The ones you change most often: SWIFT_VERSION, IPHONEOS_DEPLOYMENT_TARGET, and PRODUCT_BUNDLE_IDENTIFIER. Modern management uses xcconfig — versionable text configuration files that replace settings only visible through the GUI:

# Config/Release.xcconfig
SWIFT_VERSION = 6.0
IPHONEOS_DEPLOYMENT_TARGET = 16.0
PRODUCT_BUNDLE_IDENTIFIER = com.example.Aplikasi
CODE_SIGN_STYLE = Automatic

SWIFT_VERSION = 6.0 selects the language version — important because Swift 6 enforces concurrency. Moving settings into xcconfig makes build changes documented and reviewable in pull requests.

#Building from the Command Line

Everything the Xcode GUI does can be done from the terminal with xcodebuild:

xcodebuild -project Aplikasi.xcodeproj \
  -scheme Aplikasi \
  -destination 'platform=iOS Simulator,name=iPhone 15' \
  test

xcodebuild ... -scheme Aplikasi ... test runs the build and tests on the specified simulator. This same command is what the CI pipeline runs — consistency between local builds and CI builds makes debugging the pipeline far easier.

#Continuous Integration

#Xcode Cloud

Xcode Cloud is Apple's integrated CI: triggers on branches and tags, runs tests on simulators or devices, then signs and distributes. Its strength: full integration with App Store Connect and TestFlight with no infrastructure configuration.

#GitHub Actions for Swift

For open source and server-side Swift projects, GitHub Actions is the lightest choice. Workflows run on Linux or macOS runners:

name: iOS CI
on:
  push:
    branches: [main]
jobs:
  build:
    runs-on: macos-14
    steps:
      - uses: actions/checkout@v4
      - run: xcodebuild test \
          -scheme Aplikasi \
          -destination 'platform=iOS Simulator,name=iPhone 15'

runs-on: macos-14 provides a runner with Xcode. The workflow runs the same xcodebuild test as locally — one set of commands for every environment. For server-side packages, swift build and swift test run on ubuntu-latest.

#Bitrise

Bitrise is a mobile-focused CI/CD platform with ready-made steps: building the IPA, uploading to TestFlight, automated cert signing, and App Store Connect integration. It's useful when a team wants a documented mobile pipeline without writing a workflow from scratch.

#Code Signing and Release Builds

#Code Signing and Provisioning

Code signing signs the binary with a Developer ID certificate so devices trust it. A provisioning profile binds the app to specific devices or accounts and contains entitlements. The two must match: a development profile for dev builds, a distribution profile for App Store and ad-hoc builds.

Signing errors are the most common cause of CI build failures. Automate by managing certificates and profiles as secrets, and use Xcode's automatic signing with a team ID to save manual configuration.

#Release Builds

A distribution build uses the Release configuration with full optimization:

xcodebuild archive \
  -scheme Aplikasi \
  -archivePath ./build/Aplikasi.xcarchive \
  -configuration Release

xcodebuild archive -archivePath ... produces a .xcarchive containing the app ready for export. From there, the archive is exported to the appropriate format — .ipa for App Store or ad-hoc — and uploaded for distribution (episode 20).

#Fastlane

#Build and Deployment Automation

Fastlane is an open source tool that automates build, test, signing, and upload flows. Lanes are defined in a Ruby Fastfile:

lane :beta do
  match(type: "adhoc")
  build_app(scheme: "Aplikasi")
  upload_to_testflight
end

lane :beta do ... end defines a flow named beta: fetch signing via match, build the app, then upload to TestFlight. Run it with bundle exec fastlane beta:

bundle exec fastlane beta

bundle exec fastlane beta executes the lane step by step. Fastlane supports many platforms and is the de facto standard for iOS release automation because it replaces dozens of manual steps with a single command.

#Closing

Key takeaways:

• xcconfig moves build settings into versionable text files.
• xcodebuild provides the same CLI commands for local and CI builds.
• Xcode Cloud, GitHub Actions, and Bitrise offer CI with different approaches.
• Code signing and provisioning profiles must be consistent between dev and distribution.
• xcodebuild archive produces the artifact for release.
• Fastlane automates build, signing, and upload in a single command.

In the next episode, episode 19, we'll cover cross-platform and server-side Swift — using Swift on the server with Vapor, Kitura, and SwiftNIO, comparing use cases with other platforms, cross-platform packages, and running Swift on Linux and in Docker. Swift leaves the Apple ecosystem!