Snapshot (Fastlane) — essence, screenshot generation and setup in mobile apps

What is Snapshot (Fastlane)?

Snapshot (Fastlane) is a component of the Fastlane ecosystem that automates the creation of app screenshots for App Store. It runs UI tests on iOS simulators, takes screenshots at specified app states, and saves them in a structured directory with correct names for each language and device.

Without Snapshot, developers manually launch the simulator, open each screen, take a screenshot via Cmd+S, switch languages and repeat the process for all combinations. Screenshot automation is a key element of ASO optimization, since App Store requires up-to-date screenshots for each new release, and manually updating 60+ screenshots takes hours of work.

According to App Store Connect Documentation (2025), apps with localized screenshots get 25% more conversions in target countries. Snapshot allows teams to update visual content for 32 languages in one run, which is especially important for marketing campaigns tied to new app features.

Use Snapshot in any project that publishes to App Store — it is the standard tool for teams striving to automate the release process and improve ASO.

How Snapshot generates screenshots

The screenshot generation process in Snapshot consists of several stages: preparing UI tests, configuring Snapfile, launching simulators and collecting results. Snapshot sequentially launches each simulator for the specified devices and languages, runs UI tests and takes screenshots at the points where the snapshot() function is called.

After all tests complete, Snapshot collects screenshots into the screenshots/[Language]/ directory with names that meet App Store requirements. Each screenshot is saved in PNG format with resolution matching the target device. Snapshot also generates an HTML report for visual verification of all created screenshots.

Setting up UI tests for Snapshot

For Snapshot to work, you need to add snapshot() calls to the XCTest UI test code of the app. The function takes a screenshot of the current screen state at the moment of call. The developer places snapshot() after each key action: opening a screen, entering data, navigating through tabs or displaying results.

Example of UI test structure: the test logs into the app, calls snapshot("01-LoginScreen") to capture the login screen, then navigates to the home screen and calls snapshot("02-HomeScreen") to capture the home screen. XCTest is Apple's framework for unit and UI testing of iOS apps, integrated directly into Xcode.

// UI test for Snapshot
- (void)testScreenshots {
    XCUIApplication *app = [[XCUIApplication alloc] init];
    [app launch];
    
    snapshot(@"01-LoginScreen");
    
    [app.textFields[@"email"] tap];
    [app.textFields[@"email"] typeText:@"user@company.com"];
    [app.buttons[@"Login"] tap];
    
    snapshot(@"02-HomeScreen");
}

Working with languages and devices

Snapshot automatically switches the simulator language for each language specified in Snapfile. The app launches with the corresponding localization, and UI tests run in that language. Screenshot localization is a critical ASO factor: users in 75% of cases prefer apps with content in their native language, including screenshots in App Store.

For each device, Snapshot launches a separate simulator with the corresponding screen size. All sizes required by App Store are supported: iPhone 6.5 inches (iPhone 15 Pro Max), 5.5 inches (iPhone 8 Plus), 6.7 inches (iPhone 15 Plus) and iPad 12.9 inches. iOS Simulator is a software emulation of an iOS device built into Xcode for testing apps without a physical device.

# Generate screenshots for all devices and languages
fastlane snapshot

# Generate only for specified devices
fastlane snapshot --devices "iPhone 15 Pro Max,iPhone 15"

# Clear before screenshot generation
fastlane snapshot --reinstall_app --erase_simulator

Snapshot configuration via Snapfile

Snapfile is a Fastlane configuration file that defines screenshot generation parameters: device list, languages, timeout and launch options. Snapfile is stored in the fastlane directory and versioned together with the project, ensuring a unified configuration for all team members.

# Snapfile — screenshot configuration
devices([
    "iPhone 15 Pro Max",
    "iPhone 15",
    "iPad Pro (12.9-inch)"
])

languages([
    "en-US",
    "ru",
    "de-DE"
])

scheme("MyAppUITests")
output_directory("./screenshots")
clear_previous_screenshots(true)
reinstall_app(true)
erase_simulator(true)

The clear_previous_screenshots parameter deletes old screenshots before starting generation — this prevents accumulation of outdated screenshots in the output directory. reinstall_app reinstalls the app on the simulator before each run, ensuring a clean session without influence from previous tests on the new generation.

The erase_simulator parameter clears the simulator contents before starting tests — including cache, settings and data from previous sessions. This is especially important for tests that check onboarding or first app launch. Snapshot also supports ios_version parameter for specifying the iOS version on the simulator and stop_after_first_error to stop generation at the first UI test error.

For SwiftUI projects, the use_simulator_for_language parameter is available, which controls language switching through simulator settings instead of changing the system region. Snapshot also supports launch_arguments for passing additional arguments when launching the app — useful for tests with different backend configurations or A/B tests.

Snapshot commands for screenshot generation

Snapshot interface includes basic commands for launching generation and extended flags for precise control over the process. The main command fastlane snapshot runs the full screenshot generation cycle based on the Snapfile configuration.

Quick generation and filtering

The command fastlane snapshot --devices "iPhone 15" generates screenshots only for the specified devices, ignoring the rest from Snapfile. --languages "en-US,ru" filters languages for generation. The combination of these flags is useful for quickly checking screenshots on one device and language without a full generation cycle, which can take up to 30 minutes for 5 devices and 10 languages.

# Quick generation for one device
fastlane snapshot --devices "iPhone 15" --languages "en-US"

# Generate with app reinstall
fastlane snapshot --reinstall_app --erase_simulator

# Generate with HTML report
fastlane snapshot --output_directory "./build/screenshots"

The --output_directory flag changes the results save directory. By default, Snapshot saves screenshots to fastlane/screenshots. For integration with Deliver, specify a directory that matches the expected Deliverfile structure — this allows passing screenshots directly to the publishing process without manual file copying between folders.

Integrating Snapshot into CI/CD pipeline

Snapshot in CI/CD is automatic screenshot generation with each release commit. Snapshot runs before the Deliver stage to ensure that screenshots in App Store match the current app version and do not contain outdated UI elements from previous versions.

For Snapshot to work in CI, Xcode with installed iOS simulators is required. In CI environments, Snapshot uses simulators from Xcode, which are pre-loaded on the runner. GitHub Actions provides images with pre-installed Xcode and iOS simulators for running UI tests without additional setup.

# Run Snapshot in CI environment
fastlane snapshot --skip_open_summary \

      --output_directory "$CI_PROJECT_DIR/screenshots"

# Save screenshots as CI artifacts
cp -R "screenshots/" "$CI_PROJECT_DIR/artifacts/"

The --skip_open_summary parameter disables opening the HTML report after generation — in CI environments, the graphical interface is not available. Generation results are saved in a directory that is passed as a CI task artifact and then used by Deliver for upload to App Store together with the release.

To speed up the CI pipeline, use parallel screenshot generation through concurrent_simulators — a Snapfile parameter that launches multiple simulators simultaneously. This reduces screenshot generation time for 5 devices and 10 languages from 40 minutes to 15 minutes when using 4 parallel threads.

Common errors when working with Snapshot

When using Snapshot, developers most often encounter errors related to UI test instability, simulator problems and incorrect device configuration. Error diagnostics in Snapshot starts with analyzing the HTML report, which contains screenshots of each step and information about failed tests.

The error "Failed to build scheme MyAppUITests" occurs when the UI test scheme is not configured for building. Solution: make sure a separate Scheme for UI tests is created in Xcode and the Shared option is enabled for command line access. Xcode Scheme is a build, test and run configuration for the app that defines the set of targets and parameters for each action.

The error "No simulators found matching..." indicates that no simulator with the specified device type or iOS version exists. Solution: run xcrun simctl create to create a simulator or specify an existing device from the xcrun simctl list output. xcrun simctl is an Xcode command-line utility for managing iOS simulators: creating, deleting, launching and diagnostics.

For the error "UI test failure" the UI test fails on one of the languages or devices. Solution: run Snapshot with the --stop_after_first_error flag to stop at the first error, analyze the screenshot in the HTML report and fix the test. A common cause is different text length across languages, causing UI elements to overlap or go out of screen bounds.