An open-source AI video studio for filmmaking, animation, and Agent-assisted video production.
Download · Product tour · Get started · Architecture · Build from source · Contributing
English · 简体中文
ShotForward is an open-source, local-first AI video studio for short films, animation, commercials, music videos, and episodic work. Its script-to-video workflow connects scripts, character assets, storyboards, AI video generation, and MP4 export in one desktop project.
For multi-shot video production, reusable character and scene references support visual continuity across shots. Each generation can be traced back to its inputs, and Agent-authored edits remain visible project changes that can be reviewed and undone.
The result is a workflow organized around the production—not a collection of disconnected prompts.
| Stage | What stays connected |
|---|---|
| Script | Markdown authoring and import, scene navigation, and Agent-assisted revision |
| Assets | Reusable characters, locations, props, visual styles, and image version history |
| Storyboard | Scene and Clip order, shot prompts, generation modes, and bound references |
| Generation | Provider capabilities, persistent jobs, input snapshots, progress, and recoverable failures |
| Preview | Storyboard-order playback with non-destructive in/out trimming |
| Delivery | Background H.264/AAC MP4 export powered by FFmpeg |
No development environment is required to use an official desktop release. See the official download page for available installers. The Mac Apple Silicon version is available; the Windows version is awaiting release.
| Platform | Requirements | Official installer |
|---|---|---|
| macOS · Apple Silicon | macOS 12 or later, M-series chip | Download |
| Windows · x64 | Windows 10 / 11, 64-bit | Awaiting release |
Intel Macs are not supported.
The repository's community build workflows produce unsigned installers. Windows and macOS may show an unknown-developer warning for these builds; verify their accompanying SHA-256 files before installation. Third-party generation services may require a separate account, subscription, API key, or usage credits; pricing, content policies, data handling, and output rights are governed by each provider's terms.
Choose how to connect your models, then follow the setup steps below.
| Connection | What you need | Configuration |
|---|---|---|
| ShotForward Cloud | Account, credits, one-time login code | Settings → ShotForward account |
| Local Codex | Local sign-in and a ChatGPT subscription with the required access | Runtime settings and Agent model selection |
| Your own video API | Provider account, API key, endpoint, and model | Provider settings |
- Visit the ShotForward website, register an account, and sign in to the account center.
- Recharge credits and generate a client pairing code (called a one-time login code on the website and in the client).
- Open Settings → ShotForward account in the client and enter the pairing code before it expires to connect your account.
- Choose a cloud Agent, image, or video model. Available models and charges are shown in the account center and client.
The cloud pairing code connects your ShotForward account. It is separate from the startup pairing code used to open the local studio when running the daemon from source.
- Install Codex CLI on your machine and sign in with a ChatGPT subscription account that has the required Codex access.
- Check local Codex status in the client's runtime settings and choose a local model in Agent. Agent and Codex image capabilities use your local sign-in; availability and limits depend on your account.
For video generation through your own account, add a video provider in the client's Provider settings. Enter the API key, endpoint, and model for the correct region, then validate and enable the configuration.
Video services require a separate account and payment to the selected provider; a Codex subscription does not include third-party video API charges. See the provider guide for details. Keep pairing codes and API keys private and out of source control.
One project carries the production from script development and reusable visual assets through shot generation, continuous preview, and delivery.
Explore the studio screenshots
The Agent can work with the current script, assets, and storyboard, but it cannot write around the application's rules. Persistent edits are represented as ChangeSets, validated against current project revisions, and recorded so they can be reviewed and safely undone.
Characters, locations, props, and styles remain reusable across shots and episodes. Image and video outputs retain version history; selecting a new current version does not destroy earlier media.
Image, video, and export work runs as persistent jobs with frozen input snapshots, progress, stable failure categories, and retry context. Results enter the project only after media validation, preserving the relationship between intent, provider, and output.
Project databases and media live in the directory you choose. The local daemon binds only to the loopback interface, and credentials are kept in operating-system secure storage rather than project files. Requests to third-party generation services send the required inputs to the provider you configure and remain subject to that provider's terms.
ShotForward keeps project data independent from any single model vendor. The current codebase includes these adapters:
| Capability | Current adapters |
|---|---|
| Studio Agent | Local Codex, ShotForward Runtime |
| Image generation | Codex subscription-backed image capability |
| Video generation | Seedance, MiniMax H3, Wan |
| Media processing | FFmpeg and ffprobe |
Actual availability depends on the installed ShotForward version, provider account, region, and service status. The studio exposes only capabilities confirmed by the local daemon.
ShotForward Desktop (Tauri)
│
│ localhost + protected session
▼
React Web UI ───────────► shotforwardd
├── Application / Domain
├── SQLite + project media
├── Codex Runtime / MCP
├── generation providers
└── FFmpeg / ffprobe
The architecture keeps one authoritative path for every project mutation:
- The Tauri desktop shell owns the window, daemon lifecycle, native dialogs, and operating-system integration.
- The React UI renders server state and submits commands; it does not access project databases, files, or provider credentials directly.
shotforwarddowns domain rules, SQLite transactions, project media, background jobs, Agent sessions, and security boundaries.- Project data and application-level settings are stored separately, making individual projects easier to move and back up.
The daemon binds to a loopback address and uses short-lived pairing to establish a protected cookie session. Write requests are checked for both Origin and CSRF protections. See the architecture overview and provider guide for the full boundary model.
- Go
1.26 - Node.js
22.21.1 - Rust
1.85+for the desktop shell - FFmpeg and ffprobe for media processing and export
- Codex CLI, installed and signed in, when using the local Agent or subscription-backed image capability
Run commands from a clean checkout of the repository. Platform-specific desktop packaging also requires the standard Tauri prerequisites for Windows or macOS.
cd web
npm ci
npm test
npm run buildThe production bundle is written to the ignored daemon/internal/webui/dist build directory and embedded into the daemon binary. Build the Web UI before compiling or testing the daemon from a clean checkout.
cd daemon
go test ./...
go run ./cmd/shotforwarddThe daemon prints a loopback address and a temporary pairing code. Open the address in a browser and complete pairing to enter the studio.
Desktop releases bundle the Web UI, daemon, Codex Runtime, FFmpeg, and ffprobe. Stable version tags build unsigned Windows and macOS installers and publish them to GitHub Releases; maintainers should follow the release guide.
daemon/ Go application core, domain rules, SQLite, jobs, Agent, and local API
web/ React studio, client state, localization, and frontend tests
desktop/ Tauri shell, native integration, icons, and release tooling
docs/ Architecture, providers, release process, and screenshots
| Document | Contents |
|---|---|
| Architecture overview | Component responsibilities, data ownership, and security boundaries |
| Provider guide | Generation services, credentials, and capability model |
| Release guide | Windows and macOS builds, signing, and publishing |
| Contributing guide | Development environment, tests, and contribution conventions |
| Security policy | Vulnerability reporting and the local security model |
| Licensing guide | Permitted uses and commercial licensing boundaries |
| Contributor License Agreement | Terms for accepting source contributions |
| Trademark policy | Rules for the ShotForward name, logo, and compatible products |
Reproducible bug reports, product feedback, and focused improvements are welcome. Please open an Issue before changing project formats, domain models, provider protocols, or security boundaries. Read CONTRIBUTING.md before submitting code.
- Website and cloud account portal: shotforward.com
- Product and business inquiries: contact@shotforward.com
- Bug reports and feature requests: GitHub Issues
ShotForward's public client source code is Open Source software licensed under the Apache License 2.0. Individuals and organizations may use, study, modify, and redistribute it, including in commercial and proprietary products, subject to the license's notice and attribution requirements. Apache-2.0 does not require derivative works to publish their source code.
See the Chinese explanation, licensing guide, Contributor License Agreement, and trademark policy for details. Official hosted APIs, cloud services, accounts, credits, compute, and support are separate offerings and are not licensed by this repository's software license. ShotForward may also provide separately licensed editions and commercial arrangements; contact contact@shotforward.com.



