OpenCut

Route count is generated from opencut/_generated/route_manifest.json and reflects shipped routes only — each route is tagged implemented / dependency-gated / stub, and strategic 501 stubs are excluded from the advertised count. Run python -m opencut.tools.dump_route_manifest --check to verify it is in sync with the live Flask app, and GET /system/route-readiness for the live shipped count and stub list. The same manifest carries a literal first-party surface map: 280 shipped routes have literal first-party panel, palette, CLI, and curated MCP references, while 1,288 integration-only routes are backend/integration surfaces rather than advertised panel workflows. Generic opencut route and opt-in extended MCP remain available for deliberate route-level access.

OpenCut replaces ~$1,400/year of video-editing subscriptions with a free, MIT-licensed Premiere Pro extension. Unlimited, reviewable silence-cut passes direct to timeline, cross-project media search, stem separation, voice cloning, 55-style animated captions with exportable artifacts, local LLM highlights, and multi-platform social export -- with no subscriptions, no usage caps, and no API keys required for core local features. Cloud providers, Edge-TTS, downloads, telemetry, and social uploads are optional, explicit network features.

---

Project planning

• ROADMAP.md is the only active open-work tracker.
• CHANGELOG.md records shipped release-facing changes.
• RESEARCH.md summarizes the current research direction and points to archived research inputs.
• docs/RESEARCH_COMPETITIVE_TEARDOWN_2026-06-10.md preserves the June 2026 competitive teardown evidence.

---

Naming & distribution

Decision (2026-06-14): the product keeps the name OpenCut, but the package-manager distribution token is opencut-ppro.

There is an unrelated, popular browser-based editor also called OpenCut (github.com/OpenCut-app/OpenCut, ~48K stars). To keep search, PyPI, Homebrew, and winget unambiguous — and to stay distinct from it when it relaunches — this project distributes under a qualified token: the -ppro suffix marks the Adobe Premiere Pro integration that uniquely identifies this tool. So:

• Reserved distribution name:opencut-ppro on PyPI, Homebrew, and winget. None of those package channels is published as of 2026-07-22, so this README provides source-checkout commands only.
• Unchanged: the product name OpenCut, the Python import package (import opencut), the CLI commands (opencut, opencut-server, opencut-mcp-server), and the CEP/UXP extension IDs (com.opencut.panel, com.opencut.uxp).

The opencut-ppro name is reserved-by-decision here and in pyproject.toml; the actual PyPI publish (via trusted publishing) is tracked in the roadmap and is the one step that needs the maintainer's PyPI account.

---

Quick Start

Prerequisites

• Adobe Premiere Pro 2019 or later (CEP panel) / 25.6+ (UXP panel)
• Windows 10/11, macOS, or Linux (Windows installer, macOS/Linux source launchers, and Linux Flatpak/AppImage release packaging)
• Python 3.11-3.14 for source installs; the Windows installer bundles its own runtime
• FFmpeg must be installed and on your system PATH for all video/audio processing. The Windows installer handles this automatically; source installs require a manual install (see below)

Installation

Option A -- Windows Installer (recommended for Windows):

The latest published Windows installer is OpenCut v1.25.1. It predates the current source tree. Release artifacts are named OpenCut-Setup-<version>.exe and handle everything: server, FFmpeg, CEP extension, registry, and optional model downloads. No Python is needed for that packaged release; use Option B or C for the current source version.

Every assembled installer includes release-composition.json, opencut-artifact-sbom.cyclonedx.json, THIRD-PARTY-NOTICES.txt, and ffmpeg-provenance.json beside the installed application. These records bind the direct and transitive Python packages, packaged payloads, and bundled FFmpeg binary to SHA-256 hashes and document the exact FFmpeg source and build provenance needed to reproduce the GPL-covered component.

Option B -- Install.bat (recommended for Windows source installs):

This is the easiest way to install from source on Windows. It handles FFmpeg, Python dependencies, the CEP extension, registry keys, and launcher creation in one step.

git clone https://github.com/SysAdminDoc/OpenCut.git
cd OpenCut

Then right-click Install.bat and select Run as Administrator. The installer will:

1. Install or upgrade FFmpeg and reject releases below 8.1.3 or snapshots before 2026-07-06
2. Verify Python 3.11-3.14 is on your PATH (unsupported versions are rejected before installation)
3. Install all Python dependencies (Flask, click, rich, etc.)
4. Install the OpenCut Python package
5. Optionally install Whisper for caption generation
6. Copy the CEP extension to Adobe's extensions folder
7. Set the PlayerDebugMode registry key so unsigned extensions load
8. Create Start-OpenCut.bat on your desktop to launch the backend server

After the installer finishes, you are ready to use OpenCut -- see Launch below.

Option C -- From source (manual):

If you prefer manual control or are on macOS/Linux, follow these steps:

1. Install FFmpeg 8.1.3 or newer, or a dated post-fix git-master snapshot and make sure it is on your system PATH. OpenCut blocks older and unparseable builds before media processing because 8.1.2 is affected by CVE-2026-64832, CVE-2026-64833, CVE-2026-64835, and CVE-2026-66041:
   • Windows: download the ffmpeg-git-full snapshot from https://www.gyan.dev/ffmpeg/builds/ (the bundled build is 2026-08-03-git-01a25f74cc-full_build-www.gyan.dev, source commit 01a25f74cc446a683318bab13dfd98a467082ef7) and add its bin folder to your PATH
   • macOS: brew install ffmpeg
   • Linux: sudo apt install ffmpeg (Debian/Ubuntu) or equivalent for your distro
   • Verify: python scripts/verify_ffmpeg_provenance.py must report RESULT: OK

The bundled Windows archive is pinned to SHA-256 8c32ed9800ff421bbcfda96beb0a66783a64a7cd98869b87ec1b494d3c855fcc. Its corresponding FFmpeg source archive is pinned to SHA-256 02f09346860e4b0549eb03003443c66dceb9f355c2db4f01746db33984f1e3cf.

2. Clone and install the Python package:

   git clone https://github.com/SysAdminDoc/OpenCut.git
   cd OpenCut
   python -m pip install -e "."

   Add a supported optional profile after the core install as needed (see Dependency Tiers). On Windows, if python is not found, use py -3.12 -m pip install -e ".". If you get permission errors, add --user to the pip command.

3. Install the CEP extension (for the Premiere Pro panel):

   • Windows: copy the folder extension/com.opencut.panel to %APPDATA%\Adobe\CEP\extensions\ (create the extensions folder if it does not exist)
   • macOS: copy to ~/Library/Application Support/Adobe/CEP/extensions/
   • Then set the debug registry key so Premiere loads unsigned extensions:
     • Windows: open regedit, navigate to HKCU\Software\Adobe\CSXS.18 (create the key if needed), add a String value PlayerDebugMode set to 1. Repeat for CSXS.17, .16, etc. to cover your Premiere version.
     • macOS: defaults write com.adobe.CSXS.18 PlayerDebugMode 1

4. Start the server:python -m opencut.server

Add torch-stack or narrower feature extras only when you need Torch-backed backends such as Demucs separation, pyannote diarization, RealESRGAN/GFPGAN restoration, or TransNetV2 scene detection. WhisperX 3.8.x is not an installable OpenCut extra because its torchvision <0.24 requirement conflicts with the torchvision >=0.25 / Torch 2.10 security floor. The Dependency Dashboard reports that incompatibility instead of recommending a vulnerable environment.

Supported base runtimes are CPython 3.11, 3.12, 3.13, and 3.14 on Windows, Linux, and macOS. Optional extras are resolver-tested across their declared lanes; ai-gpu is limited to Windows and Linux, generic macOS targets exclude the ai/all bundles, and macOS Python 3.14 also excludes caption bundles until onnxruntime publishes matching wheels. Validate all declared lanes with:

python scripts/check_dependency_matrix.py --matrix

Option D -- Docker:

openssl rand -hex 32 > .opencut-auth-token
chmod 600 .opencut-auth-token
export OPENCUT_REMOTE_AUTH_TOKEN_FILE=./.opencut-auth-token
docker compose up opencut-server
docker compose --profile mcp up opencut-mcp

Docker publishes the HTTP API on port 5679 and persists data under /home/opencut/.opencut. It does not publish the optional WebSocket 5680 or MCP 5681 sidecars by default; the explicit mcp profile publishes MCP with the same mounted API token and trusts the backend's Compose service name by default. The Docker image is intentionally CPU-only: its locked dependencies, FFmpeg build, and base image do not include CUDA, NVENC, or a GPU runtime. Use the native Linux installation with the ai-gpu extra for NVIDIA acceleration. Both Compose services require the host secret file and boot without a desktop credential vault or plaintext-storage opt-in. The image validates a private runtime copy as a regular, non-symlink 0400 file; the value is never placed in Compose environment variables, OpenCut JSON, logs, image layers, or API responses.

Compose mounts are read-only by design. Rotate one by atomically replacing the host secret, then recreate the affected services with docker compose up -d --force-recreate; do not use /auth/rotate for this lane. A direct, owner-writable 0600 secret-file backend supports opencut-server --rotate-auth, while a 0400 file returns the explicit REMOTE_AUTH_TOKEN_FILE_READ_ONLY error. The image builds the exact FFmpeg snapshot commit 01a25f74cc446a683318bab13dfd98a467082ef7 from the checksum-pinned upstream source archive and fails its build-time provenance gate if the binary falls below OpenCut's security floor. Image assembly also installs Python from the universal requirements-release-lock.txt with --require-hashes and generates the same resolved SBOM, notices, and composition manifest as the desktop release lanes.

Option E -- Linux desktop package:

The repository includes Flatpak and AppImage packaging for local release builds, but no Flatpak or AppImage is currently published. See docs/LINUX_DISTRIBUTION.md for the io.github.sysadmindoc.opencut contract and local package-build command. The package launchers store user data in ${XDG_DATA_HOME:-$HOME/.local/share}/opencut (override with OPENCUT_HOME) and include security-verified ffmpeg/ffprobe binaries in the bundle.

Uninstall data safety

Windows uninstallers remove the application and integrations but preserve %USERPROFILE%\.opencut by default, including settings, jobs, journals, indexes, plugins, models, and project/agent state. The separate Also remove choice is unchecked and creates a verified ZIP in Documents\OpenCut Backups before deleting data. If backup validation or deletion fails, the data is kept.

Automated WPF removal must add --remove-user-data; the Inno uninstaller uses /REMOVEUSERDATA. Custom paths use --user-data-dir and --user-data-backup-dir (WPF), or /USERDATADIR= and /USERDATABACKUPDIR= (Inno). Quiet uninstall without the dedicated removal flag always preserves user data.

Launch

1. Start the backend server -- this must be running before the panel can connect:
   • Windows (installer): double-click Start-OpenCut.bat on your desktop or in the OpenCut folder
   • Windows (source): open a terminal in the OpenCut folder and run python -m opencut.server
   • macOS: run ./OpenCut-Server.command or python -m opencut.server
   • Linux: run ./OpenCut-Server.sh or python -m opencut.server
   • You should see output like Running on http://127.0.0.1:5679 -- keep this terminal window open
2. Open Premiere Pro and go to Window > Extensions > OpenCut
3. The panel should show a green connection indicator. Select a clip and start editing.

Troubleshooting

Panel says "Server offline" or won't connect: The OpenCut panel connects to a backend server running on http://127.0.0.1:5679. If the panel cannot connect:

• Make sure the backend server is running (step 1 above). You need a terminal window open with python -m opencut.server running.
• Check the terminal for errors. Common issues: port 5679 already in use (change with OPENCUT_PORT=5680), missing Python packages (re-run pip install -e ".[all]").
• Check that your firewall is not blocking localhost connections on port 5679.
• The "Live Updates Bridge" toggle in the Settings tab is an optional WebSocket feature for streaming progress updates. It is not required for the panel to work -- do not confuse it with the main server connection.

"Module not found" errors for AI features: Most AI features are optional dependencies. Open the Settings tab in the panel and scroll to the Dependency Dashboard -- it shows every optional package with its install status and the exact pip command to install missing ones. Or install all audited extras at once: pip install -e ".[all]".

FFmpeg missing or blocked: The server requires FFmpeg 8.1.3+ (or a dated post-fix snapshot from 2026-07-06 onward) on your PATH. Run python scripts/verify_ffmpeg_provenance.py to see the detected version and reason. If missing or below the floor, install the current ffmpeg-git-full build from https://www.gyan.dev/ffmpeg/builds/ or build the checksum-verified upstream source snapshot. Restart the terminal and OpenCut server after upgrading. Install.ps1 -SkipFFmpeg skips automatic installation only; it cannot bypass this security check.

Python not found or wrong version: OpenCut requires Python 3.11-3.14. Run python --version to check. On Windows, if Python is installed but not on PATH, use py -3.12 -m opencut.server instead, or re-run the Python installer and check "Add Python to PATH". Python 3.15+ is rejected until the dependency matrix has verified it.

---

What OpenCut adds beyond Premiere 26

Premiere 26.x now ships Object Mask, Generative Extend, Media Intelligence search, Sequence Index, Single-Word Captions, pause/filler deletion, loudness matching, bulk bleep/mute, and 90+ Film Impact transitions natively. OpenCut complements those host workflows with broader scope, reviewable proposals, exportable artifacts, and headless access:

Capability	OpenCut	Premiere 26.x Native
Silence-cut to timeline	Reviewable ripple-delete ranges, batch/headless routes, and FCP/OTIO export	Text-Based Editing Delete Pauses; OpenCut adds review and interchange scope
Stem separation	Demucs / BS-RoFormer / MDX-Net (unlimited)	No bundled stem separator; OpenCut adds unlimited local models
Voice cloning	Chatterbox TTS (15-sec training, local)	No bundled local clone; OpenCut adds local training and exportable narration
Filler word cleanup	CrisperWhisper verbatim markers, custom words, reviewable ranges, and REST/CLI access	Text-Based Editing Delete Filler Words; OpenCut adds provenance and batch scope
Animated captions	55 styles, word-level animation, native/burn-in/sidecar outputs; OTIO carries no caption schema	Captions + Single-Word Captions; OpenCut adds template breadth and export choices
LLM highlights	Ollama (local, no API key), engagement scoring, and exportable highlight artifacts	Media Intelligence search; OpenCut adds local ranking and deliverables
Cross-project footage search	Whole-library FTS5 search through REST/MCP/CLI	Media Intelligence search in the open project; OpenCut adds cross-project/headless scope
Social export	Direct YouTube/TikTok/Instagram OAuth upload	No direct social handoff; OpenCut adds explicit upload workflows
Cross-NLE export	OTIO clips, markers, and supported transitions to compatible adapters, plus MLT projects for Kdenlive and Shotcut	No bundled cross-NLE handoff; OpenCut adds interchange artifacts
Repeated take detection	Jaccard-overlap transcript similarity with reviewable proposals	OpenCut adds a dedicated repeated-take pass
Bulk transcript correction	Preview and apply literal find/replace edits with undo and a persisted per-project glossary	OpenCut adds transcript-wide correction controls
Cut review panel	Human-in-loop approve/reject before applying or exporting ranges	Native editing controls; OpenCut adds a dedicated proposal/review pass
Loudness and profanity reports	Explicit LUFS targets, batch measurement, and auditable bleep/mute ranges	Auto-Match Loudness and bulk bleep/mute; OpenCut adds reports and headless access

No usage caps. Unlike CapCut Pro ($240/yr, metered), Descript ($288-600/yr, credit burn), and Submagic ($468/yr, 40 videos/mo), OpenCut processes unlimited content for $0.

---

Feature Overview

OpenCut v1.48.0 includes 1,568 shipped API routes (implemented or dependency-gated; 25 strategic 501 stubs are tracked separately and excluded), 8 panel tabs with 50+ sub-tabs, and covers every major video editing automation task. Of those shipped routes, 280 have literal first-party panel, palette, CLI, and curated MCP references; 1,288 integration-only routes are explicitly classified rather than presented as direct user workflows.

Cut & Clean

Feature	Description	Engine
Silence Removal	Detect and stage silent segments with adjustable threshold or AI neural detection; review ranges before timeline write-back	FFmpeg / Silero VAD
Silero VAD Mode	ML-based voice activity detection -- 87% TPR vs 50% for energy thresholds. Auto-fallback if PyTorch unavailable	Silero VAD (ONNX)
Filler Word Detection	Detect and stage "um", "uh", "like", "you know" + custom words for reviewable cuts. Two backends: standard Whisper or CrisperWhisper (verbatim mode)	faster-whisper / CrisperWhisper
CrisperWhisper Mode	Modified Whisper that transcribes verbatim with [UH]/[UM] markers -- #1 on OpenASR Leaderboard for filler detection	HuggingFace transformers
Waveform Preview	Visual waveform with draggable threshold line synced to slider	FFmpeg PCM + Canvas
Trim Tool	Set in/out points to extract a clip portion (stream copy or re-encode)	FFmpeg
Full Pipeline	One reviewable local pass for silence/filler ranges, captions, and zoom	Multi-stage
Repeated Take Detection	Detect when speakers restart a sentence using transcript similarity (Jaccard overlap)	WhisperX
Auto-Edit	Motion-based and audio-based automated rough cuts	auto-editor
Cut Review Panel	Review and approve/reject individual cuts before applying to timeline	Built-in

Captions & Transcription

Feature	Description	Engine
Transcription	Speech-to-text with word-level timestamps, immutable engine/model provenance, exportable sidecars, separate text/boundary confidence, and explicit language/engine overrides	faster-whisper / WhisperX
55 Caption Styles	YouTube Bold, Neon Pop, Cinematic, Netflix, Sports, and more, with native-track and burn-in delivery paths	Pillow renderer
Animated Captions	55-style word-by-word pop, fade, bounce, glow, and highlight templates with exportable artifacts	Pillow + OpenCV
Caption Burn-in	Hard-burn styled captions directly into video	FFmpeg drawtext / ASS
Speaker Diarization	Identify who's speaking for podcasts/interviews	pyannote.audio
Multimodal Diarization	Audio + face cross-modal speaker mapping for multi-camera setups	InsightFace / facenet + pyannote
Translation	Translate captions to 50+ languages	NLLB / SeamlessM4T
Karaoke Mode	Word-by-word highlight sync for lyrics/captions	Pillow renderer
Transcript Editor	Edit segments in-panel with undo/redo and search	Built-in
Bulk Transcript Correction	Preview and apply literal find/replace edits across the transcript, undo the last pass, and persist project glossary terms	Built-in
YouTube Chapters	LLM-powered topic change detection for chapter timestamps	Ollama / OpenAI / Anthropic
SRT to Native Captions	Import any SRT file as a native Premiere Pro caption track	ExtendScript
Subtitle Resync	Preview text-matched constant-offset and clock-drift correction before writing a sidecar SRT	Whisper / local alignment
Caption XML Interchange	EBU-TT, TTML, legacy IMSC1, and IMSC 1.3 with multilingual/RTL/vertical round trips, validated against the W3C reference implementation	W3C TTML / IMSC (ttconv + imschrm)

Caption XML profiles are explicit: /delivery/caption/ttml accepts ttml, legacy imsc1 (the compatibility default), or imsc1.3; Subtitle Pro uses imsc1_3 for the 1.3 profile. Unknown profiles, invalid timing, unresolved style/region references, unsafe XML, and unrepresentable text now fail with a migration error instead of writing a document that claims unsupported conformance.

Standards labels are earned from independent validators, not self-assessed. pip install "opencut[standards]" adds ttconv (the W3C TTML reference implementation) and imschrm (the IMSC Hypothetical Render Model); the release gate runs OpenCut's own IMSC 1.3 output through both. IMF packages are checked with Netflix Photon's IMPAnalyzer when OPENCUT_PHOTON_JAR points at the jar and a JRE is on PATH, and loudness is checked against a signal whose BS.1770 value is derived from the standard's own K-weighting coefficients. When a validator is absent the report says available: false and passed: null — "not checked" never reads as "passed".

Transcript caches, caption sidecars, interview state, and JSON exports retain the exact ASR engine, model revision, alignment backend, language decision, and fallback reason. API and CLI callers can override engine, model, model_revision, and language; the panel auditions low-confidence edit boundaries before it permits a filler-removal timeline mutation. A privacy-safe GET /captions/cache/provenance/<cache_key> diagnostic returns model identity without returning transcript text.

Audio Processing

Feature	Description	Engine
Stem Separation	Isolate vocals, drums, bass, guitar, piano. Multiple backends and models	Demucs / BS-RoFormer / MDX-Net
Noise Reduction	AI noise removal + spectral gating	noisereduce / DeepFilterNet
Speech Enhancement	Full speech restoration: denoise + bandwidth extension to 44.1kHz studio quality	Resemble Enhance
Normalization	Loudness targeting (LUFS) with broadcast standards	FFmpeg loudnorm
Loudness Match	Batch normalize multiple clips to consistent LUFS	FFmpeg two-pass
Beat Detection	BPM analysis and beat marker timestamps	librosa
Beat Markers	Export beats as Premiere Pro sequence markers for snap-to-beat editing	librosa + ExtendScript
Audio Ducking	Auto-lower music under dialogue	FFmpeg sidechaincompress
Pro FX Chain	Compressor, EQ, de-esser, limiter, reverb, stereo width, and more	Pedalboard (Spotify)
TTS Voice Generation	Text-to-speech with 100+ voices. Three engines: cloud, local fast, and voice cloning	Edge-TTS / Kokoro / Chatterbox
Voice Cloning	Record 15 seconds of voice, generate narration in that voice	Chatterbox TTS
SFX Generator	Procedural tones, sweeps, impacts, noise	NumPy synthesis
AI Music Generation	Generate background music from text prompts	MusicGen (AudioCraft)

Video Effects & Processing

Feature	Description	Engine
AI Upscaling	3 tiers: Lanczos (fast), Real-ESRGAN (balanced), Video2x (premium)	FFmpeg / Real-ESRGAN
Background Removal	Per-frame (rembg, 5 models) or temporal (Robust Video Matting, 2 models)	rembg / RVM
Robust Video Matting	Recurrent neural network for temporally consistent matting -- no green screen needed	torch hub (RVM)
Depth Effects	Depth map estimation, depth-of-field bokeh simulation, 3D Ken Burns parallax zoom	Depth Anything V2
Frame Interpolation	Slow motion / frame rate conversion	FFmpeg / RIFE
Face Enhancement	Restore and upscale faces with controllable fidelity slider	GFPGAN / CodeFormer
Face Swap	Replace faces using a reference image	InsightFace
Face Blur	Privacy-aware face detection and blur/pixelate	MediaPipe / YOLO
Style Transfer	Neural artistic style transfer for video	PyTorch models
Stabilization	Deshake / vidstab with smoothing and zoom controls	FFmpeg
Chromakey	Green/blue/red screen removal + spill suppression	OpenCV HSV
Picture-in-Picture	Overlay PiP with position/scale controls	FFmpeg overlay
Blend Modes	14 modes (multiply, screen, overlay, etc.)	FFmpeg blend
34 Transitions	Crossfade, wipe, slide, circle, pixelize, radial, zoom	FFmpeg xfade
Particle Effects	7 presets: confetti, sparkles, snow, rain, fire, smoke, bubbles	Pillow renderer
Animated Titles	6 presets: fade, slide, typewriter, lower third, countdown, kinetic	FFmpeg drawtext
Speed Ramping	Time remapping with ease-in/out curves, reverse, slow-mo	FFmpeg setpts
Scene Detection	Auto-detect cuts and scene changes (threshold + neural)	PySceneDetect / TransNetV2
Film Grain / Vignette	Adjustable film look overlays	FFmpeg noise/vignette
Letterbox	Cinematic aspect ratio bars (2.39:1, 2:1, 1.85:1, 4:3, 1:1)	FFmpeg pad
LUT Library	15 built-in cinematic LUTs + external .cube/.3dl support	FFmpeg lut3d
Color Correction	Exposure, contrast, saturation, temperature, shadows, highlights	FFmpeg eq/colorbalance
Color Match	Match color profile of one clip to a reference using YCbCr histogram matching	OpenCV
Video Reframe	Resize/crop for TikTok, Shorts, Reels, Instagram, or custom dimensions (max 7680px)	FFmpeg scale/crop/pad
Face-Tracked Reframe	Auto-crop vertical video centered on the active speaker's face	MediaPipe + FFmpeg
Merge / Concatenate	Join multiple clips (fast stream copy or re-encoded)	FFmpeg concat
Watermark Removal	Auto-detect (Florence-2) or manual region + LaMA AI inpainting or FFmpeg delogo	Florence-2 / LaMA / FFmpeg
Object Removal	Click-to-select any object, track through video, inpaint with temporal consistency	SAM2 + ProPainter
Video Denoising	AI temporal denoising for noisy footage	FFmpeg / neural models

Highlight & Shorts Generation

Feature	Description	Engine
AI Highlight Extraction	LLM analyzes transcript to find viral/engaging moments with engagement scoring	Ollama / OpenAI / Anthropic
Engagement Scoring	Multi-dimensional scoring: hook strength, emotional intensity, pacing, quotability	Text heuristics + LLM
Emotion-Based Highlights	Facial emotion analysis across frames, detect emotional peaks as highlights	deepface + OpenCV
Shorts Pipeline	One-click: transcribe, highlight, trim, face-reframe, caption burn-in, export	Multi-stage
Smart Thumbnails	AI-scored frame extraction with face detection, composition balance, and sharpness analysis	OpenCV
Auto Watermark Detection	Florence-2 vision-language model auto-locates watermarks, logos, and text overlays	Florence-2 / edge fallback
AI B-Roll Planning	Transcript analysis to identify B-roll insertion points (dialogue gaps, topic shifts, visual references)	Text analysis
AI B-Roll Generation	Text-to-video B-roll from prompts using 4 backends	CogVideoX / Wan 2.2 / HunyuanVideo / SVD

Timeline Integration

Feature	Description
Apply Cuts to Timeline	Remove silences, repeated takes, or custom ranges directly in the active sequence
Beat Markers	Add detected beats as Premiere Pro sequence markers
Multicam Auto-Switch	Speaker diarization to multicam cut list, applied directly to sequence
Clip Keyframes	Write scale/position keyframes for auto-zoom effects
Batch Rename	Rename project panel clips with find/replace patterns
Smart Bins	Auto-sort project items into bins by rule (name, type, duration)
Export from Markers	Batch-export clip ranges defined by sequence markers
SRT to Native Captions	Import SRT as a native Premiere Pro caption track
Subtitle Resync	Preview and apply text-matched SRT offset/drift correction without overwriting the source by default
OTIO Export	Export timeline clips, markers, and supported transitions as OpenTimelineIO; captions remain SRT/VTT/ASS sidecars
MLT Export	Export cut lists, speed changes, and keyframed volume to Kdenlive and Shotcut

Search & AI Commands

Feature	Description
Footage Search	Index your entire media library across projects by spoken content, then query it through the panel, REST, MCP, or CLI
FTS5 Database Search	SQLite full-text search index with auto-indexing and cleanup
Natural Language Commands	Type in English -- OpenCut maps commands to API routes via keyword matching or LLM
Chat Editor	Multi-turn LLM-powered editing assistant with session memory and action parsing
Post-Production Deliverables	Generate VFX sheets, ADR lists, music cue sheets, and asset inventories from sequence data

Export & Batch

Feature	Description	Engine
13 Platform Presets	YouTube, TikTok, Instagram, Twitter/X, LinkedIn, Podcast, Snapchat, Facebook, Pinterest	FFmpeg encode
Batch Processing	Process multiple clips in parallel with GPU-aware concurrency	ThreadPool
Transcript Export	SRT, VTT, ASS, plain text, timestamped	Built-in
OTIO Timeline Export	Clips, markers, and supported transitions for Premiere, Resolve, FCP, and Avid adapters; no caption schema	OpenTimelineIO
MLT Timeline Export	Kdenlive and Shotcut project interchange with source ranges, speed, and volume automation	MLT XML
Social Media Upload	Direct posting to YouTube, TikTok, and Instagram with OAuth	Platform APIs

DaVinci Resolve Integration

Feature	Description
Resolve Bridge	Python scripting API bridge with auto-reconnect
Media Pool Access	List, import, and organize media pool clips
Timeline Info	Read timeline structure, add markers
Render Queue	Start renders programmatically

---

Panel UX

Feature	Description
Command Palette	Ctrl+K fuzzy search across all 30+ operations
Clip Preview	Thumbnail + duration/resolution/size when selecting a clip
Recent Clips	Dropdown of last 10 used clips, persisted across sessions
Auto Media Discovery	Periodic project media scan + visibility/focus refresh + post-job re-scan
Favorites Bar	Pin frequently-used operations as quick-access chips
First-Run Wizard	3-step onboarding overlay for new users
Output File Browser	Browse recent outputs with Import-to-Premiere button
Custom Workflows	Chain operations into reusable named workflows (6 built-in)
Project Templates	YouTube, Shorts, TikTok/Reels, Podcast, Cinema, Broadcast
Collapsible Cards	Click headers to collapse/expand dense form sections
Cut Review Panel	Review and approve/reject individual cuts before applying
Right-Click Context Menu	Quick-action context menu on clip selector
Job Time Estimates	Estimated processing time based on historical data
Per-Operation Presets	Save/load settings per operation
Settings Import/Export	Bundle all settings as JSON for backup or sharing
Server Health Monitor	Auto-reconnect with exponential backoff when backend goes offline
Studio Graphite UI	Single premium theme tuned for the CEP editing workspace
Workspace Polish	Premium shell, command palette, history, and output surfaces
Toast Notifications	Non-intrusive slide-in alerts for job completion
Keyboard Shortcuts	Configurable shortcuts with reference card (Ctrl+Shift+S for silence, etc.)
Quick Action Buttons	One-click workflows on Cut, Captions, Audio, and Video tabs
Status Bar	Live system health, GPU usage, uptime, and job count
GPU Adapter Selection	Choose and persist a CUDA adapter in CEP/UXP Settings; selection and available devices are exposed through /system/status and /system/gpu
i18n	Internationalization system with extensible locale files (417 keys)
Responsive Layout	4 breakpoints for compact panels (800px, 480px, 440px, 380px)
Context-Aware Guidance	Clip-specific recommendations and smart tab reordering
Engine Preferences	Per-domain AI engine selection with quality/speed labels
WebSocket Real-Time	Live job progress via WebSocket with SSE/poll fallback

---

UXP Panel (Premiere Pro 25.6+)

A modern panel (com.opencut.uxp) using Adobe's UXP platform:

• Modern JavaScript -- ES modules, async/await, native fetch()
• Same Python backend -- Connects to the same local server on port 5679
• Auto port detection -- Scans ports 5679-5689 automatically
• 9 tabs -- Cut & Clean, Captions, Audio, Video, Timeline, Search, Deliverables, Agent, Settings
• Direct Premiere API -- Uses the premierepro UXP module for sequence access
• Project media discovery -- Scans project items via UXP API with datalist autocomplete
• OTIO export -- Discover installed adapters, select a current or legacy schema target, and preflight downgrade loss before writing from either panel
• Connection-aware UI -- Buttons disable when server is offline, re-enable on reconnect
• Near-complete feature parity with CEP panel including depth effects, emotion highlights, B-roll, chat editor, social upload, engine preferences, and WebSocket bridge

Premiere 26 compatibility: Both CEP ([13.0, 99.9] host range) and UXP (minVersion 25.6) panels cover Premiere 26.x. Adobe's November 2025 guidance plans dual support for a calendar year after Premiere Pro 25.6, implying an approximately November 2026 planning horizon rather than an announced removal date. OpenCut maintains CEP reliability and security while completing the UXP migration.

---

Architecture

+-----------------------+ HTTP/JSON +-----------------------+
| Premiere Pro CEP | <================> | OpenCut Server |
| Panel (HTML/JS) | localhost:5679 | (Python/Flask) |
| | | |
| 8 tabs, 50+ sub-tabs | WebSocket:5680 | 1,568 shipped routes |
| Studio Graphite, i18n| <~~~~~~~~~~~~~~~> | 621 core modules |
| Keyboard shortcuts | SSE streaming | 107 route blueprints |
+-----------+-----------+ +-----------+-----------+
| |
+-----------+-----------+ +-----------+-----------+
| Premiere Pro UXP | | | |
| Panel (ES modules) | +--+--+ +----+---+ +---+----+
| 9 tabs, modern JS | |FFmpeg| |Whisper | |PyTorch |
+-----------------------+ |OpenCV| |Demucs | |Models |
| +------+ +--------+ +--------+
+-----------+-----------+ |
| DaVinci Resolve | +----------+----------+
| (Python scripting) | | Engine Registry |
+-----------------------+ | 18+ engines, 12 |
| domains, swappable |
+---------------------+

Core editing runs locally by default and needs no API key. Data leaves the machine only when an optional network feature is explicitly used; set OPENCUT_LOCAL_ONLY=1 to deny non-loopback egress at runtime.

---

AI Models & Backends

OpenCut supports multiple backends per feature via the Engine Registry, letting you choose speed vs. quality:

Feature	Fast	Balanced	Best Quality
Silence Detection	FFmpeg energy threshold	Silero VAD (auto)	Silero VAD
Filler Detection	Whisper + text matching	Whisper + text matching	CrisperWhisper verbatim
Transcription	faster-whisper tiny	faster-whisper base	WhisperX medium
Stem Separation	Demucs htdemucs	BS-RoFormer	Demucs htdemucs_ft
Denoising	noisereduce	DeepFilterNet	Resemble Enhance
TTS	Edge-TTS (cloud)	Kokoro (local, 82M)	Chatterbox (voice clone)
Background Removal	rembg U2Net	rembg BiRefNet	Robust Video Matting
Face Restoration	GFPGAN	CodeFormer (0.5 fidelity)	CodeFormer (0.7 fidelity)
Scene Detection	FFmpeg threshold	PySceneDetect	TransNetV2 (neural)
Watermark Detection	Edge/corner fallback	Florence-2 base	Florence-2 base
Upscaling	FFmpeg Lanczos	Real-ESRGAN	Real-ESRGAN anime
Highlights	Keyword heuristics	LLM + engagement scoring	LLM + emotion analysis
Depth Effects	--	Depth Anything V2	Depth Anything V2
B-Roll Generation	SVD (image-to-video)	Wan 2.2	CogVideoX
Speaker Diarization	pyannote.audio	pyannote + face clustering	Multimodal diarization

Engine preferences are configurable per-domain in the Settings tab and persist across sessions.

---

Dependency Tiers

Only the core tier is required -- everything else is optional and auto-detected at runtime.

Core (required, ~5MB)

flask, flask-cors, click, rich

The following profiles are available from an OpenCut source checkout. PyPI is not currently a published install channel.

Standard (recommended, ~200MB)

python -m pip install -e ".[standard]"

Adds: faster-whisper, opencv-python, Pillow, numpy, librosa, noisereduce, scenedetect

Audited convenience install (non-Torch optional stack)

python -m pip install -e ".[all]"

Adds all standard deps plus: pedalboard, edge-tts, rembg, insightface, onnxruntime, auto-editor, opentimelineio, and otio-aaf-adapter. Torch/Transformers-backed packages stay out of this release-audited lane until their advisory and resolver posture is clean.

For the larger Torch-backed stack, install the explicit extra or narrower feature extras:

python -m pip install -e ".[all,torch-stack]"
python -m pip install -e ".[diarize]"# pyannote speaker diarization
python -m pip install -e ".[nemo-asr]"# Parakeet/Canary ASR; Linux only

torch-stack includes Demucs, RealESRGAN/GFPGAN, pyannote.audio, TransNetV2, PyTorch 2.10+, torchvision 0.25+, and Transformers 5.3+. WhisperX, AudioCraft/MusicGen, and Resemble Enhance are not advertised install lanes: their published releases require obsolete Torch families below OpenCut's security floor.

The NeMo lane pins toolkit 2.7.3 and immutable Parakeet/Canary checkpoint revisions. OpenCut verifies each multi-gigabyte checkpoint with SHA-256 and picklescan before loading it. NVIDIA does not support this NeMo release on Windows or macOS, so cached NeMo transcripts remain readable there but new inference is Linux-only.

Platform	Python	CPU extras	ai-gpu	nemo-asr
Windows	3.11-3.14	Supported	Supported	Not supported
Linux	3.11-3.14	Supported	Supported	Supported; NVIDIA GPU recommended
macOS	3.11-3.13	Supported except ai and all	Not supported	Not supported
macOS	3.14	Supported except standard, captions, ai, and all	Not supported	Not supported

GPU Acceleration

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

GPU-heavy routes have built-in rate limiting (one GPU job at a time) and cancellation support. Choose the active CUDA adapter from the CEP or UXP Settings panel, or set OPENCUT_GPU_INDEX to a non-negative device index before starting the server. The selected adapter is reported by /system/status; invalid indexes return the available-device list instead of silently falling back.

---

Configuration

Variable	Default	Description
OPENCUT_PORT	5679	Server port
OPENCUT_HOST	127.0.0.1	Bind address
OPENCUT_OUTPUT_DIR	Source file dir	Default output directory
OPENCUT_GPU_INDEX	unset (Auto)	CUDA adapter index for GPU-backed operations; the Settings panel can persist the same selection
OPENCUT_LOCAL_ONLY	0	Set to 1 to deny all non-loopback outbound network access before DNS, socket, browser-launch, or network-capable subprocess I/O
OPENCUT_ALLOW_REMOTE	0	Set to 1 to permit a non-loopback bind; remote requests require the OS-vault or secure secret-file token
OPENCUT_TRUSTED_HOSTS	unset	Comma-separated hostnames this server answers for, beyond loopback and OPENCUT_HOST. Any other Host header is rejected with UNTRUSTED_HOST before auth, CSRF, or /health runs, which blocks DNS rebinding. A leading dot (.studio.lan) trusts that subtree
OPENCUT_REMOTE_AUTH_TOKEN_FILE	unset	Absolute owner-only regular token file for headless remote binds; minimum 32 characters, no symlinks or group/world permissions
OPENCUT_ALLOW_INSECURE_SECRET_STORAGE	0	Explicitly permit plaintext credential metadata only when no supported OS vault is available; leave unset for fail-closed persistence
WHISPER_MODELS_DIR	~/.cache	Whisper model cache
OPENCUT_C2PA_SIGNING_KEY	unset	Private-key file required with a certificate for embedded credentials; an Ed25519 PEM/path also signs local JSON sidecars
OPENCUT_C2PA_C2PATOOL	c2patool on PATH	C2PA Tool executable used to create and verify embedded MP4/JPEG/PNG credentials
OPENCUT_C2PA_SIGNING_CERT	unset	X.509 certificate-chain file required with the signing key for embedded credentials

Local-only mode permits outbound connections only to explicit loopback targets: localhost, *.localhost, 127.0.0.0/8, and ::1. This keeps local Ollama, OBS, GPT-SoVITS, and panel/backend traffic working. LAN/private-network targets are not implicitly trusted, so remote render nodes, SRT destinations, webhooks, cloud APIs, update/model/package downloads, OAuth browser launches, and similar egress remain blocked until local-only mode is explicitly disabled. Local files and already-installed models are the supported alternatives.

API keys, OAuth tokens, node credentials, webhook signing secrets, and the desktop remote-access token are stored through keyring in Windows Credential Locker, macOS Keychain, Linux Secret Service, or KWallet. Existing plaintext JSON is migrated only after the vault write is read back successfully. On Linux, install and unlock a Secret Service or KWallet backend before saving credentials. Check the credential_store field from GET /settings/local-only; without a secure backend, credential persistence returns CREDENTIAL_STORE_UNAVAILABLE unless the explicit insecure-storage variable above is enabled.

CLI Usage

# Silence removal with Silero VAD
opencut silence video.mp4 --method vad
# Generate YouTube chapters
opencut chapters interview.mp4 --provider ollama --model llama3
# Detect repeated takes
opencut repeat-detect recording.mp4 --threshold 0.6
# Preview subtitle offset/drift correction; add --apply after review to write a sidecar
opencut subtitle-resync captions.srt --video interview.mp4
opencut subtitle-resync captions.srt --video interview.mp4 --apply
# Search footage library
opencut search index *.mp4
opencut search query "camera lens focal length"# Match colors to reference
opencut color-match source.mp4 reference.mp4
# Normalize loudness
opencut loudness-match clip1.mp4 clip2.mp4 --target-lufs -14
# Generate post-production documents
opencut deliverables --sequence-json sequence.json --type all
# Natural language editing
opencut nlp "remove silence and add captions in Spanish" --file video.mp4
# Preflight a legacy-compatible OTIO export without writing
opencut silence interview.mp4 --format otio --otio-schema OTIO_CORE:0.14.0 --otio-preflight
# Write only after reviewing any reported downgrade fields
opencut silence interview.mp4 --format otio --otio-schema OTIO_CORE:0.14.0 --accept-lossy-otio
# Export the detected speech segments as an MLT project for Kdenlive or Shotcut
opencut silence interview.mp4 --format mlt --name "Interview Edit"# Call any generated backend route from scripts
opencut route GET /system/check-failures
opencut route POST /queue/add --data '{"endpoint":"/captions","payload":{"filepath":"C:/clip.mp4"}}'# Run the opt-in benchmark control lane (model/cloud adapters never download)# PowerShell: $env:OPENCUT_RUN_PERF_BENCHMARKS=1# POSIX: export OPENCUT_RUN_PERF_BENCHMARKS=1
opencut benchmark run --benchmark declarative_compose --backend ffmpeg-compose \
--warmup 1 --repeats 3 --output .opencut/performance/current.json
# Compare only a compatible host receipt; incompatible hardware is not a failure
opencut benchmark compare .opencut/performance/current.json .opencut/performance/baseline.json --json

The benchmark receipt records the MIT synthetic-fixture hash and license, model/dependency versions, hardware/software compatibility key, seed, warm-up and repeat counts, timing percentiles, RSS/Python allocation peaks, and adapter-supplied quality metrics. Optional backends that are not installed or do not have a local no-download adapter are recorded as skipped. Release smoke validates the registry by default and consumes a baseline only when --performance-receipt and --performance-baseline (or their OPENCUT_PERF_RECEIPT / OPENCUT_PERF_BASELINE environment variables) are provided.

---

Backend Infrastructure

Feature	Description
Async Job System	Background processing with SSE streaming, WebSocket, and polling fallback
Durable Job Queue	Sequential processing persisted atomically across restarts; active work becomes replayable interrupted entries, with collision-safe recovery and versioned JSON import/export
GPU Rate Limiting	One GPU-heavy job at a time with 429 responses when busy
FFmpeg Progress	Real-time percentage from -progress pipe:1 parsing
Cancel + Kill	Job cancellation terminates running FFmpeg subprocesses
Output Deduplication	Auto-increment suffix prevents overwriting previous outputs
Temp Cleanup	Stale preview files cleaned up on server startup
Dependency Dashboard	Grid view of all optional deps with install status and one-click install
GPU Auto-Detection	Recommend optimal settings based on detected GPU VRAM
AI Model Manager	View/delete downloaded models to free disk space
Engine Registry	Swappable AI backends per feature domain (18+ engines, 12 domains)
Job Persistence	SQLite-backed job history survives server restarts
Job Recovery	Detects and reports interrupted jobs on startup
Operation Checkpoints	CEP and UXP persist a preview and recovery plan before multi-step Premiere writes, detect interrupted work after restart, restore verified inverses, and export diagnostics for manual recovery
Structured Errors	Error taxonomy with machine-readable codes and recovery suggestions
JSON Structured Logging	File handler outputs JSON logs with job-ID correlation
Workflow Engine	Chain multi-step processing with cancellation between steps
Plugin System	Authenticated installs plus supervised workers for third-party routes and jobs
Docker Support	Multi-stage Dockerfile + docker-compose CPU and MCP profiles
Log Viewer	Filtered log tail endpoint for real-time debugging
CSRF Protection	Token-based cross-site request forgery protection
Rate Limiting	Per-endpoint rate limits to prevent abuse
Path Validation	Input sanitization with realpath + prefix whitelist to prevent path traversal
WebSocket Bridge	Real-time bidirectional communication on port 5680
Social Media Integration	OAuth-based upload to YouTube, TikTok, Instagram

---

Security

• No shell=True in any subprocess call
• Guarded dynamic execution -- timeline expressions and the scripting console validate ASTs, restrict globals/builtins, and enforce deadlines before their deliberate eval/exec calls; PyTorch checkpoints use the restricted weights_only=True loader and reject unsafe pickle payloads
• CSRF protection on all POST/DELETE routes via X-OpenCut-Token header
• Path traversal prevention via validate_filepath() with realpath + prefix whitelist
• HTML sanitization via esc() for all dynamic innerHTML content
• Input bounds on all numeric parameters (dimensions, durations, counts)
• GPU rate limiting prevents resource exhaustion from concurrent heavy jobs
• ASS subtitle injection prevention strips override sequences from caption text
• OS credential vault for OAuth tokens, API keys, node credentials, webhook signing secrets, and desktop remote-access tokens; headless remote tokens can instead use a validated owner-only secret file, and JSON retains no secret value
• Authenticated plugin installs stage outside the active loader path, verify the manifest and content lock, require exact capability consent, and activate atomically with rollback. Unsigned or tampered plugins are rejected before they can appear installed.
• Third-party plugin process isolation imports marketplace routes and jobs only inside lazy, supervised worker processes with sanitized environments, bounded IPC, timeouts, memory monitoring, and crash-loop quarantine. This is availability isolation, not an OS security sandbox; trusted bundled example plugins retain an explicitly marked compatibility lane.

Marketplace registry entries must provide artifact_sha256, capabilities, and publisher: {id, public_key, signature}. The public key and signature are base64 Ed25519 values; the signature covers opencut-plugin-artifact-v1\n<plugin-id>\n<version>\n<sha256>\n. Direct directory installs instead include plugin.signature.json, whose signature covers opencut-plugin-directory-v1\n<name>\n<version>\n<canonical-lock-sha256>\n. CEP and UXP display the full publisher fingerprint and declared capabilities and keep Install disabled until the operator explicitly approves both. Their plugin trust dashboards also show worker state, safe failure diagnostics, and an explicit restart action. Automation can read the same redacted state at GET /plugins/workers and restart one worker with a CSRF-protected POST /plugins/workers/restart body of {"name": "plugin-name"}.

---

Testing

# Verify the selected Python has runtime metadata and test tooling
py -3.12 scripts/bootstrap_check.py --metadata-only --dev
# Repair a stale repo virtualenv before running tests from it
py -3.12 -m venv --clear .venv
.\.venv\Scripts\python.exe -m pip install -e ".[dev]"# Run the default test suite (integration and slow tests are excluded)
python -m pytest tests/ -q
# Opt into network/FFmpeg integration tests explicitly
python -m pytest tests/ -q -m integration
# Run smoke tests only
python -m pytest tests/test_route_smoke.py -q
# Run core module tests
python -m pytest tests/test_core_modules.py tests/test_core_modules_batch2.py -q
# Run ExtendScript mock tests
node tests/jsx_mock.js
# Validate immutable release inputs without assembling an artifact
python scripts/release_composition.py --check-lock-only
# Generate Windows artifact evidence after staging the server and FFmpeg payload
powershell -File scripts/prepare_windows_release_metadata.ps1
# CEP panel checks from Windows UNC/HGFS checkoutscd extension/com.opencut.panel
npm ci
npx playwright install chromium
npm test
npm run test:rendered # headless CEP/UXP viewport, state, a11y, and screenshot gate
npm run audit:check:win -- --json
npm run audit:esbuild:win -- --json
npm run build
npm run build:verify:win
# Pre-commit hooks (auto-runs ruff lint/format on commit, pytest smoke on push)
pre-commit install
pre-commit install --hook-type pre-push

Fail-closed local releases

Release actions use a short-lived receipt bound to a clean main commit. Run the complete Python, Node, rendered-panel, manifest, lock, provenance, and source checks with:

python scripts/release_gate.py verify --receipt build/release-receipt.json

The command writes a machine-readable receipt only when every required check passes. A version change must consume that fresh receipt:

python scripts/sync_version.py --set 1.44.0 --receipt build/release-receipt.json

After committing the synchronized version and generating a fresh receipt, smoke-test an unsigned installer before creating its local tag:

python scripts/release_gate.py promote `--receipt build/release-receipt.json `--artifact installer/dist/wpf/OpenCut-WPF-Setup-1.44.0.exe`--artifact-kind wpf `--promotion-receipt build/release-promotion.json `--tag v1.44.0

Missing, stale, skipped, failed, wrong-branch, source-drifted, or artifact-unsmoked evidence refuses the action. The driver never signs artifacts or pushes tags.

13,700+ estimated tests across 344 root test files covering route smoke tests, core module unit tests, feature integration tests, plugin tests, and the ExtendScript mock harness.

---

FAQ

Q: The panel says "Server offline" or "Server disconnected" A: See the Troubleshooting section above. In short: the backend server must be running (python -m opencut.server or Start-OpenCut.bat), keep its terminal window open, and make sure port 5679 is not blocked by a firewall. The panel auto-reconnects with exponential backoff when the server comes back.

Q: Transcription is slow A: Install CUDA-enabled PyTorch and use faster-whisper with a GPU. The tiny model is fastest. For batch processing, insanely-fast-whisper on GPU offers 10-15x speedup.

Q: I get "module not found" errors for AI features A: See the Troubleshooting section above. Most AI features are optional. From the repository root, use python -m pip install -e ".[all]" for the audited extras. For Torch-backed features add torch-stack: python -m pip install -e ".[all,torch-stack]". The Dependency Dashboard shows source-checkout commands supported on the detected platform and Python 3.11-3.14; incompatible packages such as WhisperX explain the resolver conflict instead of offering an unsafe command.

Q: Can I use this without Premiere Pro? A: Yes. The server runs standalone with a REST API. Call any route with curl, use the CLI, or build your own frontend. DaVinci Resolve is also supported via the Resolve Bridge.

Q: Does this send data to the cloud? A: Core editing is local by default, and fresh installs emit no telemetry. Optional Aptabase telemetry is available only after explicit opt-in. Edge-TTS requires internet for voice synthesis; LLM features can use local Ollama or cloud providers. Social media upload is opt-in and requires explicit OAuth connection. Set OPENCUT_LOCAL_ONLY=1 to enforce loopback-only networking.

Q: Can I export edits to DaVinci Resolve or Final Cut Pro? A: Yes. Use the OTIO (OpenTimelineIO) export in the Timeline tab. Both panels discover the installed adapters and let you choose the current schema or a supported legacy OTIO_CORE target. OpenCut exports timeline clips, markers, and supported transitions, reports lossy downgrade fields before writing, and records the exact adapter/runtime versions inside the timeline. OTIO has no caption schema, so export captions separately as SRT, VTT, or ASS. Resolve also has a direct Python scripting bridge.

Q: How do I update? A: git pull and restart the server. Or download the latest exe from Releases.

Q: What's the difference between the CEP and UXP panels? A: The CEP panel is the current full-feature surface for Premiere Pro 2019+; the UXP panel targets Premiere Pro 25.6+ on Adobe's modern platform. Both connect to the same backend. Adobe's November 2025 guidance plans dual CEP/UXP support for a calendar year, so OpenCut uses approximately November 2026 as a planning horizon—not an announced removal date—and continues CEP security, reliability, and user-blocking fixes while migrating the remaining features.

Q: How do I choose between AI backends? A: Go to Settings > AI Engine Preferences. Each feature domain (silence, transcription, TTS, etc.) has a dropdown showing available backends with quality and speed ratings. The default "Auto" mode picks the highest-priority available engine.

---

Project Structure

opencut/
server.py # Flask app factory + startup
core/ # 621 processing modules (silence, captions, audio, video, AI, VR, dubbing)
routes/ # 128 route modules / 107 manifest blueprints
export/ # Premiere/Resolve XML, MLT, SRT, VTT, ASS, OTIO exporters
utils/ # Media probing, config dataclasses
checks.py # Dependency availability checks
errors.py # Structured error taxonomy
jobs.py # Async job system with cancellation
job_store.py # SQLite job persistence
gpu.py # GPU context manager for VRAM cleanup
security.py # CSRF, rate limiting, path validation
helpers.py # FFmpeg progress parsing, output dedup
cli.py # CLI entry point
extension/
com.opencut.panel/
client/ # CEP panel (index.html, main.js ~16,661 lines, style.css ~17,960 lines)
host/ # ExtendScript host (index.jsx ~3,874 lines)
CSXS/ # Extension manifest
com.opencut.uxp/
main.js # UXP panel (~10,186 lines)
index.html # UXP panel UI
style.css # UXP dark theme
tests/ # pytest test suite (13,700+ estimated tests, 344 root test files)
RESEARCH.md # Current consolidated research conclusions
ROADMAP.md # Active open-work tracker
docs/
RESEARCH_COMPETITIVE_TEARDOWN_2026-06-10.md # June 2026 competitive teardown
UXP_MIGRATION.md # CEP to UXP migration plan
installer/ # WPF installer (C# .NET 10 LTS) + legacy Inno Setup
scripts/ # Build and utility scripts

Cost Comparison (June 2026)

Tool	Price	Local/Cloud	Auto-Captions	Stem Separation	Voice Clone	Silence Cut
OpenCut	$0 (MIT)	Local	Whisper (unlimited)	Demucs (unlimited)	Chatterbox (unlimited)	Yes
CapCut Pro	$19.99/mo ($240/yr)	Cloud	Paywalled (was free)	No	No	Limited
Descript	$24-50/mo ($288-600/yr)	Cloud	1-12h/mo quota	No	Overdub (metered)	Yes
Submagic	$39/mo ($468/yr)	Cloud	40 videos/mo	No	No	No
AutoCut	$16/mo ($192/yr)	Local	Whisper-based	No	No	Yes
FireCut	$20/mo ($240/yr)	Local	Yes	No	No	Yes

Annual cost of paid alternatives: $192-$600/yr. OpenCut runs locally, has no usage caps, and ships every feature above for $0 under MIT.

Contributing

Issues and PRs welcome. See CLAUDE.md for codebase patterns and conventions.

Key patterns:

• Backend: Lazy imports for optional deps, structured errors, async job system, capability flags in /health, TooManyJobsError handling, GPU rate limiting
• CEP panel:_on() helper for null-safe event binding, _setHint() for capability hints, esc() for HTML sanitization, escPath() for ExtendScript strings, api() callback wrapper for all HTTP calls
• UXP panel:PProBridge for Premiere API, BackendClient for HTTP, JobPoller with completion hooks, textContent for XSS-safe DOM updates
• ExtendScript: ES3 only, JSON.stringify returns, heavy try/catch, poll loops for imports

License

MIT License. See LICENSE for details.

Built with FFmpeg, Whisper, Demucs, PyTorch, Silero VAD, SAM2, ProPainter, Florence-2, deepface, Depth Anything, OpenTimelineIO, and many other open-source projects.