Best Mac Apps for Making iPhone Product Videos (Plus a CLI Workflow with ios-sim & simctl)

If you ship iOS builds fast, you eventually hit the same wall: how do you get clean, reproducible iPhone product videos for every build without manually recording the simulator over and over?

This guide walks through two layers:

1. The best Mac apps for making iPhone product videos today
2. A step‑by‑step tutorial for automating simulator launches, navigation, and recordings using simctl and ios-sim-style workflows

You’ll end up with a repeatable, scriptable pipeline that can generate demo clips for every new build. If you want the bigger-picture view of AI-driven workflows, pair this with our pillar guide Can an AI Agent Make Your App Demo Video?.

Why Mac Apps Still Matter for iPhone Product Videos

Even with AI and agents, your Mac is still the center of gravity for iOS app preview video generation.

A few constraints define the problem:

• App Store previews must be 15–30 seconds, ≤500MB, 30 fps max, and use H.264 or ProRes 422 (HQ), with up to 3 previews per language.
• Apple now lets these "Creative Assets" appear in product page headers, search results, and via an Asset Library for reuse.
• Simulator recording is officially supported via Device Hub and simctl, so command-line automation is now a first-class workflow.

If you’re a developer, the sweet spot is: use Mac-native capture tools for polish, and wrap them in automation so every successful build can ship a fresh demo.

Best Mac Apps for Making iPhone Product Videos

Here’s the current landscape, based on real tools developers use.

1. Screen Studio – Polished Manual Capture

Best for: developers who want polished, manually-recorded demos without a full NLE.

Key traits:

• Records Mac and iOS devices with automatic zoom and cursor smoothing
• Exports vertical and horizontal formats for App Store, Product Hunt, X, and Shorts
• Great when you want a hand-crafted walkthrough but don’t want to touch a timeline editor

Limitations:

• Still requires live recording and some manual setup
• Not designed for fully automated per-build demo generation

2. CleanShot X – Utility-First Capture Stack

Best for: quick recordings, bug repros, internal demos.

Highlights:

• Fast screen recording, GIF/video export, and annotations
• Built-in cloud sharing and OCR
• Good for engineering teams who need lots of quick captures

Limitations:

• Not specialized for App Store previews
• Doesn’t understand App Store constraints or storytelling patterns

3. App Store Preview Studio & SmoothCapture – App Store-Specific

Best for: staying within Apple’s rules while automating preview formatting.

Common capabilities:

• USB device capture + simulator capture
• Auto-adaptation to App Store preview specs
• Dead-air cutting and direct App Store Connect integrations

Limitations:

• Focused strongly on App Store; less about multi-channel launch videos
• Still more recorder-first than code/agent-first

4. Template & Mockup Tools – Previewed, MakeAppShots, AppLaunchpad

Best for: static or semi-static visuals, fast mocks.

Capabilities:

• Drop screenshots into device mockups and templates
• Automated scaling and localization (MakeAppShots supports 18 languages)

Limitations:

• Don’t record real simulator flows
• Not suitable for dynamic App Store preview videos

5. Reely – AI-Native App Launch Video Generator

Best for: developers who want promo from code in minutes with agent integration.

Reely is a native macOS app plus an MCP/agent tool that:

• Hooks into your iOS Simulator and existing AI coding agent
• Lets your agent recreate flows, record them, and auto-cut dead air
• Produces 10–20s feature teasers and 30–60s full launch promos
• Keeps every scene fully editable in a motion studio with:
  • Kinetic typography systems
  • Device choreography presets
  • Music and sound cue timing
  • Brand-theme-from-app (pulling visuals right from your UI)
• Renders locally on macOS with no cloud uploads

Reely sits at the end of the pipeline we’ll build in this tutorial: your CI/agent can generate repeatable simulator recordings, and Reely turns them into launch-ready reels.

Why Automate Simulator Recordings at All?

If you ship often, manual capture doesn’t scale.

Automation wins because you can:

• Reproduce exact flows for every build (no drift between v1.0 and v1.1 demos)
• Fit into CI pipelines: generate a fresh demo on every successful build
• Feed AI agents or tools like Reely with consistent, structured footage

Industry benchmarks underline the value:

• SplitMetrics reports that improving preview assets can drive around 16% average conversion uplift, and many ASO vendors cite 20–40% gains for high-quality previews.

The rest of this article is a hands-on tutorial explaining how to do it on your Mac.

Prerequisites

Before you automate iOS simulator recordings via command line, make sure you have:

• macOS with a recent Xcode installed
• Command Line Tools for Xcode (xcode-select --install)
• An iOS app you can run in the simulator
• Basic familiarity with:
  • Terminal
  • Shell scripting (bash/zsh)

Optional but useful:

• A CI pipeline (GitHub Actions, GitLab CI, etc.)
• An AI agent or MCP-compatible tool (so you can extend this later)

Step 1: Discover Your Simulators with simctl

Apple’s modern CLI for the simulator is simctl, not ios-sim. The ios-sim npm package is legacy (last published ~6 years ago, 32 dependents), but its ideas live on in simctl.

Run this in Terminal:

xcrun simctl list devices

You’ll see output like:

== Devices ==
-- iOS 18.0 --
iPhone 15 Pro (1234ABCD-5678-...) (Shutdown)
iPhone 15 (9876ABCD-...) (Booted)

Pick the simulator you want and copy its UDID.

To make things easier, define an environment variable:

export SIM_UDID="1234ABCD-5678-..."

Now every further command can reference $SIM_UDID.

Step 2: Automate Simulator Boot & App Install

You want to go from "no simulator" to "app running" via CLI.

2.1 Boot the Simulator

xcrun simctl boot "$SIM_UDID"
open -a Simulator --args -CurrentDeviceUDID "$SIM_UDID"

This ensures the right device boots and the Simulator GUI opens (useful when you want to visually confirm flows).

2.2 Install the App

Assume you have a .app or .ipa from your build:

APP_PATH="/path/to/YourApp.app"
xcrun simctl install "$SIM_UDID" "$APP_PATH"

Note:

• Integrate this with your CI artefacts so the latest build is always installed
• Apple supports App Store Connect API for uploading previews later, but capture/creation happens here

2.3 Launch the App

Get your bundle identifier (e.g. com.yourcompany.YourApp) and run:

BUNDLE_ID="com.yourcompany.YourApp"
xcrun simctl launch "$SIM_UDID" "$BUNDLE_ID"

Now your app is running on the simulator without manual clicks.

Step 3: Automate Navigation with simctl UI Events

You can script basic flows using simulated taps, text, and system events.

simctl has evolved, but typical primitive commands look like:

• Press home button: xcrun simctl press "$SIM_UDID" home
• Simulate a tap (if supported in your version): xcrun simctl io "$SIM_UDID" touchscreen tap 120 400
• Type text into the current field: xcrun simctl io "$SIM_UDID" keyboard type "hello world"

Combine these into a script that reproduces your core user flow.

Example: login and reach a dashboard:

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

SIM_UDID="$SIM_UDID"
BUNDLE_ID="com.yourcompany.YourApp"

xcrun simctl boot "$SIM_UDID"
open -a Simulator --args -CurrentDeviceUDID "$SIM_UDID"
xcrun simctl install "$SIM_UDID" /path/to/YourApp.app
xcrun simctl launch "$SIM_UDID" "$BUNDLE_ID"

sleep 5 # wait for launch

# tap on email field
xcrun simctl io "$SIM_UDID" touchscreen tap 100 200
xcrun simctl io "$SIM_UDID" keyboard type "demo@example.com"

# tap on password field
xcrun simctl io "$SIM_UDID" touchscreen tap 100 260
xcrun simctl io "$SIM_UDID" keyboard type "password123"

# tap login button
xcrun simctl io "$SIM_UDID" touchscreen tap 180 320

sleep 8 # wait for dashboard

This script is your reproducible navigation blueprint. Once it’s stable, wire recording around it.

Step 4: Record Simulator Video from the Command Line

Apple documents direct video recording via simctl.

The canonical pattern:

OUTPUT_PATH="/tmp/demo.mp4"
xcrun simctl io "$SIM_UDID" recordVideo "$OUTPUT_PATH"

Run this while your script navigates the app. When you Ctrl+C the command, recording stops.

4.1 Wrap Recording Around Your Flow Script

Create a wrapper script like record_flow.sh:

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

SIM_UDID="$SIM_UDID"
OUTPUT_PATH="/tmp/demo_$(date +%s).mp4"

# Start recording in the background
xcrun simctl io "$SIM_UDID" recordVideo "$OUTPUT_PATH" &
REC_PID=$!

# Run your navigation script
./run_flow.sh || true

# Stop recording
echo "Stopping recording..."
kill -INT "$REC_PID" || true

echo "Saved recording to $OUTPUT_PATH"

This gives you a repeatable demo clip for every run of run_flow.sh.

Use H.264-compatible outputs for App Store preview upload; if needed, transcode with ffmpeg.

Step 5: Integrate with CI to Auto-Generate Demo Reels per Build

Once you can generate a demo clip via CLI, it’s straightforward to wire into CI.

5.1 High-Level Flow

A typical pipeline:

1. Build app as usual in CI
2. Export .app or .ipa artefact to the CI host
3. Run headless simulator on a macOS runner using simctl
4. Execute your navigation + recording scripts
5. Store the video artefact (e.g. upload to your artifacts, S3, or hand to Reely)

This satisfies queries like:

• “CI tool create app demo video after successful build”
• “tool auto generate app demo reels after build”

5.2 Example: GitHub Actions Skeleton

At a high level (pseudo-YAML):

jobs:
build-and-record:
runs-on: macos-latest
steps:
- uses: actions/checkout@v4

- name: Build app
run: |
xcodebuild \
-scheme YourScheme \
-configuration Release \
-derivedDataPath build

- name: Install and record
run: |
export SIM_UDID=$(xcrun simctl list devices | grep 'iPhone 15' | head -n1 | awk -F '[()]' '{print $2}')
./record_flow.sh

- name: Upload demo
uses: actions/upload-artifact@v4
with:
name: ios-demo-video
path: /tmp/demo_*.mp4

This turns every successful build into a self-hosted automated app demo video artefact.

From here, an AI agent or MCP tool like Reely’s can:

• Pull the latest clip
• Auto-cut dead air
• Arrange footage into feature teasers or full launch promos

Step 6: Where ios-sim Fits (and Why It’s Mostly Legacy)

The tutorial so far leaned on simctl. What about ios-sim?

• ios-sim (npm package) was popular when Xcode’s CLI capabilities were limited
• Current npm data shows version 9.0.0, last published ~6 years ago, and only 32 dependents
• Modern Apple docs emphasize simctl, Device Hub, and Xcode components instead

If you already have scripts that use ios-sim, you can:

• Gradually port them to simctl, or
• Wrap them alongside simctl recording commands

For new automation work, treat ios-sim as a conceptual ancestor rather than your primary tool.

Step 7: Feeding Your Clips into Reely for Launch-Ready Videos

Once you have repeatable simulator recordings, you still need story, pacing, and polish.

That’s where Reely slots in.

7.1 From Build Artefacts to Launch Reel

A typical agent-driven flow:

1. CI completes and produces:
   • A build artefact (your app)
   • A simulator demo recording (.mp4)
2. Your AI coding agent (plugged into Reely’s MCP tool) can:
   • Reconstruct flows directly in the iOS Simulator
   • Capture additional angles or shorter sequences as needed
3. Reely ingests:
   • Your recordings
   • Optional screenshots or even feature specs in plain English
4. Reely’s macOS app:
   • Auto-cuts dead air
   • Applies kinetic typography and device choreography presets
   • Syncs music and sound cues to your beats
   • Generates feature teasers (10–20s) or full launch promos (30–60s)

Because Reely runs locally, nothing leaves your Mac. This fits privacy-sensitive teams and indie devs who prefer no-cloud workflows.

Putting It All Together: From Code to Demo Reel

Here’s the end-to-end picture:

• Code: you ship a new feature
• Build: CI compiles and produces an .app
• Automation: simctl scripts boot the simulator, navigate, and record
• Artefact: every build stores a fresh demo clip
• Motion: Reely (or similar) turns that clip into a polished, on-brand launch video

If you want a deeper dive into how an AI agent can orchestrate this entire chain, revisit the companion piece “Can an AI Agent Make Your App Demo Video?”.

FAQ: Automating iOS Simulator Recordings on Mac

How long should my iOS App Store preview be?

Apple’s rules:

• 15–30 seconds duration
• 500MB maximum file size
• 30 fps maximum
• H.264 or ProRes 422 (HQ) codecs
• Up to 3 previews per language

Design your automated flows to hit tight, focused stories within those limits.

Can I record directly from the iOS Simulator without CLI tools?

Yes.

Apple’s Device Hub lets you:

• Select a simulated device
• Record video from within Xcode’s UI
• Save the file (usually to your Desktop)

CLI automation via simctl is still preferred if you want reproducible clips per build.

Is ios-sim still worth using?

ios-sim works, but it’s legacy:

• No recent releases in years
• Very small dependent ecosystem
• Apple now documents simctl as the primary interface

For new workflows, adopt simctl and use ios-sim only if you’re tied to old scripts.

Can I run these simulator recordings in headless CI?

Yes, if you have macOS runners.

You can:

• Boot simulators with xcrun simctl boot
• Launch apps and run navigation scripts
• Record video with simctl io ... recordVideo
• Store .mp4 files as build artefacts

This is how you build a CI tool that creates app demo video after successful build.

How does Reely fit with this CLI workflow?

Reely sits on top of your CLI automation:

• Your build pipeline produces consistent demo footage
• Reely’s macOS editor plus agent/MCP tool turns that footage into:
  • App Store previews
  • Product Hunt launch clips
  • Social-ready reels in multiple aspect ratios

Think of it as: simulator automation handles capture; Reely handles storytelling and polish.

If you’re a builder who ships faster than you can market, this combination—simctl automation + Reely—lets your app and your agent handle both code and promo. Your agent built the app. Let it build the demo reel too.