OpenCut is the most-talked-about open-source video editor on GitHub right now, positioned bluntly as the open-source CapCut alternative. As of late July 2026 it sits at 79,300 stars, 7,909 forks, MIT license, primary language TypeScript, latest release v0.3.0; the repo was created on June 22, 2025-just over 13 months ago-with star growth in the top tier of video tools. What it does in one sentence: a free, open-source video editor covering web, desktop, and mobile, no cloud lock-in, footage never uploaded, data stays on your machine. But what pushed it into the spotlight is the roadmap, not the current build-the team is rewriting the entire project from scratch with a Rust core, with Editor API, third-party plugins, MCP server, headless batch rendering, and an in-editor scripting tab all redesigned as first-class citizens; the classic version (the one opencut.app runs) is just a stopgap, the new build previews at new.opencut.app, and you shouldn't bet real work on it until it lands.
What Pain It Solves
Anyone who edits video can't avoid CapCut, but the longer you use it the more these thorns bite. One, cloud lock-in: projects live on ByteDance's cloud, and if your account gets banned or the service stops, your footage and projects are gone-export watermarks and Pro subscription tiers pile on. Two, privacy: home videos and commercial footage all get uploaded to someone else's servers, failing both compliance and confidentiality. Three, closed: want to add your own effect plugin, hook up an automated batch-rendering pipeline, or let an AI agent drive editing-CapCut opens zero such doors. Four, cross-platform fragmentation: what you cut on mobile doesn't line up on desktop, with versions, fonts, and effects running their own way on each end. OpenCut fixes all of this at once: MIT open source, runs locally, footage never leaves your machine; three platforms from one codebase (Rust core rewrite in progress); plugins are first-class and freely extensible; headless mode plus an in-editor scripting tab let you batch-render and automate; the MCP server exposes editing capability to AI agents, turning "AI edits video" from a gimmick into a callable interface. The core shift is from "someone else's cloud tool" to "a local toolchain you control."
Three Platforms, One Codebase: The Rust Core Rewrite from Scratch
The README leads with a one-line status: OpenCut is being rewritten from the ground up. The weight of this needs unpacking. The current state is that the classic build (repo opencut-app/opencut-classic) works, opencut.app runs it in production, and this is the one to reach for today; the new build still previews at new.opencut.app and hasn't taken over the main site. The core move of the rewrite is swapping the editor kernel for Rust, emitting web, desktop, and mobile from a single codebase-not three ports written separately, but one shared Rust core with each platform's UI and shell wrapped around it. The direct payoff is cross-platform consistency: a project cut on mobile opens on desktop without breaking, no missing effects; the Rust kernel also pulls performance and memory to native levels, unlike pure-JS solutions that choke on long timelines and 4K footage. Alongside this comes the Editor API-exposing editor capability as an interface so external programs can drive it for automation. In one line: the classic build today is "usable," the rewritten new build is "extensible, automatable, and consistent across platforms."
MCP Server + Scripting Tab: Letting AI Actually Edit Video
This is the most imaginative part of OpenCut's roadmap. An MCP (Model Context Protocol) server means OpenCut packages its editing capability as an MCP service that AI agents call directly via a standard protocol-trim, add subtitles, apply templates, export-with the agent orchestrating calls itself after receiving a natural-language task. This isn't the "AI generates a video in one click" gimmick; it's letting AI act as a editing operator doing deterministic cutting work. Pair it with the in-editor scripting tab: without leaving the editor, you write scripts in the panel to drive it, automating repetitive chores (batch-adding intros, templating subtitles, batch-rendering a set of shorts). MCP is for AI agents, the scripting tab is for humans, and both point at the same thing-turning editing from GUI operations into programmable calls. For developers building "AI editing" apps, this means no need to build an editing engine from scratch; hook up the MCP server and you have a complete video-editing backend.
Plugin-First + Headless Batch Rendering
These two decide whether OpenCut can enter a production pipeline. Plugin-first architecture: third-party plugins are first-class citizens, not a bolted-on afterthought but a slot reserved at architecture-design time-meaning effects, transitions, subtitle styles, and export formats can all be extended by the community or your own team, not gated by the official feature list. This is a different mindset from CapCut's "use what we give you" closed model. Headless mode is the other end: running without a GUI, dedicated to automation and batch rendering-for example, a machine overnight auto-rendering 100 short videos against a template, or wiring editing into CI as a schedulable task. Stacked together, these make OpenCut more than "a CapCut replacement editor"-a programmable editing backend that fits into content-production pipelines: plugins handle extension, headless handles batch runs, MCP/scripting handle orchestration. Note these are all roadmap items in the rewrite; the classic build doesn't have them, and you wait for the new build to land.
Three-Minute Setup
# 1. Install proto (moonrepo's toolchain manager; OpenCut uses it to pin versions)
# Linux / macOS / WSL
bash <(curl -fsSL https://moonrepo.dev/install/proto.sh)
# Windows PowerShell
irm https://moonrepo.dev/install/proto.ps1 | iex
# 2. Clone the repo, install the toolchain pinned in .prototools
git clone https://github.com/OpenCut-app/OpenCut.git
cd OpenCut
proto use
# 3. Start local dev servers
moon run web:dev # http://localhost:5173
# moon run api:dev # API service localhost:8787
# moon run desktop:dev # desktop, see apps/desktop/README.mdVerify: open http://localhost:5173 in a browser and see the OpenCut editor interface-that's it running. Don't want the local hassle? Just open opencut.app and use the classic build, editing in-browser with zero install; the new build previews at new.opencut.app. On Windows, if shims fail to run, follow the README and allow local scripts for your user: Set-ExecutionPolicy -Scope CurrentUser RemoteSigned.
Who It's For + Four Pitfalls
For: creators who want CapCut's features without cloud lock-in-OpenCut runs locally, footage never leaves your machine; content teams and batch-production scenarios building bulk-render pipelines with headless mode plus the scripting tab; AI app developers who use the MCP server to expose editing capability to agents and build "AI editing" apps without engineering an editor from scratch; self-hosting and privacy scenarios where MIT license and local deployment beat cloud tools on compliance and confidentiality.
Four pitfalls. One, don't pick the wrong version: the stable one to use today is classic (opencut.app / the opencut-app/opencut-classic repo); the Rust rewrite still previews at new.opencut.app with release only at v0.3.0-betting real work on the new build means stepping on bugs at any moment. Two, you can't contribute code: during the architecture-design phase the team explicitly isn't accepting outside PRs; to follow along you join Discord or open an issue, and if you want to hack the source you can fork it for your own use but it won't merge back. Three, unfamiliar toolchain: OpenCut uses proto + moon instead of npm/yarn to run the project, so first contact means installing proto, reading .prototools, and learning moon commands-a learning curve. Four, feature-delivery timing: MCP server, headless, the plugin system, and Editor API are all roadmap items the classic build doesn't have-if you're coming for these specifically, you wait for the new build to land; don't assume they work today.
vs. the Competition
Set beside CapCut, DaVinci Resolve, and OSS editors like Kdenlive, the positioning differences are clear at a glance:
| Dimension | OpenCut | CapCut | DaVinci Resolve | Kdenlive et al. (OSS) |
|---|---|---|---|---|
| License | MIT, fully open source | Proprietary, free + Pro subscription | Proprietary, free + paid Studio | GPL, open source |
| Deployment | Local/self-hosted, data stays on-device | Cloud-first + desktop/mobile | Local install | Local |
| Platforms | web + desktop + mobile, one codebase (Rust rewrite in progress) | web + desktop + mobile | Desktop only | Desktop only |
| AI integration | MCP server, callable by AI agents | AI features built-in but closed | Limited | No native MCP |
| Plugin extensibility | First-class, third-party extensible | Not open | Fusion scripting/limited | Limited |
| Automated batch rendering | Headless mode + scripting tab (roadmap) | None | Scripting limited | No native headless |
| Maturity | Rewrite phase v0.3.0, classic usable | Mature commercial | Mature pro-grade | Mature OSS |
In one line: for a mature, stable commercial editing experience pick CapCut or DaVinci, and for pro color grading DaVinci is still the ceiling; but for an unclouded, extensible, AI- and script-driven, cross-platform-consistent local toolchain, OpenCut is currently the only open-source option with all of this on its roadmap-the tradeoff being it's still mid-rewrite, so you lean on classic in the meantime.
References
- OpenCut GitHub repo (79.3k stars, MIT, TypeScript): https://github.com/OpenCut-app/OpenCut
- Live stable build opencut.app (runs classic): https://opencut.app
- New build preview new.opencut.app (Rust rewrite): https://new.opencut.app
- opencut-classic repo (the stable build to use today): https://github.com/opencut-app/opencut-classic
- Discord community (follow rewrite progress, file issues): https://discord.gg/zmR9N35cjK
- proto toolchain (moonrepo, a local dev dependency): https://moonrepo.dev/proto