Why OpenCut Is Tearing Down Its Engine to Rebuild in Rust

Building a cross-platform non-linear video editor is one of the nastiest problems in software engineering. You are juggling frame-accurate timeline synchronization, massive memory throughput, platform-specific hardware acceleration, and the unforgiving expectation of real-time 60fps playback across mobile screens, desktop monitors, and web browsers. Most teams attempt this by gluing together brittle platform bridges until the technical debt crushes the roadmap. The team behind OpenCut is taking a different path: they are throwing away the old playbook and executing a complete ground-up rewrite.

Instead of patching legacy cracks, OpenCut is shifting to a unified Rust core. The goal is ambitious but clear. They want a single, high-performance codebase targeting web, desktop, and mobile simultaneously, paired with a modern control plane built for both human creators and programmatic workloads.

       +-----------------------------------------------+
       |             OpenCut Plugin-First Core         |
       |                   (Rust Core)                 |
       +-----------------------------------------------+
          /                    |                    \
         /                     |                     \
+-----------------+   +-----------------+   +-----------------+
|  Web Interface  |   | Desktop Client  |   | Mobile Target   |
| (Vite Port 5173)|   | (Native Shell)  |   | (Unified Build) |
+-----------------+   +-----------------+   +-----------------+
         \                     |                     /
          \                    |                    /
       +-----------------------------------------------+
       |         Automation & AI Control Plane         |
       |  (Headless Mode, Scripting Tab, MCP Server)   |
       +-----------------------------------------------+

The Architectural Pivot: Rust, Plugins, and Headless Engines

The new OpenCut architecture addresses the traditional shortcomings of creator software: isolation and lack of extensibility. Most editors treat third-party extensions as an afterthought, exposing brittle macro systems that break between minor updates. OpenCut is restructuring around a plugin-first philosophy backed by an Editor API, making deep customization a first-class citizen rather than a hack.

The technical overhaul introduces three critical capabilities:

Unified Rust Engine: By anchoring the core timeline and processing pipeline in Rust, the engine compiles natively across desktop platforms, drives mobile targets, and runs inside web environments without maintaining parallel implementations.
Model Context Protocol (MCP) Server: The engine includes a native MCP server designed specifically for AI agents, allowing external intelligence layers to query timelines, execute edits, and manipulate project states deterministically.
Headless Mode and Scripting Tab: High-volume pipelines cannot rely on manual UI interaction. OpenCut introduces a headless execution layer for batch rendering and server-side automation, complemented by an in-editor scripting tab for on-the-fly local automation.

Classic vs. The Next-Gen Rewrite

The project is running two tracks while the next iteration takes shape. Users who need a functional timeline today can continue running the original implementation, while the new foundation develops in isolated repositories and staging domains.

Capability / Attribute	OpenCut Classic	Next-Gen Rewrite
Codebase Target	`opencut-app/opencut-classic`	Unified Core (`new.opencut.app`)
Core Language	Legacy Architecture	Rust Core
Platform Target	Web / Desktop / Mobile variants	Single unified codebase for Web, Desktop, and Mobile
Extensibility	Standard functionality	Plugin-first with dedicated Editor API
AI Integration	None / Manual	Native MCP server for AI agents
Automation	UI-driven editing	Headless mode, batch rendering, and in-editor scripting tab
Production Domain	`opencut.app`	Transitioning: `new.opencut.app` to `opencut.app`

Local Development: Spinning Up the Workspace

The engineering team utilizes proto for unified toolchain management and moon for monorepo task orchestration. You can pull down the dependencies and spin up the developer services in a few minutes.

First, ensure proto is installed in your local environment:

bash
bash <(curl -fsSL https://moonrepo.dev/install/proto.sh)

From the root of the cloned OpenCut repository, pin and activate your toolchains, then launch the development processes:

bash
# Pin and install managed toolchains
proto use

# Launch the local Web UI (served on http://localhost:5173)
moon run web:dev

# Launch the local API service (served on http://localhost:8787)
moon run api:dev

If you are working on the native desktop wrapper, consult the configuration details inside apps/desktop/README.md to configure platform dependencies.

Ecosystem, Governance, and Licensing

Because the core architecture is under active design, the maintainers have paused external code contributions to focus on baseline stability. Engineering progress and discussions remain open through their Discord community and GitHub issue trackers.

OpenCut is released under the permissive MIT license, ensuring that the engine remains freely forkable and modifiable for commercial and private use. The project's infrastructure and development efforts are supported by community backers and commercial sponsors, including fal.ai, which provides generative media models across image, video, and audio domains.

Rebuilding an editor from scratch is a massive gamble, but swapping runtime glue for a single Rust core with native headless execution turns OpenCut from a simple web toy into a serious contender for modern developer-driven media workflows.

Reference

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