Short Video Factory: an Electron desktop app that turns a prompt and clip footage into batch-rendered short videos

What Short Video Factory actually automates

The repository describes the project as a desktop application that simplifies short video production through AI: the user supplies a prompt plus video storyboard footage, and the app cuts product marketing or general content clips automatically. That framing matters, because it is not a text-to-video model. Nothing here synthesizes footage from a prompt. The prompt produces a script; your own clips supply the pixels.

The intended user is someone who already has raw material and needs throughput. The README lists batch processing as a first-class feature: one batch task keeps composing videos according to a preset. That is a different job from editing a single video well. If you make one carefully crafted clip a week, the automation buys you little. If you make fifty variations of the same product spot, the preset-driven loop is the whole point.

The README also states the app runs fully locally, and package.json backs part of that claim: the render path pulls in ffmpeg-static, better-sqlite3, and pixi.js, all of which run on the machine rather than in a hosted service. The one clear exception is speech synthesis, which is built on EdgeTTS, and script generation, which the roadmap says is compatible with the generic OpenAI interface format. Both of those are network calls to services you configure.

The pipeline: prompt to script to speech to a composed video

The chain is visible in the dependency list and the roadmap. Script generation runs through the Vercel AI SDK with the OpenAI provider (@ai-sdk/openai and ai in devDependencies), so any endpoint speaking the OpenAI chat format can serve it. Speech synthesis uses EdgeTTS, credited in the acknowledgements to rany2/edge-tts and duyquangnvx/edge-tts. Composition then merges script, video, audio, and subtitles, with automatic mixed cutting, per the roadmap entry for video editing.

Subtitle handling is not hand-rolled. The project depends on the subtitle package at 4.2.2-alpha.0, and the roadmap still lists richer subtitle effects as an unchecked item, which tells you the current subtitle support is functional rather than a styling system. The alpha version pin is worth noticing: it is a pre-release dependency sitting in the render path.

State and UI are conventional Electron plus Vue: pinia with pinia-plugin-persistedstate for the store, i18next with a filesystem backend for the locales directory, pixi.js for canvas work, and better-sqlite3 for local persistence. The entry point is dist-electron/main.js, with the Electron main process in electron/ and the renderer in src/. The native/ directory and a post-install script (build/scripts/post-install.js) suggest platform-specific binaries are fetched or patched at install time, which is the usual reason an Electron video tool needs a custom postinstall step.

Installing Short Video Factory and running a first batch

The README points users to GitHub Releases for the latest build and to the official documentation site for the manual. There is no published package-manager install path, so the download is the supported route. The current release is v1.2.2, published 2026-04-07, following v1.2.1 on 2026-03-12 and v1.2.0 on 2026-01-22.

From the repository root, the package manifest defines the install and build scripts. The preinstall script runs npx only-allow pnpm, so npm or yarn will fail at that gate:

pnpm install
pnpm build

pnpm build chains vue-tsc, a Vite build, and electron-builder, which means a full build produces the desktop installer rather than a browser bundle. For development, pnpm dev starts the Vite dev server with the Electron shell:

pnpm dev

The README states Windows, macOS, and Linux are supported, and the repository carries a native/ directory plus a lipo-ffmpeg script, which is the macOS universal-binary step.

Once the app is open, the first real task is a batch job: provide the prompt text, point the app at your storyboard clips, choose a voice, and let the preset drive repeated composition. The README does not document the exact field names for that configuration, so treat the in-app UI and the official manual as the source of truth rather than guessing at config keys.

Where the automation gives up control

The honest limitation is the same one every template-driven editor has: you trade cut-level control for volume. The README describes automatic mixed cutting, and the roadmap leaves more comprehensive parameter adjustment unchecked. Until that lands, the knobs for fine-tuning a render are thinner than what a manual editor offers, and the subtitle effects item is also unchecked. If your output depends on a specific rhythm, a precise beat cut, or branded subtitle styling, the preset will approximate it rather than execute it.

A second constraint is the alpha subtitle dependency. Pinning subtitle at 4.2.2-alpha.0 in the main dependency set means subtitle behaviour can shift when that package changes, and the project has no control over its release schedule.

A third is the network boundary. The README says the app runs fully locally, and the render does, but script generation needs an OpenAI-compatible endpoint and speech synthesis goes through EdgeTTS. If your environment blocks outbound calls, or your scripts cannot leave the machine, the two features that make this more than a template renderer are the two that stop working. The README does not document an offline fallback for either.

How it differs from Gyoridavid/short-video-maker and headless pipelines

People searching for this project often arrive from Gyoridavid/short-video-maker, and the two take opposite architectural bets. Short Video Factory is a packaged Electron desktop application: you install a binary, click through a UI, and your machine does the ffmpeg work. The alternative pattern in that space is a server-side or headless pipeline where you drive generation through an API or a job queue and the rendering happens somewhere you control programmatically.

The practical difference shows up in three places. Deployment: a desktop app needs no container or host, but it also cannot be scheduled from CI. State: this project persists locally through better-sqlite3, so your job history lives on one machine rather than in a shared database. Extensibility: a headless tool exposes its stages as callable steps, while here the stages are wired into the Electron main process and the Vue UI, so repurposing the script generator alone means working inside the app's structure.

Neither approach is better in the abstract. If you want a batch of clips rendered tonight without standing up infrastructure, the desktop route is shorter. If you want rendering to be a step in an automated content system, the headless route fits that shape better.

Maintenance, releases, and the AGPL-3.0 question

The repository is not archived, and the last push was on 2026-09-03, which is recent relative to the release cadence. The release history shows a steady but not fast rhythm: three releases across the first four months of 2026, with v1.2.2 in April. The CHANGELOG.md at the repository root is where the project records what changed between them, and it is the file to read before upgrading, because the README itself does not document migration or rollback steps.

Upgrade cost is mostly the Electron and native-dependency surface. better-sqlite3, ffmpeg-static, and the native/ directory all involve platform binaries, and the postinstall script exists precisely because those need work after a plain dependency install. A version bump that changes the Electron major or the ffmpeg-static build can require a clean reinstall rather than an in-place update. The README does not describe an update mechanism inside the app.

On licensing: the project is AGPL-3.0, and the LICENSE file is at the repository root. AGPL-3.0 is a strong copyleft licence with a network-use clause, which is a materially different obligation from permissive licences. If you plan to distribute a modified build, or to expose the software as a network service, the terms of that licence are what govern, and this is a question for your own legal review rather than something a review can settle.

Editorial conclusion

Adopt Short Video Factory if you produce marketing or general short-form video in volume, want the render to happen on your own machine, and are comfortable configuring an OpenAI-compatible endpoint. Skip it if you need frame-level control over every cut, or if AGPL-3.0 does not fit how you plan to distribute the result. Before committing, download v1.2.2 from GitHub Releases, run one batch job end to end, and check the CHANGELOG for how the 1.2.x line changed the clip and subtitle behaviour you depend on.

Frequently asked questions

Official sources

1. License: AGPL-3.0
2. Project website
3. README
4. Releases
5. YILS-LIN/short-video-factory on GitHub