Self‑hosted demo video generators: how to build an agent‑first Linux stack

Indie devs can build a self‑hosted demo video generator on Linux by treating the agent as the director and a chain of deterministic tools as the crew…

Overhead view of hexagonal washers clustered on the left, symbolizing modular self-hosted demo video tools.

Indie devs can build a self‑hosted demo video generator on Linux by treating the agent as the director and a chain of deterministic tools as the crew: ffmpeg/wf-recorder or scrcpy for capture, Playwright for scripted flows, OBS + WebSocket/CLI for scene control, and local AI models for planning, captions, and cuts. This stack produces clean app footage that an app launch video generator like Reely—or similar tools—can ingest when you want more control over infrastructure and privacy.

In this guide, we’ll walk through how to design an agent‑first video workflow on Linux, using open tooling to generate launch‑ready footage while keeping everything self‑hosted.

Why a self‑hosted demo video generator stack on Linux?

Most indie teams want three things from a demo video workflow:

  • Privacy: no production builds or internal dashboards leaking into random clouds.
  • Automation: videos generate from code, tests, and agents—not from screen‑recording marathons.
  • Launch‑ready outputs: short, paced reels for App Store, Product Hunt, and social.

A self‑hosted Linux stack gives you:

  • Deterministic capture of your app flows via CLI tools.
  • Agent‑driven orchestration, where your AI agent scripts the whole process.
  • Local AI processing, using tools like Ollama and whisper.cpp.

Instead of “AI invents the entire video,” the agent:

  1. Plans shots and flows.
  2. Launches emulators / browsers.
  3. Records real app footage.
  4. Assembles cuts, captions, and exports.

That footage can then be pulled into a launch‑specific generator like Reely when you want studio‑level motion design.

Self‑hosted open source demo video generator: core building blocks

A practical self‑hosted open source demo video generator stack on Linux is built from four layers:

  1. Capture layer (what records the screen or device)
  2. Orchestration layer (your agent and scripts)
  3. Post‑processing layer (cuts, captions, audio)
  4. Launch packaging (App Store previews, promos, teasers)

1) Capture layer: ffmpeg, wf-recorder, scrcpy, and OBS

Use purpose‑built tools depending on what you’re demoing.

Desktop / Simulator (X11)

  • ffmpeg with x11grab is still the workhorse for X11 capture.
  • Example:

ffmpeg \
-f x11grab -framerate 60 -video_size 1920x1080 -i :0.0+0,0 \
-f pulse -i default \
-codec:v libx264 -preset veryfast -crf 18 \
output-demo-x11.mp4

This gives you deterministic, scriptable recording you can call from any agent.

Desktop / Simulator (Wayland)

  • wf-recorder is a Wayland‑friendly screen recorder built around ffmpeg.
  • It supports custom geometry, codecs, and audio capture.

wf-recorder -f output-demo-wayland.mkv -g 1920x1080@60 -a

PipeWire under the hood keeps audio/video low‑latency and sandbox‑friendly.

Android devices and emulators

  • scrcpy excels at Android screen recording on Linux.
  • It supports --record, --no-audio, and --time-limit, writing timestamped files.

scrcpy --record android-feature-demo.mp4 --time-limit 00:00:30

Combine this with the android CLI (for emulator create/list/start/stop) to launch emulators from scripts.

Scene‑driven recordings with OBS

  • OBS has built‑in WebSocket control since v28.
  • obs-cmd (or any OBS CLI) lets your agent:
    • Start/stop recordings
    • Switch scenes
    • Save replay buffers

This is crucial if you want more cinematic demos: framing, device frames, and overlays without manual clicking.

2) Orchestration layer: agent‑first video generation tools (2026)

The key to an agent‑first video generation tool is that the agent orchestrates everything. On Linux, you can:

  • Run an AI coding agent that:
    • Parses feature specs or PR descriptions.
    • Plans a demo flow as a sequence of actions.
    • Uses CLIs to launch emulators, run tests, and trigger capture.

Typical orchestration workflow:

  1. Plan: Agent reads a feature spec (FEATURE.md) and writes a shot list.
  2. Setup: Agent compiles the app, launches emulator or browser.
  3. Drive: Agent executes a Playwright or UI test suite for the flow.
  4. Record: Agent launches ffmpeg, wf-recorder, scrcpy, or OBS.
  5. Trim: Agent calls ffmpeg again to cut dead air.
  6. Annotate: Agent generates captions and overlay copy locally.

Instead of a desktop UI, you have a headless, scriptable demo video generator.

Screen recording app demo automation with Playwright

If your product has a web or web‑view surface, screen recording app demo automation with Playwright is a natural fit.

Playwright’s video recording features let you:

  • Record per‑test videos.
  • Save them when a browser context closes.
  • Attach video file paths to test metadata.

Example Playwright config snippet:

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

export default defineConfig({
use: {
video: {
mode: 'on',
size: { width: 1280, height: 720 },
},
},
});

Your agent can:

  • Generate Playwright tests from a story like “signup → enable notifications → complete onboarding.”
  • Run them after a successful build.
  • Collect the .webm or .mp4 files from Playwright’s output folder.

These deterministic captures become one of the inputs to your self‑hosted open source demo video generator pipeline.

Automated app demo video generator from code: CI‑driven flows

A fully automated app demo reel auto generate after build workflow treats CI as the trigger.

CI tool create app demo video after successful build

Pipeline outline:

  1. Build stage
    • Compile your app.
    • Run tests.
  2. Demo stage (agent‑driven)
    • Start emulator / simulator.
    • Run UI tests or Playwright flows.
    • Launch screen capture via ffmpeg, wf-recorder, scrcpy, or OBS.
  3. Post‑process stage
    • Trim recordings to 10–60 seconds.
    • Auto‑generate subtitles and overlays locally.
    • Export a master .mp4 at the right aspect ratio.
  4. Artifacts stage
    • Store the rendered demo video as a CI artifact.
    • Optionally, post links in Slack or open a PR comment.

This is the concrete version of a CI tool create app demo video after successful build. Your agent writes the scripts; CI just runs them.

AI video creator offline: local models for privacy and control

A AI video creator offline local processing code mindset keeps everything on your machine. Instead of sending code or footage to a cloud service, you use local runtimes:

  • Ollama for local LLMs:
    • Plan shot lists
    • Draft scripts and captions
    • Generate short launch copy
  • whisper.cpp for local ASR (speech‑to‑text):
    • Transcribe voiceover
    • Generate subtitles and SRTs

Wistia’s 2025 State of Video Report shows this approach is mainstream:

  • 41% of professionals were using AI to create videos, up from 18% the year before.
  • Another 19% planned to start soon.
  • Scripting and editing were the top AI uses.

That aligns with a workflow where AI handles planning and editing, not synthetic footage.

Secure AI app demo generators: self‑hosted, privacy‑first design

For many teams, the priority search is secure AI app demo generators no code leak. Self‑hosting your stack on Linux gives you that:

  • No cloud uploads for builds, recordings, or source.
  • Local‑only models via Ollama and whisper.cpp.
  • Controlled surfaces: only CI artifacts or a dedicated asset bucket ever see the output.

Best practices:

  • Run capture tools (ffmpeg, scrcpy, OBS) on machines that hold your builds anyway.
  • Store demo footage in the same encrypted storage as your build artifacts.
  • Treat your agent scripts as part of your infra‑as‑code repo.

When you’re ready for launch‑grade motion design, you can still feed these locally generated assets into a dedicated app launch video tool.

App preview video generator from simulator recordings

For iOS and mobile, app preview video generator simulator recordings are particularly important because Apple is strict.

Apple’s App Preview specs (as of 2025+):

  • Up to 3 previews per language.
  • Each 15–30 seconds long.
  • Max 500 MB file size.
  • Accepted formats:
    • H.264 in .mov, .m4v, .mp4.
    • ProRes 422 HQ in .mov.
  • Previews are device‑specific and appear before screenshots.

Your Linux stack can’t directly access the iOS Simulator, but it can:

  • Recreate flows on cross‑platform components or web UIs via Playwright.
  • Generate scripts, captions, and pacing from these rehearsals.
  • Maintain reproducible storyboards and beats.

Those storyboards and scripts then become inputs when you or your teammate uses a Mac‑based tool like Reely to:

  • Drive the actual iOS Simulator.
  • Capture Apple‑compliant footage locally.
  • Apply brand‑theme‑from‑app visuals, kinetic typography, and device choreography.

This hybrid approach keeps your agent‑first workflow and Linux‑native automation, while still hitting App Store constraints.

Self‑hosted demo video tools for indie developers: a reference stack

Let’s put it all together into a concrete stack tailored to indie and small teams.

1. Capture stack (Linux)

For a self‑hosted open source demo video generator privacy setup, a common combination is:

  • **Desktop / web:
    • ffmpeg with x11grab (X11)
    • wf-recorder (Wayland)
  • **Android:
    • scrcpy for screen + optional audio
  • **Multi‑scene / overlays:
    • OBS + obs-websocket + obs-cmd CLI

These are all scriptable and run fully on your infra.

2. Automation stack

  • Agent runtime of your choice (e.g. a local LLM or MCP‑compatible agent).
  • Playwright for scripted browser flows and built‑in per‑test video recording.
  • Android CLI + scrcpy for mobile flows.
  • Shell scripts or Python orchestrators that:
    • Start capture tools
    • Run flows
    • Stop capture
    • Move files into a structured directory

3. Local AI stack

  • Ollama for storyboarding and copy:
    • Shot lists
    • On‑screen text
    • Short launch blurbs
  • whisper.cpp for transcriptions:
    • Voiceover transcripts
    • Subtitles
  • Optional: local video tools that help with automated cut detection.

4. Launch packaging and motion design

Here’s where a purpose‑built app launch generator enters.

Once your Linux stack has produced constant‑quality footage and metadata, you can:

  • Export 10–20s feature teasers.
  • Assemble 30–60s full launch promos.
  • Match multiple aspect ratios and 4K masters.
  • Add kinetic typography, device choreography, and sound cues.

A tool like Reely is designed specifically around this “promo from code in minutes” story. Its macOS app keeps recording and rendering local, with launch‑oriented pacing and automatic dead‑air removal, while its agent/MCP integration mirrors the same agent‑first philosophy you’re using on Linux. For a deeper survey of specialized tools in this space, see this related guide: descriptive anchor text.

How Reely fits into a self‑hosted Linux workflow

Even if your dev machines and CI run on Linux, a Mac often enters the picture for iOS footage and final motion polish. You can still keep your automated app demo video generator from code privacy self hosted SDK mindset.

A practical hybrid workflow:

  1. On Linux (CI/agent)
    • Build & test
    • Generate Playwright or Android demo recordings
    • Plan shot lists and copy with local AI
  2. Sync outputs to a Mac
    • CI uploads into a private artifact store.
    • Mac pulls the latest demo bundle when ready.
  3. On macOS with Reely
    • Agent reconstructs flows in the iOS Simulator.
    • Reely records, removes dead air, and applies motion systems.
    • You export App Store‑ready previews and launch promos.

Throughout, your privacy constraints remain intact:

  • No code or footage is uploaded to third‑party clouds.
  • All recorder and model runtimes stay on machines you control.
  • The agent stays the single source of truth for both build and reel.

If you want to experiment with this kind of agent‑native, local‑first motion workflow, you can try the macOS app and MCP integration at getreely.co.

FAQ: self‑hosted demo video generators on Linux

How do I record my desktop on Linux for app demos without leaking data?

Use ffmpeg with x11grab on X11 or wf-recorder on Wayland. Both run locally, and you can restrict capture to a single window or region. Store outputs in the same secure storage as your build artifacts.

Can I generate a demo video automatically after each CI build?

Yes. Add a demo stage in your CI pipeline that:

  • Launches an emulator or browser.
  • Runs scripted UI flows (Playwright, UI tests).
  • Starts and stops a screen recorder (ffmpeg, wf-recorder, scrcpy, OBS).
  • Saves the resulting video as a CI artifact.

Your agent can generate the scripts and orchestrate the sequence.

Is it possible to keep all AI processing offline?

Yes. Use Ollama for local LLMs (planning, scripting, captions) and whisper.cpp for local transcription. Combine them with command‑line tools for cutting and muxing, and you have a full AI video generator that runs locally on your computer.

How do I record Android demos on Linux with privacy in mind?

Use scrcpy for Android recording. It supports --record and --time-limit, and writes local files without cloud dependencies. Pair it with the Android CLI to automate emulator lifecycle from your agent.

Can I use Reely if my main stack is Linux?

Yes, via a hybrid approach. Run builds, tests, and planning on Linux, then sync footage and shot lists to a Mac where Reely runs locally, drives the iOS Simulator, and generates polished launch videos from your agent’s plan.

A self‑hosted Linux stack doesn’t mean giving up on agent‑first launch workflows—it means owning the infrastructure that your agent directs. Use open capture tools, CI automation, and local AI to produce deterministic app footage, then plug those assets into specialized launch tools when you want studio‑quality reels without sacrificing privacy.

← All posts