clipforge site · download · faq
Turn podcasts, webinars, streams and interviews into ready-to-post vertical clips.
AI-picked moments, virality scores, animated captions, auto zoom and speaker-aware reframing.
Opus Clip is great, but it costs a subscription, runs in the cloud, and uploads your footage. ClipForge does the same job as a free desktop app. You bring an OpenAI API key and pay cents per video instead of dollars per month.
| ClipForge | Opus Clip (and similar SaaS) | |
|---|---|---|
| Price | Free and open source (MIT). Pay only OpenAI API cents | Monthly subscription |
| Your footage | Stays on your machine. Only audio, transcripts and a few frames go to the API | Uploaded to their cloud |
| Processing minutes | Unlimited | Capped per plan |
| Watermark | Your own logo, or none | Removed on paid tiers |
| Models | Your choice (GPT-5 series, or the budget legacy option) | Theirs |
| Extensible | Fork it, script it, PR it | Closed |
Typical cost: ~$0.36/hour of video for Whisper transcription plus a few cents of LLM analysis with the default gpt-5.4-mini.
Pick a mode at setup: let the AI find clips, or caption the whole video end to end.
Two ways to work
- Find viral clips. The AI reads the transcript, cuts the best moments out and scores them, and you pick from the results.
- Caption the whole video. No clip finding: give it a 16:9 video and it comes back as one vertical, captioned edit you can trim, restyle and export. Optionally tracks the speaker across the whole video and adds auto zoom. Both modes work on the same project, and the transcript is shared between them.
Finding the clips
- Import anything. Local files (MP4/MOV/MKV/WEBM and more) or paste a URL from YouTube, Vimeo, TikTok, Twitch, or any site yt-dlp supports. Private or SSO-protected videos (like enterprise Vimeo) work by borrowing the login from your browser. No server integration needed.
- Whisper transcription with word-level timestamps. Long videos are chunked automatically and checkpointed, so retries and re-generations never pay for transcription twice.
- Viral moment detection backed by research. An LLM picks self-contained hook, build, payoff micro-stories (not clips that trail off mid-setup). You can steer it with your own prompt if you want, like "find the funniest exchanges". A second AI pass reviews every clip ending and extends it to the beat that actually completes the thought.
- Two-pass virality scoring (0-99). A text rubric based on Berger and Milkman's What Makes Online Content Viral? (JMR 2012), plus measured vocal energy, combined with a vision pass from Kayal et al. (ACL 2025) that scores sampled frames for scroll-stopping potential.
Making them good
- Auto zoom. Scene-aware punch-ins on the speaker's most energetic lines, jump zooms that cover cuts, and slow creep on static stretches. The kind of thing top short-form editors do to keep people watching.
- Tighten cuts. Pauses and filler words ("um", "uh") get removed automatically. Captions, B-roll, zoom and the face track all remap to the shorter timeline.
- Speaker-aware auto-reframe. On-device audio-visual active speaker detection (UltraFace face tracking + the LR-ASD model via ONNX Runtime, no cloud) checks every face's lip movement against the actual soundtrack, so the crop stays on the person talking — not whoever moves or gestures. The 9:16 crop cuts between speakers like a camera switch.
- 12 caption styles plus your own fonts. Karaoke-style word highlighting burned in with libass. Upload any TTF/OTF and previews match exports exactly.
- Your branding. Overlay your logo or watermark (corner, size, opacity) on the preview and every export.
- AI B-roll. Say "Yoda" and a picture of Yoda pops over the video at that word. Uses Wikipedia and Openverse images, no extra API keys.
- A real editor. Filmstrip trim with waveform and live playhead, click-to-seek transcript that doubles as a trim tool, aspect ratios (9:16 / 1:1 / 16:9), and a live preview that matches the export.
Shipping them
- Export H.264/AAC MP4s with burned-in captions. Loudness-normalised to -14 LUFS, gentle audio tail fade, three quality tiers, NVIDIA NVENC GPU encoding with automatic CPU fallback. Optionally encode once to fit under a megabyte cap (Discord, email, WhatsApp).
- AI post captions. One click writes a scroll-stopping TikTok/Reels/Shorts caption (hook-first line, one engagement driver, niche hashtags). Copy it and jump straight to TikTok Studio upload.
- In-app updates. Packaged builds download and install updates themselves. Source checkouts update with one click (pull, rebuild, relaunch).
git clone https://github.com/JeremySNR/clip-forge.git
cd clip-forge
npm install
npm run dev # development with hot reload
npm run package # distributable build (dmg / nsis / AppImage)Most people should just download the app from the releases page — there's no need to run anything from source. To cut a new release, bump the version and push a tag; the Release workflow builds the macOS .dmg, Windows installer and Linux AppImage and publishes them, along with the update manifests the in-app updater reads:
npm version patch # or minor / major — bumps package.json and creates the tag
git push --follow-tags # pushes the commit and the vX.Y.Z tagWindows packages can also be listed on winget after a one-off first submit.
Once a user has installed any build, later releases install themselves automatically. The macOS app is not code-signed yet, so on first launch the user right-clicks the app and chooses Open to get past Gatekeeper (a one-time step). Signing + notarization removes that prompt and is what enables fully silent macOS auto-updates — add an Apple Developer ID certificate and wire the signing secrets into the workflow when you're ready.
You need Node.js 20+ and an OpenAI API key. Enter it in the app and it gets stored encrypted with Electron safeStorage. FFmpeg is bundled, so there is nothing else to install. Prebuilt Linux AppImages are on the releases page. On Windows, winget install JeremySNR.ClipForge will work once the winget package is listed.
Everything except transcription and analysis runs locally. Rendering, face tracking, editing, zoom and export never leave your machine. Only extracted audio, transcripts and a few sampled frames go to the OpenAI API. Never the full video.
src/
├── main/ Electron main process
│ ├── pipeline/
│ │ ├── ffmpeg.ts probe, audio chunk extraction, thumbnails
│ │ ├── openai.ts minimal REST client (Whisper + structured chat)
│ │ ├── transcribe.ts chunked transcription, timestamp stitching
│ │ ├── highlights.ts LLM viral-moment detection, scoring, ending review
│ │ ├── faces.ts auto-reframe orchestration + focus track building
│ │ ├── asd.ts LR-ASD audio-visual active speaker detection
│ │ ├── facetracks.ts per-person face tracking (IOU + interpolation)
│ │ ├── detect.ts UltraFace face detection + scene-cut detection
│ │ ├── mfcc.ts MFCC audio features for the ASD model
│ │ ├── energy.ts per-segment vocal energy (arousal signal)
│ │ ├── ytdlp.ts yt-dlp binary management + URL downloads
│ │ ├── broll.ts LLM keyword tagging for B-roll inserts
│ │ ├── imagesearch.ts keyless Wikipedia/Openverse image search
│ │ ├── encoders.ts NVENC detection/verification, GPU ffmpeg download
│ │ ├── captions.ts ASS karaoke subtitle generation
│ │ ├── socialCaption.ts AI post-caption writer
│ │ └── render.ts cut, reframe, auto zoom, watermark, burn-in
│ ├── updates.ts GitHub release checks + self-update
│ ├── fonts.ts custom caption fonts (sfnt parsing, merged fontsdir)
│ ├── ipc.ts typed IPC handlers
│ ├── settings.ts encrypted API key, models, branding
│ └── projects.ts project persistence (userData/projects)
├── preload/ context-isolated typed bridge
├── shared/ types, caption styles/layout, tighten + zoom planners
└── renderer/ React UI (Tailwind, Zustand)
The live preview and the export share the same planning code in src/shared/ (caption layout, tighten cuts, zoom), so what you see is what gets rendered.
Unit tests, typecheck and lint run in CI on every push, alongside the offline pipeline test and a UI smoke test:
npm test # vitest unit tests
npm run typecheck
npm run lintIntegration test scripts live in scripts/ (test-pipeline, test-e2e, test-quality, test-wholevideo, test-encoders, test-resilience, test-broll, test-youtube, test-asd, smoke-test.sh). See each file's header for what it covers. The e2e ones need OPENAI_API_KEY.
To measure clip quality on your own projects, scripts/eval-clips.ts reads every saved project and reports how many clips open mid-sentence, cut a sentence off, or trail into dead air, plus the length spread. Add --rerun (needs OPENAI_API_KEY, a few cents per project, no transcription cost) to re-run clip detection on the saved transcripts with the current prompts and compare, which is how to check a prompt change actually helps:
npx tsx --tsconfig tsconfig.node.json scripts/eval-clips.ts --verboseThe bundled active-speaker model (resources/models/lr-asd-*.onnx) is exported from the MIT-licensed LR-ASD weights with scripts/export-asd-onnx.py (requires Python with torch, onnx, onnxruntime, python_speech_features).
Is it actually free? The app is free and MIT licensed, forever. You pay OpenAI directly for transcription and analysis, which works out at roughly $0.36 per hour of video. There is no subscription, no account, no processing-minute cap and no paid tier holding features back.
Do I need an OpenAI API key? For finding clips and captioning, yes, because that is what does the transcription and the analysis. Everything else runs locally without one: the editor, trimming, caption styling, auto zoom, speaker reframing, watermarks and export. If you already have a transcript from a previous run, you can keep editing and exporting offline.
Does my video get uploaded anywhere? No. Only extracted audio, the transcript and a handful of sampled frames go to the OpenAI API. The full video never leaves your machine, and rendering, face tracking, zoom and export are entirely local.
How is this different from Opus Clip's free tier? Free SaaS tiers cap your processing minutes and usually watermark the output. ClipForge has no cap because it runs on your hardware, and the only watermark is one you add yourself.
Do I need a GPU? No. ClipForge uses NVIDIA NVENC if it finds it and falls back to CPU encoding automatically. A GPU makes exports faster, nothing more. Speaker detection runs on-device through ONNX Runtime and is fine on CPU.
How long can my video be? There is no fixed limit. Audio is chunked and transcription is checkpointed to disk as it goes, so hour-plus recordings work and a failure part way through does not mean paying to transcribe it again.
Does it work in languages other than English? Transcription does. Set the language in Settings (it defaults to English, which is more reliable than auto-detect, since auto occasionally mislabels English as something else). Captions burn in whatever Whisper returns. Translating captions into another language is on the roadmap, not built yet.
Can it post to TikTok or YouTube for me? Not automatically. It writes the post caption and hands you the file, then you upload. Direct publishing needs an audited TikTok/YouTube app, which is on the roadmap and a good contribution if you fancy it.
Can I use the clips commercially? Yes. MIT licence, and the output is yours. Do check the rights on any source footage you did not create, and note that AI B-roll pulls from Wikipedia and Openverse, whose images carry their own licences.
macOS says the app cannot be opened. Why? The macOS builds are not code-signed yet, so Gatekeeper objects on first launch. Right-click the app and choose Open, which is a one-time step. Signing and notarisation are wanted; see CONTRIBUTING.md if you can help.
Which OpenAI models does it use?
whisper-1 for transcription and gpt-5.4-mini for analysis by default. Both
are configurable in Settings, including a cheaper legacy option.
Can I run it against a local or non-OpenAI model?
Yes, if it speaks the OpenAI REST shape. Set the API base URL in Settings
(or OPENAI_BASE_URL) to Azure OpenAI, OpenRouter, Groq, LM Studio, Ollama,
or anything else with /v1/chat/completions. Transcription can point at a
separate local Whisper server (faster-whisper, whisper.cpp’s compatible
endpoint) — it must return word-level timestamps, because captions and
tighten-cuts depend on them. Bundled in-process Whisper (no server at all)
is still on the roadmap.
Each of these is an open issue, so the discussion and the detail live there. Contributions very welcome.
- Multi-language caption translation
- Manual zoom keyframes on the timeline
- Bundled on-device Whisper, so transcription needs no server at all
- Direct publishing and scheduling to socials (needs an audited TikTok/YouTube app)
Looking for somewhere to start? The good first issues need no deep knowledge of the pipeline.
Issues and PRs are welcome. The codebase is TypeScript end-to-end. npm test && npm run typecheck && npm run lint must pass. CI enforces all three plus an offline render test.
See CONTRIBUTING.md for setup (including how to explore the UI without an API key), how the code is laid out, and the handful of things that are easy to get wrong. Release history is in CHANGELOG.md. Security issues go through SECURITY.md rather than a public issue.