iOS App Preview Video Generator From Simulator: Kap vs ios-sim vs Xcode vs Reely

Meta title: iOS app preview video generator from simulator — Kap vs ios-sim vs Xcode vs Reely

Meta description: Learn how to generate iOS App Store preview videos from simulator recordings. Compare Kap, ios-sim, Xcode, and Reely, and see CI-ready App Store preview automation examples.

If you’re looking for an iOS app preview video generator from simulator footage, you’re probably stuck between three paths:

• manual tools like Kap,
• scripting utilities like ios-sim + simctl,
• or native Xcode workflows.

And if you’re AI‑native, you’re probably wondering how Reely plugs into this so your agent can make the app demo video the moment a build goes green.

This guide compares Kap, ios-sim, Xcode’s built‑in options, and Reely for automation, repeatability, CI, and agent-driven workflows. It includes a practical, copy‑pasteable recipe to go from XCUI test → xcodebuild → simctl recordVideo → App Store‑ready preview.

For a broader, strategy-level view of agents and launch videos, see our pillar article: “Can an AI Agent Make Your App Demo Video?” (linked from the Reely blog).

Why simulator-based App Store previews matter

Apple’s App Store previews are short, device-specific marketing videos, not just screen recordings. Apple’s current guidance (see App Preview specifications) requires:

• Length: 15–30 seconds per preview
• Count: up to 3 previews per language
• Codec: H.264 or ProRes 422 HQ (as of Apple’s documentation, accessed 2026-08-10)
• Frame rate: up to 30 fps
• Max file size: 500 MB per preview
• Resolutions: device-specific; for iPhone, accepted examples include 886×1920 portrait and 1920×886 landscape

Apple also recommends (see App Previews overview):

• keep footage inside the app UI (no hands/fingers filming the phone)
• use graphics and transitions for clarity
• rely on on-screen copy, because sound is muted by default

That means your workflow needs to:

1. Capture clean simulator footage in the right device frame
2. Make the flow repeatable (tests, scripts, agents)
3. Add titles, pacing, and music to turn raw capture into a launch-ready preview

The four options at a glance

Here’s the high-level comparison between Kap, ios-sim, Xcode built-in tools, and Reely.

| Tool | Primary role | Automation level | Best for | |-----------|-----------------------------------------------|----------------------------|------------------------------------| | Kap | Menu-bar screen recorder | Low (manual) | Quick, ad hoc captures | | ios-sim | CLI launcher for iOS Simulator | Medium (scripted launch) | Booting/launching apps in scripts | | Xcode | First-party automation + capture stack | High (tests + simctl) | Repeatable simulator recordings | | Reely | AI-native app launch video generator | Very high (agent-first) | App Store previews & launch reels |

The rest of this article dives into how each fits into CI, agent workflows, and App Store preview automation.

Option 1: Kap – fast manual capture, not CI-friendly

Kap is an open source, menu-bar-driven screen recorder for macOS.

What Kap does well

Kap is great when you:

• Want to record a quick iOS simulator demo by hand
• Prefer a visual UI to start/stop recordings
• Need lightweight editing/export plugins (GIFs, MP4s, etc.)

Typical workflow:

1. Launch Kap
2. Choose a region (e.g., your simulator window)
3. Hit record
4. Reproduce your flow in the simulator
5. Stop recording via the menu bar

Where Kap falls short for automation

From Kap’s docs and UI, everything is built around interactive use:

• No first-class CLI for scripted recordings
• No awareness of Xcode simulators or XCUI tests
• No built-in triggers for CI pipelines

That makes Kap a poor choice if you want to:

• Automate iOS simulator recording in CI
• Tie recordings to xcodebuild test runs
• Have an agent recreate flows deterministically

Summary: Kap is the best screen recording tool for app demos when you’re clicking around manually. It’s not an iOS app preview video generator from simulator in the CI/agent sense.

Option 2: ios-sim – launcher utility, not a recorder

ios-sim is a command-line utility for launching apps in the iOS Simulator.

The repo describes commands like:

• install: install an app onto a simulator
• launch: launch a particular app
• showdevicetypes, showsdks: list available devices/SDKs

As of 2026-08-10, the repository notes ~1.5k stars and the latest commits are a few years old; always check the GitHub page for up-to-date status.

Strengths

• Useful for scripted simulator booting
• Can integrate into build scripts (e.g., ios-sim launch ...)
• Good glue tool when you want to run the simulator from node scripts or other CLIs

Limitations

• Not a video tool: it doesn’t record or export videos
• No direct integration with App Store preview specs
• No concept of dead-air trimming, pacing, titles, or sound

Summary: ios-sim is excellent plumbing for launching your app, but you still need xcrun simctl io recordVideo (or Xcode’s Device Hub) to capture footage and something else to shape it into a preview.

Option 3: Xcode – first-party capture and automation stack

Apple’s first-party stack (XCTest/XCUIAutomation, xcodebuild, simctl, Device Hub) is the only path that natively supports both scripted UI flows and simulator video capture.

Key components:

• XCUIAutomation/XCTest: record user interactions into test code
  • See Apple’s docs: Recording UI tests and XCUIAutomation recording
• xcodebuild: run tests on a server/CI
  • Apple recommends running tests on a server to improve consistency and free dev machines (Testing with Xcode guide)
• Simulator recording via simctl:
  • CLI: xcrun simctl io booted recordVideo <file> (documented in Capturing screenshots and videos)
• Device Hub in Xcode: GUI for screenshots and videos
  • Apple notes simulator recordings are saved to the Desktop by default, with filenames beginning with Screen Recording plus device name and timestamp

Why Xcode is the best baseline for CI

For App Store preview automation and repeatable simulator recordings, Xcode gives you:

• Repeatable flows via XCUI tests
• Server-based test execution via xcodebuild
• Scriptable video capture via simctl

This is where the industry is moving: script first, capture second.

1. Write a UI test that encodes your ideal demo flow
2. Run that test inside CI with xcodebuild
3. Wrap it with simctl recordVideo to capture the session

You get consistent, replayable footage that can be regenerated every time the UI changes.

Option 4: Reely – from simulator flow to launch reel

Reely sits on top of the Xcode stack and turns simulator footage + app context into finished launch videos.

Reely is an AI-native app launch video generator for mobile developers. It runs as:

• a native macOS editor that renders locally and works with the iOS Simulator
• an MCP/agent tool that plugs into your existing AI coding agent and shipping workflow

What Reely adds beyond Xcode

Xcode gets you raw footage. Reely gets you:

• Two primary outputs:
  • 10–20s feature teasers
  • 30–60s full launch promos
• Studio-level motion system:
  • kinetic typography systems
  • device choreography presets
  • editorial pacing with automatic dead-air removal
  • music and sound cue timing
• Brand-theme-from-app:
  • pulls visual identity from your app
  • matches titles, backgrounds, and devices to your UI
• Multi-aspect output:
  • App Store resolutions
  • 9:16 (Shorts, Reels)
  • 16:9 (YouTube, landing pages)
  • 4K masters

Most importantly for this article, Reely is agent-first:

Your agent built the app. Let it build the demo reel too.

The same AI that wrote your feature can:

1. Reconstruct flows in the iOS Simulator
2. Trigger scripted simulator recordings
3. Hand off footage and specs to Reely for an editable motion project

You get “promo from code in minutes”, not just another MP4.

Automate App Store preview generation from simulator recordings (CI examples)

In this section, we’ll walk through a practical recipe to:

1. Script a UI flow with XCUI tests
2. Run it via xcodebuild in CI
3. Capture video with xcrun simctl io booted recordVideo
4. Hand the result to Reely for polishing

This is the foundation for any CI tool that creates app demo video after a successful build.

Quick commands reference (simctl, xcodebuild, ios-sim)

# Record iOS simulator via command line (requires Xcode + Xcode command line tools)
# Start recording
xcrun simctl io booted recordVideo --codec=h264 ./ScreenRecording.mp4
# Stop recording: press Ctrl+C

# Example xcodebuild test run for a workspace
xcodebuild \
-workspace MyApp.xcworkspace \
-scheme MyApp \
-destination 'platform=iOS Simulator,name=iPhone 15,OS=latest' \
test

# Example xcodebuild test run for a project
xcodebuild \
-project MyApp.xcodeproj \
-scheme MyApp \
-destination 'platform=iOS Simulator,name=iPhone 15,OS=latest' \
test

# ios-sim examples (when installed)
ios-sim showdevicetypes
ios-sim install ./build/MyApp.app
ios-sim launch com.example.MyApp --devicetypeid "iPhone-15"

Requirements:

• macOS runner with Xcode installed (for both xcodebuild and xcrun simctl)
• Xcode version that includes the Device Hub and simctl recording (Xcode 11+ covers this; always check current docs)

Practical recipe: XCUI test → xcodebuild → simctl recordVideo → Reely

This is a copy-pasteable example you can adapt.

1. Create an XCUI test that encodes your demo flow

In your UI test target, create a test like this:

// MyAppUITests/DemoFlowUITests.swift

import XCTest

final class DemoFlowUITests: XCTestCase {

let app = XCUIApplication()

override func setUp() {
super.setUp()
continueAfterFailure = false
app.launchArguments += ["-UITestDemoFlow"]
app.launch()
}

func testDemoFlow() {
// 1. Landing screen -> tap "Get Started"
app.buttons["Get Started"].tap()

// 2. Fill in a sample form
let nameField = app.textFields["Name"]
nameField.tap()
nameField.typeText("Reely User")

// 3. Continue to summary
app.buttons["Continue"].tap()

// 4. Wait for summary state (stabilize UI)
let summary = app.staticTexts["Summary"]
XCTAssertTrue(summary.waitForExistence(timeout: 5))

// 5. Brief pause to let animations play for the recording
sleep(2)
}
}

This test makes the demo flow repeatable for both local runs and CI.

2. Run the test via xcodebuild (locally or in CI)

From your project root:

# Run only the DemoFlowUITests
xcodebuild \
-workspace MyApp.xcworkspace \
-scheme MyApp \
-destination 'platform=iOS Simulator,name=iPhone 15,OS=latest' \
-only-testing MyAppUITests/DemoFlowUITests \
test

Alternatively, use -project if you don’t have a workspace.

3. Wrap xcodebuild with simctl recordVideo

To automate iOS simulator recording in CI, you can wrap the test run with simctl.

Shell script example:

#!/usr/bin/env bash
set -euo pipefail

OUTPUT_DIR="./artifacts/videos"
mkdir -p "$OUTPUT_DIR"
VIDEO_PATH="$OUTPUT_DIR/app-preview-iphone15.mp4"

# Boot the simulator (optional if xcodebuild will do it)
xcrun simctl boot 'iPhone 15' || true

# Start recording in the background
xcrun simctl io booted recordVideo --codec=h264 "$VIDEO_PATH" &
SIMCTL_PID=$!

# Run the demo flow test
xcodebuild \
-workspace MyApp.xcworkspace \
-scheme MyApp \
-destination 'platform=iOS Simulator,name=iPhone 15,OS=latest' \
-only-testing MyAppUITests/DemoFlowUITests \
test

# Stop recording (Ctrl+C for the background process)
kill -INT "$SIMCTL_PID" || true
wait "$SIMCTL_PID" || true

echo "Recorded preview at: $VIDEO_PATH"

Expected result:

• A file like ./artifacts/videos/app-preview-iphone15.mp4
• Codec: H.264 (per --codec=h264)
• Duration: driven by your test (aim for 15–30 seconds to match Apple’s preview rules)

4. Hook into CI (GitHub Actions example)

Here’s a minimal GitHub Actions step that uses a macOS runner to run the script after a successful build.

name: iOS App Preview CI

on:
push:
branches: [ main ]

jobs:
app-preview:
runs-on: macos-latest
steps:
- uses: actions/checkout@v4

- name: Select Xcode version
run: sudo xcode-select -s /Applications/Xcode.app

- name: Install dependencies
run: |
pod install || true

- name: Run demo flow and record simulator
run: |
chmod +x ./scripts/record_demo_flow.sh
./scripts/record_demo_flow.sh

- name: Upload preview artifact
uses: actions/upload-artifact@v4
with:
name: app-preview-video
path: artifacts/videos/app-preview-iphone15.mp4

With this in place, your CI will automatically generate app demo reels from build artifacts (raw MP4s) every time you push.

5. Post-processing with Reely

Once the MP4 is generated, you can:

• Open it directly in the Reely macOS editor
• Or let your coding agent pass the file and flow description to Reely’s MCP tool

From there, Reely can:

• Trim the clip to 15–30 seconds
• Add kinetic titles and device choreography
• Match colors and typography to your app
• Output App Store-ready previews plus variants for X, Product Hunt, and Shorts

Now your CI tool creates app demo video after successful builds, and your agent can ship polished launch videos without touching a traditional NLE.

Limitations & gotchas when automating simulator recording

Automation isn’t free. A few practical constraints matter in CI:

1. macOS runner with GUI session

• iOS Simulator is not fully headless; it assumes a GUI session
• For GitHub Actions and most hosted CI, you need macOS runners (e.g., macos-latest)
• For self-hosted runners:
  • ensure a logged-in user session
  • disable display sleep or use tools like caffeinate

2. Permissions and first run dialogs

• The first time the simulator runs, macOS may ask for:
  • screen recording permission
  • accessibility permissions
• You must approve these once on the runner so subsequent CI runs don’t hang

3. Headless vs UI-borne simulators

• xcrun simctl can boot simulators without opening Xcode, but there’s still a WindowServer context
• Some CI environments may kill the simulator if the user session logs out
• Prefer long-lived runners or make sure each job boots and closes simulators cleanly

4. Timing issues in XCUI tests

• Automated tests can run faster than humans, making clips feel rushed
• Add brief sleep or expectation waits to allow animations to read well on video

5. App Store preview rules can change

• Always check Apple’s current App Preview specs
• Verify length, allowed codecs, frame rates, and resolutions before your final export

Comparison: which tool for which job?

When to use Kap

Use Kap when:

• You’re doing a one-off demo for internal stakeholders
• You want to manually control every move
• CI and repeatability are not important

Kap is easy, but it doesn’t scale with frequent releases or agent workflows.

When to use ios-sim

Use ios-sim when:

• You need to launch simulators from non-Apple tooling
• You’re scripting around legacy or cross-platform build systems

Pair it with simctl for recording, but remember ios-sim is not a video generator.

When to use Xcode alone

Use Xcode’s stack when:

• You want first-party, deterministic simulator recordings
• You’re building a CI-friendly pipeline with XCUI tests
• You’re comfortable doing manual editing in a separate NLE

Xcode is the baseline for repeatability.

When to bring in Reely

Use Reely when:

• You ship new builds weekly (or daily) and can’t afford manual editing
• You want App Store previews, Product Hunt trailers, and Shorts from the same pipeline
• You’re already working with AI agents and want them to handle the reel

Reely is the app launch video generator for mobile developers:

• Agent writes the XCUI test
• CI runs the test and captures simulator video
• Reely turns that video + context into polished launch clips

If your question is “Which tool is best for repeatable simulator recordings in CI?” the answer is:

• Xcode for capture
• Reely to transform that capture into a story

FAQ: iOS simulator recording and App Store previews

Marked up for FAQ-style snippets and AI-powered search.

How to record iOS simulator via command line?

To record the iOS simulator via command line, use Apple’s simctl tool:

xcrun simctl io booted recordVideo --codec=h264 ./ScreenRecording.mp4

Steps:

1. Ensure Xcode and its command line tools are installed
2. Boot a simulator (via Xcode or xcrun simctl boot 'iPhone 15')
3. Run the recordVideo command
4. Reproduce your flow
5. Stop recording by pressing Ctrl+C

Apple documents this workflow in Capturing screenshots and videos from devices.

Can I automatically generate app demo reels from build artifacts?

Yes. You can:

1. Use XCUI tests to encode your demo flow
2. Run them via xcodebuild after a successful build
3. Wrap the test run with xcrun simctl io booted recordVideo
4. Store the output MP4 as a build artifact
5. Feed that artifact into tools like Reely to generate:
   • App Store previews
   • Product Hunt trailers
   • Shorts/Reels clips

This pattern turns your CI into an iOS app preview video generator from simulator recordings, with Reely handling the editorial work.

Which tool is best for repeatable simulator recordings in CI?

For repeatable simulator recordings in CI:

• Use Xcode’s stack (XCUI tests + xcodebuild + simctl):
  • Deterministic, first-party, supported by Apple
• Optionally use ios-sim to launch apps if your scripting requires it
• Avoid relying on manual tools like Kap for CI

If you also need polished launch videos, combine Xcode with Reely so your recordings automatically become launch-ready assets.

What are Apple’s current App Store preview video requirements?

According to Apple’s App Preview specifications (accessed 2026-08-10):

• Duration: 15–30 seconds
• Maximum count: up to 3 previews per language
• Codec: H.264 or ProRes 422 HQ
• Frame rate: up to 30 fps
• Max file size: 500 MB
• Resolutions: device-specific; for iPhone, accepted sizes include 886×1920 (portrait) and 1920×886 (landscape)

Always re-check Apple’s docs before submission, as these requirements can evolve.

How does Reely differ from generic AI video generators?

Reely is built specifically for app launch videos:

• Integrates with iOS Simulator and your coding agent
• Understands app flows, not just stock footage
• Includes kinetic typography, device choreography, and pacing tuned for product demos
• Works locally on macOS with no cloud upload of your builds

Generic AI video tools don’t speak Xcode, simulators, or XCUI tests. Reely does.

Wrap-up: from code to preview in minutes

If you’re a mobile developer who ships faster than you can market, the path forward is clear:

• Use Xcode and simctl for repeatable simulator recordings
• Use CI to run those flows after every successful build
• Use Reely to turn those recordings into App Store previews and launch reels in minutes

Your agent built the app. Now let it build the demo reel.