iOS App Preview Video Generator: Simulator Recordings, App Store Preview Automation & Agent-Driven Tools (Xcode → Reely)

Launch videos are no longer just “hit record on your phone.”

Accordion-fold booklet of device outlines symbolizing simulator-driven iOS app preview video generation.

iOS app preview video generator from simulator recordings

Launch videos are no longer just “hit record on your phone.”

If you’re shipping iOS features fast, you need an iOS app preview video generator that can work directly from simulator recordings, build artifacts, and your existing AI agent workflow.

This guide maps the ecosystem of mobile app simulators for launch videos — from Xcode Simulator and scriptable simctl capture to camera-sim tools and agent-first environments like Reely — and shows how to turn them into a reliable source of truth for App Store preview automation.

We’ll cover:

  • How modern simulators impact demo video quality and speed
  • The core tools: Xcode Simulator, camera sim, “just-sim” utilities, and code/agent sims
  • How to auto-generate app demo reels from build artifacts (CI/CD → simulator recordings)
  • How Reely uses simulator flows to build polished launch reels without timelines
  • Practical CI/CD snippets you can copy-paste today

Why simulators matter for launch videos

For iOS developers, simulators are the closest thing to a programmable camera.

Instead of:

  • Booking devices and manual recording sessions
  • Re-running the same flow for every feature or bug fix

You can:

  • Drive flows in the Xcode Simulator
  • Record deterministic video with xcrun simctl io booted recordVideo
  • Feed those clips into an iOS app preview video generator (like Reely) to create launch-ready reels.

Apple’s own docs confirm this shift:

  • Device Hub in Xcode captures full-resolution screenshots and simulator video directly from the canvas, not from your Mac display resolution. Apple Developer
  • Command-line capture is supported via xcrun simctl io booted recordVideo <filename>.<extension>. Apple Developer

That means simulator footage can be scripted, versioned, and folded into CI/CD — the same way you already handle tests and build artifacts.

App Store preview constraints: what your video generator must respect

Before you automate anything, it’s worth grounding in Apple’s current constraints for App Store previews.

Per Apple’s App Store Connect documentation: App Store Connect Help – App Preview Specifications

  • Length: app previews must be 15–30 seconds
  • File size: up to 500 MB per preview
  • Frame rate: up to 30 fps
  • Formats & codecs:
    • H.264 in .mov, .m4v, or .mp4
    • ProRes 422 (HQ) in .mov
  • Previews per device size & language: up to 3 previews per supported size/language
  • Screenshots: 1–10 screenshots per device size/language App Store Connect Help – Upload App Previews and Screenshots

These values are subject to change, so always verify against the latest Apple docs when you ship.

For a simulator-driven pipeline, this implies:

  • Your recordVideo step should be designed around 15–30s segments
  • Your export settings must target ≤30 fps and supported containers/codecs
  • Your video generator (Reely, or custom scripts) should produce previews that map cleanly to Apple’s requirements.

The simulator ecosystem for launch videos

When people say “simulator” or “sim,” they’re often talking about different layers:

  • Xcode iOS Simulator – the official Apple simulator
  • Capture-aware tools – RocketSim, SimCam, Device Hub extensions
  • Camera sim tools – streaming your Mac camera or injected images into the simulator
  • Code sim / coding sim / agent-first tools – AI agents that drive simulators and pipe footage to video generators
  • Generic ‘x-sim’ projects – motion/robotics simulators that aren’t relevant for iOS app demos

Below, we’ll focus on what actually matters for iOS app preview video generator simulator recordings.

Xcode iOS Simulator: your primary source of truth

Apple’s iOS Simulator is the foundation of most modern app demo pipelines.

What Xcode Simulator offers for video capture

From Apple’s documentation:

  • Device Hub lets you:
  • Command-line recording via simctl:
    • xcrun simctl io booted recordVideo filename.mov
    • You can specify output filename and extension; Apple documents .mov with H.264/ProRes as supported for App Store previews.

This combination means:

  • You can capture repeatable flows without touching a physical device
  • You can embed capture commands in scripts, Fastlane, or CI/CD

Configuring the simulator for realistic demos

Apple also documents how to adjust simulator environment: Configuring the Environment of a Simulated Device

You can script or manually set:

  • Appearance: light/dark mode
  • Text size: Dynamic Type settings
  • Liquid Glass effects
  • Location: simulated GPS values
  • Orientation: portrait/landscape
  • Audio & mute behavior
  • Screen size & device presets

For launch videos, best practice is:

  • Match the device class you expect users to see in the App Store (e.g., iPhone 15 Pro)
  • Configure locale and language to match the preview’s metadata
  • Ensure text size and layout look clean at the chosen resolution

Simulator fidelity vs real devices

Apple explicitly warns that the Simulator:

  • Runs on the Mac’s CPU, memory, and network
  • Can appear faster and smoother than a real device
  • Is not an accurate test of performance, memory usage, or networking speed

Apple Developer – iOS Simulator Guide

For launch videos, this means:

  • Simulator captures are excellent for repeatability and scripted flows
  • For performance-sensitive UIs, you may want a device validation pass or occasional on-device recordings, especially if your app feels different on hardware.

Camera sim and capture-aware tools (RocketSim, SimCam)

The stock Xcode Simulator has a clear gap: no built-in camera support.

RocketSim’s documentation highlights that:

  • Xcode’s Simulator does not expose a camera by default
  • RocketSim adds simulator camera features:
    • Streams your Mac camera into the simulator
    • Injects images, video, or QR codes into simulator camera flows
    • Enables faster camera-based testing and capture without a physical device
    • RocketSim – Simulator Camera Support

Tradeoffs RocketSim notes:

  • Camera captures use the Mac camera’s resolution, not the original device camera resolution
  • Simulator-camera videos do not contain audio

SimCam and similar tools follow a similar pattern: local-only camera streams into the simulator.

For demo video pipelines, camera-sim tools help when:

  • Your app uses QR scanning or AR-style camera interactions
  • You want repeatable camera flows without pointing a phone at test cards

They work best as adjacent tools:

  • Drive camera flows with RocketSim/SimCam
  • Capture the resulting simulator footage with Device Hub or simctl
  • Feed that footage into your AI video creator with offline local processing.

Agent-first and code sim environments (Reely, coding agents)

Beyond the simulator itself, the big shift is agent-first video generation tools.

Reely positions itself as:

  • An AI-native app launch video generator built for mobile developers
  • A native macOS app that drives local Xcode and iOS Simulators
  • A tool that connects to your AI coding agent via an MCP/agent integration
  • A system where the app flow is the shot list / source of truth for the reel

These are vendor claims based on Reely’s documentation: Reely – Install and Reely – Directing Flows.

How Reely uses simulators for video generation

According to Reely’s docs, Reely:

  • Requires a Mac with Xcode 26 and iOS Simulators installed
  • Can recreate app flows in the iOS Simulator, record them, and auto-cut dead air
  • Turns code, screenshots, or English prompts into:
    • 10–20s feature teasers
    • 30–60s full launch promos
  • Runs locally, with on-device rendering, so builds aren’t uploaded to cloud services (vendor claim: Reely)

It layers a studio-level motion system on top:

  • Thirteen typography systems
  • Device choreography presets
  • Music and sound cue timing
  • Editorial pacing tuned for product demos

Crucially, Reely treats flow definition as the source of truth:

  • Which screens the video walks through
  • In what order
  • How long it rests on each one

Reely – Directing Flow

This aligns directly with the simulator-driven pipeline:

  • Your agent builds the feature
  • The same agent or MCP tool drives the simulator flow
  • Reely consumes the flow + capture and generates a finished reel

Auto-generate app demo reels from build artifacts (CI/CD → simulator recordings)

To make simulators a reliable source of truth for video generation, you want them in your CI/CD pipeline.

Example: GitHub Actions + xcrun simctl

This example shows how to:

  1. Build your iOS app
  2. Boot an iOS Simulator
  3. Install and run your app through a simple UI test
  4. Record video with simctl
  5. Upload the resulting app demo reel as a build artifact

# .github/workflows/simulator-demo.yml
name: Simulator Demo Video

on:
workflow_dispatch:
push:
branches: [ main ]

jobs:
demo-video:
runs-on: macos-14

steps:
- name: Checkout
uses: actions/checkout@v4

- name: Set up Xcode
run: sudo xcode-select -switch /Applications/Xcode.app/Contents/Developer

- name: Build app
run: |
xcodebuild \
-workspace MyApp.xcworkspace \
-scheme MyApp \
-destination 'platform=iOS Simulator,name=iPhone 15 Pro,OS=latest' \
build

- name: Boot simulator
run: |
SIM_ID=$(xcrun simctl list devices | grep 'iPhone 15 Pro' | grep -v unavailable | head -n1 | awk -F '[()]' '{print $2}')
echo "SIM_ID=$SIM_ID" >> $GITHUB_ENV
xcrun simctl boot "$SIM_ID"

- name: Install app
run: |
xcrun simctl install "$SIM_ID" build/Debug-iphonesimulator/MyApp.app

- name: Start recording
run: |
mkdir -p demo
xcrun simctl io "$SIM_ID" recordVideo demo/app-preview.mov &

- name: Run UI test flow
run: |
xcodebuild \
-workspace MyApp.xcworkspace \
-scheme MyAppUITests \
-destination "platform=iOS Simulator,id=$SIM_ID" \
test

- name: Stop simulator
run: |
xcrun simctl shutdown "$SIM_ID" || true

- name: Upload demo artifact
uses: actions/upload-artifact@v4
with:
name: app-preview-simulator
path: demo/app-preview.mov

You can then:

  • Feed demo/app-preview.mov into Reely or another AI video generator that runs locally on computer
  • Keep previews in sync with every main-branch merge or tagged release

Example: Fastlane + shell script

For local automation or CI systems like Bitrise/CircleCI, you can use Fastlane:

# Fastfile
lane :record_simulator_preview do
device = "iPhone 15 Pro"

sh <<-EOS
set -e
SIM_ID=$(xcrun simctl list devices | grep '#{device}' | grep -v unavailable | head -n1 | awk -F '[()]' '{print $2}')
mkdir -p fastlane/previews
xcrun simctl boot "$SIM_ID"
xcrun simctl install "$SIM_ID" build/Debug-iphonesimulator/MyApp.app
xcrun simctl io "$SIM_ID" recordVideo fastlane/previews/app-preview.mov &
EOS

run_tests(
scheme: "MyAppUITests",
devices: ["iPhone 15 Pro"],
)

sh "xcrun simctl shutdown `xcrun simctl list devices | grep '#{device}' | grep -v unavailable | head -n1 | awk -F '[()]' '{print $2}'` || true"
end

This gives you a repeatable “app demo reel auto-generate after build” step that any tooling (including Reely) can consume.

Reely vs Screen Studio iOS app demos

Developers often ask how Reely vs Screen Studio compares for iOS app demos.

Here’s a concise, fact-based comparison, using vendor docs and typical usage patterns.

Local vs cloud processing

  • Reely: Vendor claims a native macOS app with local rendering and local simulator driving; no cloud uploads required for your builds. Reely
  • Screen Studio: Also a macOS app; records locally from your screen and exports locally. No mandatory cloud pipeline. Screen Studio

Simulator-driving capability

  • Reely: Documentation describes driving Xcode and iOS Simulators via an MCP/agent tool and using flows as the shot list. Reely Docs
  • Screen Studio: Focused on general screen recording, not simulator orchestration; you manually run the app and Screen Studio records whatever is on screen.

Automation & agent integration

  • Reely:
    • Agent-first: integrates with AI coding agents via MCP
    • Designed for “build feature → build demo reel” in the same workflow
  • Screen Studio:
    • No native agent integration; you automate via generic scripting (e.g., start recorder, run app), but editing is manual.

Camera-sim support

  • Reely: Works with whatever the simulator produces; camera-sim support is indirect (via RocketSim/SimCam) rather than core to the product.
  • Screen Studio: Records any on-screen content (including simulators), but does not provide simulator camera injection itself.

Pricing & licensing model

  • Reely: Simple subscription (vendor-quoted examples include $19/month or $123/year) plus an honor-based offer aimed at indie devs. Reely
  • Screen Studio: Licenses and pricing documented on their site; commonly a one-time or subscription license for the recorder. Screen Studio Pricing

Typical output formats

  • Reely: Focused on 10–20s feature teasers and 30–60s launch promos, with aspect ratios tuned for App Store, Product Hunt, X, Shorts, etc. Vendor claims include 4K masters and multiple aspect ratios. Reely
  • Screen Studio: Exports general-purpose demo videos in common formats (e.g., .mp4) with auto zooms and cursor smoothing; you configure duration and format manually.

In short:

  • Pick Screen Studio when you want manual craft in a traditional recorder.
  • Pick Reely when you want agent-first automation — your app’s flow as structured input, and “promo from code in minutes.”

Best screen recording tools for app demos (for developers)

If you’re building a simulator-centric pipeline, these tools are worth stacking:

  • Xcode Device Hub
    • Pros: Official Apple tooling; full-resolution captures; integrates directly with Xcode
    • Cons: More interactive than scriptable; not a creative editor
  • xcrun simctl io recordVideo (CLI)
    • Pros: Scriptable; perfect for CI/CD and automated flows
    • Cons: Produces raw video only; you still need an editor or generator
  • Screen Studio
    • Pros: Beautiful default motion (zoom, cursor smoothing); great for polished manual demos
    • Cons: No simulator-driving or agent integration; timeline editing still takes time
  • RocketSim / SimCam (camera sim & capture-aware tools)
    • Pros: Camera streams, QR injection, quick capture for camera-heavy features
    • Cons: Not primary video editors; resolution/audio limitations; iOS-only
  • Reely (app launch video generator for mobile developers)
    • Pros (vendor claims): agent-first, simulator-aware, local rendering, kinetic typography, device choreography, App Store- and launch-ready outputs
    • Cons: Focused on app demos; not a general-purpose live-action video editor

Most high-velocity teams use a stack:

  • Simulator + simctl for capture
  • RocketSim/SimCam when camera flows matter
  • Reely for automated demo reels
  • Screen Studio for one-off, highly crafted walkthroughs.

Making simulators a reliable source of truth for video generators

To turn simulators into a dependable pipeline for tools like Reely, focus on three layers:

1. Consistent device & environment

  • Lock in device models (e.g., iPhone 15 Pro, iPad Pro 13″) for each target preview size
  • Standardize:
    • Light/dark mode per reel
    • Locale and language
    • Dynamic Type settings
    • Orientation

Treat this as config-as-code so your previews don’t drift between builds.

2. Scripted flows instead of manual gestures

  • Use UI tests or agent-driven scripts to:
    • Navigate through your key feature beats
    • Trigger meaningful states (empty vs populated, error vs success)
  • Map those flows directly to your shot list in Reely or other tools.

This ensures:

  • Every run creates the same visual narrative
  • The video generator can assume a stable sequence of screens.

3. Clean capture and export settings

  • Always record at a device resolution that maps cleanly to App Store requirements
  • Keep frame rate ≤ 30 fps for previews
  • Use H.264 or ProRes 422 (HQ) in supported containers for final export

If you’re feeding raw .mov into Reely, it can handle motion, typography, and music while respecting these constraints (per vendor claims).

FAQ: mobile app simulators for launch videos

What bitrate and export settings should I use for App Store previews?

Apple doesn’t prescribe a specific bitrate, but does enforce:

  • 15–30s duration
  • ≤500 MB file size
  • ≤30 fps
  • H.264 (.mov/.m4v/.mp4) or ProRes 422 (HQ, .mov)

App Preview Specifications

In practice:

  • Use H.264, 10–20 Mbps for 1080p, and verify file size stays under 500 MB for your duration.

Should I crop or scale simulator footage before generating previews?

Strategies:

  • Prefer device-native resolution from Device Hub or simctl to avoid scaling artifacts
  • If you must crop/scale, do it in a way that preserves the aspect ratio Apple expects for each device class.

Tools like Reely can wrap simulator footage in device frames and kinetic compositions without you manually cropping timelines.

Do I need separate previews for each locale and device size?

Apple allows:

  • Up to 3 previews per supported device size and language
  • 1–10 screenshots per size/language

Upload App Previews and Screenshots

Best practice:

  • Create at least one preview per major locale and primary device size (phone vs tablet)
  • Use simulator configs to switch language and region per run.

How do agent-first tools like Reely integrate with my coding workflow?

Per Reely’s documentation:

  • Reely exposes an MCP/agent tool so your AI coding agent can:
    • Build the feature
    • Drive simulator flows
    • Hand spec + capture to Reely’s motion studio

This makes “generate demo video from code” a natural extension of your build/test pipeline.

Can I run an AI video creator offline with local processing only?

Yes, if you choose tools that are local-first.

Vendor claims from Reely and RocketSim emphasize:

  • macOS-native apps
  • Local rendering and simulator driving
  • No mandatory cloud upload of your builds

Always confirm current behavior in product docs, but the trend is clear: local-first, privacy-respecting demo pipelines are becoming standard.

If your agent can build the app, it should be able to build the demo reel too.

By treating Xcode Simulator and capture-aware tools as a programmable camera — and pairing them with an AI-native app launch video generator like Reely — you can go from “feature merged” to “launch-ready promo” in minutes, without touching a traditional timeline editor.

← All posts