OpenScene

A local-first desktop video editor with an AI agent that can drive it — your media stays on your machine, and you choose which model providers, if any, it talks to.

Quick start · The workspace · Edit Agent · Mobile · Providers · Your data · Contributing

Important

Early. There are signed installers on the releases page for macOS, Windows and Linux, and the app updates itself once installed. The mobile app is on the App Store and Google Play. Running from source is still the fastest way to follow dev. The screenshots below are captures of the desktop app; the hero is an illustration.

The desktop app was called OpenVideo through 0.2.0. Because the rename changes the application id, an existing OpenVideo install will not update itself to OpenScene — download 0.3.0 once and the old one can be removed.

What is OpenScene?

OpenScene is an open-source video editor for your own machine — an Electron desktop app, and a React Native app that shares its editing core rather than approximating it. You open a folder as a project, put clips on a timeline, and export an MP4 with your local FFmpeg.

What makes it different is the Edit Agent: a chat panel that sits beside the timeline and can actually operate the editor — read the timeline, add and trim clips, generate voice or video, and start an export. It asks for approval before anything that changes your project.

Nothing is uploaded on its own. Model providers are opt-in, connected one at a time with your own API key or sign-in, and the app works with none of them connected.

Architecture

flowchart LR
  Creator[Creator]

  subgraph Renderer["Renderer — React UI"]
    Editor["Timeline · Program Monitor"]
    Agent["Edit Agent · approval UI"]
    Studios["Voice · Image · Video studios"]
  end

  Bridge["Preload — typed window.videoTool bridge"]

  subgraph Main["Electron main process"]
    Policy["Validation · approval · provider policy"]
    Projects["Local projects · assets · chats"]
    Jobs["FFmpeg export · AI job manager"]
    Secrets["safeStorage · OAuth tokens"]
    Tools["TypeMCP tool surface"]
  end

  subgraph Shared["Shared editing core"]
    Timeline["Timeline rules · composition · validation"]
    Planning["Shot planning · cost estimation"]
    Contracts["IPC · provider contracts"]
  end

  Local[("User-controlled local files")]
  Providers["Connected providers\nonly after explicit approval"]

  Creator --> Renderer --> Bridge --> Main
  Renderer <--> Shared
  Main <--> Shared
  Main <--> Local
  Jobs --> Providers
  Tools --> Policy

Loading

The renderer collects intent and renders editor state; it never receives raw IPC, FFmpeg execution paths or arguments, or stored provider credentials and OAuth tokens. The preload layer exposes only the typed window.videoTool bridge. The main process owns local projects, secrets, job lifecycle, local FFmpeg execution, and the TypeMCP tool surface. Editing rules, composition, validation, and generation planning live in the portable shared core, which desktop and mobile use together.

Project folders, imports, generated results, chats, and exports remain local. A connected provider is contacted only for an operation you explicitly start: in a generation studio, that is the visible Generate action; for an agent-initiated mutation or job, the Edit Agent asks for approval before execution. The Program Monitor is a best-effort review surface; local FFmpeg MP4 export is the authoritative saved output.

The workspace

The Projects page asks what you want to make. Video Editing opens a timeline project; AI Creation opens a story and scene production project. Existing projects keep their saved type when reopened. Chats stay with their project.

In Video Editing, the media bin, Program Monitor, inspector, timeline and Edit Agent share one workspace.

Editing

• Import local media into a project folder and place it on video and audio tracks
• Trim, split, move, duplicate, and delete clips, with undo/redo
• Adjust opacity, scale, position, rotation, and volume, with keyframes, transitions, and per-track audio mix
• Review with a playhead and a best-effort Program Monitor
• Export H.264/AAC MP4 through your local FFmpeg
• Keyboard shortcuts throughout, remappable in Settings
• Deliver reviewed automatic captions by burning them into the MP4, exporting a UTF-8 SRT/WebVTT/ASS sidecar, doing both, or doing neither. Manual titles always remain independent.
• Style titles and approved captions with shared Clean, Boxed, Cinema or Social presets, bounded outline/background controls, and aspect-aware title-safe anchors used by preview and final renderers.

AI Creation: story to scenes

Start with a production brief. Choose Plan the whole film to review a screenplay and scene plan before making shots, or Build scene by scene to make one scene and decide what comes next. The planning UI offers 5, 10 and 15 minute targets; shots are planned in five-second units. Connect the selected writing provider in Settings before requesting a plan. Planning and media generation are separate actions with separate cost checks.

Open a planned shot to inspect its prompt, references, candidate videos and approval state. Generate or regenerate a take explicitly, review it, then assemble approved material on the project sequence. Make a single clip instead opens the shot workbench without requiring a full film plan. Provider-supported clip lengths may differ from the planned shot length.

Voice generation

Open Advanced tools → Voice & captions in an AI Creation project. Qwen3-TTS (local) is the default desktop voice model. It runs a user-configured local wrapper with an authorized reference sample; OpenScene does not install the model. Configure local Qwen TTS before generating, then write a script, prepare and approve the narration plan, generate a WAV take, listen to it and import it into the project. A missing configuration produces a setup error rather than switching to a cloud model.

VieNeu-TTS v3 Turbo is another selectable local model for Vietnamese voices. Select it to start or connect to its loopback server and discover its available voices. On Windows, npm run setup:local-ai prepares the optional managed VieNeu and whisper.cpp runtimes; it does not install Qwen. OpenAI and ElevenLabs remain cloud choices that require your connected API keys. Automatic transcription uses whisper.cpp separately from speech synthesis.

Mobile can edit, approve and apply the same narration and caption plan. Speech synthesis and desktop-local Qwen/VieNeu runtimes are unavailable on mobile; their choices show the platform limit.

Image generation

Under Advanced tools → Scenes → Reference frames, create stills from a prompt and aspect ratio. A saved or approved reference can then be used by a video model that accepts image input. Generation is an explicit action.

The Edit Agent

The chat panel is not a copilot that writes suggestions for you to apply. It calls the same operations the UI does, through a typed tool surface in the main process:

The agent can	Tool
Read a project timeline and asset metadata	getProjectTimeline
Watch footage — sampled frames arrive as images it can actually see	watchProjectVideo
Place, trim, and restyle clips	addClipToTimeline, trimTimelineClip, updateClipEffects
Generate speech or video and follow the job	createSpeechJob, createVideoJob, getJobStatus
Import a finished generation into the project	importGeneratedResult
Start a local export	exportProjectVideo

Anything that writes to your project or starts a job pauses for approval first. Read-only calls run immediately.

Conversations are kept per project as sessions: start a new one, switch back to an earlier one, or delete it. History is stored in a path-free chats.json inside the project folder.

On a phone

mobile/ is a React Native app that runs the same editing rules as the desktop. Every timeline operation — placing, trimming, splitting, moving, what plays at a given moment, what an export composites — is a pure function in src/shared/, imported by both. Neither reimplements a rule, which is what stops a project behaving one way on a laptop and another on a phone.

It is published on both stores: App Store · Google Play.

Projects live inside the app rather than in a folder you file away, because a phone user has no filesystem they think in. Export hands you the finished MP4 through the share sheet.

• A timeline with a preview, playback, pinch-to-zoom, draggable clips and trim handles, and a media bin
• Video and image generation against the shared provider catalog; narration planning and captions share the desktop project format, while speech synthesis remains desktop-only
• A tool-calling assistant that shows every call for approval before it runs
• Spending permission asked per kind — allowing every image is a different decision from allowing every video, and they do not cost the same
• Multi-shot planning and reviewed candidates using shared shot and continuity rules

Export renders natively on both: AVFoundation on iOS, Media3 Transformer on Android. Where a surface genuinely cannot do something it says so rather than failing quietly — holding a still image in the composition is not implemented on iOS yet, so the app refuses those exports there instead of producing a video with the picture missing.

The mobile app is paid for by ads. That is the business model, not an incidental feature: a banner above the tab bar and a full-screen ad after a finished export, mediated by Unity LevelPlay with Unity Ads, AppLovin, Meta and Pangle bidding into it. There is no paid tier and nothing is unlocked by watching one. The app also reports anonymous usage counts to the publisher's own server.

The desktop app has neither. No ads, no analytics, no account — the difference is deliberate, and it is why the two surfaces declare different things to different reviewers. Both are described under your data; the usage counts have a switch in Settings, the ads do not.

cd mobile
npm install
npx expo run:ios     # or: npx expo run:android

Providers and models

The provider and model registry is generated from a snapshot of the models.dev catalog — roughly 150 providers and several thousand models — and is regenerated with scripts/generateLlmCatalog.mjs.

• Local: Ollama runs models on your machine with no key and no account.
• Cloud chat: connect a provider in Settings → Providers with an API key. Only connected providers' models appear in the pickers.
• OpenAI: two login methods on one provider — an API key, or a ChatGPT sign-in (PKCE OAuth) for the model set that backend serves. Tokens stay in main-process safe storage; the renderer only learns whether you are connected.
• Generation: runnable video models across Google Gemini Omni/Veo, OpenAI Sora, Runway, Luma and a user-managed ComfyUI Wan Animate worker — Runway also fronts Seedance, Veo 3.1, HappyHorse and a separate Gemini Omni route on one key. Google image generation uses the current Nano Banana family through Gemini Interactions, or an experimental desktop-only background browser worker that drives the normal Gemini UI with the user's encrypted signed-in session. Providers without a real adapter stay listed but honestly unavailable rather than pretending to work, and every model says which it is.

A provider API key is entered in Settings and sent once through the typed bridge to Electron safeStorage; stored provider credentials are never returned to the renderer.

Quick start

Prerequisites

• Node.js 22+ and npm 10+
• FFmpeg, for MP4 export
• macOS: Screen Recording permission for the terminal running OpenScene, if you use window capture

Install and run

git clone https://github.com/Theorvane/openscene.git
cd openscene
npm install
npm run dev

OpenScene uses your FFmpeg. Either make ffmpeg discoverable through an absolute directory on PATH, or point at it explicitly:

VIDEO_TOOL_FFMPEG_PATH=/absolute/path/to/ffmpeg npm run dev

Relative FFmpeg paths are rejected. Without a usable FFmpeg, OpenScene reports the problem instead of starting an export.

Try the agent without any cloud account

ollama pull qwen2.5-coder
ollama serve

Then pick the local model in the chat panel's model picker. Note that watching footage needs a vision-capable model.

Where your data lives

Projects are folders you choose. Assets, chat history, and generated results are written inside them; app-managed projects and recordings live under Electron user data.

VIDEO_TOOL_RECORDINGS_DIR=/absolute/path/to/recordings npm run dev

The renderer talks to the main process through a narrow typed window.videoTool bridge. Raw ipcRenderer, FFmpeg executable paths and arguments, stored credentials, and OAuth tokens stay outside it. Some safe display paths and an API key entered in Settings cross through explicit typed operations; a picked reference image, for example, crosses as bytes, never as a path.

• The mobile app carries ads; the desktop does not. The Google Mobile Ads SDK is in the mobile binary and reports device identifiers to Google — a banner above the tab bar and one interstitial after a finished export. Consent is gathered through Google's UMP before any ad is requested. There is no switch for this one; it is how the mobile app is paid for.
• No account, no crash reporting. The desktop app sends nothing about you anywhere. The mobile app reports anonymous usage counts — which screens are opened, whether an export ran and finished — to the publisher's own server, never to a third party, and never carrying prompts, projects, media, file names or keys. It is a switch in Settings.
• No background network calls. The app talks to a provider only when you ask it to, using a provider you connected.
• Capture is scoped. Window capture grants access to the single source you select.
• Removable. Projects can be removed from the list — a folder you chose is only unregistered, never deleted recursively — and conversations can be deleted.

Current boundaries

Works today	Not yet
Selected-window capture to local WebM	Full-screen capture; mic or system-audio mix in the recorder
Local projects, media, timeline editing, undo/redo	Holding a still image in an iOS export — the app refuses those there rather than dropping the picture
Local H.264/AAC MP4 export	Other export formats; frame-perfect multitrack mastering guarantees
Signed installers and auto-update on all three desktop platforms, and the mobile app on the App Store and Google Play	Cloud sync, hosted rendering, accounts
Agent-driven editing, generation, and export	Unattended operation — changes ask for approval
Veo image-to-video, Start-End interpolation, and 1-3 character/product references; desktop ComfyUI Wan Move/Mix Motion Control with user-supplied API workflows	Sora reference images (needs a multipart upload path this build does not send); bundled ComfyUI/models

Program Monitor is a best-effort review surface. FFmpeg export is the authoritative output.

Verify from source

npm run typecheck
npm test
npm run build

npm run build compiles main, preload, and renderer into out/. It does not package an installer.

Some behavior can only be checked by hand: OS permissions, real provider calls, and final render quality.

Contribute

1. Read AGENTS.md and search existing issues and pull requests.
2. Create or find a GitHub issue, update dev, and branch as <type>/<issue-number>-<description>.
3. Add or update tests for behavior changes.
4. Run the checks above and open a pull request against dev.

See CONTRIBUTING.md, CODE_OF_CONDUCT.md, SUPPORT.md, and SECURITY.md.

License

MIT