Fastlane

A Go tool that generates the standard Ruby-based Fastlane files (Fastfile, Appfile, and Deliverfile/Supplyfile) from the merged store.jsonc configs, into each build directory build/xcode/fastlane and build/android/fastlane, and mirrors them into the assembled source projects (build/<platform>/sources/fastlane). This way, developers familiar with Fastlane can easily inspect, debug, and run standard fastlane release commands, rather than relying on a giant, hard-to-read bash script with dozens of CLI arguments.

Run after task appconf, as the final step that generates the projects.

What is Fastlane?

Fastlane is an open source platform aimed at simplifying Android and iOS deployment. It automates every aspect of the development and release workflow so a single command can run a lane. The most common use cases are:

  • Automate screenshots: automatically capture localized screenshots for each language and device the app supports, configured once and stored so anyone on the team can regenerate them.

  • Beta deployment: distribute beta builds to testers, automating incrementing the build version, code signing, building, uploading, and setting a changelog. Supports TestFlight, Play, and other beta services.

  • App Store deployment: create a repeatable workflow to build, upload, and distribute new releases to the store, including app metadata, screenshots, and submitting new versions for review.

  • Code signing: store signing identities and profiles in an encrypted git repository so every developer can reproduce signed builds on any machine.

  • Continuous Integration: integrates with Jenkins, GitHub Actions, GitLab, CircleCI, Bitrise, and other CI services.

Workflows are defined as lanes in a Fastfile. Each lane chains actions such as increment_build_number, build_app, capture_screenshots, upload_to_testflight, and upload_to_app_store, and can be extended with hundreds of community-built actions and plugins.

See the Fastlane documentation for details.

Generated files

Each lane in the generated Fastfiles passes the full configured parameter block (supply/deliver/gym/match/gradle) as keyword arguments, so the store configuration values map directly to Fastlane parameters. Output is deterministic: fixed key order per block, and reruns are byte-stable.

Android (build/android/fastlane/)

  • Appfile — package_name and json_key_file from store.jsonc.

  • Supplyfile — the upload_to_play_store parameters from store.jsonc.

  • Fastfile — build lane (gradle) and release lane (supply).

  • metadata/android/<locale>/ — title.txt, short_description.txt, full_description.txt, video.txt and changelogs/default.txt from the localized metadata block.

Xcode (build/xcode/fastlane/)

  • Appfile — app_identifier, apple_id, team_id, itc_team_id and team_name from store.jsonc.

  • Deliverfile — the upload_to_app_store parameters from store.jsonc, including the nested submission_information hash.

  • Matchfile — the code signing parameters from store.jsonc.

  • Fastfile — certificates lane (match), build lane (gym), and release lane (deliver).

  • metadata/<locale>/ — name.txt, subtitle.txt, promotional_text.txt, description.txt, keywords.txt, privacy_url.txt, support_url.txt, marketing_url.txt and release_notes.txt from the localized metadata block.

Key file handling

Repo-relative path values such as json_key_file (lib/android/config/play-store-key.json) and app_rating_config_path are resolved against the working directory. When the file exists it is copied next to the Fastfile and the emitted value becomes its basename (json_key_file("play-store-key.json")). When it is missing the value is emitted verbatim and a warning is printed to stderr, so the default configs (which reference key files that do not exist yet) keep working.

Requirements

  • Go 1.26 or newer (only for compilation. dist/ directory contains binaries).

  • go-task (optional, only for the tasks below).

  • The merged store configs, produced by task jsonc.

Usage

From the repository root:

tools/fastlane/dist/fastlane-{{os}}-{{arch}}

This reads build/xcode/config/store.jsonc and build/android/config/store.jsonc, generates the Fastlane files, and mirrors them into the assembled projects. Run the lanes from the assembled projects with the per-platform tasks (requires task gen):

cd build/android/sources && task fastlane.run.release
cd build/xcode/sources   && task fastlane.run -- release

Flags

All flags have defaults that point to the standard build/ tree.

Flag Required Description

--xcode-config

No

Path to the merged Xcode store config. Default: build/xcode/config/store.jsonc.

--android-config

No

Path to the merged Android store config. Default: build/android/config/store.jsonc.

--xcode-out

No

Path to the generated Xcode fastlane directory. Default: build/xcode/fastlane.

--android-out

No

Path to the generated Android fastlane directory. Default: build/android/fastlane.

--xcode-sources

No

Path to the assembled Xcode source tree. Default: build/xcode/sources.

--android-sources

No

Path to the assembled Android source tree. Default: build/android/sources.

Tasks

From the repository root:

  • task fastlane (fl): generate the Fastlane files for both Xcode and Android.

  • task fastlane.build (flb): build the tools/fastlane binary.

From each assembled project (build/<platform>/sources/, requires task gen):

  • task fastlane.run (fr): run a lane, defaulting to build; pass another lane after -- (task fastlane.run — release).

  • task fastlane.run.release (frr): run the release lane.

From tools/fastlane/src:

  • task build (b): cross-compile binaries into ../dist/ for macOS (amd64/arm64), Linux (amd64) and Windows (amd64).

  • task test (t): run the test suite.

Release binaries

dist/ contains prebuilt binaries for each platform, named fastlane-<os>-<arch> (Windows uses .exe).