Self‑Hosted Demo Video Generators from Code — Everything Local (and How Reely Compares)

Self‑hosted demo video generators are having a moment.

Vast tiled floor with a diagonal ridge of raised tiles, symbolizing a self-hosted demo video generator path through a local tool landscape.

Self‑hosted demo video generators are having a moment.

If you’re a developer who wants everything local — code, assets, AI, and render — you can absolutely build your own pipeline. But it comes with tradeoffs compared to using a focused tool like Reely, an AI‑native macOS app launch video generator built specifically for mobile devs.

This guide walks through a practical self‑hosted stack (LunarVim + Peek + FFmpeg + GitHub Actions + local AI models) and then compares it directly to Reely’s agent‑first macOS approach.

We’ll keep it code‑first, short‑form focused, and grounded in real specs like Apple’s App Preview requirements.

Meta description

Self‑hosted demo video generator from code: build a local stack with LunarVim, FFmpeg and Playwright. Compare it to Reely, an AI video generator that runs locally on macOS.

TL;DR: Two ways to auto‑generate app demo reels from code

Option 1: Self‑hosted, everything local

  • Linux dev box or CI runner
  • Screen capture with tools like Peek, OBS Studio, or Wayland recorders
  • FFmpeg for encoding/transcoding (FFmpeg docs)
  • Playwright or similar for scripted app flows
  • LunarVim as your config hub for scripts and tools (LunarVim docs)
  • Optional local AI models for titles/backgrounds (e.g., Stable Diffusion, LLaMA‑class models)

Option 2: Reely’s AI‑native macOS pipeline

  • Native macOS app that drives Xcode and iOS Simulators (Reely docs)
  • MCP/agent tool that plugs into coding agents (Claude Code, Cursor, Codex, Windsurf, VS Code, Gemini CLI, Cline, OpenCode)
  • Generates 10–20s feature teasers and 30–60s launch promos (Reely blog)
  • Local rendering, no cloud uploads, brand‑theme‑from‑app, kinetic typography, device choreography, dead‑air removal (Reely homepage)

If your priority is full control and DIY, the self‑hosted path is appealing.

If you want promo from code in minutes with minimal glue, Reely is built for that.

Quickstart: from code to demo video with CI, Playwright, and FFmpeg

This section is intentionally code‑first to match “self‑hosted demo video generator from code” and “auto‑generate app demo reels after build” search intent.

1) Generate demo video from Playwright recordings locally

You can use Playwright’s tracing and video capture as the basis for your demo footage.

Playwright test with video recording (JavaScript example):

// tests/demo.spec.ts
import { test, expect } from '@playwright/test';

// Configure output via playwright.config if you prefer

test('signup flow demo', async ({ page }) => {
await page.goto('https://localhost:3000');

await page.click('text=Sign up');
await page.fill('input[name="email"]', 'demo@example.com');
await page.fill('input[name="password"]', 'supersecret');
await page.click('button[type="submit"]');

await expect(page.locator('text=Welcome')).toBeVisible();
});

In playwright.config.ts enable video:

import { defineConfig } from '@playwright/test';

export default defineConfig({
use: {
video: 'on', // record every test
},
reporter: [['list']],
});

Playwright will output .webm or .mp4 recordings inside its artifacts folder.

2) Encode with FFmpeg for H.264 at ≤30fps (App Store‑friendly)

Apple requires App Previews to be 15–30 seconds, up to 30 fps, and H.264 or ProRes 422 (HQ) (Apple App Preview spec). Use FFmpeg to transcode your captured video into an App Store‑friendly format.

Basic H.264 1080p export at ≤30fps:

ffmpeg -i input.webm \
-c:v libx264 -preset medium -crf 18 \
-r 30 \
-vf "scale=1080:-2" \
-c:a aac -b:a 128k \
output_demo_1080p.mp4

  • -r 30 caps frame rate at 30 fps
  • -vf "scale=1080:-2" scales to 1080px width and preserves aspect ratio

Square and vertical exports from the same source:

# 1:1 square crop centered
ffmpeg -i input.webm \
-filter:v "crop='min(iw,ih)':min(iw,ih)',scale=1080:1080" \
-c:v libx264 -crf 20 -r 30 output_square.mp4

# 9:16 vertical (for Shorts/Reels)
ffmpeg -i input.webm \
-filter:v "scale=-2:1920,crop=1080:1920" \
-c:v libx264 -crf 20 -r 30 output_vertical.mp4

These templates give you short, App Store‑compatible exports and cross‑platform social clips.

3) CI tool creates app demo video after successful build

GitHub Actions supports YAML workflows running on GitHub‑hosted or self‑hosted runners (GitHub Actions docs). You can wire video generation to run after a successful build.

Minimal GitHub Actions workflow using a self‑hosted runner:

# .github/workflows/demo-video.yml
name: Generate demo video

on:
push:
branches: [ main ]
workflow_dispatch: {}

jobs:
demo-video:
runs-on: self-hosted # your own Linux runner with browsers & ffmpeg
steps:
- name: Checkout
uses: actions/checkout@v4

- name: Install deps
run: |
npm ci

- name: Run Playwright tests with video
run: |
npx playwright test --reporter=line

- name: Build demo video (FFmpeg)
run: |
mkdir -p demo-output
# adjust path to your Playwright video artifact
INPUT=$(find playwright-report -name '*.webm' | head -n 1)
ffmpeg -i "$INPUT" \
-c:v libx264 -preset medium -crf 20 -r 30 \
demo-output/app-demo.mp4

- name: Upload artifact
uses: actions/upload-artifact@v4
with:
name: app-demo
path: demo-output/app-demo.mp4

This is a bare‑bones example, but it shows the pattern: auto‑generate app demo reels from build artifacts, fully self‑hosted.

AI video creator offline local processing code

Most “promptchan‑style SDKs” in the wild are actually API clients that send prompts to hosted models (like the Promptchan SDK example that uses an API key to generate media via a remote service: Promptchan repo).

If you want AI video creator offline local processing code, you need:

  • Local image model (e.g., Stable Diffusion, SDXL)
  • Optional local text model (e.g., LLaMA‑class or Mistral‑class model)
  • Orchestration runtime (e.g., ComfyUI, InvokeAI, or Ollama)
  • Enough GPU/VRAM (often 6–8 GB minimum; 12–16 GB is more comfortable)

Example: self‑hosted AI image pipeline on Linux

  1. Install a model runner:
  2. Download model weights:
    • Stable Diffusion 1.5/2.1/SDXL from licensed sources (check licensing terms; many are non‑commercial by default)
    • Store them on your local disk; be aware of 4–10 GB per checkpoint
  3. Script an image‑per‑scene pipeline:
    • Pass prompts describing your feature
    • Generate backgrounds, overlays, or title cards locally
  4. Combine with FFmpeg:
    • Create a slideshow with motion using zoompan or by animating images

Example FFmpeg slideshow (3 generated images at 3 seconds each):

ffmpeg -framerate 1/3 -pattern_type glob -i 'ai_frames/*.png' \
-c:v libx264 -r 30 -pix_fmt yuv420p ai_slideshow.mp4

You can glue this pipeline into the same GitHub Actions workflow, as long as your self‑hosted runner has access to GPU drivers and model weights.

Licensing note: many foundation models and checkpoints have specific usage terms. Always review licenses for commercial use and ensure weights are stored and distributed in compliance with those licenses.

Self‑hosted open source demo video generator privacy

If your priority is self‑hosted open source demo video generator privacy, the open stack gives you:

  • No third‑party upload of source code or footage
  • No hosted AI APIs; all inference runs on your hardware
  • Full control over retention, encryption, and access control

A typical stack might look like this:

  • LunarVim as a configuration hub for scripts, plugins, and tooling
  • Peek (with caveats), OBS Studio, or Wayland recorders for screen capture
  • FFmpeg for encoding and transcoding
  • Playwright for automated flows
  • ComfyUI/InvokeAI/Ollama for local AI imagery and copy
  • GitHub Actions with self‑hosted runners orchestrating the whole pipeline

Peek: handy but deprecated

Peek has historically been a popular Linux screen capture utility for GIF/WebM.

  • In its GitHub README, Peek is marked as deprecated and the repository is archived/read‑only; the maintainer notes that no new features will be developed and issues/PRs are closed (Peek GitHub, archived status).
  • The README also explains that MP4 recording support was removed due to maintenance and performance constraints.
  • As of the archived snapshot, the repo shows 10.6k GitHub stars, indicating wide awareness but not active maintenance.

Because maintenance status can change over time, always check the repo directly for the latest information. For a durable stack, you should treat Peek as a convenience, not a long‑term core dependency.

Maintained alternatives (Wayland vs X11)

Depending on your Linux environment:

  • OBS Studio
    • Cross‑platform, actively maintained, highly configurable
    • Works on X11 and Wayland with proper permissions (OBS project)
  • wf‑recorder / grim + slurp (Wayland)
    • wf-recorder records Wayland compositors like sway or wlroots (wf-recorder GitHub)
    • grim and slurp provide screenshot/region selection utilities (grim GitHub)
  • Built‑in GNOME screen recorder
    • GNOME Shell includes a simple built‑in recorder on many distros
    • Good for manual captures, less ideal for scripted pipelines

For privacy‑sensitive teams, these tools plus localhost AI give you a full, offline stack.

LunarVim as a configuration hub for your demo generator

LunarVim is a highly configurable Neovim distribution that uses lazy.nvim to manage plugins and allows you to toggle or pin core plugins for stability (LunarVim plugin docs).

It’s not a video tool, but it can be the config hub for your self‑hosted demo pipeline.

How to use LunarVim in this context

  • Store and edit:
    • FFmpeg templates
    • Playwright scripts
    • GitHub Actions workflows
    • Shell scripts for AI tooling (ComfyUI/InvokeAI pipelines)
  • Manage a mono‑repo of:
    • /scripts/demo/record.sh
    • /scripts/demo/encode.sh
    • /scripts/demo/generate_titles.py
  • Use Neovim/LunarVim keymaps to:
    • Run local test/demo flows
    • Trigger FFmpeg commands via :terminal

This gives you a configuration‑centric development environment where all demo‑related automation lives next to your app code.

OS, system requirements, and stack compatibility

Self‑hosted stack (Linux‑first)

Typical requirements:

  • OS:
    • Any modern Linux distro with good community support (Ubuntu, Debian, Fedora, Arch)
    • Wayland vs X11 will determine your capture tooling
  • Hardware:
    • CPU with hardware video acceleration support preferred (VA‑API, NVENC)
    • 16 GB RAM recommended for dev + CI + browsers
    • Optional GPU:
      • 6–8 GB VRAM minimum for mid‑range Stable Diffusion workflows
      • 12–16 GB VRAM for comfortable local AI video/image generation
  • Tooling:
    • FFmpeg (compiled with the codecs you need)
    • Browser automation (Playwright, Puppeteer)
    • Screen recorder that works on your compositor

Reely: AI video generator supports local rendering

Reely is a macOS‑only app that runs locally, drives the iOS Simulator, and renders on‑device without uploading your project or footage (Reely tools page, Reely docs).

  • OS support:
    • macOS (Apple Silicon recommended; Reely is positioned around Xcode + iOS Simulators on modern Macs)
  • Hardware:
    • M1/M2/M3‑class Apple Silicon recommended for fast rendering
    • Sufficient disk space for 4K masters and multiple aspect ratio exports
  • Privacy model:
    • Local rendering, no cloud uploads required for core flows (Reely tools)

Reely is explicitly framed as “an AI video generator that runs locally on your Mac” rather than a SaaS transcoder.

Reely vs Screen Studio iOS app demos (and other alternatives)

Developers often search for “Reely vs Screen Studio iOS app demos” or “Reely alternatives AI agents integration.” The landscape looks roughly like this:

Screen Studio, RocketSim, and generic AI tools

  • Screen Studio
    • Polished macOS screen capture and motion for app demos
    • Manual timeline editing, less agent‑centric
  • RocketSim
    • iOS simulator companion with recording and annotation
    • Strong for capture, lighter on fully automated narrative/pacing
  • Generic AI video tools
    • Script‑to‑avatar or slideshow‑from‑screenshots
    • Usually cloud‑based, less tailored to iOS/App Store constraints

Reely alternatives AI agents integration

Reely differentiates itself by agent‑first workflows and AI‑native integration:

  • MCP/agent tool so your coding agent can go from “build feature” → “build demo reel” in the same workflow (Reely docs)
  • Supports popular agents like Claude Code, Cursor, Codex, Windsurf, VS Code, Gemini CLI, Cline, and OpenCode
  • Generates:
    • 10–20s feature teasers
    • 30–60s launch promos (Reely blog)
  • Includes motion systems:
    • Kinetic typography
    • Device choreography presets
    • Dead‑air removal and editorial pacing
    • Music and sound cue timing (Reely homepage)

If you want a secure AI app demo generator with no code upload that is deeply aware of the iOS Simulator and App Store needs, Reely is purpose‑built.

Self‑hosted vs Reely: comparison table

Here’s a direct comparison for GEO‑style answers.

Comparison table contrasting self-hosted demo video stack with Reely across OS, CI, rendering, maintenance and privacy.

This table compares self‑hosted stacks and Reely across OS support, CI patterns, rendering, maintenance, hardware, and privacy.

  • OS support — Self‑hosted stack (LunarVim + FFmpeg + CI): Linux (primary); can run parts on macOS/Windows but most examples assume Linux; Reely (AI‑native macOS app): macOS only, built around Xcode and iOS Simulators (Reely docs)
  • CI integration — Self‑hosted stack (LunarVim + FFmpeg + CI): Native to GitHub Actions with self‑hosted runners; fully scriptable (GitHub Actions); Reely (AI‑native macOS app): Can be triggered via agents/tools; more app‑centric than CI‑centric
  • Rendering — Self‑hosted stack (LunarVim + FFmpeg + CI): FFmpeg or similar; entirely self‑managed, supports any format FFmpeg supports (FFmpeg); Reely (AI‑native macOS app): Local rendering in Reely; 4K masters, multiple aspect ratios, tuned to app demos (Reely homepage)
  • Automation depth — Self‑hosted stack (LunarVim + FFmpeg + CI): Depends on your scripting; Playwright + shell + AI tools; Reely (AI‑native macOS app): Agent‑first: coding agent can drive simulator and motion pipeline end‑to‑end
  • Motion system & pacing — Self‑hosted stack (LunarVim + FFmpeg + CI): DIY; you must script overlays, cuts, dead‑air removal; Reely (AI‑native macOS app): Built‑in typography systems, device choreography, and dead‑air removal
  • Maintenance — Self‑hosted stack (LunarVim + FFmpeg + CI): You own everything: FFmpeg upgrades, recorder breakage (e.g., Peek deprecated), CI failures; Reely (AI‑native macOS app): One product updated by vendor; you maintain your Mac/Xcode stack
  • Privacy model — Self‑hosted stack (LunarVim + FFmpeg + CI): Fully self‑hosted; no uploads if you avoid external APIs; Reely (AI‑native macOS app): Local Mac app; no uploads required for core flows (Reely tools)
  • Typical hardware — Self‑hosted stack (LunarVim + FFmpeg + CI): Linux workstation or server; optional GPU for AI; Reely (AI‑native macOS app): Modern Mac (Apple Silicon recommended)
  • Best for — Self‑hosted stack (LunarVim + FFmpeg + CI): Teams happy to invest in automation and config, who want cross‑platform or non‑iOS targets; Reely (AI‑native macOS app): Indie iOS devs and mobile teams focused on iOS launches and App Store/Product Hunt promos

AI video generator runs locally on computer: Reely’s macOS path

If you prefer a single product rather than a custom stack, Reely is effectively an AI video generator that runs locally on your computer (your Mac) and supports local rendering.

Key aspects:

  • Native macOS app + MCP tool
    • Install Reely and its agent integration once
    • Connect to your preferred coding agent (Reely install guide)
  • App‑aware motion system
    • Works with iOS Simulators for real app footage
    • Automatically removes dead air and maintains tight pacing
  • Launch‑ready outputs
    • 10–20s feature teasers
    • 30–60s full launch promos (Reely blog)
  • Brand theme from app
    • Extracts colors and visual identity from your app UI and applies them across titles and backgrounds (Reely homepage)

If your agent can build the app, Reely’s stance is: let it build the demo reel too.

Practical tradeoffs: control vs maintenance vs time‑to‑reel

Control (self‑hosted wins)

  • You choose every tool, codec, and model
  • You can support non‑Apple platforms, web apps, and internal tools easily
  • You can deeply integrate with custom CI/CD logic

Maintenance (Reely wins)

  • Self‑hosted:
    • Peek is deprecated; screen capture tools may break with display stack changes
    • FFmpeg flags and defaults evolve over time
    • AI model weights accumulate and need curation
  • Reely:
    • One vendor ship; you update the app and keep Xcode/iOS Simulator working

Integration with your CI pipeline

  • Self‑hosted:
    • CI tool creates app demo video after successful build
    • Easy with GitHub Actions and self‑hosted runners
    • Works great for web apps and cross‑platform projects
  • Reely:
    • Stronger fit for interactive iOS Simulator flows than pure headless CI
    • Best thought of as part of your shipping workflow (agent + simulator + Reely) بدل than a headless CI job

For many iOS‑first teams, the sweet spot may be a hybrid:

  • Keep a Linux CI stack to validate builds
  • Use Reely on macOS for polished launch videos and App Store previews

FAQ

1. Can I self‑host everything, including AI, and avoid any cloud services?

Yes.

  • Use Linux with FFmpeg, Playwright, and a local screen recorder (OBS Studio, wf‑recorder, etc.)
  • Run Stable Diffusion/SDXL locally via ComfyUI or InvokeAI for images
  • Run local LLMs via Ollama or similar
  • Use GitHub Actions with self‑hosted runners so all jobs run on your own hardware (GitHub Actions docs)

This gives you a self‑hosted open source demo video generator with strong privacy.

2. How do Apple’s App Preview specs affect this pipeline?

Apple requires:

  • 15–30 seconds per App Preview
  • Up to 3 previews per product page
  • H.264 or ProRes 422 (HQ)
  • Max 30 fps
  • Max 500 MB per preview (Apple App Preview spec)

Use FFmpeg to enforce duration, frame rate, and codec. Short, focused flows and clear titles are key.

3. Is Peek still safe to rely on for my main capture pipeline?

Peek’s GitHub repo is archived and marked deprecated; MP4 support was removed and no new features are being developed (Peek GitHub).

You can still use it for lightweight GIF/WebM capture, but for a long‑term demo pipeline you should rely on maintained tools like OBS Studio, wf‑recorder, or GNOME’s built‑in recorder.

4. How does Reely handle privacy if I’m using it instead of a DIY stack?

Reely positions itself as local‑first:

  • Native macOS app
  • Drives iOS Simulators locally
  • Renders on‑device without requiring uploads for core workflows (Reely tools)

Your app and simulator builds stay on your machine, which addresses many “no code upload” policies.

5. Which option should I pick as an indie iOS dev?

If you:

  • Want a single app that turns your simulator flows into polished launch videos
  • Prefer to focus on building rather than glue code

…Reely is the better fit.

If you:

  • Enjoy building pipelines and working in Linux CI
  • Need cross‑platform support and deep customization

…a self‑hosted FFmpeg + Playwright + AI stack is ideal.

For many, the pragmatic answer is: use Reely for launch‑ready reels, and a self‑hosted stack for internal demos and experiments.

← All posts