OpenCut: Self‑hosted, open‑source CapCut alternative for creators and developers

Key Takeaway: OpenCut is a privacy-first, open-source CapCut alternative that you can self-host, customize, and wire into AI-powered editing workflows on your own infrastructure.

OpenCut is a free, open-source video editor designed as a privacy-first alternative to CapCut that you can run in your browser, on desktop, or as part of a self-hosted stack. It focuses on timeline-based, multi-track editing with a real-time preview, without watermarks, tracking pixels, or recurring subscriptions.

Under the hood, OpenCut is built with a Next.js web app, TypeScript, and a modern stack that makes it friendly for web developers who want to tweak the UI, extend features, or integrate it into larger workflows.

Why OpenCut matters for modern creators

OpenCut emerged because many creators wanted CapCut-like simplicity without giving up control over their data or being locked behind paywalls. Instead of sending videos to a third-party cloud, you keep editing local, which is crucial for client work, sensitive projects, or regions with slower upload speeds.

For developers and technical creators, OpenCut is even more interesting: it exposes a clear project structure and uses a monorepo layout (apps/web, shared components, hooks, and stores), making it straightforward to customize or embed into other platforms. With community tools like an MCP-based OpenCut Controller, you can even let AI agents drive the editor programmatically for automated video workflows.

Key features at a glance

Timeline-based editor with multi-track support for video and audio.
Real-time preview for fast iteration on cuts, transitions, and overlays.
No watermarks, subscriptions, or tracking pixels; analytics are anonymized and non-invasive.
Web-first interface that runs locally at http://localhost:3000 during development.
Optional backend stack (PostgreSQL + Redis) for user accounts, projects, and cloud-style features via Docker.

Prerequisites and system requirements

To run OpenCut from source, you’ll need a fairly standard modern development environment. At a minimum:

Node.js 18 or later.
Bun, which OpenCut uses as the preferred runtime and package manager.
Git for cloning the repository.

If you want authentication, persistent projects, and Redis-powered features, you should also have:

Docker Desktop with Docker Compose enabled.
Enough disk and memory to run PostgreSQL and Redis containers comfortably.

OpenCut runs on macOS, Windows, and Linux as long as these dependencies are available.

Step 1: Install Bun

Bun is used for dependency management and development scripts, and the official docs recommend it over plain npm for this project. Install it with one of the following commands:

# macOS / Linux
curl -fsSL https://bun.sh/install | bash

# Windows (PowerShell)
powershell -c "irm bun.sh/install.ps1 | iex"

After installation, restart your terminal and ensure bun is in your PATH; running bun --version should print a version number. If the command is not found on macOS or Linux, source your shell config (for example source ~/.zshrc or source ~/.bashrc) and try again.

Step 2: (Optional) Install Docker and Docker Compose

If you plan to use user accounts, project saving, or the full backend experience, install Docker Desktop, which includes Docker Compose on all major platforms. When Docker is active, OpenCut can spin up PostgreSQL, Redis, and a small HTTP adapter for serverless-style Redis operations.

Step 3: Clone the OpenCut repository

Next, clone the official repository and set up your environment:

# Clone repository
git clone https://github.com/OpenCut-app/OpenCut.git
cd OpenCut

# Copy example environment file
cp apps/web/.env.example apps/web/.env.local

On Windows, you can use copy or Copy-Item instead of cp when copying .env.example to .env.local. This .env.local file will hold database URLs, auth secrets, and optional integration keys.

Step 4: Install dependencies

From the project root, install dependencies with Bun:

bun install

This pulls in all workspace packages used by the web app and shared libraries. If you previously used npm and see workspace:* errors, switching to Bun or updating npm to a recent version usually resolves them.

Step 5: Start optional backend services with Docker

If you want the full experience with database-backed projects and caching, start Docker services from the repo root:

docker compose up -d db redis serverless-redis-http

This will boot:

PostgreSQL on port 5432.
Redis on port 6379.
A serverless Redis HTTP adapter on port 8079.

Ensure the DATABASE_URL in apps/web/.env.local matches the Docker config, which by default looks like:

DATABASE_URL="postgresql://opencut:opencut@localhost:5432/opencut"

Step 6: Run OpenCut locally

With dependencies installed (and optional services running), start the development server:

bun dev:web

Open your browser and visit:

http://localhost:3000 – the OpenCut homepage and main interface.

You should see an empty project timeline, an import area for your assets, and controls for basic editing operations.

If port 3000 is already in use, you can choose a different one:

PORT=3001 bun dev:web

Or free the existing port:

# macOS / Linux
lsof -ti:3000 | xargs kill

# Windows
netstat -ano | findstr :3000
taskkill /PID <PID> /F

First run: Exploring the interface

Once OpenCut loads, you’ll land on a clean interface built around a familiar three-part layout: media library, preview window, and timeline. The timeline supports multiple tracks, making it easy to layer B-roll, overlays, sound effects, and music.

You can import files in common formats like MP4, AVI, MOV, MP3, and WAV by dragging and dropping them into the project area, then dragging the resulting clips into the timeline. Playback in the preview window lets you iterate quickly on cuts and transitions without exporting every minor tweak.

Basic editing workflow in OpenCut

Once media is imported, a typical beginner-friendly workflow looks like this:

Create or open a project – Start from the homepage and open a new or existing project from the project picker.
Import media – Drag videos, images, and audio into the import area; OpenCut will index them for quick access.
Build your rough cut – Drag clips onto the timeline, arrange them in order, and trim the start/end points to match your story.
Refine with multi-track layers – Add overlays, titles, and background tracks on additional tracks for a more polished look.
Preview in real time – Scrub and play the timeline while adjusting cuts, transitions, and timing until it feels right.
Export your video – Use the built-in export flow to render your final video with your desired resolution and format.

Because OpenCut runs locally, exports happen on your machine, giving you predictable performance and avoiding upload bottlenecks.

Optional: Auth, cloud-like features, and integrations

When Docker services are enabled and your environment variables are configured, OpenCut can provide:

User authentication and accounts.
Project persistence backed by PostgreSQL instead of local-only state.
Redis-powered caching and optional features built on serverless-style Redis access.

There is also support for advanced workflows like automated transcription using Python, Whisper, Cloudflare R2, and Modal, which can be wired into OpenCut for automatic captions. This is helpful if you regularly produce content for TikTok, Reels, or YouTube Shorts and want quick subtitle generation without third-party SaaS tools.

Troubleshooting common issues

Even with a clean setup, a few common issues can show up during installation.

bun command not found: Restart your terminal and ensure your shell config sources Bun’s environment variables; if needed, run source ~/.bashrc or source ~/.zshrc on macOS/Linux.
Database connection errors: Confirm Docker is running (docker ps), check container health with docker compose ps, and verify that DATABASE_URL in .env.local matches the default configuration.
Port conflicts: If http://localhost:3000 shows another app, change the PORT value or free the existing process as shown earlier.

Who should use OpenCut?

OpenCut is ideal if you:

Want a CapCut-like experience without watermarks or subscription lock-in.
Need a privacy-first editor that keeps raw footage and exports on your own infrastructure.
Are a developer who wants to hack on the editor, extend it, or wire it into AI/agent workflows.
Run an agency or media team and want a reproducible, self-hosted editing stack that you can standardize across machines.

With its open-source license, modern stack, and growing community, OpenCut is a strong foundation for both solo creators and teams who want more control over their video tooling.