OpenCut

1. Project/Product Overview

Basic Information

Project Positioning

The positioning of the OpenCut is very clear: to be a free, open source, privacy-first alternative to CapCut (overseas version cut) . Project Readme:

"A free and open source video editor for web, desktop, and mobile ."

The core idea is to let users really have their own data and tools-all video processing is done on local devices, no need to upload to the cloud, no need to register an account, no paywall, and no watermark to export.

Development Status: Full Rewriting

This is the most critical background information for understanding the current state of the OpenCut. The project currently has two parallel versions:

1. opencut-classic (Classic Edition): Archive warehouse, maintenance has been stopped. Based on Next.js FFmpeg.wasm WebGL/wgpu, it provides a web-side video editor. opencut.app is still running this version.
2. opencut (rewritten version, main warehouse): Rewriting from zero, the architecture is completely different. The goal is to build a Rust unified core plug-in-first architecture platform-wide coverage (web/desktop/mobile) next-generation editor. Currently only v0.3.0 has some features.

The rewritten version of the core vision:

-Editor API: Allows developers to extend editor functionality through APIs

-Plugin Priority Architecture: First-class third-party plugin system

-Unified Code Base: Desktop (Mac/Windows/Linux), mobile (iOS/Android) and browser share a Rust core

-MCP Server: allows AI Agents (such as Claude and Cursor) to directly drive the editor

-Headless Mode: No GUI mode for automated batch rendering, CI/CD integration

-Script panel embedded in editor: Users can write scripts directly in the editor to control the editing process

2. What does it mostly do?

Classic version (currently available)

Based on the Notes Release v0.3.0, the classic version has implemented a fairly rich feature set:

Timeline editing

-Multi-track video/audio timeline, support drag, crop, stitch, split

-Ripple Editing (ripple editing): automatically adjust the position of subsequent fragments after moving/deleting material, based on diff algorithm

-Multi-selection operation: Shift/Ctrl plus selection, batch movement and zoom timeline fragments

-Track labels, waveform display (RMS algorithm, high-performance scrolling rendering)

-Keyframe track expansion: Right-expand to see separate tracks for each animation property

Visual Effects

-Masks: split, rectangle, ellipse, star, heart, diamond, movie wide black edge, supports feathering (JFA algorithm) and stroke

-Key frame animation: position X/Y independent control, zoom width and height independent control, Bezier curve easing editor

-Special Effects System: Based on wgpu/Rust compositor, Blur and other effects are supported.

-Mixed Mode: global composition modes such as Multiply, Screen, and Overlay

-Canvas background: blur, solid color, gradient

-Stickers/Shapes/Flags/Emoji: A material system based on the provider architecture

Audio Processing

-Audio and video elements independent volume control

-Speed control (with pitch hold option)

-Audio waveform visualization

Text and Fonts

-Google Fonts integration (1000 fonts, AVIF sprite instant rendering)

-Automatic system font recognition

-Multi-line text, custom line height, word spacing

-Color picker (Hex/RGB/HSL with color picker)

Export

-H.264/MP4 format

-1080P HD Export

-No watermark

-Fixed the compatibility issue of MP4 with audio export failure on Firefox

Other

-Automatic subtitle generation for subtitle file import (SRT, etc.)

-Custom canvas size

-Bookmark system (rich text bookmark, with notes, color, duration)

-Real-time preview of zooming and panning

-Undo/Redo (command mode)

Rewrite version in planning

-Native desktop app (GPUI Rust)

-Mobile (same Rust core)

-MCP Server(AI driven editing)

-Headless batch rendering

-Complete third-party plugin ecosystem

-Editor built-in script panel

3. Applicable Scenario

4. Not quite the scene

5. Core Competence List

Classic Edition Technical Capabilities

Rendering Engine

-Full migration from WebGL to Rust/wgpu WASM compositor

-Rust core crates:

-'rust/crates/compositor'-synthesizer

-'rust/crates/effects'-Effects Pipeline

-'rust/crates/masks'-mask system (JFA feathering algorithm)

-'rust/crates/gpu'-GPU context management

-'rust/crates/time'-time system (MediaTime,120,000 ticks/second integer representation)

-WASM binding layer: 'rust/wasm/'→ TypeScript consumption via 'src/lib/wasm/'

Time System

-'MediaTime': integer tick count, 120,000 ticks/sec

-Can divide all standard frame rate denominators (23.976 → 5005 ticks/frame, 29.97 → 4004, 30 → 4000)

-'FrameRate' is a rational number type '{numerator, denominator}', not using floating point numbers

-Avoid floating-point precision cumulative error, frame alignment accurate

State Management

-Zustand manage global editor state

-Command mode (Command Pattern) driven undo/redo system

-Each edit operation is encapsulated as a separate command object

Storage

-Local IndexedDB persistence (browser side)

-25 migration steps overwrite schema changes (v9 → v25 16 new steps have been added in v0.3.0)

-Persistence storage protection (browser storage pressure protection)

Type Schema

-'SceneTracks': replaces the flat array with three explicit fields 'overlay', 'main' (singleton 'VideoTrack'), 'audio'

-Type level forces track order to prevent mixing

Deployment

-Docker one-click self-hosting ('docker compose up -d')

-Cloudflare Workers deployment (via OpenNext wrangler.jsonc)

-Vercel native deployment

Rewritten Architecture Features

-Moon Repo Replace Turbo:monorepo toolchain

-Proto management development tool version (moon 2.3.3, bun 1.3.11)

-Bun replaces npm/pnpm as package manager and runtime

-'apps/desktop/':GPUI Rust native desktop application (framework built, features to be implemented)

-'apps/web/':Vite front end (port 5173)

-'apps/api/':API service (port 8787,Cloudflare Workers compatible)

6. Architecture/deployment/integration approach

Classic version architecture diagram

┌─────────────────────────────────────────────┐
│                   apps/                      │
│  ┌──────────────┐  ┌──────────────────────┐ │
│  │  web/        │  │  desktop/ (GPUI)     │ │
│  │  Next.js     │  │  Rust 原生           │ │
│  │  React       │  │  (开发中)            │ │
│  └──────┬───────┘  └──────────────────────┘ │
└─────────┼───────────────────────────────────┘
          │ 调用
┌─────────▼───────────────────────────────────┐
│              rust/ (平台无关核心)            │
│  ┌──────────┐ ┌──────────┐ ┌─────────────┐ │
│  │compositor│ │ effects  │ │    masks    │ │
│  │  wgpu    │ │  pipeline│ │   JFA alg   │ │
│  └──────────┘ └──────────┘ └─────────────┘ │
│  ┌──────────┐ ┌──────────────────────────┐ │
│  │   gpu    │ │   time (MediaTime)       │ │
│  └──────────┘ └──────────────────────────┘ │
│  ┌──────────────────────────────────────┐   │
│  │     rust/wasm/ → WASM bindings       │   │
│  └──────────────────────────────────────┘   │
└─────────────────────────────────────────────┘

Local Development Environment (Classic)

# 1. Clone classic 版（当前可用的完整版本）
git clone https://github.com/opencut-app/opencut-classic.git
cd opencut-classic

# 2. 配置环境
cp apps/web/.env.example apps/web/.env.local

# 3. 启动依赖服务（Docker Compose）
docker compose up -d db redis serverless-redis-http

# 4. 安装依赖并启动
bun install
bun dev:web
# 访问 http://localhost:3000

Local Development Environment (Rewrite Edition)

# 1. Clone 主仓库
git clone https://github.com/OpenCut-app/OpenCut.git
cd opencut

# 2. 安装 proto 工具链
bash <(curl -fsSL https://moonrepo.dev/install/proto.sh)

# 3. 安装指定版本依赖
proto use  # 安装 bun 1.3.11 + moon 2.3.3
bun install

# 4. 启动开发服务
moon run web:dev  # localhost:5173
moon run api:dev  # localhost:8787

Docker Production Deployment (Classic)

# 一键启动所有服务（含生产构建的 Web 应用）
docker compose up -d
# 访问 http://localhost:3100

Cloudflare Workers deployment

-Deploy Next.js app to Cloudflare Workers via OpenNext adapter

-Configuration file: 'wrangler.jsonc' 'apps/web/open-next.config.ts'

WASM Local Development Process

# 安装 Rust 工具链
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
cargo install wasm-pack
cargo install cargo-watch

# 构建 WASM 包并链接到 Web 应用
bun run build:wasm
cd rust/wasm/pkg && bun link
cd apps/web && bun link opencut-wasm
bun dev:wasm  # 监听 Rust 变更自动重编译

Integration mode

How to use #7.

End User Usage (Online Version)

1. Open the browser to access the https://opencut.app
2. Drag or click to import video/audio/picture material
3. Drag the material to the timeline and superimpose multiple tracks.
4. Cut, divide and adjust the duration of the material
5. Add text, stickers, transition, mask and other effects
6. Create animations through the keyframe editor.
7. Adjust volume, speed
8. Click Export, select the resolution, download MP4 without watermark

Developer Self-Hosting

Simplest way (Docker):

git clone https://github.com/opencut-app/opencut-classic.git
cd opencut-classic
docker compose up -d

Acces'http: // localhost:3100 'can be used, and the data is stored in the local PostgreSQL database.

Core Code Sample (Classic Version)

Timeline Manager (Command Mode):

// apps/web/src/core/managers/timeline-manager.ts
export class TimelineManager {
  addTrack({ type, index }: { type: TrackType; index?: number }): string {
    const command = new AddTrackCommand(type, index);
    this.editor.command.execute({ command });
    return command.getTrackId();
  }

  insertElement({ element, placement }: InsertElementParams): void {
    const command = new InsertElementCommand({ element, placement });
    this.editor.command.execute({ command });
  }
}

Special effects registration system (plug-in design):

// apps/web/src/lib/effects/registry.ts
export class EffectsRegistry extends DefinitionRegistry {
  constructor() {
    super("effect");
  }
}

Rust Core Time Type:

// rust/crates/time — MediaTime 整数 tick 表示
// 120,000 ticks/秒，能精确表示所有标准帧率
// FrameRate 为 {numerator, denominator} 有理数类型

8. What can I say before sales

Core Speech: Adjust the cut-in angle according to the customer type

To technical decision maker (CTO/Technical Director)

"OpenCut is an open source video editor based on Rust's high-performance core, using wgpu/WASM architecture to achieve near-native rendering performance on the browser side. Its MIT license allows for fully private deployment and secondary development, the code is auditable, and the data never comes out of the local device. The team is currently working on a complete rewrite from TypeScript to Rust. In the future, it will provide Editor API, plug-in system and MCP Server, which can let AI Agent directly control the video editing process. For companies with video editing needs, this is the best way to get rid of the lock-in of commercial software vendors and achieve autonomous control."

Keywords:MIT license, full privatization, Rust high performance, secondary development, autonomous control, free from vendor lock-in

To the business decision maker (CEO/VP/Director)

"CapCut has been charging for a large number of functions since it was free. templates need money, AI functions need money, and HD export needs money. If your team has dozens or hundreds of people using similar tools, the annual subscription fee is a big expense. The core value of OpenCut is: one-time deployment, permanent free, no subscription wall, no watermark, data stays on its own server. 60000 community support from GitHub Star and nearly 100 contributors means the project has continued vitality. Vercel and fal. AI are sponsoring it, indicating that the industry is confident in this direction."

Keywords: cost savings, no subscription, no watermark, data security, industry endorsement

Safety and Compliance Team

"One of the hidden dangers of commercial video editors is that all materials must be uploaded to the manufacturer's cloud for processing. Similar to customer interview videos in the financial industry and case demonstration videos in the medical industry, there are risks of compliance and data leakage. The OpenCut architecture design principle is local processing-video rendering is done entirely in the browser or local server, and there is no need to upload any material to a third-party platform. Open source code can be subject to security audits, and the MIT license allows any modifications to the code to meet compliance requirements."

Keywords: local processing, data not leaving the country, auditable, compliance

To AI/Innovation Team

"The MCP Server OpenCut are building is a bright spot. It means that in the future, AI agents can be used to drive video editing-for example, by describing the desired effect in natural language, AI can call OpenCut editor capabilities through the MCP protocol and complete them automatically. Combined with fal. AI generative video/image model, an end-to-end AI video production pipeline can be built. This has huge imagination in scenes such as automated marketing video generation and mass content production."

Keywords:AI-driven, MCP Server, automated production, generative AI integration

Analogy

"OpenCut vs. CapCut is like VS Code vs. Sublime Text-the former is open source, community-driven, and highly scalable, while the latter is also excellent but limited by business strategy. OpenCut's MIT license guarantees that it will never go the paid route of CapCut."

9. Frequently Asked Customer Questions

Q1: How is OpenCut maturity now? Can it be used?

A: Need to distinguish between the two versions:

- Classic version (opencut.app) already has v0.3.0 version, which covers common requirements such as multi-track editing, key frame animation, masking, special effects, subtitles, audio processing, 1080P export, etc. It can be used for basic editing scenes. But it has been officially archived and is no longer maintained.

-Rewritten version (main repository) is still in the early development stage (apps/desktop only have the main.rs skeleton), and the function is not yet complete. Not recommended for use in production environments.

Suggestion: If the customer is only evaluating or internal pilot, PoC can be done based on the classic version. If you want to use it in a formal production environment, it is recommended to wait for the rewrite to release at least v1.0.

Q2: What is the difference between it and CapCut/shear ratio?

A:

-Material library is far less rich than CapCut (no video templates, music library, AI special effects library, etc.)

-CapCut's social sharing feature is not supported

-No version available for mobile

-No professional format support such as ProRes/RAW

-Rendering performance may have bottlenecks in complex projects (limitations of browser WASM)

-Lack of AI-driven functions such as one-key film formation and intelligent keying

But the advantages are also very obvious: completely free, unlimited export, data privacy, can be secondary development.

Q3: Is it commercially available? What are the restrictions?

A: Fully commercially available. The MIT license is one of the industry's most permissive open source protocols, allowing:

-Free to use (including commercial use)

-Modify the source code

-Distribute the modified version

-Privatization Deployment

-Integration into commercial products

The only requirement is to retain the original copyright statement and the text of the license. There is no copyleft contagious clause.

Q4: What platforms are supported?

A:

-Current(classic version):Web side (any modern browser, Windows/Mac/Linux)

-Planning (Rewritten Version):Windows/Mac/Linux Native Desktop (GPUI Rust), iOS/Android Mobile

Q5: Is deployment complex?

A: Not complicated. The classic version can be deployed through a single command of Docker, and the database and cache are arranged through docker-compose. The rewritten version is expected to provide a similar ease of deployment.

Q6: What's the difference with open source editors like Olive/Kdenlive/Shotcut?

A: The biggest difference is the architecture concept:

-Olive/Kdenlive/Shotcut is a traditional desktop application and depends on local FFmpeg installation.

-OpenCut web-first, run the rendering pipeline in the browser via WASM, with the goal of a unified cross-platform experience

-OpenCut planned MCP Server and Headless mode, with a more forward-looking layout in terms of AI and automation

-OpenCut technology stack is more modern (Rust wgpu Tauri) with greater performance potential

Q7: How about security? Will there be a back door?

A: As an open source project, the entire code is publicly available on GitHub and can be audited by anyone. Data processing is completely local and there is no logic for reporting to the server (the classic version only includes optional anonymous analysis and can be disabled). For customers with high security requirements, you can also fork and do security reinforcement.

Q8: Will the project die? Is the community active?

A:60,000 Star, 4,700 Fork, 98 contributors, Vercel and fal. AI sponsorship, these indicators show that the project has a strong community vitality. Even if the original maintainer stops development, the community can fork to continue maintenance-this is a core advantage of open source. The MIT license guarantees business continuity in this case.

10. PoC Recommendations

PoC Target

Verify whether the OpenCut can meet the video editing needs of customers in actual business scenarios, and evaluate its maturity, scalability, and integration difficulty.

PoC Phase Division

Phase I: Functional Verification (1-2 days)

Objective: Assess whether basic features meet customer needs

Specific steps:

1. Deploy the classic version of Docker instance (complete within 30 minutes)
2. Use the customer's typical video material (such as 3-5 common business video scenes) for editing operation
3. Verify the list of key features:

• [ ] Material import (video/audio/picture format compatibility)
• [ ] Multi-track timeline editing
• [ ] Crop, Split, Splice
• [ ] Text Overlay
• [ ] Export quality (resolution, code rate, watermark)
• [ ] Browser compatibility (Chrome/Firefox/Safari/Edge)

1. Record unsupported functions and stuck points

Phase 2: Integration Verification (2-3 days)

Objective: Verify integration into customer's existing workflow

Specific steps:

1. Brand customization: modify UI color matching/Logo to match customer brand (front-end development resources are required)
2. API Feasibility Assessment: Evaluate the API interfaces that can be exposed in existing code.
3. Storage docking: verify whether the IndexedDB data can meet the customer's persistence requirements
4. Deployment validation: Deploy in a customer test environment (Docker or Cloudflare Workers)
5. Permissions Integration: Evaluate how to interface with the customer's authentication system, if needed

Phase III: Pressure and Boundary Testing (1-2 days)

Objective: Test performance limits and exception scenarios

Specific steps:

1. Large file test (>1GB video file)
2. Long duration project (>30 minutes timeline)
3. Multi-track overlay (10 tracks render simultaneously)
4. Browser memory usage monitoring
5. Clipping experience in case of network disconnection
6. Export stability (5 consecutive exports)

PoC Success Criteria

PoC Risk Mitigation

1. Function does not meet : Clarify which functions can be supplemented through secondary development and which need to be rewritten
2. Performance Issues: Evaluate whether it can be resolved by upgrading hardware or optimizing the format of footage
3. Stability issue : Establish a fallback scheme (such as temporarily using CapCut free version as a backup)
4. Time Risk : There is no clear release schedule for the rewritten version. Do not promise unfinished functions.

11. Risks and Considerations

Technical Risk

Project Risk

Business Risk

12. My Pre-Sales Judgment

Overall Assessment

Recommended Strategies

Scenarios recommended for advancement

1. Internal tools/pilot project: If customers have exploratory video editing needs, OpenCut can be used as a low-cost experimental solution. Especially in combination with self-hosted Docker deployment, it is suitable for use in an enterprise intranet environment.
2. Privacy Compliance Just Needs Scenarios : Financial, medical, government and other industry customers who have the requirements of not leaving the country or uploading data to the cloud are OpenCut very few choices to meet this demand.
3. AI Video Editing Research: AI teams interested in MCP Server and Headless mode can layout in advance.
4. Teams with extremely limited budgets: Educational institutions, NGOs, startups, etc., can use OpenCut to reduce video production costs.

Suggested wait-and-see scenario

1. Production-level video production: Wait for the rewrite to reach at least Beta stage.
2. Users who need a lot of materials/templates : Material ecology still needs time to build.
3. Customers who need official technical support: There is no commercial support system.
4. Mobile-first scenario : Waiting for native application release.

Key time node prediction

Competitive Landscape Analysis

                     简单易用 →
                 ┌──────────────────
      价格低 ↓   │ CapCut/剪映  │ OpenCut(未来)
                 │ (免费变收费) │ (免费开源)
                 ├──────────────┼────────────────
                 │ 专业工具     │ DaVinci Resolve
                 │ Premiere     │ (免费版功能强)
                 │ Final Cut    │
                 └──────────────┘

OpenCut has a unique advantage in the "free simple" quadrant-CapCut is moving in the direction of "fee", while OpenCut guarantees permanent "free" with the MIT license ". This positioning is very accurate.

13. REFERENCE

Official Resources

-GitHub master repository (rewritten version):https://github.com/OpenCut-app/OpenCut

-GitHub Classic (Archive):https://github.com/OpenCut-app/opencut-classic

-Online Experience (Classic):https://opencut.app

-Online Experience (Rewrite):https://new.opencut.app

-Discord Community: https://discord.gg/zmR9N35cjK

-License (MIT):https://github.com/OpenCut-app/OpenCut/blob/main/LICENSE

-Sponsor mailbox: sponsor@opencut.app

Version Release

-v0.3.0 Release(2026-04-15):https://github.com/OpenCut-app/OpenCut/releases/tag/v0.3.0

-v0.2.0 Release(2026-03-02):https://github.com/OpenCut-app/OpenCut/releases/tag/v0.2.0

-v0.1.0 Release(2026-02-23):https://github.com/OpenCut-app/OpenCut/releases/tag/v0.1.0

Related Technologies

-Moon Repo(monorepo Tools):https://moonrepo.dev

-Proto (version management):https://moonrepo.dev/proto

-Bun(JavaScript runtime):https://bun.sh

-GPUI (the Rust UI framework used by the Zed editor)

-wgpu (cross-platform GPU API):https://wgpu.rs

-fal. AI (Generic AI Model):https://fal.ai

-Vercel (deployment platform):https://vercel.com

Third-party reporting and analysis

-"Cuned by cutting members? OpenCut this open source project gives everyone a second choice"-open source glean (headline)

-"OpenCut: The Open-Source CapCut Alternative With 45,000 GitHub Stars" - TheMenonLab Blog

-"OpenCut is an Open-source Alternative to CapCut" - Medevel

-"OpenCut Getting Started"-CSDN

Competitor Reference

-CapCut/Cut: https://www.capcut.com

-Shotcut (open source desktop editor):https://shotcut.org

-Olive (open source node graph editor):https://olivevideoeditor.org

-Kdenlive(KDE Video Editor):https://kdenlive.org

-DaVinci Resolve (Pro Free Version):https://www.blackmagicdesign.com/products/davinciresolve