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. Running from source is still the fastest way to follow dev. The hero and screenshots below show the real interface.

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.

The workspace

Open a folder and you land in the workspace. One tab strip switches between editing and the two generation studios; the agent chat stays docked beside all three.

Projects and past conversations live on the start page. Picking a chat reopens its project and restores the transcript.

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

Voice generation

Write a script, pick a voice model, generate, and import the result straight into the project.

Video generation

Prompt with a style, aspect ratio, and duration — and optionally a reference image to seed image-to-video.

Image generation

Stills from a prompt, at the aspect ratio you need — and a seed for image-to-video on the engines that accept one.

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.

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, image and voice generation against the same provider catalog, with any OpenAI-compatible endpoint addable yourself
• 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 video that continues each shot from the last frame of the one before

Export renders natively with AVFoundation on iOS. On Android it is not implemented yet and says so — editing, generation and frame extraction all work there; only the render does 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: 17 runnable video models across Google Veo, OpenAI Sora, Runway and Luma — Runway alone fronts Seedance, Veo 3.1, HappyHorse and Gemini Omni Flash on one key. Eight image models and seven voices. Providers without a real adapter stay listed but honestly unavailable rather than pretending to work, and every model says which it is.

API keys are written to Electron safeStorage in the main process and never reach 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, filesystem paths, FFmpeg arguments, API keys, and OAuth tokens stay outside it — a picked reference image, for example, crosses as bytes, never as a path.

• No account, no telemetry. No analytics, crash reporting, or usage tracking.
• 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	A published mobile build — the app exists, the store listing does not
Local H.264/AAC MP4 export	Other export formats; frame-perfect multitrack mastering guarantees
Signed installers and auto-update on all three desktop platforms	Cloud sync, hosted rendering, accounts
Agent-driven editing, generation, and export	Unattended operation — changes ask for approval
Veo image-to-video via a reference image	Sora reference images (needs a multipart upload path this build does not send)

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