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.
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.
Jun 26, 2026
OpenKnowledge from Inkeep ships a Notion-like WYSIWYG markdown editor, LLM wiki with MCP and skills, and no-code GitHub team sync — now open source at 444 stars with a macOS app and ok CLI for every platform.
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. But OpenCut is now expanding to Desktop, Android, and iOS—each becoming a thin UI layer wrapped around the same underlying engine.
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.
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 platform-agnostic core that any UI can wrap around.
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. You can:
The team posts sneak peeks and early builds to Discord first, so join if you want to test features before official releases.
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 with active contribution opportunities:
Code contributions:
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.