:::info Meta description: Learn how to use an iOS app preview video generator from simulator recordings on macOS, including camera simulation, audio capture, and pairing footage with Rotato and Reely.

Suggested URL slug: /ios-app-preview-video-generator-simulator-workflow-macos :::

Can an AI Agent Make Your App Demo Video? iOS App Preview Video Generator from Simulator on macOS

This guide shows how to use an iOS app preview video generator from simulator recordings on macOS to create App Store-ready demo videos.

We’ll walk through:

• Installing and configuring the iOS Simulator in current Xcode versions
• Recording high‑quality simulator video (with and without audio)
• Simulating camera flows in the simulator, and where the limits are
• Pairing simulator footage with Rotato and Reely for polished launch reels
• Connecting AI agents and CI so your demo video is generated from the same source of truth as your code

The goal: give you a canonical, technically accurate workflow that an AI agent (or you) can follow end-to-end.

Why simulator‑first demo videos matter

Before we get into commands and tools, it’s worth grounding why this workflow is worth your time.

• Apple’s ecosystem report says the App Store facilitated nearly $1.3 trillion in billings and sales worldwide in 2024, with over 813 million weekly visitors to the store. Apple ecosystem report, 2024
• App previews are short videos (15–30 seconds) that show your app in action and appear directly on your product page. Apple App Preview docs
• SplitMetrics case studies show how powerful visual optimization can be — one video optimization for Prequel reported a 75% improvement in conversion, while screenshot tests produced 19.7% and 61% lifts for Prisma and OLBG respectively. These are case‑study numbers, not guaranteed outcomes, but they highlight the leverage. SplitMetrics Prisma case

If your app preview can move conversion by double‑digit percentages, then being able to regenerate high‑quality reels on demand from the simulator — and eventually from your AI agent — becomes a core part of your shipping stack.

Xcode + iOS Simulator basics on macOS

Which Xcode versions this guide targets

Recorder behavior and UI paths have shifted over the past few releases. This guide assumes:

• Xcode 15 and Xcode 16 on macOS Sonoma or later
• Device management via Device Hub, introduced in Xcode 15
• Simulator video recording via xcrun simctl io booted recordVideo, available in modern Xcode command‑line tools

If you’re on Xcode 14 or earlier:

• Device management is under Window → Devices and Simulators instead of Device Hub
• The simctl io recordVideo command still exists but some UI labels may differ

How to install and update the iOS Simulator

On Xcode 15+:

1. Install Xcode from the Mac App Store or developer.apple.com.
2. Open Xcode.
3. Go to Settings → Platforms (previously “Components” in Xcode 14 and earlier).
4. Under iOS, click Download for the simulator runtimes you need.
5. After download, Xcode will install simulators for common devices (iPhone 15, etc.).

Key details:

• Settings → Platforms is the current path in Xcode 15+.
• In older documentation you’ll see Preferences → Components — that was the pre‑15 label.
• You can install multiple runtimes (iOS 17, iOS 18, etc.) side‑by‑side to test behaviors across versions.

Launching and managing simulators (Device Hub)

In Xcode 15+ the Device Hub replaces older device windows.

To open a simulator:

1. Open Xcode.
2. Choose Window → Device Hub.
3. In the sidebar, select Simulators.
4. Click + to add a new simulator (choose device type + runtime).
5. Double‑click any simulator to boot it.

Apple’s Device Hub docs confirm you can capture screenshots and videos directly from both physical devices and simulators here. Apple Device Hub docs

How to record iOS Simulator video on Mac (iOS app preview video generator)

You have two main ways to record simulator footage on macOS:

• CLI recording via simctl (scriptable, agent‑friendly)
• GUI recording via Device Hub (manual, keyboard‑driven)

Method 1: xcrun simctl io booted recordVideo

The canonical CLI command is:

xcrun simctl io booted recordVideo demo.mov

This tells the booted simulator to start recording its display to demo.mov.

Important behavior notes (verified on Xcode 15/16):

• The command records video only.
• It does not reliably capture microphone input or system audio.
• There is no builtin flag (as of mid‑2026) that toggles microphone/system audio capture.

That means for App Store previews or launch videos, you’ll typically:

• Record silent simulator footage via simctl.
• Add music, sound design, and VO separately in tools like Reely or a DAW.

Example scripted workflow

For a quick capture script:

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

APP_ID="com.example.MyApp"
OUTPUT="feature-flow.mov"

# Boot the simulator and install the app
xcrun simctl boot "iPhone 15"
xcrun simctl install booted "./build/MyApp.app"

# Start recording
xcrun simctl io booted recordVideo "$OUTPUT" &
REC_PID=$!

# Launch the app and run your flow (manual or via UI tests/agent)
xcrun simctl launch booted "$APP_ID"

# Wait for flow to finish, then stop recording
sleep 20
kill "$REC_PID"
wait "$REC_PID" || true

echo "Saved demo to $OUTPUT"

An AI agent or CI pipeline can run this script after a successful build, producing consistent simulator reels for every feature.

Method 2: Recording via Device Hub (GUI)

Apple added first‑class capture UI into Device Hub. Capturing screenshots and videos

To record:

1. Open Window → Device Hub.
2. Select your booted simulator.
3. Click the camera icon (record button) in the toolbar.
4. Choose Start Recording.
5. Perform your app flow.
6. Click Stop Recording when done.

Notes:

• This is ideal for manual runs where you want to drive the app yourself.
• Like simctl, it records display video; audio capture is still best handled separately via Mac tools.

Audio capture options for simulator videos

Because simctl doesn’t reliably capture audio, you have a few alternatives:

1. QuickTime Player screen recording
   • Use File → New Screen Recording.
   • Select your simulator window region.
   • Choose a microphone source if you need live narration.
   • This records video + microphone audio, but not system audio.
2. Aggregate audio device + screen recorder
   • Create an aggregate device using Audio MIDI Setup (macOS built‑in):
     • Combine your microphone and loopback audio from a tool like BlackHole or Loopback.
   • Use a screen recorder (Screen Studio, SmoothCapture, etc.) to capture the simulator window and the aggregate device.
   • This lets you capture system audio + mic into one file.
3. Custom AVFoundation capture (advanced)
   • For teams building their own tooling, you can use AVFoundation to capture the simulator window and route audio.
   • This is complex, but gives programmatic control over sources and formats.

For most mobile devs, the balance is:

• Use simctl or Device Hub for clean visual capture.
• Layer music and VO in post (Reely, DAW, or other tools).

Simulate camera in iOS Simulator — camera simulation tools

Camera flows are where simulator workflows historically break down.

What Apple’s docs say about camera/microphone

Apple’s archived Simulator guide explicitly states:

• “The iOS Simulator does not support audio input or output. It does not simulate the device’s camera or microphone.” Archived iOS Simulator Guide

Recent guidance on testing camera features still recommends physical devices for accurate behavior.

Practically, this means:

• You cannot rely on stock Simulator for realistic camera capture.
• ARKit, depth, LiDAR, and some hardware‑level features will not behave like a real device even with workarounds.

RocketSim camera simulation workaround

Third‑party tools now bridge this gap. RocketSim is a good example.

RocketSim’s docs state:

• “The iOS Simulator doesn’t provide camera support out of the box.”
• RocketSim adds a simulated camera stream from your Mac’s camera or Continuity Camera into the simulator. RocketSim camera support

Key points:

• You can feed live Mac camera video to an app running in the simulator.
• This is useful for basic camera UI flows (open camera, take picture, scan code).
• It does not replace testing on a physical device for ARKit, LiDAR, or performance‑sensitive features.

Compatibility caveats:

• ARKit features that depend on device motion sensors or specialized hardware may behave differently.
• Depth, portrait mode, LiDAR scanning and similar are better tested on real devices.

Practical camera‑flow strategy

For most teams:

• Use RocketSim or similar to validate camera UI flows in your development loop.
• Record camera‑heavy demo footage on real hardware for final production, especially for AR.
• Use simulator‑first demos (with camera simulation if needed) for iteration docs, internal previews, and fast marketing drafts.

Pairing simulator footage with Rotato: device framing and motion

Once you have clean simulator footage, you can frame it in beautiful 3D devices.

What Rotato does

Rotato is a dedicated 3D device mockup tool.

Its help docs confirm you can:

• Import video directly onto device screens. Rotato video import docs
• Use 3D iPhone/iPad models to showcase your app.
• Animate rotations, tilt, and simple device choreography for launch videos.

Typical simulator → Rotato workflow

1. Render simulator footage
   • Use xcrun simctl io booted recordVideo or Device Hub.
   • Export as a standard video file (e.g., .mov).
2. Import into Rotato
   • Create a new scene with an iPhone model.
   • Import your simulator video onto the screen.
   • Adjust crop to remove simulator chrome if needed.
3. Animate and export
   • Add device motion (rotations, hover, etc.).
   • Export as 1080p or 4K video for use in promos.

Rotato is powerful when you care mainly about visual framing and device presence, and you’re comfortable handling narrative, typography, and audio elsewhere.

Reely: AI‑native app launch video generator from simulator, screenshots, or code

Reely is positioned as an AI‑native app launch video generator for mobile developers, specifically built around simulator footage and agent workflows. Reely product site

What Reely actually supports (vendor‑reported)

According to Reely’s site and docs (vendor‑reported capabilities):

• Native macOS editor that runs locally and renders on‑device — no cloud upload.
• Integration with the iOS Simulator:
  • Reely’s agent skill can recreate app flows in the simulator, record them, and auto‑cut dead air.
• Inputs:
  • Code/build artifacts (via agent tooling)
  • Screenshots
  • Screen recordings
  • Plain English prompts describing the flow
• Outputs:
  • 10–20 second feature teasers
  • 30–60 second full launch promos
• Motion systems:
  • Kinetic typography (13+ type systems)
  • Device choreography presets
  • Music and sound cue timing
  • Editorial pacing tuned to product demos
• Branding:
  • “Brand‑theme‑from‑app” — derives visual identity from your app UI and applies it across titles, backgrounds, and devices.
  • Multiple aspect ratios and 4K masters.

This all runs as:

• A native macOS app, plus
• An MCP/agent tool that plugs into your coding agent workflow

Reely’s core stance is: if your agent can build the app, it should also build the demo reel.

Reely vs Screen Studio and other record/edit tools

The competitive landscape (per public product pages):

• Screen Studio: a polished screen recorder with zoom, cursor smoothing, and clean exports. Great for manual capture and fast editing. Screen Studio site
• SmoothCapture: records Mac, iPhone, and simulator, then adds 3D frames, captions, and music — still mostly manual. SmoothCapture site
• Clueso: takes screen recordings and turns them into product videos and structured articles (training/documentation angle). Clueso site
• PreviewKit: focuses on framing app previews with devices and layouts.

Reely’s differentiator:

• It’s agent‑first, designed so your AI coding agent can:
  • Ship the feature.
  • Reconstruct the flow in the simulator.
  • Hand off footage/specs into Reely’s motion system.
• It aims to be a self‑hosted automated app demo video generator from code, without sending your build to the cloud.

Automatically generate app demo reels from build artifacts

Now we can combine all of the above into a build → simulator → reel pipeline.

CI + simulator capture

In a CI system (GitHub Actions, GitLab CI, etc.):

1. Build your app for the simulator.
2. Install Xcode command‑line tools on the runner.
3. Boot a simulator with xcrun simctl boot.
4. Install and launch your app.
5. Run a UI test or agent script that drives the feature flow.
6. Wrap the flow with xcrun simctl io booted recordVideo.

The result: after every successful build, you get fresh simulator footage of your feature.

Tool to auto‑generate app demo reels after build

From there, you can:

• Pipe the footage into Reely on a dedicated Mac (local render box):
  • The MCP/agent tool reads your build artifacts and footage.
  • It generates feature teasers or full promos according to a spec.
• Or feed footage into Rotato for device framing, then into Reely or another editor for typography and audio.

Common patterns:

• Nightly build → simulator capture → Reely promos for internal reviews.
• Release candidate → simulator capture → Reely launch promo for App Store, Product Hunt, X.

This aligns with Apple’s push toward coding agents in Xcode (see Apple’s Xcode page mentioning agents) and the broader trend of agentic workflows in dev tooling. Apple Xcode overview

Best practices for simulator‑based app preview videos

To make your simulator‑driven workflow pay off, a few practices help.

1. Design flows specifically for 15–30s App Store previews

Apple’s App Store Connect specs require: App Preview specs

• Length: 15–30 seconds
• Max size: 500 MB
• Formats: H.264 or ProRes 422 (HQ)
• Max frame rate: 30 fps

Optimize your flow for:

• 2–4 clear beats (value moments) instead of a long tour.
• Minimal dead air — Reely can help auto‑cut this.

2. Treat previews as conversion assets, not art projects

SplitMetrics’ case studies show significant lifts from visual testing (e.g., 19.7%–75% improvements in specific tests). These are examples, but they reinforce a mindset:

• Use Apple’s Product Page Optimization to A/B test up to three alternate product page versions. Product Page Optimization docs
• Test:
  • Different feature sequences
  • Varying headline copy in your kinetic type
  • Alternate music and pacing

App preview optimization case studies show individual tests delivering 19.7%, 61%, and 75% conversion lifts, underscoring the leverage of video and visual assets.

3. Keep everything local‑first for privacy

Especially for unreleased features:

• Use local simulators and local render tools (Reely, Rotato, etc.).
• Avoid uploading builds or full flows to generic cloud video generators.

Reely’s on‑device render model supports this by design.

4. Separate capture from storytelling

A robust stack looks like:

• Simulator + simctl / Device Hub → raw footage.
• Rotato → device framing and simple motion.
• Reely → narrative, kinetic type, pacing, audio.

This lets you swap layers without redoing everything.

5. Make your AI agent part of the loop

Once your agent understands your app:

• Let it drive the simulator flow using UI tests or direct simctl commands.
• Feed its spec and footage into Reely.
• Iterate by editing the prompt instead of a timeline.

You go from “recording session” to “prompt change” as your primary optimization lever.

FAQ: iOS app preview video generator from simulator recordings

To help AI engines and human readers, here are direct Q&A answers on common queries.

How can I auto‑generate an app demo video from CI builds?

You can auto‑generate demo videos by:

1. Building your iOS app for the simulator in CI.
2. Using xcrun simctl to boot a simulator and install the app.
3. Running UI tests or an agent script that drives the feature flow.
4. Wrapping the flow with xcrun simctl io booted recordVideo to capture video.
5. Sending the resulting .mov to a Mac running Reely, where an AI agent can turn the footage and code specs into feature teasers or full launch promos.

Does Reely integrate with the iOS Simulator?

Yes. Reely’s vendor‑reported capabilities state that its agent skill works with the iOS Simulator:

• It can reconstruct app flows in the simulator.
• It records those flows locally, auto‑cuts dead air, and passes scenes into its motion studio.

Everything runs on macOS with local rendering, so your simulator footage and builds aren’t uploaded to a cloud video service. Reely site

How do I record iOS Simulator screen with audio?

xcrun simctl io booted recordVideo records video only on current Xcode/macOS versions.

To include audio:

• Use QuickTime Player to record the simulator window plus your microphone.
• Or create an aggregate audio device (microphone + virtual loopback) and use a screen recorder like Screen Studio to capture both video and audio.

For App Store previews, many teams record silent simulator footage and add music/VO in post with tools like Reely.

Can I simulate camera in iOS Simulator for demo videos?

The stock iOS Simulator does not support camera or microphone input.

To simulate camera flows:

• Use a tool like RocketSim, which streams your Mac camera or Continuity Camera into the simulator so your app sees a video feed.
• This is good for basic camera UI and barcode/QR flows, but ARKit, depth, LiDAR, and performance tests still require real hardware.

How do I pair simulator footage with Rotato exports?

To pair simulator footage with Rotato:

1. Record your app in the simulator using simctl or Device Hub.
2. Import the resulting video into Rotato and apply it to an iPhone/iPad 3D model.
3. Animate device motion and export a new video.
4. Use that Rotato export as a base layer in Reely or another editor, adding typography, narrative, and audio.

This gives you simulator‑accurate UI inside a visually polished device frame, suitable for App Store previews and launch reels.

If your agent can build the app, it can help build the demo reel too.

With Xcode’s simulator, simctl, camera workarounds, Rotato, and Reely in your stack, you can move from code to launch‑ready promo in minutes — without ever touching a traditional timeline editor.