explainx / blog
OpenCut announced a complete ground-up rewrite in May 2026, expanding from web-only to Desktop, Android, and iOS with a unified TypeScript engine. New features include a plugin system, headless rendering, scripting tab, MCP server for AI agents, and public Editor API for building custom video tools.
Jun 21, 2026
Palmier Pro is the first video editor where your AI agent has hands on the timeline. Free to download, open source, Swift-native. Claude connects via a local MCP server and can generate footage, trim, reorder clips, and iterate prompts — all in one project. We used it to edit a YouTube Short and built a skill for it. Here is the full setup guide.
Jul 20, 2026
李博杰 (Bojie Li) open-sourced 《深入理解 AI Agent》 with 10 chapters, PDFs in four languages, and chapter-matched demos. This guide answers the questions GitHub Trending readers ask: cost, English lag, first runnable projects, and how it connects to explainx.ai's MCP, skills, and harness coverage.
Jun 29, 2026
video-use is an open-source skill for Claude Code (and Codex, Hermes, Openclaw) that edits videos via natural language — no timeline scrubbing, no NLE menus. It reads footage as transcript text, reasons over word-level timestamps, calls ffmpeg, self-evaluates every cut, and outputs final.mp4. 11.6k GitHub stars in two months. Here is the full setup and how it works.
Update — July 14, 2026: The
rewritebranch merged tomain(~3 days ago per GitHub) — desktop app scaffolded, moonrepo + proto dev toolchain, 67k★ / 7k forks. Use today: opencut-classic at opencut.app. Rewrite preview: new.opencut.app until takeover. Rust core replaces browser-only TypeScript engine. Outside PRs paused while architecture settles. Sponsor: fal.ai.
On May 27, 2026, the OpenCut team announced they're rebuilding their open source video editor from the ground up. What started as a web-only video editor is evolving into something much bigger: a multi-platform video editing engine with plugins, headless rendering, scripting capabilities, and an MCP server for AI integration.
The rewrite addresses a fundamental architectural decision: the original TypeScript engine running in a browser was fine when web was the only platform. The July 2026 rewrite targets web, desktop, and mobile from one codebase with a Rust core — each platform a thin UI layer around shared rendering logic.
Beyond platform expansion, the rewrite introduces four major capabilities that weren't possible in the original architecture: a plugin system, headless mode, a scripting tab, and an MCP server. These additions transform OpenCut from a traditional video editor into a programmable video platform that developers can build on.
| Question | Answer |
|---|---|
| Edit videos today? | opencut.app — classic build |
| Try rewrite? | new.opencut.app — preview only |
| GitHub | OpenCut-app/OpenCut — 67k★, MIT |
| Classic repo | opencut-app/opencut-classic |
| Core stack | Rust core + TypeScript UI (97% TS in repo today) |
| Dev setup | proto use → moon run web:dev (5173), api:dev (8787), desktop:dev |
| Contribute PRs? | Paused — architecture still being designed |
| AI hook | MCP server planned for agent-driven editing |
| Sponsor | fal.ai — generative image/video/audio models |
This article covers what's changing, why the team chose a complete rewrite, the new capabilities being added, and how to follow along with development.
The OpenCut team made a clear decision: complete rewrite rather than incremental refactoring. The reason comes down to architecture.
The original OpenCut was built with a TypeScript engine running in the browser. That architecture works well for a web-only editor, but it creates friction when expanding to native platforms:
Rather than maintaining separate codebases or dealing with cross-platform compromises, the team chose to rebuild the engine as a Rust-core platform that any UI can wrap around — web (Vite on port 5173), desktop (scaffolded July 2026), and mobile targets sharing one monorepo under moonrepo.
Local dev (rewrite main, July 2026):
bash <(curl -fsSL https://moonrepo.dev/install/proto.sh)
proto use # tools from .prototools
moon run web:dev # localhost:5173
moon run api:dev # localhost:8787
moon run desktop:dev # see apps/desktop/README.md
The rewrite also enables capabilities that would be difficult to retrofit into the existing codebase:
In the team's words: "Everything in this post comes from one decision." That decision is the foundation rewrite.
After the rewrite, OpenCut will run on four platforms:
| Platform | Implementation | Status |
|---|---|---|
| Web | Current TypeScript engine, modernized | In development |
| Desktop | Native wrapper around shared engine | In development |
| Android | Native wrapper around shared engine | In development |
| iOS | Native wrapper around shared engine | In development |
Each platform gets a thin UI layer optimized for its input methods and design conventions, but the editing engine, rendering pipeline, and feature set remain identical across all platforms.
This architecture means:
The web version remains the primary development target, with other platforms following as the engine stabilizes.
The rewrite includes a brand new user interface designed from the ground up. While the team calls it "revolutionary" with a touch of humor, the real focus is on workflow efficiency.
Key UI improvements:
The keyboard-first mode is particularly interesting for developers and power users. When enabled, you can perform most editing operations without touching the mouse—similar to Vim or Emacs workflows in code editors.
Beyond the architectural changes, the rewrite brings several features users have been requesting:
Improved automatic caption generation with better accuracy and formatting options.
A much bigger effects library with professional transitions, filters, and color grading tools. Effects are GPU-accelerated for real-time preview.
Finally, you can group multiple timeline elements and edit them as a unit—essential for complex compositions.
The new rendering pipeline is rebuilt for performance and reliability, with better memory management and progress reporting.
These improvements set the stage for the bigger architectural additions.
OpenCut is getting a full plugin system that allows users to install third-party plugins from the Plugin Store or build and publish their own.
The Plugin API provides structured access to:
The announcement includes several plugin concepts that illustrate the system's flexibility:
Custom snapping — Snap to audio peaks in the timeline instead of just frame boundaries. Useful for syncing video edits to music beats.
Cross-platform publishing — Publish to TikTok, YouTube, Instagram, and more inside the editor. No need to export and upload manually.
Silence remover — Scan the timeline and automatically cut any silence longer than a threshold you set. Essential for podcast editing.
Third-party developers can build plugins for niche workflows like:
The plugin system transforms OpenCut from a fixed-feature editor into a platform that grows with its community.
Headless mode is one of the most powerful additions for developers: the ability to run OpenCut's engine without a UI.
Instead of opening the editor, clicking through menus, and manually exporting, you script what you want and OpenCut renders a finished video.
Batch rendering — Queue 50 clips with the same template, come back to finished files. Perfect for generating multiple versions of the same content.
Template pipelines — Define your format once, swap the assets, re-render. What took an hour of clicking is now a script you run. Ideal for recurring content like weekly shows or product demos.
Server-side rendering — Build anything on top of OpenCut. Your users click a button and a render comes out. They never see the editor. This enables SaaS products built on OpenCut's engine.
Automated social media clips — A script watches a folder for new podcast episodes, extracts 1-minute clips based on transcript timestamps, adds branded intros and subtitles, and uploads to YouTube Shorts.
Personalized video at scale — An e-learning platform generates custom certificate videos for each student by swapping names and achievement data into a template.
Data visualization videos — A financial dashboard exports monthly reports as videos by feeding chart data into OpenCut templates and rendering overnight.
Headless mode makes OpenCut a video rendering engine, not just an editor.
While plugins are for permanent additions, the scripting tab is for one-off automation and experimentation.
The scripting tab is a panel in the editor where you can write scripts that talk directly to OpenCut:
// Example: Add a 1-second fade transition between all clips
const clips = timeline.getClips();
for (let i = 0; i < clips.length - 1; i++) {
timeline.addTransition(clips[i], clips[i+1], 'fade', 1.0);
}
Use cases:
The scripting tab provides immediate feedback, making it easy to experiment with the Editor API without setting up a development environment.
OpenCut will expose an MCP (Model Context Protocol) server, allowing AI agents to work alongside you while editing.
While you're editing, an AI agent can:
The MCP server works with Cursor, Claude Code, and any MCP-compatible client.
You're editing a product demo video. You tell your AI agent:
"Add a 0.5-second crossfade between every scene, then boost audio by 3dB on all voiceover clips."
The agent uses OpenCut's MCP server to:
This level of AI integration turns OpenCut into a collaborative editing environment rather than a solo tool.
For developers unfamiliar with MCP, it's a protocol that allows AI agents to access application functionality through a standardized interface. Learn more at explainx.ai's MCP guide.
All four new capabilities—plugins, headless mode, scripting, and MCP—rely on the Editor API: a fully public API that exposes everything you can do in the editor.
The team's promise:
"Everything you'll be able to do in the editor, you'll be able to do through a fully public API. Build on it, script it, automate it, ship products on top of it."
This is the foundation that makes OpenCut more than a video editor—it's a programmable video platform.
OpenCut is building in the open on GitHub — rewrite merged to main July 2026 after months on the rewrite branch.
| Surface | URL | Status |
|---|---|---|
| Production editor | opencut.app | Classic codebase |
| Rewrite preview | new.opencut.app | Early — not default yet |
| Classic source | opencut-app/opencut-classic | Stable for daily edits |
| Rewrite source | OpenCut-app/OpenCut | 67k★ · MIT · v0.3.0 (Apr 15, 2026) |
July 2026 contributor policy: README says the team is not accepting outside contributions yet while architecture is designed — follow along via Discord, issues, and discussions instead of opening feature PRs.
You can still:
The team posts sneak peeks and early builds to Discord first.
Here's the full scope of the rewrite:
Platform support:
New capabilities:
Requested features:
The rewrite is in active development with no firm release date. The team is prioritizing stability and quality over speed.
At explainx.ai, we teach MCP integration, AI agent development, and automation workflows. OpenCut's rewrite exemplifies a trend we've been tracking: open source tools becoming platforms for AI and automation.
Key observations:
OpenCut's approach—complete rewrite to support programmability—is the right move for a tool aiming to be a platform, not just an app.
The combination of headless mode + MCP server + scripting creates a powerful foundation for:
We're excited to see what developers build on top of OpenCut.
Understanding OpenCut's architectural evolution helps explain why a complete rewrite was necessary rather than incremental refactoring.
The first version of OpenCut was built as a browser-based video editor with:
This architecture was elegant for web-only deployment but created constraints:
The rewrite introduces a platform-agnostic core with native wrappers:
Core Engine Layer (TypeScript/Rust hybrid):
Platform Adapter Layer:
API Layer:
This layered approach means core logic is written once (in the engine layer) and platform-specific code is minimal (just the adapter layer).
The rewrite includes several performance improvements:
GPU acceleration:
Memory management:
Multi-threading:
Streaming architecture:
The plugin system is one of the most technically ambitious parts of the rewrite. Here's how it works under the hood:
Plugins get access to a subset of the Editor API with security boundaries:
Allowed operations:
Restricted operations:
When a plugin is loaded:
plugin.json for metadata, permissions, and entry pointinit() function is called with the Plugin APIWhen a plugin is unloaded:
cleanup() function is calledHere's what a real plugin looks like:
// plugin.json
{
"name": "silence-remover",
"version": "1.0.0",
"permissions": ["timeline.read", "timeline.write", "audio.analyze"],
"entry": "index.js"
}
// index.js
export default class SilenceRemoverPlugin {
async init(api) {
// Register a button in the toolbar
api.ui.addButton({
label: "Remove Silence",
icon: "scissors",
onClick: () => this.removeSilence(api)
});
}
async removeSilence(api) {
const tracks = api.timeline.getAudioTracks();
for (const track of tracks) {
// Analyze audio for silence
const silenceRanges = await api.audio.detectSilence(track, {
threshold: -40, // dB
minDuration: 0.5 // seconds
});
// Remove detected silence
for (const range of silenceRanges.reverse()) {
api.timeline.(track, range., range.);
}
}
api..( + silenceRanges. + );
}
() {
}
}
This plugin:
The Plugin Store is a centralized repository where:
Security measures:
For enterprise users, OpenCut will support private plugin repositories where companies can host internal plugins without going through the public store.
Headless mode transforms OpenCut from an interactive editor into a programmable rendering service.
When running headless, OpenCut:
Start the headless server:
opencut serve --headless --port 8080
Submit a render job via HTTP:
curl -X POST http://localhost:8080/render \
-F "project=@my_project.opencut" \
-F "output_path=/tmp/output.mp4" \
-F "resolution=1920x1080" \
-F "fps=60" \
-F "codec=h264"
Check render status:
curl http://localhost:8080/render/abc123/status
# Returns: {"status": "rendering", "progress": 0.45, "eta_seconds": 120}
Download finished render:
curl http://localhost:8080/render/abc123/download -o output.mp4
For programmatic control, use the Node.js API:
const OpenCut = require('opencut');
async function renderVideo() {
const editor = await OpenCut.createHeadless();
// Load project from file
await editor.loadProject('./template.opencut');
// Programmatically modify the timeline
editor.timeline.addClip({
file: './footage.mp4',
start: 0,
duration: 10,
track: 0
});
editor.timeline.addText({
content: "Hello World",
start: 2,
duration: 5,
style: { fontSize: 48, color: '#ffffff' }
});
// Export with custom settings
await editor.export({
output: './output.mp4',
resolution: [3840, 2160], // 4K
fps: 30,
codec: 'h265',
bitrate: '50M'
});
console.log('Render complete!');
}
renderVideo();
1. Social Media Automation Platform
A SaaS product that generates branded social videos:
2. E-Learning Content Pipeline
An online course platform generating lecture videos:
3. News Agency Video Generation
A newsroom generating daily video summaries:
The MCP server is OpenCut's bridge to the AI agent ecosystem. Here's how it works in practice:
Model Context Protocol (MCP) is a standardized way for AI agents to communicate with applications. OpenCut's MCP server exposes tools that agents can invoke:
Available MCP tools:
opencut.timeline.getClips() - List all clips in the timelineopencut.timeline.addClip(file, start, track) - Add a video/audio clipopencut.timeline.addTransition(clip1, clip2, type, duration) - Insert transitionopencut.effects.apply(clip, effect, params) - Apply effect to clipopencut.export.start(settings) - Begin export with specified settingsopencut.project.save(path) - Save current projectopencut.script.execute(code) - Run JavaScript in scripting tabUser working in OpenCut with Claude Code running:
User: "I need to add a 1-second fade transition between every scene in this timeline."
Claude Code (via MCP):
opencut.timeline.getClips() to retrieve all clipsopencut.timeline.addTransition(clipA, clipB, 'fade', 1.0)User: "Now export this as a 4K YouTube video."
Claude Code:
opencut.export.start({ format: 'mp4', resolution: '3840x2160', preset: 'youtube' })opencut.export.status()Advanced users can run multiple specialized agents simultaneously:
Each agent uses the MCP server to read and modify the timeline in coordination. OpenCut's undo system allows reverting any agent-made changes.
The MCP server requires authentication to prevent unauthorized access:
Users can grant per-agent permissions:
How does OpenCut stack up against other video editing tools?
DaVinci Resolve:
OpenCut:
When to choose OpenCut: Automation pipelines, custom workflows, embedding in other tools
When to choose DaVinci: High-end color work, VFX, professional productions
FFmpeg:
OpenCut:
When to choose OpenCut: Need both interactive editing and automation
When to choose FFmpeg: Pure command-line automation, maximum control
Remotion:
OpenCut:
When to choose OpenCut: Team includes non-developers, need interactive editing
When to choose Remotion: Pure code-first workflow, React expertise available
Adobe Premiere Pro:
OpenCut:
When to choose OpenCut: Budget constraints, automation needs, open source requirements
When to choose Premiere: Professional workflows, Adobe ecosystem, advanced features
The OpenCut team has outlined several post-rewrite priorities:
OpenCut is community-driven — but outside PRs are paused on the rewrite while architecture stabilizes (July 2026 README).
While PRs are closed:
rewrite progressWhen contributions reopen (expected post-architecture lock):
Code contributions (future):
Design contributions:
Community support:
OpenCut uses a core team + community model:
All major decisions are discussed in GitHub Discussions before implementation.
Development is in progress. Feature availability and timelines subject to change. Follow github.com/OpenCut-app/OpenCut/issues/811 for updates. All code examples are illustrative and subject to API changes before final release.