Georgii EmelianovGuides

How to Generate an iOS App Preview Video from the Simulator: Make a Product Hunt Launch Video from a SwiftUI Feature

If you’re shipping a SwiftUI feature that uses the camera (AR, QR/barcode scanning, photo picker) and you want a Product Hunt launch video or App Store…

Macro close-up of engraved metal surface suggesting digital video pipelines for iOS app preview creation

If you’re shipping a SwiftUI feature that uses the camera (AR, QR/barcode scanning, photo picker) and you want a Product Hunt launch video or App Store preview, the iOS Simulator is both your best friend and your biggest blocker.

Apple’s Simulator doesn’t expose your Mac’s camera to iOS by default, so camera-dependent flows appear as a dead black view instead of a real-world scene.

This guide shows you, step by step, how to wire your Mac’s camera into the Simulator feed, capture believable footage, and then turn that into a polished launch reel using an iOS app preview video generator from simulator recordings like Reely.

We’ll cover:

  • System requirements (macOS, Xcode, iOS simulator runtimes)
  • How to stream a Mac or Continuity Camera feed into the Simulator
  • How to record clean simulator footage for App Store previews & Product Hunt
  • How to generate a demo reel using Reely
  • How to automatically generate app demo reels from build artifacts in CI with agents
Note: Some details below reference third-party vendor claims and docs. Always confirm the latest behavior in their official documentation.

Why camera-accurate simulator recordings matter for your launch

If you’re building AR, QR, document scan, or camera-first flows, fake or blank camera views make your launch video feel untrustworthy.

Apple’s App Store reaches more than 813 million weekly visitors across 175 regions and supports 50 languages and over 2 billion devices worldwide, according to Apple’s 2024–2025 ecosystem report and App Store documentation.[^apple-ecosystem] With that reach, your preview video is often the first touch.

Apple also sets strict rules for App Store previews:

  • Up to 3 previews per language, each up to 30 seconds
  • Device-specific; must primarily show in-app content
  • Avoid filming people using the device; focus on the app itself
  • Use simple transitions and captions for context

(Source: Apple App Store preview guidelines.[^apple-previews])

On Product Hunt, makers consistently report that the demo video can matter more than static images for launch performance.[^ph-video] A clean, believable camera flow can be the difference between “cool idea” and “this looks real and shippable.”

Prerequisites & system requirements

Before you turn your SwiftUI feature into a launch video, make sure your setup supports simulator camera routing and local rendering.

macOS, Xcode, and iOS versions

At minimum, you’ll want:

  • macOS: Ventura (13) or later strongly recommended
    • For Continuity Camera, Apple officially supports macOS Ventura or later with iOS 16 or later on the iPhone.[^continuity]
  • Xcode: Xcode 15 or later recommended for modern SwiftUI and iOS 17+ simulators
  • iOS simulator runtimes: iOS 16+ simulators generally work best with third‑party simulator camera tools

Tools for simulator camera routing

Apple’s docs explicitly say that the Simulator does not provide access to the Mac’s camera.[^apple-sim] To simulate a camera feed, you’ll use a dedicated tool.

Common options (vendor claims, check docs for specifics):

  • RocketSim
    • macOS app that integrates with Xcode’s Simulator
    • Offers Simulator Camera support for routing a Mac camera or Continuity Camera into the simulator as a virtual feed (per RocketSim’s docs).[^rocketsim-camera]
  • SimCam / SimulatorCamera
    • Tools focused on feeding virtual camera, video, and QR sources into the Simulator for testing.[^simcam]

In the walkthrough below we’ll use RocketSim because its docs explicitly describe Simulator Camera support for QR, barcode, and photo flows.[^rocketsim-camera]

Reely requirements

To go from simulator recordings to a finished launch reel locally, you can use Reely, an AI‑native app launch video generator for mobile developers.

Reely runs as:

  • A native macOS app (no cloud upload; renders locally)[^reely]
  • An MCP/agent tool so your coding agent can move from “build feature” → “build demo reel” in a single workflow (vendor positioning; see Reely’s site for details).[^reely]

Step 1: Build a camera-friendly SwiftUI demo flow

First, create a deterministic, camera-dependent flow that showcases the value of your feature. Think in terms of beats, not just screens.

Design a simple 20–30 second story

Aim for a short, instructional, authentic demo. HubSpot’s 2024 report says short‑form (21–60 seconds) delivers the highest ROI in video marketing.[^hubspot] Wistia finds instructional videos significantly outperform generic ones, with 74% engagement for 3–5 minute instructional videos vs 43% for other 3–5 minute videos.[^wistia]

For a Product Hunt launch video, you might structure:

  1. Hook (3–5s): “Scan any QR to track your tasks instantly.”
  2. Core action (10–15s): Show the SwiftUI view scanning a QR code and updating state.
  3. Result (5–10s): Show the updated list or AR overlay, plus one more micro interaction.

Build a deterministic SwiftUI scene

Your demo should be:

  • Predictable – same behavior every time
  • Fast – no long loading indicators
  • Camera-forward – the camera view is central in the frame

For example, a simplified QR scanner view:

struct QRScannerDemoView: View {
@State private var scannedCode: String? = nil

var body: some View {
VStack(spacing: 24) {
Text("Scan a QR to add a task")
.font(.title2.bold())
.multilineTextAlignment(.center)

CameraScannerView(onCodeScanned: { code in
withAnimation {
scannedCode = code
}
})
.frame(height: 320)
.clipShape(RoundedRectangle(cornerRadius: 16, style: .continuous))

if let code = scannedCode {
Text("Added: \(code)")
.font(.headline)
} else {
Text("Point your camera at a QR code")
.foregroundStyle(.secondary)
}
}
.padding()
}
}

Use your real production view if possible, but consider a demo mode flag (e.g., DemoMode.enabled) to control content and timing.

Step 2: Install and configure RocketSim’s Simulator Camera

Next, you’ll connect your Mac or Continuity Camera to the Simulator using RocketSim’s Simulator Camera feature.

The following steps are based on RocketSim’s public documentation and may change. Always confirm the latest install flow on their site.[^rocketsim-camera]

2.1 Download and install RocketSim

  1. Go to the RocketSim site or Mac App Store (as linked from their docs).
    Docs: https://www.rocketsim.app/docs/features/capturing/simulator-camera-support/
  2. Download and open the .dmg (if using the direct download).
  3. Drag the RocketSim app into Applications.
  4. Launch RocketSim from Applications or Spotlight.

On first launch, macOS may request:

  • Screen recording permission (System Settings → Privacy & Security → Screen Recording → enable RocketSim)
  • Camera permission if RocketSim needs to access your camera source directly

Grant these; without them RocketSim can’t route video into the iOS Simulator.

2.2 Connect RocketSim to a specific Simulator

  1. Open Xcode.
  2. Run your iOS app on a simulator (e.g., iPhone 15 Pro – iOS 17.5).
  3. Ensure the Simulator window is visible.
  4. Open RocketSim.

RocketSim typically detects available simulator instances automatically. In the RocketSim menu:

  1. Select your active Simulator device if prompted (e.g., iPhone 15 Pro).
  2. Look for a Simulator Camera or Camera submenu as described in the docs.
  3. Choose your camera source:
    • Built-in Mac camera
    • Continuity Camera (your iPhone)
    • Or a virtual camera if you’re using one

2.3 Verify the virtual camera attachment

To confirm the simulator is receiving the feed:

  1. In your running app, navigate to the SwiftUI camera view (e.g., CameraScannerView).
  2. If you’re using AVCaptureDevice or VNDocumentCameraViewController under the hood, check if preview shows a live feed rather than a blank screen.
  3. Move your hand in front of the Mac or iPhone camera; you should see motion in the simulator.

If you see a black or static frame, jump ahead to the troubleshooting section.

Step 3: Prepare realistic AR, barcode, and photo flows

With the camera feed wired into the simulator, script a believable real-world scenario.

3.1 For QR/barcode scanning

  • Print or display a high-contrast QR code on another device or paper
  • Place it ~10–20 cm from the Mac/iPhone camera
  • Ensure plenty of light and avoid reflections

Set up a simple script:

  1. Start at the SwiftUI feature entry point.
  2. Tap into the scanner view.
  3. Hover the QR code into the camera frame until the app recognizes it.
  4. Show the resulting list or action.

3.2 For AR overlays

If you’re demonstrating ARKit content:

  • Place a few physical anchors (e.g., a flat desk, cube, or box) in view of the camera
  • Gently move the MacBook lid or iPhone so the Simulator sees parallax

Plan:

  1. Open the AR view.
  2. Slowly move to let the AR session detect a plane.
  3. Tap once to place the AR content.
  4. Slightly orbit to show stability.

3.3 For document/photo capture flows

For VNDocumentCameraViewController or photo-picker flows:

  • Prepare a document, receipt, or photo in front of the camera
  • Ensure it fits fully in frame

Sequence:

  1. Tap from your SwiftUI list into the capture view.
  2. Align the document; let auto-capture trigger or tap the shutter.
  3. Show the processed result view.

Keep each flow under 30 seconds if you want to reuse it as an App Store preview.[^apple-previews]

Step 4: Record simulator footage for App Store preview videos

Now you’ll record clean, App Store–ready simulator footage.

4.1 Recording options

You have several ways to capture simulator recordings:

  • RocketSim’s built-in recorder (if available per their docs)
  • QuickTime Player → File → New Screen Recording → select the Simulator window
  • Xcode’s built-in recording (limited) via the Device and Simulators window
  • Third‑party tools like Screen Studio for polished, click-aware recording (not camera routing focused)[^screen-studio]

For App Store previews, Apple’s guidelines emphasize:

  • Showing only in-app content
  • Avoiding hands-on-device shots
  • Clear captions for context

(Source: Apple App Store preview docs.[^apple-previews])

4.2 Capture a tight, no-dead-air run

When recording:

  1. Close all extra windows and notifications.
  2. Set the Simulator to the exact device you’re targeting for your App Store preview.
  3. Start recording before launching your app to capture the full journey.
  4. Perform the scripted flow smoothly:
    • One or two taps to reach the camera view
    • A single, decisive scan/capture
    • A quick reveal of the result
  5. Stop recording as soon as the “aha” moment is done.

Aim for 10–20 seconds for feature teasers and 30–60 seconds for full launch promos. Short-form content drives better ROI for most marketing use cases, according to HubSpot’s 2024 report.[^hubspot]

Export or save your recording as a high-quality .mov or .mp4 file.

Step 5: Turn simulator recordings into a Product Hunt launch video with Reely

Raw screen capture is only the first half. To stand out on Product Hunt, X, and LinkedIn, you want motion design, kinetic typography, and pacing that feels like a studio cut — without spending hours in a timeline.

That’s where Reely, an AI-native mobile app preview video generator from simulator recordings, comes in.

The specifics below are based on Reely’s current product positioning and docs at getreely.co. Features and flows may evolve.[^reely]

5.1 Import simulator footage into Reely’s macOS app

  1. Install and open Reely on your Mac.
  2. Create a new project and choose the output type:
    • Feature teaser (10–20s)
    • Launch promo (30–60s)
  3. Drag your .mov / .mp4 simulator recording into Reely.

Reely is designed to:

  • Run locally on macOS
  • Work with the iOS Simulator as a source
  • Render on-device (no cloud upload for your build footage)[^reely]

5.2 Generate motion design and pacing from your app

Reely can:

  • Extract your brand’s visual theme from the app UI (“brand-theme-from-app”)[^reely]
  • Auto-time kinetic typography, device motion, and music cues
  • Automatically cut dead air and tighten pacing around key interactions (vendor claims)[^reely]

You can describe the flow in plain language, such as:

“Show scanning a QR code to instantly add a task. Emphasize how fast it is and end on the updated list.”

Reely’s AI will then:

  • Trim your simulator footage to focus on those beats
  • Add titles like “Scan any QR” → “Instantly tracked”
  • Apply device choreography and background motion

All layers remain editable if you want to tweak scenes manually.

5.3 Export multi-channel versions

Product Hunt, App Store, and social platforms all prefer slightly different formats.

Reely lets you export:

  • Multiple aspect ratios (16:9, 9:16, 1:1, etc.)
  • 4K masters for YouTube and high-resolution embeds
  • Short social loops for X, LinkedIn, and Shorts

Wistia’s 2026 State of Video report notes that LinkedIn has become the top B2B video-sharing channel for many teams.[^wistia-2026] Repurpose your Product Hunt launch video there to maximize discovery.

For a deeper strategy on using agents to build these reels, see our related guide: Can an AI Agent Make Your App Demo Video? (pillar article).

Step 6: Automate app demo reel generation after build (CI & agents)

Once you have a repeatable way to record simulator camera flows, you can go further: use a CI tool to create an app demo video after each successful build and let an AI agent orchestrate the process.

This section outlines a concrete pattern teams use to automatically generate app demo reels from build artifacts.

6.1 High-level automation flow

A typical pipeline looks like this:

  1. CI build completes successfully (e.g., Xcode Cloud, GitHub Actions, Bitrise).
  2. CI exports an .app or .ipa build artifact.
  3. A headless simulator runner launches the app on the iOS Simulator.
  4. An MCP/agent tool (e.g., Reely’s agent, vendor claim) drives the app through a scripted demo flow.
  5. The agent records the simulator session to a video file.
  6. The recording is passed into Reely’s motion system to generate:
    • A feature teaser
    • A full launch promo
  7. Outputs are stored as CI artifacts or pushed to a media bucket for review.

6.2 Example: GitHub Actions + simulator + Reely agent (conceptual)

This example uses GitHub Actions. Adapt paths and commands to your environment.

1. Export the app from CI

In your CI job, add a step that builds and archives your iOS app:

- name: Build iOS app
run: |
xcodebuild \
-scheme MyApp \
-sdk iphonesimulator \
-destination 'platform=iOS Simulator,name=iPhone 15 Pro,OS=17.5' \
build \
-derivedDataPath build

The resulting .app bundle lives under build/Build/Products/Debug-iphonesimulator/MyApp.app.

2. Launch the simulator and app

Use xcrun simctl to boot and install:

xcrun simctl boot "iPhone 15 Pro"
xcrun simctl install booted build/Build/Products/Debug-iphonesimulator/MyApp.app
xcrun simctl launch booted com.example.MyApp

3. Trigger an agent script to drive the demo flow

When Reely’s MCP/agent integration is installed on your CI runner (vendor setup), you might invoke it via a CLI command such as:

reely-agent demo-run \
--bundle-id com.example.MyApp \
--simulator "iPhone 15 Pro" \
--script ./ci/demo-flow.yaml \
--output ./ci/artifacts/demo_raw.mov

The command above is illustrative. Check Reely’s documentation for actual CLI flags and supported agent workflows.[^reely]

The demo-flow.yaml could describe steps like:

steps:
- tap: {label: "Scan"}
- wait: 1.5
- present-camera: true
- hold: 3.0 # allow QR to be recognized
- tap: {label: "Done"}
- hold: 2.0

4. Auto-generate a reel from the recording

After recording, a second agent command can create a polished reel:

reely-agent build-reel \
--input ./ci/artifacts/demo_raw.mov \
--type feature-teaser \
--prompt "Show QR scan to task creation in under 15 seconds." \
--output ./ci/artifacts/demo_teaser.mp4

Again, treat this as a pattern: the exact commands depend on Reely’s agent implementation.

6.3 Where to store artifacts and how to wire approvals

In CI, you typically:

  • Upload the raw simulator recording and finished reels as build artifacts
  • Or push them to object storage (S3, GCS) with build number and git SHA

Then:

  • Share a link with your team in Slack (many CI tools support Slack notifications)
  • Treat “approve this reel” as a checklist item before shipping a major feature

Over time, you can:

  • Maintain a library of auto-generated reels tied to builds
  • Quickly assemble a Product Hunt launch video from recent feature clips

This is where Reely’s point of view—“your agent built the app, let it build the demo reel too”—becomes practical.

Reely vs Screen Studio: Which iOS app demo tool should you use?

Many developers search for Reely vs Screen Studio iOS app demos when deciding on their tool stack. They solve related but different problems.

Screen Studio

According to Screen Studio’s guide, it excels at polished macOS screen recording with automatic zooms on clicks and smooth camera movement.[^screen-studio]

Best for:

  • High-quality desktop walkthroughs
  • Manual, curated product demos where you control every movement
  • Polishing an already-recorded session with auto-zooms and cursor emphasis

Limitations for our use case:

  • Does not solve the Simulator camera input problem directly
  • Focused on recording and visual polish, not agent-based automation or app-code integration

Reely

Per Reely’s site, it is specifically positioned as an app launch video generator for mobile developers.[^reely]

Best for:

  • iOS app preview video generator from simulator recordings
  • Turning code, screenshots, or English prompts into feature teasers and launch promos
  • Integrating with AI coding agents and MCP tools to go from build → reel
  • Local-first rendering (no cloud upload for your builds)

Limitations:

  • Not a general desktop recorder
  • Optimized for app flows, not generic screencasts

How they fit together

In practice, many teams use both:

  • Use RocketSim + Simulator + Reely for iOS app-specific camera flows and launch reels.
  • Use Screen Studio for desktop dashboard, CLI, or web admin demos that complement your app.

Troubleshooting: common simulator camera & recording issues

Camera routing and simulator recordings can be finicky. Here’s a quick checklist.

1. Black camera preview in Simulator

Symptoms: Your SwiftUI camera view shows a solid black rectangle.

Possible causes & fixes:

  • RocketSim not attached to the right Simulator
    • Ensure the correct device is selected in RocketSim.
    • Restart RocketSim and the Simulator.
  • Camera permission not granted
    • macOS: System Settings → Privacy & Security → Camera → enable RocketSim.
    • Quit and relaunch RocketSim.
  • App using physical-device-only APIs
    • Confirm you’re not hard-coding AVCaptureDevice.default(.builtInWideAngleCamera, ...) that fails on simulator.

2. Simulator not seeing virtual camera

Symptoms: RocketSim shows an active camera, but your app’s preview is frozen.

Fixes:

  • Reset the Simulator: xcrun simctl shutdown all xcrun simctl erase all Then re-open Xcode, boot a fresh simulator, reattach RocketSim.
  • Try a different runtime (e.g., iOS 17 instead of 16) if supported by your tool.

3. Continuity Camera not connecting

Symptoms: iPhone not available as Continuity Camera source.

Requirements & fixes:

  • macOS Ventura or later and iOS 16 or later on the iPhone[^continuity]
  • Same Apple ID on both devices
  • Wi‑Fi and Bluetooth enabled on both
  • Keep the iPhone near the Mac, unlocked, and not in use

If it still doesn’t appear, restart both devices.

4. Missing permission prompts

Symptoms: RocketSim never asks for camera or screen recording permissions.

Fixes:

  • Manually reset permissions:
    • System Settings → Privacy & Security → Screen Recording / Camera
    • Remove RocketSim from the list, then relaunch it.
  • If necessary, reset the TCC database for the user (advanced; use with caution).

5. Choppy or stuttering recordings

Symptoms: Final .mov stutters, especially with AR.

Fixes:

  • Close heavy apps (browser tabs, emulators).
  • Reduce Simulator scale to 75% or 50%.
  • Record a smaller region (just the Simulator window) with QuickTime or your chosen recorder.

Common Q&A: iOS simulator recordings and app preview video generators

How do I record simulator camera for an App Store preview?

  1. Use a tool like RocketSim to provide Simulator Camera support from your Mac or Continuity Camera.[^rocketsim-camera]
  2. Run your app’s camera-dependent SwiftUI view on the iOS Simulator.
  3. Use QuickTime, RocketSim’s recorder, or another capture tool to record the Simulator window.
  4. Edit the recording to a ≤30-second clip following Apple’s preview guidelines.[^apple-previews]

Can I auto-generate demo videos from build artifacts?

Yes. A common pattern is:

  • CI builds your app, exports an .app or .ipa.
  • A script launches the Simulator and installs the build.
  • An agent (such as Reely’s MCP tool, per vendor docs) drives the app through a demo flow and records it.
  • Another agent step feeds the recording into an app preview video generator to produce a finished reel.

What is the best iOS app preview video generator from simulator recordings?

For mobile developers specifically, Reely is designed as an app launch video generator that:

  • Works with Simulator footage
  • Extracts branding from your app
  • Auto-times motion, typography, and music
  • Integrates with AI agents for build → reel workflows (vendor claims)[^reely]

General-purpose tools like Screen Studio are excellent at recording and zooms but don’t focus on app-code integration or simulator camera routing.

Do I need a physical iPhone to capture my SwiftUI camera feature?

You need an iPhone for Continuity Camera if you prefer that feed, but you can often record believable flows using:

  • Built-in Mac camera routed to the Simulator via RocketSim, SimCam, or SimulatorCamera
  • Printed or on-screen QR codes, documents, or AR anchors in front of the Mac camera

This avoids constantly screen‑mirroring physical devices.

Can AI tools generate product demo videos directly from code?

Yes, in a limited but growing way. Tools like Reely position themselves as AI tools that generate product demo videos from code and prompts, especially when paired with agents that:

  • Understand your app’s navigation
  • Rebuild flows in the Simulator
  • Capture and hand off footage to a motion system

For a deeper dive, check our pillar guide: Can an AI Agent Make Your App Demo Video?

Wrap-up: from SwiftUI camera feature to launch-ready reel

With the right setup, you can:

  • Route your Mac or Continuity Camera into the iOS Simulator
  • Capture realistic AR, QR, and photo flows
  • Follow Apple’s preview rules while creating authentic, instructional footage
  • Use a tool like Reely to turn simulator recordings into launch-ready reels in minutes
  • Wire the whole thing into CI so every major build can ship with its own demo video

Your agent built the SwiftUI feature. Now let it build the demo reel too.

[^apple-ecosystem]: Apple, “Apple Global Ecosystem Report,” 2024–2025. https://www.apple.com/newsroom/pdfs/2024-Apple-Global-Ecosystem-Report-June2025.pdf [^apple-previews]: Apple, “App Previews,” App Store guidelines. https://developer.apple.com/app-store/app-previews/ [^apple-sim]: Apple, “Running your app on simulated or physical devices,” Xcode Documentation. https://developer.apple.com/documentation/Xcode/running-your-app-on-simulated-or-physical-devices [^continuity]: Apple Support, “Use iPhone as a webcam on Mac (Continuity Camera).” https://support.apple.com/ [^hubspot]: HubSpot, “2024 Video Marketing Report.” https://blog.hubspot.com/marketing/video-marketing-report [^wistia]: Wistia, “State of Video Report – Instructional video engagement.” https://wistia.com/blog/insights-state-of-video-report [^wistia-2026]: Wistia, “State of Video 2026: Distribution trends.” https://wistia.com/explore/state-of-video-report [^ph-video]: Product Hunt community threads, “How do you make your Product Hunt launch video?” https://www.producthunt.com/p/general/how-do-you-make-your-product-hunt-launch-video [^rocketsim-camera]: RocketSim Docs, “Simulator Camera support.” https://www.rocketsim.app/docs/features/capturing/simulator-camera-support/ [^simcam]: SimCam, “Xcode Simulator camera feed.” https://simcam.swmansion.com/ [^screen-studio]: Screen Studio, “Auto-zoom guide.” https://screen.studio/guide/auto-zoom [^reely]: Reely, product site and docs. https://getreely.co/

← All posts