OpenCut: The Open-Source CapCut That Can't Be Enshittified

CapCut followed the playbook every free creative tool eventually follows: launch free, build a massive user base, then progressively paywall features and train models on your footage. OpenCut is the community's answer — and the MIT license makes the CapCut playbook structurally impossible.

If you've edited a video in the last three years, you've felt the squeeze. CapCut (剪映国际版) started free and easy. Then basic transitions went premium. Then higher export resolutions. Then watermarks on free exports. Then the parent company started training AI models on user-created content. The tool you depended on slowly became a funnel.

A group of developers decided to build the alternative that can't do any of that. OpenCut is a free, open-source video editor that runs on web, desktop, and mobile — MIT-licensed so nobody can ever lock it down. It crossed 68,000+ GitHub stars in under a year and sat at the top of GitHub Trending through July 2026.

This is a deep look at what OpenCut actually is, why the architecture (Rust core compiled to WebAssembly) matters, how it compares to CapCut feature-by-feature, the self-host path, what it honestly can't do yet, what it costs, and where your footage goes. The privacy angle is the reason it belongs on this blog: a video editor that uploads your raw footage to a server is the opposite of "AI you can run on your own machine."

1. The Enshittification of Free Creative Tools

The pattern is now a cliché, and it's worth naming because it explains why OpenCut exists. A tool launches free, builds a user base, then extracts value from that base through paywalls or data monetization. The moment "free and simple" drops the "free," the moat evaporates.

CapCut's competitive advantage was never technology. Timeline-based editing is a solved problem — Premiere Pro, DaVinci Resolve, and Final Cut have done it for decades. The moat was being the free, easy version for people who found professional tools overwhelming. Remove "free," and a huge chunk of the user base has no reason to stay.

OpenCut rebuilt the same value proposition with a structural guarantee that it stays free.

2. What OpenCut Is

OpenCut is a timeline-based video editor built with Next.js on the web, a native desktop app using GPUI (the same framework powering the Zed editor), and a platform-agnostic Rust core for GPU compositing, effects, and masks.

Core promise, in three lines from the README:

Privacy — your video stays on your local device, never uploaded to the cloud.
Free features — core capabilities are all free under MIT.
Simple — CapCut-like ease of use.

The privacy one is the headline for this blog. Video processing runs entirely in-browser (WebAssembly) on the web build, and the desktop build renders natively. No account required — no CapCut account, no Apple ID, no Google sign-in. Local-first video processing

3. The Privacy Architecture

This is the part that separates OpenCut from every cloud editor:

Video processing runs entirely in-browser (WebAssembly) on the web build — your files never leave your device.
No account required — no behavioral tracking tied to an identity.
Anonymous analytics only — no behavioral tracking or fingerprinting.
Open-source codebase anyone can audit.

Contrast that with mainstream free editors, where footage is uploaded to a server for processing and becomes training data. For corporate, client, or personal content, "your footage never leaves your machine" isn't a nice-to-have — it's the difference between a tool you can use and a liability you can't.

4. Architecture: Why Rust Compiled to WASM

The Rust core is the key architectural decision. By building the rendering pipeline in Rust and compiling to WebAssembly, OpenCut gets near-native performance in the browser while sharing the same rendering logic across all platforms. This is the same approach Figma used to dominate browser-based design tools.

Project structure:

apps/web/ — Next.js web application
apps/desktop/ — native desktop app (GPUI)
rust/ — platform-agnostic core: GPU compositor, effects, masks, WASM bindings
docs/ — architecture and subsystem documentation

Tech stack: Bun for package management and development, Docker Compose for local development (Postgres + Redis), WASM bindings from the Rust core. The team is actively migrating business logic from TypeScript to Rust — a signal they're optimizing for performance and cross-platform consistency rather than shipping features fast and fixing performance later.

5. Installation: Four Ways In

Option 1 — Web app (easiest). Visit opencut.app. Nothing to install. The classic version is fully functional.

Option 2 — Self-host the classic version:

git clone https://github.com/OpenCut-app/opencut-classic.git

cd opencut-classic

bun install

cp apps/web/.env.example apps/web/.env.local

docker compose up -d db redis serverless-redis-http

bun dev:web

open http://localhost:3000

Option 3 — Build from source (rewrite):

git clone https://github.com/OpenCut-app/OpenCut.git

cd OpenCut

proto use

moon run web:dev      # localhost:5173

moon run api:dev      # localhost:8787

moon run desktop:dev

Option 4 — Docker (full stack):

git clone https://github.com/OpenCut-app/opencut-classic.git

cd opencut-classic

docker compose up -d

open http://localhost:3100

Building the Rust core (advanced):

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

cargo install wasm-pack cargo-watch

bun run build:wasm

6. Features That Ship Today

On the mature classic build:

Timeline editing with multi-track support
Real-time preview without pre-rendering
No watermarks on any export, at any resolution
No subscriptions, no premium tier, no locked features
Web, desktop, and mobile from the same codebase
Self-hostable via Docker

For simple edits — trimming a phone clip, adding two lines of subtitles, cutting a dead opening, exporting a clean MP4 — the current version is genuinely enough.

7. OpenCut vs CapCut

| Feature | OpenCut | CapCut |
|---|---|---|
| Price | Free (MIT) | Freemium (features paywalled) |
| Privacy | Local processing | Cloud-based |
| Source | Open | Proprietary |
| Platforms | Web, Desktop, Mobile (planned) | Web, Desktop, Mobile |
| AI integration | MCP server, headless mode | Built-in AI features |
| Extensibility | Plugin API (upcoming) | Limited |
| Automation | Scripting, batch rendering | Manual only |
| Effects library | Growing (community) | Extensive (proprietary) |
| Learning curve | Simple (CapCut-like) | Simple |
| Export | Standard formats | Standard + TikTok optimization |

Choose OpenCut if privacy is critical (corporate, client, or personal content), you need automation (batch rendering, CI/CD), or you want to extend the editor with custom plugins. Choose CapCut if you need the extensive built-in effects/stickers library today, prioritize mobile editing right now, or want TikTok-optimized export presets and don't mind cloud processing.

8. The MIT Guarantee

This is the structural guarantee that separates OpenCut from CapCut's trajectory. MIT is the most permissive open-source license — anyone can use, modify, fork, and distribute the code for any purpose.

What this means in practice: if the maintainers ever tried to add a paywall, force account creation, or train AI on user projects, the community would fork the repository and ship an identical product without those changes within days. The 4,700+ existing forks (earlier snapshots) mean the codebase is already distributed across thousands of independent copies.

You can't enshittify software that anyone can fork. That's not a marketing line — it's a license property.

9. Hands-On: Edit a Phone Clip in the Browser

1. Open opencut.app (no install, no account).
2. Drag your clip onto the timeline. It processes locally — the file never uploads.
3. Trim the dead opening by dragging the clip edges.
4. Add a subtitle track; type two lines.
5. Hit export. The render happens in-browser via WASM. No watermark, no resolution cap.

That's the entire flow for 80% of casual editing. The friction is roughly zero, and the privacy cost is exactly nothing.

10. The Rewrite: Why They Tore It Down

The maintainers didn't pile features onto the classic version. They're rewriting it from the ground up — the new repo's README literally says "OpenCut is being rewritten from the ground up." A source-code check found the main branch is still early scaffolding: the web home is a placeholder, the desktop is a bare GPUI window, the API only has health-check and echo endpoints. The real timeline, decoder, effects pipeline, renderer, and plugin system haven't landed yet.

Why rewrite a 68k-star product that works? Because the truly hard part of an "open-source CapCut" isn't a similar UI — it's a stable, extensible, portable editing core. The new architecture puts a Rust core, a unified Editor API, and a plugin boundary at the center. The direction is right; the rewrite is just not done.

11. Roadmap

The team is actively building:

1. Editor API — a stable, documented API for programmatic editing (create projects, add tracks, apply effects, export). Perfect for SaaS products embedding video editing.
2. Plugin system — third-party plugins with sandboxed execution and a marketplace.
3. Desktop/Mobile/Browser parity — the Rust core enables true cross-platform; the GPUI desktop app is in progress, mobile uses the same core.
4. Enhanced MCP server — granular editing control, real-time collaboration, AI video generation integration (fal.ai partnership).
5. Scripting tab — TypeScript autocompletion for the Editor API, community script gallery, headless automation.

12. Honest Limitations

OpenCut is honest about what's not done. The contributing guide marks certain areas as "avoid for now": preview panel enhancements (fonts, stickers, effects) are being refactored, and export is migrating to a new binary rendering approach. The desktop app is marked in-progress; the web version is the most mature surface.

If you need a fully polished desktop editor today, DaVinci Resolve (free tier) is still the answer. But OpenCut is shipping fast — 90+ contributors and 1,280+ commits mean the gap is closing weekly.

Also be aware: the rewrite means the "new" repo and the "classic" repo are different codebases. The README explicitly tells users who need a finished product today to use opencut-classic. Don't clone main expecting a working editor.

13. What It Costs

OpenCut is free. Your only costs:

Your hardware — rendering happens on your machine, so a slow laptop renders slowly. There's no cloud render bill because there's no cloud.
Your time — if you self-host, you run Docker and manage it yourself.

There is no subscription, no per-export fee, no watermark-removal upsell. The MIT license guarantees that stays true.

14. Where Your Footage Goes

Nowhere you didn't choose. On the web build, processing is in-browser WASM — the file is read from your disk, edited in memory, and written back to your disk. On self-hosted Docker, it's your server. The only thing that leaves your machine is whatever you explicitly export and upload yourself.

This is the cleanest possible privacy posture for an editor, and it's the reason OpenCut is on this blog instead of yet another cloud editing wrapper.

15. Troubleshooting

Web app feels slow on a big project? You're rendering in-browser on CPU/GPU via WASM. Close other tabs; consider the desktop build for heavier work.
Cloned main and it's empty? That's the rewrite scaffold. Use opencut-classic for a working editor.
Self-host port conflict? The compose file uses 3000/3100 by default; change it in your env.
Export fails mid-render? The export path is migrating to a new binary renderer; on classic it's stable, on rewrite it may be incomplete. Stick to classic for now.
Want AI features? The MCP server and fal.ai integration are roadmap, not shipped. Today, AI is "bring your own" via the scripting/headless path.

16. Who Should Use It

Use OpenCut if: you're a creator who wants simple editing without cost, complexity, or cloud training on your footage; you're a team that needs automation (batch rendering, CI/CD); or you're a developer who wants to embed or extend a video editor with plugins.

Skip it (for now) if: you need the polish and effects breadth of DaVinci Resolve or the mobile-first maturity of CapCut today, or you rely on TikTok-optimized export presets.

17. FAQ

Is OpenCut really MIT? Yes — and that's the point. Forkable, un-enshittifiable.

Does it upload my video? No. Web processing is in-browser WASM; desktop is native. Your footage stays on your device.

Can I self-host it? Yes — docker compose up -d on the classic repo, available at localhost:3100.

Mobile app ready? The Rust core is designed for it, but mobile isn't mature yet. Web and desktop are the real surfaces today.

How does it compare to DaVinci Resolve? Resolve is more powerful and more polished today. OpenCut wins on zero-cost, zero-account, local-only privacy, and extensibility — not on raw capability yet.

18. Hands-On: Building a Batch Render Pipeline

One feature that justifies OpenCut for teams is headless scripting. Say you're a agency with 40 client clips that all need the same intro, outro, and watermark. Doing that by hand in any editor is a day of soul-crushing work. OpenCut's scripting path (once the Editor API lands) lets you define it once and run it on a folder.

The shape of the workflow:

// pseudo-API once Editor API ships
import { Project, Track, Clip } from "opencut";

const proj = new Project("client-batch");

proj.addTrack("video");

proj.addClip("intro.mp4", { at: 0 });

for (const file of listClientClips("./incoming")) {

  proj.addClip(file, { after: "intro.mp4" });

  proj.addClip("outro.mp4", { after: file });

  proj.addWatermark("studio.png", { corner: "br" });

}

await proj.renderAll({ outDir: "./rendered" });

Today this is roadmap, not shipped — but the direction is what matters for a self-hosted shop: your render farm is your own machine, your footage never touches a cloud render queue, and the cost is electricity, not per-minute SaaS fees. For a studio doing volume, that math is the whole pitch.

19. The Economics of Local Editing

Let's put numbers on "free." A cloud editor monetizes you three ways: subscription, per-export upsells, and — quietly — training on your footage. OpenCut removes all three. Your only costs are hardware and power.

A mid laptop (8-core CPU, integrated GPU) renders 1080p H.264 at maybe 1–2× realtime. A desktop with a discrete GPU (even a 2-year-old RTX) does 3–5×. The point: you already own the render farm. The cloud editor was renting you compute you have.

The trade: a cloud service smoothers over device differences and offloads heavy effects to their GPUs. OpenCut asks your machine to do the work. For 80% of creators (talking-head videos, product clips, short social posts), the local machine is more than enough. For 4K multicam with heavy color, you'll want the desktop build on real GPU — which is exactly the hardware you'd need for any serious editing anyway.

20. OpenCut in a Team: Self-Host for a Studio

For a small studio, self-hosting OpenCut on one box (Docker Compose, localhost:3100) gives every editor the same tool with zero per-seat cost and zero footage leaving the building. That's a compliance story as much as a cost story: client NDA says "don't upload raw footage to third parties"? OpenCut makes that the default, not a policy you have to enforce.

The caveats for team use: the desktop app is still in progress (web is the mature surface), and there's no built-in multi-user auth on the classic build — you'd put it behind your own reverse proxy with auth. The rewrite's plugin marketplace and scripting will make team workflows real, but those are roadmap. For now, self-host the classic web build internally and treat it as a single-tenant tool.

21. OpenCut vs DaVinci Resolve vs Kdenlive

To place OpenCut honestly, a three-way:

| | OpenCut | DaVinci Resolve | Kdenlive |
|---|---|---|---|
| Cost | Free (MIT) | Free tier + $295 Studio | Free (GPL) |
| Privacy | Local / in-browser | Local | Local |
| Ease | CapCut-like | Pro learning curve | Moderate |
| Effects | Growing (community) | Industry-leading | Solid |
| Automation | Scripting/headless (roadmap) | Fusion scripts | MLT scripts |
| Maturity | Web mature, desktop WIP | Mature | Mature |

Use OpenCut when you want zero-cost, zero-account, local-only privacy and CapCut-like simplicity, and you can live without the deepest effects until the rewrite lands. Use Resolve when you need color, Fusion, and delivery polish today. Use Kdenlive when you want a mature free desktop editor without the CapCut aesthetic. OpenCut's edge is the privacy-and-fork guarantee, not capability yet.

22. Contributing and the Fork Guarantee

Because OpenCut is MIT and has 4,700+ forks, the "enshittification" path is closed. If the maintainers ever added a paywall or trained on user footage, the community forks and ships a clean version within days. That's not theoretical — the forks already exist.

For contributors: the classic repo (opencut-classic) is where you should build today; the rewrite (OpenCut) is stabilizing its architecture and not yet accepting outside PRs on every subsystem. The rust/ core, apps/web/, and apps/desktop/ are the places to look. The team runs an active Discord; 90+ contributors ship weekly. If you want to influence a 68k-star project, now is the window — before the rewrite freezes the API.

24. A Creator's Week With OpenCut

To make the privacy win concrete, a week of real content work:

Monday — client sends raw interview footage. You drag it into OpenCut's web app. It never uploads; it processes in-browser. You trim the dead air, add two subtitle lines. Export MP4, no watermark. The client's footage never touched a server.
Tuesday — a batch of 12 short clips needs the same intro/outro. You queue them (once the scripting path lands) and walk away. Local render, your machine, your power.
Wednesday — a personal vlog. No client, but you still use OpenCut because there's no account, no telemetry, no "sign in to continue."
Thursday — a sensitive internal video for a friend's startup. NDA says no cloud editing. OpenCut is the default, not a workaround.
Friday — you realize you haven't thought about "where did my footage go?" once all week. That absence of worry is the product.

For a creator, the switch from "did that upload?" anxiety to "it's all local" is the reason to use OpenCut even when CapCut's effects library is bigger. Privacy you can feel is rare in creative tools.

25. The MCP and AI Future

OpenCut's roadmap is where it gets interesting for "AI you run yourself." The enhanced MCP server will expose editing operations granularly — so an AI agent (say, hermes-agent or OpenWorker) could drive OpenCut: "cut the silent parts, add captions, export 1080p." The fal.ai partnership brings image/video/audio generation into the same local-first frame.

The scripting tab (TypeScript autocomplete for the Editor API, community script gallery, headless execution) turns OpenCut from an editor into a component — embeddable in SaaS products, automatable in CI/CD, scriptable for bulk work. That's the trajectory from "CapCut alternative" to "the open video layer everyone builds on."

For this blog's thesis — AI you can run on your own machine — OpenCut is the creative pillar: local video, local AI, no footage leaving the drive.

27. Self-Hosting OpenCut for a Studio

For a small studio, self-hosting the classic build on one box is the privacy-and-cost play:

git clone https://github.com/OpenCut-app/opencut-classic.git
cd opencut-classic
docker compose up -d
internal URL, e.g. edit.studio.local:3100

Put it behind your reverse proxy with auth (Caddy/Trailing). Every editor gets the same tool; no per-seat fee; no footage leaves the building. For client NDA work, that's the default, not a policy you enforce manually.

Caveats for team use: the classic build has no built-in multi-user auth, so the proxy does that job. The desktop app is still in progress, so the web build is your real surface. And you own updates — pin a version and pull when you're ready. For a studio doing volume, the math beats a cloud editor's per-export and per-seat fees handily, and the privacy posture is simply unavailable from CapCut.

28. The Roadmap, Honestly

The rewrite is the bet: a Rust core, a unified Editor API, a plugin marketplace, and an MCP server for AI-driven editing. If it lands, OpenCut becomes the open video layer other products embed — not just a CapCut alternative.

But "rewrite" means the new repo isn't finished. The web classic is what works today. Don't clone main expecting a polished editor; use opencut-classic until the rewrite ships stable. The team's velocity (90+ contributors, 1,280+ commits) suggests the gap closes fast, but "fast" in open source is not a date. Plan around what works now; treat the roadmap as upside.

30. OpenCut and the Creator Economy

The bigger pattern: OpenCut is one node in a wave of open-source replacements for enshittifying free tools — CapCut → OpenCut, Figma(pricing) → Penpot, Notion(complexity) → AppFlowy, Google Analytics(privacy) → Plausible, Heroku(free tier) → Coolify. The playbook is consistent: launch free, build a base, extract value via paywalls or data. Open source replies with a structural guarantee against the same trajectory.

For creators, this matters beyond price. When your editor is open source and local, you're not the product. Your footage isn't training data. Your workflow isn't a funnel. You own the tool the way you own a hammer. That's a different relationship with software than the subscription era taught us to accept.

OpenCut reaching 68k stars says the market wants that relationship back. The Rust/WASM core and the MIT license make it durable. For a creator in 2026, editing locally on OpenCut isn't a compromise — it's the sane default.

31. Verdict

OpenCut is the open-source CapCut done right: free, local, forkable, and honest about what's unfinished. The Rust/WASM core is the correct architectural bet, and the MIT license is the structural guarantee that it can never turn into the thing it replaces. If your footage is yours, edit it on a tool that agrees.

Related:

OpenCut: The Open-Source CapCut Alternative That Keeps Your Footage on Your Drive