iOS App Preview Video Generators: Simulator Recordings vs Screen Capture on macOS

iOS App Preview Video Generators: Simulator Recordings vs Screen Capture on macOS

App Store preview videos are your app’s fastest story on launch day. They autoplay in search and on your product page, and Apple even reuses them in ads. But capturing and packaging them correctly is harder than it looks.

This guide compares simulator-based recording, screen capture, and physical-device workflows on macOS — plus tools like Kap, OBS, Rotato, and Reely — so indie iOS and mobile devs can ship App Store–ready launch videos without becoming video editors.

What Apple Actually Requires for App Store App Preview Videos

Before you pick a capture workflow, you need to know Apple’s constraints. These rules come from Apple’s official App Store Connect and App Preview documentation so you can verify them directly.

Key App Preview specs (iOS/iPadOS):

• Duration: 15–30 seconds per preview
• File size: up to 500 MB per video
• Frame rate: up to 30 fps
• Codecs / formats:
  • Upload formats: .mov, .m4v, .mp4 depending on codec
  • Video codecs: H.264 or ProRes 422 (HQ only)
  • Audio: stereo AAC or PCM
• Inventory: up to three previews per language and per device size

Source: Apple App Preview specifications and App Previews overview, checked on 2026-08-27.

What about HEVC?

• As of Apple’s current docs, App Store Connect explicitly lists H.264 and ProRes 422 (HQ) as supported video codecs for previews.
• The docs do not list HEVC (H.265) as an accepted codec for App Previews.
• In practice, App Store Connect often re-encodes uploaded assets for delivery, but you should encode to H.264 or ProRes 422 HQ to stay within documented requirements.

Editorial guidance (often overlooked):

• Focus on the core experience and keep assets evergreen.
• Avoid prices, external URLs, and unsubstantiated claims.
• Keep transitions straightforward and make sure on-screen copy carries context because previews autoplay muted by default.

Source: Apple asset best practices, checked on 2026-08-27.

Simulator vs Screen Capture vs Device: High-Level Comparison

For iOS devs on macOS, you really have three capture paths:

• Simulator-based recording (Xcode / simctl / agentic flows)
• Screen capture (QuickTime, Screenshot app, ScreenCaptureKit-based tools)
• Physical device recording (mirroring or on-device capture)

Here’s how they compare.

Capture Workflow Comparison Table

| Workflow | Pros | Cons | Determinism / CI-friendly | Fidelity / realism | Best use cases | Recommended tools | |---------------------------------|----------------------------------------------------------|-----------------------------------------------------------|-----------------------------------|-------------------------------------------|------------------------------------------------------|-----------------------------------------------------| | Simulator-based recording | Repeatable flows, scriptable, runs on Mac, no cables | Not full hardware fidelity; touch vs mouse differences | High — ideal for CI/agents | Medium — great UI fidelity, not performance | App Store previews, feature demos, automation | Xcode Device Hub, xcrun simctl, Reely (vendor claim) | | Screen capture (macOS display) | Works with any simulator/IDE/window, low friction | Mouse cursor, desktop clutter, manual start/stop | Medium — scriptable via APIs | Medium — same as source; can capture artifacts | Tutorials, coding streams, quick social clips | Screenshot app, QuickTime, ScreenCaptureKit apps, Kap, OBS | | Physical device recording | True device performance, real gestures/haptics | Less scriptable; cables or on-device capture required | Low–Medium — harder to automate | High — real hardware, networking, sensors | Performance validation, UX realism, marketable b-roll | Xcode Device Hub (device), QuickTime with iPhone, built-in iOS screen record |

Apple explicitly notes that simulators do not replicate device performance or all features:

• Simulators run on the Mac and are great for rapid prototyping and repeatable flows.
• They are not accurate tests of performance, memory usage, or networking speed.

Source: Apple — running apps on simulated or physical devices and iOS Simulator guide, checked on 2026-08-27.

How to Record iOS Simulator on Mac (simctl & ScreenCaptureKit)

This is one of the most common queries from iOS devs: how do I record the iOS Simulator on macOS, ideally in an automated way?

There are two main approaches:

• Xcode’s built-in Device Hub / Simulator recording
• Command-line via xcrun simctl

Option 1: Xcode Device Hub / Simulator GUI

For manual, one-off recordings:

1. Open Xcode and launch your app in the iOS Simulator.
2. Use Device Hub (Window → Devices and Simulators) to select the target simulator.
3. Use the built-in screenshot and video capture controls.
4. Recorded videos from simulated devices are saved to your Desktop by default and named Screen Recording ....

Source: Apple — capturing screenshots and videos from devices, checked on 2026-08-27.

Option 2: simctl command-line recording

For repeatable and CI-friendly recording, use xcrun simctl.

Basic example (copy-paste ready):

# List available simulators
xcrun simctl list devices

# Replace with your booted simulator's UDID
SIMULATOR_UDID="YOUR-SIM-UDID-HERE"

# Start recording to a .mov file
xcrun simctl io "$SIMULATOR_UDID" recordVideo \
--codec=h264 \
--force \
"app-preview.mov"

# Run your scripted UI flow here (manually or via UI tests/agent)

# Hit Ctrl+C to stop recording when done

Notes:

• Use --codec=h264 to align with App Store’s documented preview codecs.
• Combine this with UI tests or an AI agent that drives the simulator for fully automated demo flows.

Documentation: Apple — simctl command-line utility (section on simctl), checked on 2026-08-27.

Where ScreenCaptureKit Fits

ScreenCaptureKit is Apple’s modern API for high-performance screen capture. It’s especially relevant if you’re building your own app preview video generator or agent-driven pipeline.

Capabilities (per Apple docs):

• Capture specific windows, apps, or displays via content filters.
• Receive video and audio sample buffers for real-time processing.
• Support HDR capture, microphone input, multi-display screenshots.
• Provide direct-to-file recording controls (June 2024 update).

Source: ScreenCaptureKit overview and ScreenCaptureKit updates, checked on 2026-08-27.

Minimal Swift usage snippet (conceptual):

import ScreenCaptureKit

// Request a stream for a specific display
let display = try await SCShareableContent.current.displays.first
let config = SCStreamConfiguration()
config.width = 1920
config.height = 1080
config.showsCursor = false

let stream = SCStream(filter: SCContentFilter(display: display!),
configuration: config,
delegate: self)

try stream.addStreamOutput(self,
type: .screen,
sampleHandlerQueue: .main)
try stream.startCapture()

// Implement SCStreamOutput to handle CMSampleBuffer frames

For production use, refer to Apple’s sample projects linked from the ScreenCaptureKit docs.

Best Screen Capture Apps for macOS (Native & Open Source)

The macOS capture ecosystem splits into three buckets:

• Native built-ins (QuickTime, Screenshot app, Xcode Simulator/Device Hub)
• Open source recorders (Kap, OBS)
• Specialized promo/preview tools (Rotato, App Preview packaging apps, Reely)

Native Tools: QuickTime & Screenshot App

macOS ships with solid capture tools out of the box.

Screenshot app (Shift-Command-5)

• Record full screen or selected portion.
• Choose microphone, timer, and output file location.
• Good for quick clips and simple demos.

Source: Apple support — screen recording on Mac, checked on 2026-08-27.

QuickTime Player

• Record the Mac desktop or a connected iPhone/iPad screen.
• Lightweight trimming support for basic edits.
• Ideal for physical device mirroring plus narration.

Use this for:

• Fast bug repro videos for teammates.
• Informal demo clips for X/Twitter and Slack.

Kap Screen Recorder macOS — When to Use It

Kap is a popular open source screen recorder for macOS.

Vendor and community signals (checked 2026-08-27):

• GitHub repo: about 19.3k stars and ~890 forks.
• Exports GIF, MP4, WebM, APNG.
• Offers click highlighting, trimming, and plugins.

Source: Kap GitHub and Kap official site.

Best use cases for indie devs:

• Short looping previews (GIFs) of micro-interactions.
• QA repro clips with cursor highlights.
• Quick feature teasers for social — not full App Store previews.

Trade-offs:

• Not wired directly into Simulator or Xcode.
• No concept of App Store preview specs or automatic conforming.
• Manual start/stop; not designed as a CI-friendly generator.

OBS: Production-Grade Scene Control

OBS Studio is a heavy-duty, open source tool for multi-source recording and streaming.

Signals (checked 2026-08-27):

• GitHub repo: about 75.3k stars.
• Current release noted in repo: 32.2.2 (Aug. 14, 2026).
• macOS 13.0+ supported for current Mac build.

Source: OBS GitHub and OBS quick-start guide.

Best for:

• Multi-window demos (simulator + slides + webcam).
• Developer livestreams and long-form tutorials.

Caveats:

• Configuration-sensitive; OBS recommends test recordings before going live.
• Overkill for simple 15–30s App Store previews.

Rotato App Preview Maker — Mockups, Not Capture

Rotato positions itself as a 3D device and promo-video mockup tool.

Vendor-sourced capabilities (checked 2026-08-27):

• 30+ 3D devices built-in.
• Supports 50+ image/video formats.
• Output up to 8K.
• Used by 200,000+ brands and freelancers.

Source: Rotato site.

Important distinction:

• Rotato is not a recorder.
• It’s a finishing layer that ingests screenshots or video and wraps them in device mockups and motion.

Good for:

• Polishing a single hero shot for landing pages.
• Making your app feel at home in a slick device frame.

Limitations for App Store previews:

• You still need a capture workflow (Simulator, QuickTime, ScreenCaptureKit, etc.).
• Rotato’s output must be encoded to H.264 or ProRes 422 HQ and kept within 30s/500MB to meet App Store specs.

App Preview Packaging Utilities

There are Mac apps dedicated to converting generic videos into App Store-ready previews.

Example: App Preview Video Maker (Mac App Store listing).

Vendor-described capabilities (checked 2026-08-27):

• Convert videos into App Store-accepted preview formats.
• Re-encode multiple videos at once.

Source: App Preview Video Maker on Mac App Store.

Use these when:

• You already have footage and need quick, spec-compliant packaging.
• You don’t want to juggle ffmpeg presets manually.

Agent-Native Generators: Reely and "Promo from Code" Workflows

The market is shifting from “record then edit” to “describe then generate”. Agent-native tools try to turn your code and simulator flows directly into finished demo reels.

What Reely Claims to Do (Vendor-Sourced)

Reely positions itself as an “app launch video generator for mobile developers.” It’s an AI-native, Mac-first product.

Key vendor claims (checked 2026-08-27 on getreely.co):

• Native macOS app that renders locally and works with Xcode’s iOS Simulator.
• Agent/MCP tool so your coding agent can go from “build feature” → “build demo reel” in the same workflow.
• Outputs:
  • 10–20s feature teasers
  • 30–60s full launch promos
• Motion systems:
  • Kinetic typography presets
  • Device choreography
  • Music/sound cue timing
  • Automatic dead-air removal for tight pacing
• Visuals:
  • "Brand-theme-from-app" — pulls colors/fonts from your app UI
  • Multiple aspect ratios, 4K masters, native gestures, adaptive backgrounds
• Pricing (vendor-stated):
  • Around $19/month or $123/year
  • A "2 + 1 Honor Offer" that discounts if you promise to tell people about Reely.

Important notes:

• These are vendor-sourced, marketing claims; if you adopt Reely, you should verify technical details (local rendering, agent integration behavior, pricing) against the current product.
• As with any tool, consider vendor lock-in (proprietary project formats) and privacy (even with local rendering, check what data the app collects).

Potential benefits for devs:

• "Promo from code in minutes" — less time in timelines, more time shipping features.
• Keep App Store preview videos and Product Hunt trailers updated as your app changes.

Neutral alternatives / approaches:

• Build your own self-hosted demo video generator from code using:
  • simctl for deterministic simulator capture
  • ScreenCaptureKit for high-performance recording
  • ffmpeg for spec-compliant packing to H.264
  • A small motion system (e.g., scripting After Effects or a custom compositor).

Tool vs Use-Case Matrix for Indie iOS Devs

To make this scannable, here’s a condensed matrix.

This matrix maps popular macOS capture tools to app preview use cases so you can pick the right stack for App Store, social, and live demos.

| Tool / approach | Primary role | App Store preview friendly? | Output formats | Automation / CI friendliness | Price / licensing (checked 2026-08-27) | |-------------------------------------|-----------------------------------------|-------------------------------------|------------------------------------------|-------------------------------------|----------------------------------------------------| | Xcode Simulator + simctl | Deterministic simulator recording | Yes, when encoded to H.264/ProRes | .mov (codec configurable) | High — scriptable, UI tests | Bundled with Xcode (free) | | Screenshot app / QuickTime | Native Mac/Device recording | Yes, with manual export/encode | .mov | Low–Medium — manual GUI | Bundled with macOS (free) | | ScreenCaptureKit-based custom app | API-first screen capture | Yes, if encoding matches specs | Programmable (H.264/ProRes) | High — programmable, agent-friendly | Requires custom dev; API free via Apple SDK | | Kap (open source) | Lightweight recorder & GIF export | Indirect — needs re-encode/packaging| GIF, MP4, WebM, APNG | Medium — has CLI/plugins | Open source (free); donations welcomed | | OBS Studio (open source) | Multi-source production & streaming | Possible but overkill for short previews | Customizable via encoders | Medium — scenes/macros possible | Open source (free) | | Rotato (vendor) | 3D device mockup & promo visuals | Yes, as a finishing layer | Many image/video formats; up to 8K | Low — manual design flow | Commercial license; check current pricing | | App Preview Video Maker (vendor) | Packaging to App Store formats | Yes, spec-focused | App Store-ready preview files | Medium — batch re-encoding | Paid Mac App Store app; see listing | | Reely (vendor) | AI app preview generator from simulator | Yes, by design (per vendor claim) | 10–20s teasers, 30–60s promos, 4K masters| High — agent-driven workflow | Subscription; honor offer; verify on getreely.co |

For strict App Store compliance, always validate against Apple’s latest App Preview specs.

Privacy, Vendor Lock-In, and Local Rendering Considerations

When you move from native tools to vendor products, think about:

• Local vs cloud rendering
  • Native macOS tools and custom ScreenCaptureKit apps typically render on-device.
  • Vendor tools may upload source footage or app data; always check their privacy policy.
  • Reely’s marketing claims highlight local rendering and no cloud uploads for builds, but you should confirm this against the current product.
• Project portability
  • Open source tools (Kap, OBS) use more open or documented formats.
  • Proprietary motion systems (Rotato, Reely, others) may store timelines in custom formats.
• Automation hooks
  • API-first tools (ScreenCaptureKit, simctl) are best for self-hosted demo video generators.
  • UI-only apps will be harder to wire into CI/CD.

FAQ: App Preview Video Generators for iOS Devs

Can I auto-generate app demo reels after build?

Yes. You can auto-generate demo reels after each build by combining:

• xcrun simctl io ... recordVideo for simulator recording.
• UI tests or an AI agent to drive the app flow.
• A packaging script (ffmpeg or a tool like App Preview Video Maker) to encode to H.264 and meet Apple’s preview specs.

Vendor tools like Reely claim to automate this end-to-end via an MCP/agent integration, but you should validate their CI hooks and output formats for your workflow.

Is there a self-hosted demo video generator from code?

You can build a self-hosted generator with:

• simctl for deterministic simulator capture.
• ScreenCaptureKit for high-performance recording and fine-grained window selection.
• A small motion engine (your own compositor, scripted graphics, or an open-source stack) to add titles and pacing.

This gives you full control and keeps app footage on your own infrastructure.

How does Reely compare to Kap for developer workflows?

Based on public descriptions (checked 2026-08-27):

• Kap
  • Open source, lightweight screen recorder.
  • Great for quick clips and GIFs.
  • No simulator control or app-preview-specific automation.
• Reely (vendor-sourced claims)
  • Built specifically as an app launch video generator for mobile developers.
  • Integrates with the iOS Simulator and an MCP/agent so the same AI that builds the app can build the demo reel.
  • Focuses on App Store previews, feature teasers, and launch promos.

If you only need simple screen recordings, Kap is enough. If you want agent-driven, spec-aware launch videos, Reely or a custom ScreenCaptureKit/simctl pipeline is a better fit.

What’s the best way to capture a physical iPhone screen on macOS?

Two reliable options:

• QuickTime Player + Lightning/USB-C cable
  1. Connect your iPhone to your Mac.
  2. Open QuickTime → File → New Movie Recording.
  3. Select your iPhone as the camera source.
  4. Record and save as .mov, then encode to H.264.
• On-device iOS screen recording
  1. Enable Screen Recording in Control Center.
  2. Record your app flow directly on the device.
  3. Export the video to your Mac and re-encode if needed.

Use these when you care about real-device performance and gestures.

Are simulator recordings acceptable for App Store previews?

Yes. Apple does not require that previews be captured from physical devices. You can use simulator footage as long as:

• The video meets duration, size, codec, and fps constraints.
• The content accurately represents the app on real devices.

Apple’s caveat is about testing — simulators do not fully reflect real performance — but they are fine as visual source for previews.

Ship Faster by Choosing the Right Capture Stack

For indie iOS and mobile devs, the goal is simple: ship more, fiddle less.

A pragmatic approach:

• Use Simulator + simctl for deterministic, App Store-ready flows.
• Use QuickTime / Screenshot app for quick, human-driven demos and device captures.
• Reach for Kap/OBS when you need flexible screen recording or streaming.
• Layer in Rotato or similar to polish specific hero shots.
• Consider agent-native generators like Reely or a self-hosted ScreenCaptureKit pipeline when you’re ready to automate “promo from code.”

Align each tool with the job it’s good at, and your app previews will feel like part of your build system — not a separate production ceremony.