OpenCut

A free, open-source Premiere Pro extension that brings AI-powered video editing automation, caption generation, audio processing, and visual effects -- all running locally on your machine. No subscriptions, no cloud, no API keys required.

Quick Start

Prerequisites

• Adobe Premiere Pro 2019 or later (CEP panel) / 25.6+ (UXP panel)
• Windows 10/11 (macOS/Linux: server works, installer is Windows-only)

Installation

Option A -- Installer (recommended):

Download the latest OpenCut-Setup-1.28.0.exe from Releases and run it. Handles everything: server, FFmpeg, CEP extension, registry, and optional model downloads. No Python needed.

Option B -- From source:

git clone https://github.com/SysAdminDoc/OpenCut.git
cd OpenCut
pip install -e ".[all]"
python -m opencut.server

Then copy extension/com.opencut.panel to your CEP extensions folder and set PlayerDebugMode = 1 in the registry.

Option C -- Install.bat:

Clone the repo and run Install.bat as Administrator. Handles FFmpeg check, Python deps, CEP deployment, registry keys, and launcher creation.

Option D -- Docker:

docker-compose up          # CPU only
docker-compose -f docker-compose.gpu.yml up  # With GPU

Launch

1. Start the backend: run OpenCut-Server.bat, the installed launcher, or python -m opencut.server
2. In Premiere Pro: Window > Extensions > OpenCut
3. Select a clip and start editing

Feature Overview

OpenCut v1.28.0 includes 1,334 API routes, 8 panel tabs with 50+ sub-tabs, and covers every major video editing automation task.

Cut & Clean

Captions & Transcription

Audio Processing

Video Effects & Processing

Highlight & Shorts Generation

Timeline Integration

Search & AI Commands

Export & Batch

DaVinci Resolve Integration

Panel UX

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
• 8 tabs -- Cut & Clean, Captions, Audio, Video, Timeline, Search, Deliverables, 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 -- Export timeline edits in universal format from within the 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

Migration note: CEP support in Premiere Pro ends approximately September 2026. The UXP panel is the future-facing option. See docs/UXP_MIGRATION.md for the migration plan.

Architecture

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

Everything runs locally. No data leaves your machine. No API keys needed for core features.

AI Models & Backends

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

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

Standard (recommended, ~200MB)

pip install opencut[standard]

Adds: faster-whisper, opencv-python-headless, Pillow, numpy, librosa, pydub, noisereduce, deep-translator, scenedetect

Full (everything, ~2-5GB depending on GPU)

pip install opencut[all]

Adds all standard deps plus: whisperx, demucs, pyannote.audio, pedalboard, edge-tts, realesrgan, rembg, gfpgan, insightface, audiocraft, simple-lama-inpainting, opentimelineio, deepface, kokoro, chatterbox-tts, diffusers, websockets

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.

Configuration

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

# 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

Backend Infrastructure

Security

• No shell=True in any subprocess call
• No eval/exec/pickle anywhere in the codebase
• 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
• Social OAuth credentials stored locally at ~/.opencut/social_credentials.json

Testing

# Run all tests
python -m pytest tests/ -q

# 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

# Pre-commit hooks (auto-runs ruff lint/format on commit, pytest smoke on push)
pre-commit install
pre-commit install --hook-type pre-push

5,742+ tests across 77 test files covering route smoke tests, core module unit tests, feature integration tests, plugin tests, and ExtendScript mock harness.

FAQ

Q: The panel says "Server offline" A: Make sure the backend is running. Check that port 5679 is not blocked. The panel will auto-reconnect 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: Most AI features are optional. Install them individually or use pip install opencut[all]. Check the Dependency Dashboard in Settings to see what's installed. Each missing feature shows an install button in the panel.

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: No. Everything runs locally. No telemetry, no API keys for core features. 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.

Q: Can I export edits to DaVinci Resolve or Final Cut Pro? A: Yes. Use the OTIO (OpenTimelineIO) export in the Timeline tab. OTIO files can be imported into Resolve, FCP, Avid, and any OTIO-compatible editor. 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 supports Premiere Pro 2019+ and has full feature coverage. The UXP panel is for Premiere Pro 25.6+ using Adobe's modern platform. Both connect to the same backend. CEP will be deprecated by Adobe around September 2026.

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/              # 360 processing modules (silence, captions, audio, video, AI, VR, dubbing)
  routes/            # 73 route blueprints (audio, video, captions, timeline, etc.)
  export/            # Premiere XML, 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 ~8500 lines, style.css ~5000 lines)
    host/            # ExtendScript host (index.jsx ~2200 lines)
    CSXS/            # Extension manifest
  com.opencut.uxp/
    main.js          # UXP panel (~1700 lines)
    index.html       # UXP panel UI
    style.css        # UXP dark theme
tests/               # pytest test suite (5,742+ tests, 77 test files)
docs/
  RESEARCH.md        # Open source feature research (80+ projects analyzed)
  ROADMAP.md         # Implementation roadmap with status tracking
  UXP_MIGRATION.md   # CEP to UXP migration plan
installer/           # WPF installer (C# .NET 9) + legacy Inno Setup
scripts/             # Build and utility scripts

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.