Georgii EmelianovComparisons

Rotato vs Raw iOS Simulator Captures — Best iOS App Preview Video Generator for App Store & Launch Videos

For mobile developers, choosing the right iOS app preview video generator from simulator recordings is now part of the launch stack.

Developer comparing raw iOS Simulator capture with Rotato 3D device frame for iOS app preview videos

For mobile developers, choosing the right iOS app preview video generator from simulator recordings is now part of the launch stack.

Do you show your simulator window directly, or wrap it in Rotato’s glossy 3D device frames?

This comparison dives into clarity, polish, and App Store compliance—and how each option fits into modern launch-video workflows.

Why this decision matters: App Store rules vs launch-video polish

Before picking a tool, you need to optimize for two different outcomes:

  • App Store app previews (strict rules, review risk)
  • Launch videos for Product Hunt, X, YouTube Shorts, and LinkedIn (style and clarity-first)

Apple’s official guidance leans heavily toward raw, in-app footage:

  • App previews must show only content from your app and avoid misleading visuals.
  • Guidelines warn about including device images or frames that can misrepresent the experience.

Key sources:

Rotato, by contrast, is optimized for polish and presentation:

  • 3D device mockups, cinematic motion, and App Store screenshot templates.
  • High-fidelity exports like 4K 60fps, ProRes 4444, and HEVC.

Pricing snapshot (verified 2026-06-19 from Rotato’s site, may change):

Raw iOS Simulator captures: pros, cons, and best-fit workflows

Raw simulator recordings are the compliance baseline for App Store previews.

Apple explicitly supports this workflow via Xcode:

  • Device Hub can record videos from simulated devices at native resolution.
  • Videos are saved directly to your Mac in the right format for further editing.

How to record raw simulator video (GUI)

Use Xcode’s built-in Devices and Simulators window:

  1. Open Xcode.
  2. Go to Window → Devices and Simulators.
  3. Select your simulated device under the Simulators tab.
  4. Click … (action menu) and choose Record Screen.
  5. Perform your app flow in the iOS Simulator.
  6. Click Stop; Xcode saves the video to your Desktop at full device resolution.

Apple’s documentation: Capturing screenshots and videos from devices.

How to record simulator video via CLI (xcrun)

If you prefer command-line tools or want CI hooks, simctl is your friend:

# Ensure a simulator is booted
xcrun simctl boot "iPhone 16"

# Record video from the booted simulator
xcrun simctl io booted recordVideo app-preview.mov

# Press Ctrl+C to stop recording

Key points:

  • booted targets the currently running simulator.
  • Output is a .mov file usable in any editor.

Raw simulator capture: strengths

For clarity and compliance, simulator-first workflows are hard to beat:

  • Native UI resolution – Apple explicitly recommends capturing at native resolution (no zooming), which simulator recordings follow by default. (App previews — Apple design guidance)
  • Review safety – No extra device frames means fewer reasons for App Review to push back under Guideline 2.3.4.
  • Exact fidelity – What you record is exactly what users see in the app.

Apple forum threads confirm that including hardware frames can trigger rejections under 2.3.4, even when core footage is fine—example: a developer reporting preview rejection specifically for including non-Apple device imagery. (Developer forums example thread)

Raw simulator capture: drawbacks

The main tradeoffs:

  • Less visual polish – A plain simulator window can feel utilitarian in launch promos.
  • Manual editing – You still need to cut dead air, add titles, and pace the story.
  • No built-in motion system – Cursor motion, device tilt, and kinetic typography all require extra tooling.

Best use cases for raw simulator recordings

Use raw simulator capture when you need:

  • App Store app previews that strictly follow Apple guidance.
  • Internal demos (stakeholder updates, QA clips) where fidelity matters more than style.
  • Source footage for AI-native tools like Reely that handle motion and titles downstream.

Recommended workflow:

  1. Record via Xcode Device Hub or xcrun simctl io booted recordVideo.
  2. Trim endpoints and remove dead air in a lightweight editor or automation tool.
  3. Layer text callouts to compensate for muted autoplay.
  4. Export in H.264 or ProRes 422 (HQ) at 30 fps max, within 500MB, per Apple’s spec. (App Preview Specifications)

Rotato: pros, cons, and where device frames shine

Rotato sits firmly on the presentation-first side of the spectrum.

It’s built for turning raw screenshots or simulator clips into 3D device scenes:

  • 30+ device mockups
  • Cinematic camera motion
  • Automated App Store screenshot layouts
  • 4K 60fps exports and ProRes/HEVC support (Rotato feature overview)

Rotato: strengths

For launch videos and marketing assets, Rotato offers:

  • Instant polish – Your app sits in a staged device frame with camera moves that feel like a product commercial.
  • Context – The device framing helps non-technical viewers understand “this is a phone app.”
  • High-resolution exports – Ideal for big screens, YouTube, and promo reels.

Rotato’s positioning is explicit: raw UI can feel unfinished; 3D device framing creates a “marketing-ready” first impression.

Rotato: drawbacks

For App Store previews, device frames introduce risk:

  • Guideline 2.3.4 conflicts – Non-Apple hardware images and stylized frames can be interpreted as misleading, especially if they obscure UI.
  • Less screen real estate – The frame reduces visible UI size, working against Apple’s emphasis on native resolution and legibility.
  • Potential rejections – Apple Developer Forums contain real-world cases where previews with frames were rejected under 2.3.4. (Example forum thread)

Rotato itself does not claim App Store compliance for framed previews; it optimizes for presentation.

Best use cases for Rotato

Use Rotato’s 3D device framing when you’re shipping:

  • Launch videos for X, Product Hunt, and YouTube Shorts.
  • Website hero sections that need cinematic UI presentation.
  • Pitch decks and investor materials where the device frame adds professionalism.

Recommended workflow:

  1. Capture raw simulator footage at native resolution.
  2. Import into Rotato and place it inside a device scene.
  3. Add camera moves that highlight flows (onboarding, key feature beats).
  4. Export at 4K or high-quality ProRes/HEVC for social and web use.

For App Store previews, use Rotato only if you remove the device frame and present raw app footage that adheres to Apple’s specs.

Clarity vs polish: how each option performs in real contexts

To choose the best path, evaluate your UI presentation on three dimensions:

  • Clarity – Can users instantly understand what’s happening on screen?
  • Polish – Does the video feel like a finished marketing asset?
  • Compliance – Is the asset safe under App Store rules?

Here’s how raw simulator capture and Rotato stack up.

Chart comparing clarity, polish, and App Store compliance for simulator vs Rotato UI videos

Raw simulator footage wins on clarity and App Store compliance; Rotato wins on polish for social and web launch videos.

Clarity

  • Simulator: Full device resolution, no framing distractions, UI is maximally legible.
  • Rotato: Framing aids context but shrinks visible UI area; good for non-technical audiences, less ideal for dense interfaces.

Polish

  • Simulator: Looks like a dev tool unless you add motion and typography via other tools.
  • Rotato: High perceived production value with minimal setup; feels like a studio-made spot.

App Store performance

Based on Apple’s guidance and reviewer anecdotes:

  • Simulator (raw): Safest choice; aligns with 2.3.4 and app-preview docs.
  • Rotato (framed): Best reserved for non-App-Store contexts; may be rejected if frames are considered hardware imagery or misleading.

Combine this with Product Page Optimization:

  • Test variants where the footage stays raw but you iterate on titles, pacing, and first 3–5 seconds.
  • Apple allows up to 3 treatments and 90 days per test, with results surfacing after at least 5 first-time downloads. (Product Page Optimization)

CI/CD: Automatically generate app demo reels from build artifacts

Modern teams increasingly want simulator recordings App Store preview automation built straight into CI.

The typical flow:

  • Build passes.
  • Tests run in the iOS Simulator.
  • A demo flow is driven automatically.
  • A preview or launch reel is generated.

CLI capture hooked into CI

You can trigger recording in CI using xcrun simctl.

Example GitHub Actions snippet:

name: iOS Demo Capture

on:
workflow_dispatch:

jobs:
capture-demo:
runs-on: macos-latest

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

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

- name: Boot simulator
run: xcrun simctl boot "iPhone 16"

- name: Record demo
run: |
xcrun simctl io booted recordVideo demo-preview.mov &
RECORD_PID=$!
# Run UI tests or a scripted demo here
xcodebuild \
-scheme YourScheme \
-destination 'platform=iOS Simulator,name=iPhone 16' \
test
kill $RECORD_PID

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

This gives you a raw simulator .mov after every successful test run.

A similar pattern works with Fastlane:

lane :record_simulator_demo do
sh "xcrun simctl boot 'iPhone 16'"
sh "xcrun simctl io booted recordVideo demo.mov &"
sh "xcodebuild -scheme YourScheme -destination 'platform=iOS Simulator,name=iPhone 16' test"
sh "pkill -f 'simctl io booted recordVideo'"
end

Auto-generating reels from builds (Reely angle)

Tools like Reely extend this capture-first CI workflow into motion:

  • Your agent builds the app.
  • The same agent, via Reely’s MCP, drives the simulator and records flows.
  • Reely auto-cuts dead air, adds kinetic typography and device choreography, and outputs:
    • 10–20s feature teasers
    • 30–60s full launch promos

Reely is effectively a mobile app preview video generator app store and launch tool that lives in your developer workflow:

  • Native macOS app using the iOS Simulator, no cloud uploads.
  • Agent integration so your coding agent can go from “build feature” → “build demo reel” in one run.
  • Brand-theme-from-app, multiple aspect ratios, and 4K masters ready for App Store, Product Hunt, and X.

For CI queries like “CI tool create app demo video after successful build,” Reely is designed to be that motion endpoint.

Reely vs Screen Studio — features, pricing, and workflow fit

Screen Studio is a popular screen recording tool for app demo videos; Reely is an AI-native app demo video generator.

How they differ:

  • Screen Studio iOS app demo focus:
    • Polishes manual recordings.
    • Cursor smoothing and zoom.
    • Good for tutorial-style videos.
  • Reely iOS app demo focus:
    • Uses simulator and agents to reconstruct flows.
    • Auto cuts dead air and adds narrative pacing.
    • Outputs teasers and promos without timeline editing.

At-a-glance comparison: Rotato vs Simulator vs Reely vs Screen Studio

| Tool / workflow | Core focus | CI integration / automation | Pricing & licensing (indicative) | Support / onboarding | |---------------------------------------------|--------------------------------------|---------------------------------------------|---------------------------------------------------------------------|-----------------------------------------------| | Raw iOS Simulator capture (Xcode / CLI) | Compliance-first, raw UI fidelity | High — easy to script via xcrun simctl | Included with Xcode (no extra license) | Apple docs, dev community, forums | | Rotato | 3D device frames, cinematic polish | Low–medium — manual import; no CI-native | One-time: Basic $79, Standard $89, Premium $199 (2026-06-19 snapshot) | Docs, tutorials; classic indie tool support | | Reely | AI-native app launch video generator | High — MCP/agent plugs into dev workflow | Subscription: e.g. $19/month or $123/year; honor-based promo offers | Builder-to-builder support, agent-first flow | | Screen Studio | Screen polishing & tutorials | Medium — can be scripted, but user-driven | Subscription (varies by tier; check site) | Indie-friendly, tutorial-heavy onboarding |

This table answers common queries like “simulator recordings App Store preview automation” and “Reely vs Screen Studio iOS app demos” at a glance.

SmoothCapture, indie pricing, and customer support (and where Reely sits)

Tools like SmoothCapture (and similar indie capture utilities) focus on:

  • Affordable screen recording with cursor zoom and smoothing.
  • Simple pricing and responsive customer support.

They’re great for developers who:

  • Want cheap, reliable capture.
  • Value fast support from a small team.
  • Are comfortable doing their own editing in a timeline.

Reely’s stance is different:

  • Pricing is still indie-friendly (e.g. ~$19/month), but optimized for motion systems and agent integration, not just capture.
  • The “2 + 1 Honor Offer” trades a discount for simply telling people about Reely—trust-based, with no proof required.
  • Support is focused on helping you wire the app, agent, and simulator together, not on generic screen recording.

If you only need a best screen recording tool for app demos, a SmoothCapture-style product or Screen Studio can be enough.

If you want “promo from code in minutes” with no timeline editing, Reely is designed for that.

Practical recommendations: when to choose each option

To wrap it up, here are clear, scenario-based recommendations.

For App Store app preview videos

  • Primary choice: Raw iOS Simulator capture.
  • Workflow:
    • Record via Xcode Device Hub or simctl io booted recordVideo.
    • Edit for pacing, remove dead air, and add on-screen text.
    • Export within Apple’s App Preview specs.
    • Optionally feed footage into Reely (or similar) as long as the final output remains app-first and frame-free.

Avoid device frames (Rotato-style) in the final App Store asset to stay safe under Guideline 2.3.4.

For Product Hunt, X, and launch promos

  • Best choice for polish: Rotato or Reely.
  • Workflow:
    • Capture raw simulator footage.
    • For Rotato: add device frames and cinematic camera moves; export 4K for social.
    • For Reely: let the agent reconstruct flows and auto-generate 10–60s reels with kinetic typography and sound design.

You can even combine them: use Reely for the narrative structure, Rotato for a few hero shots.

For CI-driven demo capture and automation

  • Best choice: Raw simulator + Reely.
  • Workflow:
    • Integrate xcrun simctl recording into GitHub Actions or Fastlane.
    • Use your AI coding agent plus Reely’s MCP to run scripted flows after each build.
    • Output updated demo reels automatically whenever you ship new features.

FAQ — common questions about simulator recordings, Rotato, and Reely

Can I use framed videos (Rotato-style) for App Store previews?

You can technically upload framed videos, but it’s not recommended.

Apple’s App Store Review Guidelines 2.3.4 caution against non-Apple hardware imagery and misleading visuals, and forum reports show frames can be a disqualifier.

For safest App Store submissions, stick to raw, frame-free footage that shows only your app’s UI.

How do I record simulator video via CLI?

Use xcrun simctl:

xcrun simctl boot "iPhone 16"
xcrun simctl io booted recordVideo preview.mov
# Perform your app flow, then Ctrl+C to stop

The resulting preview.mov can be edited and exported according to Apple’s App Preview specs.

How do I integrate simulator recording into CI?

In CI (GitHub Actions, Fastlane, etc.), you:

  • Boot a simulator.
  • Start simctl io booted recordVideo.
  • Run UI tests or a scripted demo.
  • Stop recording and upload the artifact.

The GitHub Actions snippet earlier in this article is a ready-to-adapt template.

How do I auto-generate app demo reels after a CI build?

Use a capture + generator stack:

  1. Capture raw simulator video via xcrun simctl in CI.
  2. Pipe the resulting file and flow spec into an AI-native tool like Reely.
  3. Let Reely’s agent recreate the flow, cut dead air, and output app demo reels:
    • Short feature teasers.
    • Longer launch promos.

This gives you auto-generated app demo reels from build artifacts without manual editing.

How does Reely integrate with the iOS Simulator?

Reely runs as a native macOS app and has an MCP/agent tool that plugs into your AI coding agent.

The agent:

  • Drives the iOS Simulator to recreate specific flows.
  • Records the sessions locally (no cloud uploads).
  • Passes footage and spec into Reely’s motion studio.

Reely then applies kinetic typography, device choreography, and pacing—keeping scenes editable while still giving you “promo from code in minutes.”

If your agent can build the app, it should also build the demo reel.

Use raw simulator capture for App Store safety, Rotato for cinematic launch visuals, and Reely to bridge them—turning your code, simulator, and agent into finished reels in minutes.

← All posts