ReelMind

An open-source, AI-native video editor for Windows — you and your agent
edit video together on the timeline. It doesn't replace CapCut or Premiere; it
does the technical, repetitive work fast and hands the result off to them.

⚠️ Status: active development, not yet packaged. The desktop app runs and
the core editor + AI + MCP are working: import, timeline editing, real-time
preview, FFmpeg export, colorization, multicam sync, audio enhancement, angle
switching, script-based take segmentation, and an "export to Premiere / DaVinci
/ Final Cut" handoff. Some end-to-end flows (take detection, the NLE handoff)
are implemented and unit/integration-tested but still pending verification on
real footage / in a real NLE. AI media generation and a Windows installer
are next. Full plan & state: docs/PROJECT_PLAN.md.

What it does today

ReelMind focuses on the technical, repeatable parts of an editing job so a human
(or an agent) can move fast, then hands a clean, still-editable project to a
finishing editor:

• Import video/audio/images from files, folders, or URLs (direct links, and
  platform links — YouTube/Instagram/TikTok/… — via yt-dlp).
• Multicam sync — align two angles of the same take by audio
  cross-correlation, tag them as a linked group.
• Angle switching — cut between synced angles (non-destructive or ripple).
• Colorization — per-clip color grade + .cube LUTs, live in the WebGL
  preview and baked exactly on export.
• Audio enhancement — non-destructive voice cleanup / loudness chain (Web
  Audio live, FFmpeg on export).
• Segment by scripts ("guiones") — paste your scripts; it transcribes, aligns
  each script to where it was recorded, and opens each take as a clean, editable
  tab.
• Timeline editing — trim / move / split / ripple / snap, keyframes,
  transform, crop, opacity, fades, undo/redo.
• Export — one flat MP4 (FFmpeg), or a handoff to a finishing editor (see
  below).

Handoff to a finishing editor (Premiere / DaVinci Resolve / Final Cut)

Subtitles and effects aren't ReelMind's job — they're the editor's. So instead of
only rendering a flat MP4, the "Enviar a editor" button writes an editable
project the editor opens in their NLE (Non-Linear Editor — Premiere Pro,
DaVinci Resolve, Final Cut):

• A Final Cut Pro 7 XML (xmeml) sequence — the one interchange format all
  three import reliably.
• Baked media with our color grade + audio enhancement already in the
  pixels/audio, but with clips still separate and re-editable — so the editor
  keeps your look and just adds titles/effects/transitions.

Output lands in a handoff/<project>-<timestamp>/ folder (.xml + media/ +
luts/ + a README with per-NLE import steps).

Drive it from Claude Code (MCP)

ReelMind embeds an MCP server, so an external agent (Claude Code, Cursor,
Claude Desktop) can operate the editor with the same command surface a human
uses — in natural language: "load this folder, download these videos, sync the
angles, colorize, segment by my scripts, export to Premiere."

# with the app open:
claude mcp add --transport http reelmind http://127.0.0.1:4399/mcp

Full tool list, the workflow, and setup: MCP.md.

Credit where it's due

This is an independent, cross-platform derivative of
Palmier Pro — the AI-native
video editor for macOS by Palmier, Inc., released under
GPL-3.0. Palmier Pro is a native macOS/Swift app and cannot run on Windows; this
project rebuilds the platform-locked parts on cross-platform technology while
carrying forward Palmier's "built for AI" design.

Huge thanks to the Palmier team. See ATTRIBUTION.md for the
full statement of what is reused and what is re-implemented. This project is
not affiliated with or endorsed by Palmier, Inc. and does not use the
"Palmier" name for its product.

Vision

The core idea, inherited from Palmier Pro: an AI agent should be a first-class
operator of a real, non-linear video editor — not a chatbot beside it. The agent
can read the timeline, cut filler words, add captions, place clips, and generate
new media, using the same command surface a human uses. External tools like
Claude Code and Cursor drive it over MCP.

Why a separate project (not a fork)

Palmier Pro is ~99% Swift on Apple-only frameworks (AppKit/SwiftUI, AVFoundation,
CoreML, Speech, Sparkle). A Windows version is effectively a rewrite, so this is
an independent repository — with full attribution — rather than a fork. The
high-value, portable parts (data model, editing algorithms, the AI tool
contract, the MCP design) are re-implemented in TypeScript.

Architecture

• Electron 3-context model. Main (Node): project IO, FFmpeg/ffprobe,
  secrets via Windows safeStorage/DPAPI, the embedded MCP server, the agent
  runner. Preload: a narrow, context-isolated, sandboxed bridge. Renderer
  (React): UI, live editing state, and the pure engines.
• EditorController command API — every edit is one named, undoable command.
  The UI, the in-app agent, and the MCP server all call the same commands.
• Frame-based time throughout (integers), matching upstream — which also
  makes the FCP7-XML handoff map 1:1 with no rounding.
• Preview = pooled <video> + Canvas compositor (real-time); export =
  one FFmpeg filter_complex (exact). Both share one geometry/opacity/color/
  volume module so they stay consistent.
• AI = one tool contract (Zod → JSON Schema) + one executor, shared by two
  transports: the in-app agent (@anthropic-ai/sdk, BYOK) and the MCP server
  (@modelcontextprotocol/sdk). Bring-your-own-key only.
• Interchange = a pure src/core/interchange/ builder (FCP7 xmeml) + a bake
  planner, orchestrated in main to produce editable media for the handoff.

Roadmap

Done:

• P0 — Repo + scaffold ✅
• P1 — Media import + bin (ffprobe, thumbnails, waveforms), .vproj format ✅
• P2 — Timeline editing (trim / move / split / ripple / snap, keyframes, undo/redo) ✅
• P3 — Real-time multi-track preview ✅
• P4 — FFmpeg export ✅
• P5 — AI agent tool contract + in-app chat (BYOK) ✅
• P6 — Embedded MCP server (Claude Code / Cursor / Claude Desktop) ✅
• Colorization — per-clip grade + LUTs, live + export ✅
• Multicam sync + angle switching ✅
• Audio enhancement (voice cleanup / loudness) ✅
• Segment by scripts (transcription + take tabs) ✅ (pending on-footage E2E)
• NLE handoff (FCP7 XML + baked media → Premiere / Resolve / FCP) ✅ (pending real-NLE verification)

Next:

• Generation — Higgs Field, then fal.ai / Replicate (multi-provider, BYOK)
• CapCut handoff — experimental draft-JSON writer
• Packaging — Windows installer (electron-builder) + auto-update

Getting started (development)

Prerequisites

• Windows 10/11
• Node.js 20+ (developed on v24)
• FFmpeg 6+ on your PATH (developed on 8.0.1) — the
  bundled binary ships with packaging (npm run fetch:ffmpeg)
• Optional: yt-dlp on your PATH to import
  from YouTube/Instagram/TikTok/… links
• Optional keys (bring-your-own): ANTHROPIC key (set in the app's AI panel) for
  the agent; ELEVENLABS_API_KEY in .env for transcription

Run

npm install      # install dependencies
npm run dev      # launch the app in development (hot reload)
npm run build    # production build into out/
npm run typecheck
npm test         # unit + integration tests (vitest)

License

GPL-3.0-or-later. As a derivative of GPL-3.0 software, this project
is and remains GPL-3.0; you may use, study, modify, and redistribute it under
those terms. See ATTRIBUTION.md for upstream credit and
third-party notices.