Dawn Cut
kwakseongjae/dawn-cut
Editor de vídeo local com edição por texto, legendas IA e zero dependências em cloud
Ver no GitHubEditor de vídeo open-source 100% local que permite edição baseada em texto, legendas automáticas em coreano, remoção de silêncios e ajustes visuais — tudo sem nuvem, conta, watermark ou assinatura. Funciona como um processador de texto para vídeo, com núcleo determinístico testado e server MCP para automação.
Instalação
npx convez-ai kwakseongjae/dawn-cut1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Editar vídeos com transcrição e corte baseado em texto
- Gerar legendas automáticas em coreano e português localmente
- Remover silêncios e fazer color grading sem deixar dados na nuvem
- Automação de edição via agente MCP para workflows programáticos
Veredito

Solução genuinamente inovadora que une privacidade total com capacidades IA reais. O núcleo determinístico e a transparência sobre o que é estável (v0.1) vs experimental são admiráveis; recomendado para quem precisa editar vídeos localmente ou construir workflows de automação sem depender de APIs externas.
README
A tradução para o português deste README ainda está na fila.
dawn-cut
The open-source video editor where your footage never leaves your machine.
Edit video like a document — auto subtitles, text-based cutting, and automatic silence removal, 100% local. No cloud, no account, no watermark, no subscription.
English · 한국어
Status: v0.1. The deterministic editing core is real, tested, and ready to use — text-based cut, silence removal, Korean auto-subtitles, 1-tap adaptive auto-enhance, low-confidence subtitle review & correction, color grading, 9:16/1:1 reframing, image/sticker/GIF overlays, one-click style packs, TTS, and SRT/chapter export, all 100% local. Natural-language AI editing and the headless MCP agent server also work locally, but ship labeled experimental — they need a one-time local model download and are still maturing. We label everything honestly: What works today · Experimental · Roadmap.
Demo
(demo GIF coming with the first release — see docs/PRODUCTION.md)
Placeholder. A reproducible end-to-end run (real
whisper.cpp+ FFmpeg) already exists underdemo-output/: a 23.6s English-narrated clip is transcribed, text-edited, silence-trimmed to 17.3s, and exported with a muxed soft (toggleable) subtitle track + SRT + a reusable.dawnproject. (The UI can also burn subtitles in; Korean is covered by unit + integration tests.) Regenerate it withpnpm demo:assets && pnpm demo:run && pnpm demo:ui.
Why dawn-cut
Every popular "AI video editor" makes you pick one of two things you actually want: privacy or AI assistance. The cloud tools take your footage; the local tools can't think. dawn-cut is built so you don't have to choose.
| dawn-cut | CapCut | Vrew | Descript | OpenCut | |
|---|---|---|---|---|---|
| Runs 100% locally | Yes | No (cloud) | No (cloud STT) | No (cloud) | Yes (browser) |
| No account / no watermark / no subscription | Yes | No | Free tier limited | Credits/limits | Yes |
| Word-level STT + text-based editing | Yes | No | Partial | Yes | No |
| Auto subtitles (incl. Korean) | Yes (local) | Cloud | Cloud | Cloud | No |
| Deterministic, verifiable edit core (EDL + invariants) | Yes | No | No | No | No |
| Open source | Yes (MIT) | No | No | No | Yes (MIT) |
- vs CapCut — Your video never leaves your laptop. No telemetry, no terms that claim a license to your face and voice, no export watermark.
- vs Vrew — Comparable Korean auto-captioning (whisper
large-v3-turbo), but local, unlimited, and free. dawn-cut reassembles Korean eojeol (word + particle) losslessly from whisper tokens — seewhisper.ts. - vs Descript — The same "delete a sentence, delete the footage" text-based editing — but with no cloud, no credits, no upload.
- vs OpenCut — OpenCut owns the general-purpose, hand-edited browser timeline. dawn-cut takes the gap it leaves: word-level STT, text-based editing, and a deterministic edit core a machine can drive — the foundation for agent editing.
What works today
Honest list — every item below is implemented in packages/core
and covered by unit/property tests, or wired through the Electron UI.
- Word-level transcription —
whisper.cpp(MIT, local) produces per-word timestamps; Korean eojeol are reconstructed losslessly (validated char-accuracy, zero mojibake). - Text-based editing — delete a word range and the corresponding footage is cut
and rippled gaplessly (
deleteWordRange,cutSourceRange). - Automatic silence removal — detect silent intervals and trim them with
configurable padding (
removeSilences). - Filler-word detection — conservative Korean filler lexicon, exact-match only
(
detectFillers). - Subtitle accuracy review & correction — surface low-confidence (likely-misheard)
eojeol from whisper token probabilities (
lowConfidenceWords), highlight them in the transcript, jump between them, and fix a word inline — corrections flow into cues / SRT / burn-in and are recorded in the audit log (correctWordverb). - 1-tap adaptive auto-enhance — analyze the actual footage (FFmpeg
signalstats: brightness / contrast / saturation) and apply a computed color grade — brightens dark clips, pops dull ones — without ever over-correcting (analyzeVideo→ pureautoEnhanceParams→applyAutoEnhance; length-invariant, exact numbers recorded in the EDL). - Auto subtitles — group live words into program-timed cues, break on sentence
ends / cuts / word caps, per-word reveal / karaoke animation, export SRT
(
transcriptToCues,captionFrames,formatSrt). - Auto chapters — rule-based YouTube
M:SS titlechapter list from the transcript (extractChapters,formatChapters). - Glossary substitution — deterministic term replacement across the transcript
(
applyGlossary). - Color grading — 6 presets (warm / cool / punch / cinematic / flat / vivid) with
intensity weighting, applied through the command bus and rendered with FFmpeg
eq/curves(applyColorgrade,COLOR_PRESETS). - 9:16 / 1:1 reframing — turn landscape footage into vertical shorts / square with an
overlay-aware center crop (
cropForAspect,renderEdl({ reframe })). - Image / sticker / GIF overlays — position, scale, opacity, z-order, rotation,
blend modes, and multi-keyframe motion paths, composited into the exported video
via the FFmpeg overlay filter (
OverlayClip,overlay.ts,draw.ts,renderEdl). - One-click style packs — 6 genre presets (viral-punch, mukbang-sizzle, beauty-glow,
golden-hour, city-night, talk-clean) expressed as plans (
EditCommand[]bundles), so the GUI, the LLM planner, and MCP all share them (STYLE_PACKS,templates.ts). - TTS voiceover — synthesize narration (macOS
say) and mix it into the export. - Deterministic EDL export — the timeline compiles to an Export Decision List
that the FFmpeg sidecar renders (
timelineToEdl). - Transcript ↔ timeline sync — provable two-way mapping between words and
program time (
wordToProgram,programToWord). - Project save / open — versioned
.dawnJSON; full undo/redo (history.ts). - Electron desktop app — import media, transcribe, edit by text, scrub, preview subtitles live, and export.
Built on data contracts, not vibes
The editing core is the moat. It is pure TypeScript — it may not import
electron, fs, child_process, or path (enforced by dependency-cruiser).
Every model is governed by validated invariants:
- Time is integer microseconds (µs); intervals are half-open
[start, end). validateSyncproves the transcript↔timeline roundtrip (SYNC-INV).validateEdlproves the export list is contiguous and total-duration-exact (EDL-INV).validateCuesproves subtitles are sequential, non-overlapping, and in-bounds (SUB-INV).- Commands are pure functions returning
{ before, after, removedProgramUs }, so every edit is undoable and replayable.
These properties — determinism, validation, undo, headless execution — are exactly the non-functional requirements an AI editing agent will need.
Experimental (opt-in)
These work locally and end-to-end today, but are labeled experimental because they depend on a one-time model download and/or have known gaps. They're real, not mockups — just maturing. Enable them deliberately; the core above never depends on them.
- Natural-language editing (local LLM planner) — type "cut the filler words and make
it cinematic" and a local
llama.cppplanner (default Qwen2.5-1.5B, Apache-2.0) emits a validatedEditCommandplan you preview (dry-run diff) before applying. Grammar-constrained decoding keeps output on-schema; if no model is installed it falls back to a deterministic rule planner. Setup:pnpm setup:llm. Caveats: requires the model download; planning quality is bounded by the 1.5B model; CI verifies the rule path (the LLM path is exercised manually). - MCP agent server — a headless Model Context Protocol
server (
@dawn-cut/mcp) lets an external agent (Claude Desktop / Cursor) drive the same command bus over.dawnprojects:open_project → command_manifest → plan → dry_run → apply → save_project → render(incl. 9:16/1:1 reframe). Every edit goes through the same invariants + hash-chained audit log as the GUI. Caveats:renderdoes not yet burn in subtitles/overlays (cut + color + zoom + reframe only); run headless via the workspace (thenpx-installable bin is not yet published). Seedocs/P4-MCP.md.
Vision
Say what you want; the AI proposes the edit; you review the timeline/EDL; then render. Not a black box.
The endgame is an editor where you type "cut the dead air and put captions on the
key points" and an LLM emits a list of validated, serializable EditCommands
that the deterministic core applies and renders — with a dry-run diff you approve
first. Because the core already exposes a reviewable intermediate representation
(timeline + EDL) and validates every step, an agent's edits are reproducible and
auto-checkable rather than opaque.
Much of this is now built. The command bus (Zod-derived EditCommands + invariant
validation + a hash-chained audit log), one-click style packs (templates expressed as
plans), and 9:16/1:1 reframing all ship in the core; a local llama.cpp planner (natural
language → plan → dry-run → approve) and a headless MCP server with a render tool
(external AI drives the same command bus over .dawn projects) ship as
experimental. Still open: a live-app↔MCP bridge, MCP subtitle
burn-in, transitions / beat-sync, and multitrack. See the roadmap below and
docs/PRODUCTION.md.
Roadmap
- Phase 1 — Command bus. Lift the editing actions scattered in the UI store into
a single serializable
EditCommandunion with oneapplyCommanddispatcher, each verb backed by one Zod schema (→ TS type + runtime guard + JSON-Schema manifest). Post-condition gate runs the invariant validators after every command. - Phase 2 — Dry-run / diff / commit + audit log. Preview an edit on a cloned state, show the diff (removed µs, changed cues, length delta), commit through an append-only hash-chained log. Add a real render pipeline for punch-in zoom and color grading (effect-aware EDL).
- Phase 3 — Local LLM planner (the differentiator). A
llama.cppsidecar (reusing thewhisper.cppIPC pattern) with grammar-constrained decoding produces a validatedEditCommandplan from natural language, dry-run + approve + commit — 100% local, no cloud. - Phase 4 — MCP server + OTIO + multitrack. Expose the command registry as an MCP server for external agents (Claude Desktop / Cursor), generalize to multitrack / multi-source (B-roll, PIP, music), and add OTIO export for Premiere/Resolve/FCP interop.
Quickstart
Requires Node ≥ 20, pnpm 10, and (for transcription) cmake + FFmpeg.
pnpm install # install workspace deps
pnpm verify # lint + core boundary check + build + unit + E2E
# (whisper-dependent steps self-skip; integration runs when fixtures present)
pnpm setup:binaries # build whisper.cpp + download the model (needs cmake + ffmpeg)
# default model: large-v3-turbo (~1.6GB);
# lighter setup: DAWN_WHISPER_MODEL=base pnpm setup:binaries
pnpm make:fixture # generate a deterministic test video (uses macOS `say`)
Other useful scripts: pnpm test:unit, pnpm test:int, pnpm test:e2e,
pnpm demo:assets && pnpm demo:run && pnpm demo:ui (full real-media demo).
Architecture
Three layers, with a strict portability boundary at the core:
UI / shell ──► editing core ──► AI / render sidecars
(Electron, React) (pure TS) (Node subprocess wrappers)
packages/core— portable, pure-TypeScript editing core: transcript / timeline / sync / commands / EDL / subtitles / overlays / chapters. No Node, no Electron (enforced). This is what a future agent will drive.packages/ui— React UI + Zustand store (@dawn-cut/ui).apps/desktop— Electron shell (@dawn-cut/desktop).sidecar/stt—whisper.cppsubprocess wrapper, word-level timestamps (MIT).sidecar/ffmpeg— FFmpeg / ffprobe subprocess wrapper (LGPL, subprocess only).sidecar/tts— text-to-speech (macOSsayoffline by default; Piper opt-in).
The EDL is the deterministic IR that separates editing from exporting: the
core produces it, the FFmpeg sidecar consumes it, so the same edit always renders the
same output. Full design: docs/ARCHITECTURE.md and the PoC
docs under docs/poc/.
Verification-driven
Every milestone gate is backed by an automated test. pnpm verify exiting 0 is the
necessary condition for "done." See docs/poc/03-TEST-GATES.md.
License
MIT — see LICENSE and NOTICE. The core stays free and local, forever.