Clips Kitty — open-source AI video clipping that runs on your own PC

Clips Kitty was called Clips Studio until version 1.1.3, renamed to meet Microsoft Store naming requirements. Same app, same repository, same data.

Turn long streams and videos into ready-to-post Shorts, Reels, and TikToks — entirely on your own machine. Clips Kitty is a free, open-source AI clip generator and video editor for creators: paste a YouTube, Twitch, or Kick link and it finds the best moments, crops them to 9:16 with the speaker kept centred, burns in word-synced captions, and writes titles, descriptions, and hashtags.

No cloud AI. No subscription. No per-clip fees. No upload of your footage to anyone.

Why it exists: most creators growing a channel are doing all of it themselves — filming, streaming, editing, posting. Clipping is how people find you and it is usually the first thing that gets dropped: an editor is a cost most channels cannot justify yet, clipping tools charge per video or per month, and cutting them by hand takes a day you needed elsewhere. This runs on hardware you already own, so it costs nothing to use and there is no cap on how many clips you make.

Local AI video processing · AI clip generator · Twitch clip generator · Kick clip generator · YouTube Shorts automation · AI video editor · open-source OpusClip alternative

---

Contents

• What it does
• How it works
• Features
• What it's built for
• Requirements
• Install and run
• Pick your AI model
• Tested hardware and performance
• Supported platforms
• Supported languages
• GPU acceleration
• Command line use
• Build on it
• Architecture
• Contributing
• Roadmap
• License

---

What it does

You give Clips Kitty a long video. It gives you back a folder of finished vertical clips you can post, plus a studio to review and fix them before you do.

It is built for the content most clipping tools handle worst: live streams, IRL and talking-head footage, podcasts, and gym/fitness content — long, loosely structured videos where the good moments are buried and a transcript alone won't find them.

How it works

        Video input  (YouTube · Twitch VOD · Kick VOD · local file)
             │
             ▼
        Transcription           faster-whisper, word-level timestamps, local
             │
             ▼
        AI video analysis       audio · visual · reaction signals, computed
             │                  over the whole video in 1-second bins
             ▼
        Clip detection          local LLM scores the transcript in context of
        and scoring             those signals; signal peaks become candidates
             │                  too, so laughs and hype aren't missed
             ▼
        Video editing           YOLOv8 pose tracking + TalkNet active-speaker
             │                  detection → 9:16 crop that cuts to whoever is
             │                  speaking; trims, cuts, watermark
             ▼
        Captions/subtitles      word-synced, burned in, fully editable
             │
             ▼
        Multilingual            translate, subtitle, or dub into 19 languages
             │
             ▼
        Export                  organized folders, clean filenames, metadata

Every stage above runs on your computer. The only thing that touches the network in a normal run is downloading the source video.

The stages in detail

Transcription — faster-whisper. Word-level timestamps, running on CUDA where available and falling back to CPU. Word timing is what makes captions land on the right syllable and clips start on a real sentence boundary.

AI clip scoring. The transcript is one signal among five. Audio gives loudness spikes, burst density (what laughter and applause look like), and silence→explosion payoff shapes. Visual gives scene cuts, motion, and face-area changes. A reaction signal fuses those. Each is normalized within that video, so a quiet podcast and a screaming stream both produce meaningful peaks. Where real audience data exists — Twitch chat replay measured by unique chatters, YouTube's most-replayed heatmap — it adds a small capped bonus.

The local LLM sees the transcript plus a timeline of those events, so it can weigh "the words are mild but the room exploded" correctly. Because small models score everything in a narrow band, the finalists then get compared head-to-head in one rerank call — relative judgment is much easier for a 7B model than absolute scoring.

Creator Profiles. The app builds a knowledge base per creator across their videos: recurring topics, series, collaborators, running jokes, and ongoing storylines. That context helps it write accurate titles and spot callbacks. It is deliberately conservative — a catchphrase has to actually repeat before it counts, knowledge that stops being mentioned goes dormant, and every score contribution from it is additive, capped, and can be switched off.

Video editor. Non-destructive: trims, internal cuts, mutes, muted words, volume, fades, speed, hook text, music, and watermark are stored as operations and applied at render time. There's an AI edit chat too — "make it 5 seconds longer", "the caption says gost, it should say ghost" — where the model proposes and validated code applies.

Long-form processing. An opt-in 16:9 path using the same analysis: horizontal clips, X/Twitter-length cuts, a best-of highlight reel, or the full stream with dead air removed.

Multilingual pipeline and AI dubbing. Captions are translated and shown for review before anything is written or burned, so a bad line gets fixed while it's still fixable. A glossary protects channel names, sponsors, and in-jokes from being translated. Dubbing uses local TTS with auditionable voices.

Local GPU acceleration. CUDA for detection and transcription, hardware video encoding via NVENC/AMF/QSV (auto-detected, with CPU fallback), and the LLM on GPU through Ollama.

Features

• Multimodal clip detection — moments scored 0–100 by fusing what's said, audio excitement, visual activity, on-screen reactions, and hook/payoff strength. Every clip clearing the quality bar is kept, with no arbitrary cap.
• Speaker-aware face tracking — YOLOv8 pose detection keeps the subject centred, and in group footage the camera follows whoever is actually speaking, decided by TalkNet active-speaker detection from the face and the audio together rather than from movement. When the speaker changes the framing cuts to them instead of panning across, the way an editor would. Crop-only framing: never stretched, never distorted.
• Podcast mode — for multi-camera footage, each shot gets its own steady crop on one person, so cuts land on a face with no panning. Within a shot the subject is chosen by mouth motion, falling back to the most prominent face.
• Editable burned-in captions — word-synced, in your style: colour, size, position, words per line, casing, or off. Fix a transcription mistake line by line before export.
• AI edit chat — describe what's wrong in plain language and it re-edits.
• AI titles, descriptions, and hashtags, all editable before export.
• Creator Profiles — the app learns each creator over time to pick and title clips better. Everything stays on your computer, and you can inspect, correct, or wipe it.
• Multilingual publishing — 19 languages, with review before anything is burned.
• AI dubbing — local text-to-speech with voice auditioning per language.
• Long-form export — 16:9 clips, highlight reels, or a de-duplicated stream edit.
• Watermark and branding profiles — per-creator defaults applied automatically.
• Model manager — swap the AI brain from inside the app; download, remove, and switch models with progress bars and no terminal.
• In-app feedback — bug reports with auto-collected diagnostics, no account needed.
• Accessible UI — keyboard focus, reduced-motion support, adjustable font and size.

What it's built for

Everything runs on any video you give it. These are the cases where it's doing more or less thinking than the feature list suggests, so nothing comes as a surprise:

Clip selection is transcript-and-signal driven. When the funny thing is visual only and nobody comments on it, expect to find it yourself in the editor.

Requirements

If you use the installer, this is the whole list:

• Windows PC (the Python engine should run on Linux/macOS; the app is developed and tested on Windows). No Mac build exists and the maintainer has no Mac to test one on — see #62 if you have one and want to help
• 16 GB of RAM. Not a suggestion: 8 GB will analyse a whole video and then render nothing, which looks like a crash rather than a memory limit
• Recommended: an NVIDIA GPU (see GPU acceleration)
• Around 20 GB free, plus room for the videos you clip

Running from source needs the things the installer would otherwise bundle for you:

• Python 3.10+ and Node.js 18+
• FFmpeg on your PATH
• Ollama with a model pulled: ollama pull gemma:7b

Install and run

The easiest way is the Microsoft Store. One click, it updates itself, and Windows raises no security prompt — Microsoft certified and signed the package, so the SmartScreen warning described below does not appear at all.

Or grab the installer. The latest Web Setup from Releases and run it. It carries the app, the Python engine, every library, FFmpeg, the AI runtime and all the detection and transcription weights — no Python, no PATH, no terminal, and no second program to install.

The one thing it doesn't carry is the language model itself, because those ship under licences the person downloading has to accept rather than something that can be accepted on your behalf. The setup wizard starts that download by itself, picks the size that suits your graphics card, and shows a progress bar. So: one download, one double-click, one progress bar. After that it runs offline.

Windows will warn that the app is unsigned the first time you run it — click More info → Run anyway. A signing certificate is on the list.

From source

git clone https://github.com/ColinGPT9/clips-studio
cd clips-studio
pip install -r requirements.txt

cd ui
npm install
npm run dev        # opens the Clips Kitty desktop app

The app starts its own Python engine automatically. Paste a link in Clip Editor, press Generate clips, and watch the progress live.

Building the installer yourself is one command — see CONTRIBUTING.md.

With Docker — nothing else to install

For contributors. You need Docker Desktop and nothing else — no Python, no Node, no FFmpeg, no PyTorch.

git clone https://github.com/ColinGPT9/clips-studio
cd clips-studio
docker compose up

Three services come up together:

Then pull a model — docker compose exec ollama ollama pull gemma3:4b — and you have a working checkout.

Run the checks the same way:

docker compose run --rm engine pytest
docker compose run --rm ui npm run typecheck

Skip the ten-minute first build: docker compose pull fetches a prebuilt engine image instead of compiling PyTorch and OpenCV locally.

The desktop shell itself still runs on your host, since Electron needs a display — everything else is containerised. Details, and what this can't tell you, in docs/DOCKER.md.

Pick your AI model

Open the Models page to see what's installed and what your GPU can handle:

One axis only: how much VRAM you have. These are the same rows the app shows, from RECOMMENDATIONS in llm/manager.py — the wizard and the Models page read that one table so they cannot disagree with each other, or with this.

And the models worth picking for a reason other than VRAM:

Only the three marked "tested" have been run against real streams, and gemma:7b is the one with the most hours on it — it is what config/settings.yaml ships with. Everything else is listed because it is a sensible size and free to use commercially, not because clip quality has been measured with it. They all work, since the app talks to every model identically through Ollama, but nobody has checked whether they pick better moments. Closing that gap is #38.

Anything Ollama serves works, and switching is one click. Translation can use a different model than clipping — set llm.translation_model.

Tested hardware and performance

Clips Kitty is developed and tested daily on this machine, so it's a useful reference point if you're comparing your own results:

Everything in this repo — the default settings, parallel_renders: 3, the 5-minute analysis chunk size — is tuned for roughly this class of machine. On a bigger GPU, raise llm.num_ctx and analysis.chunk_seconds together and move up a model size; on a smaller one, drop to gemma3:4b.

If you benchmark Clips Kitty on different hardware, please post it in Discussions — real numbers from real machines help everyone size their setup.

Supported platforms

Supported languages

Clips can be translated, subtitled, and dubbed into 19 languages — and the interface itself is translated into all 19 too, so the app is usable in the same languages it publishes in:

English · Spanish · Portuguese (Brazilian) · French · German · Hindi · Indonesian · Japanese · Russian · Arabic · Chinese (Simplified) · Vietnamese · Filipino · Turkish · Urdu · Bengali · Thai · Korean · Italian

Adding a language is one row in multilingual/languages.py plus a locale file in ui/src/renderer/src/locales/ — the translator and subtitle writer are language-agnostic.

Help wanted: the maintainer only speaks English

18 of those 19 interface translations have never been read by somebody who speaks the language. Half of them aren't finished. Every language has its own issue, written in English and in that language, and reporting a bad word is a complete contribution — no pull request needed. How it works.

Needs finishing (about 68 strings still in English): বাংলা (Bengali) · Italiano · 한국어 (Korean) · ไทย (Thai) · Tagalog (Filipino) · Türkçe (Turkish) · اردو (Urdu) · Tiếng Việt (Vietnamese) · 中文 (Chinese)

Needs checking (complete, but nobody has verified it reads naturally): العربية (Arabic) · Deutsch (German) · Español (Spanish) · Français (French) · हिन्दी (Hindi) · Bahasa Indonesia (Indonesian) · 日本語 (Japanese) · Português (Portuguese) · Русский (Russian)

Want a language that isn't here? #61.

GPU acceleration

Video encoding is hardware-accelerated automatically on all three vendors — NVIDIA (NVENC), AMD (AMF), and Intel (QSV). The engine test-encodes a frame with each at startup and uses the first that actually works, falling back to CPU. Force a choice with video.encoder in config/settings.yaml.

Detection and transcription are fastest with CUDA. Out of the box pip install torch gives you the CPU-only build — for NVIDIA:

pip uninstall torch torchvision -y
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu130

Which cards use the GPU: GTX 16-series, RTX 20-series, and everything newer including the RTX 50-series. GTX 10-series and older run detection on the CPU — still fully functional, just slower.

Use the cu130 index above, not an older one. Older CUDA builds have no code for recent cards, and the app then falls back to the CPU on hardware that should be fast.

AMD GPU owners: tracking and transcription run on CPU on Windows — still fully functional, just slower. Your GPU is still used for video encoding via AMF and for the LLM through Ollama, which supports AMD itself.

Video decoding goes through FFmpeg with hardware acceleration rather than OpenCV, for both the tracking pass and rendering. Reading sample frames this way costs about a tenth of the CPU that decoding them in Python did, which matters because the tracking pass runs over every clip.

CPU sharing. Detection and rendering both want every core, and left alone they fight each other and the interface. The engine divides the cores between render workers at startup and deliberately holds two back, so the app stays responsive while a batch runs. Tune with video.parallel_renders.

Command line use

Everything works without the desktop app:

python main.py process "https://www.youtube.com/watch?v=VIDEO_ID"   # one video
python main.py models                                               # list/switch models
python main.py status                                               # processing state
python main.py serve                                                # just the API engine

Settings live in config/settings.yaml — the top of the file is a short quick-setup block, everything advanced is below it. Every LLM prompt is a plain text file in config/prompts/, so you can tune how clips are scored without touching Python.

Build on it

The desktop app is a window onto a local HTTP API, which is running whenever Clips Kitty is open. A Discord bot, a batch runner, a web front end or an OBS integration can drive the same pipeline, and nothing has to be added to the app first.

python main.py serve --port 8765          # the engine on its own, no window

curl -X POST http://127.0.0.1:8765/jobs \
  -H "Content-Type: application/json" \
  -d '{"url": "https://www.youtube.com/watch?v=VIDEO_ID"}'
# {"job_id": 149}

Clips come back as JSON, with the score breakdown that produced them and an MP4 you can stream:

curl -s http://127.0.0.1:8765/videos/VIDEO_ID/clips \
  | python -c "import json,sys; [print(c['score'], c['title']) for c in json.load(sys.stdin)]"

docs/API.md documents the endpoints worth building on, with working examples and the traps that cost people an afternoon. The service also serves its own interactive docs at http://127.0.0.1:8765/docs.

It has no authentication and it binds localhost for that reason — see the security note in the API docs before you point anything at it.

Architecture

See ARCHITECTURE.md for the full design: the pipeline, the scoring engine, tracking, creator intelligence, the API surface, and the design rules that keep it modular.

Contributing

Contributions are welcome — see CONTRIBUTING.md for dev setup and pull request expectations, and SECURITY.md to report a vulnerability. Issues labelled good-first-issue are small and well-scoped if you want somewhere to start.

The website lives in site/ and is published to GitHub Pages and a Hugging Face Space. See docs/MIRRORS.md — GitHub is where work happens, and the website mirror is force-pushed one way, so a commit made on it will be overwritten.

Packaging and release documentation:

• docs/RELEASING.md — building and publishing the Windows installer, which is the primary channel
• docs/MSSTORE.md — the Microsoft Store package, from creating a developer account through to certification
• packaging/winget/ — the winget manifests, which point at the installer above
• whop-app/ — the Whop app, which puts Clips Kitty in front of members of clipping communities. Marketing pages only: it does not process video, store anything, or talk to the desktop app
• docs/DOCKER.md — running the engine without installing Python, FFmpeg and PyTorch yourself
• PRIVACY — what the app stores and what can leave your machine (short answer: nothing, unless you submit a bug report)

Changelog, known issues, roadmap

• CHANGELOG.md — what changed in each release, in plain terms.
• KNOWN-ISSUES.md — what is broken or missing right now, and the workarounds. Everything on it has actually been observed.
• ROADMAP.md — what is shipped, what is next, and the long-term direction.

Roadmap detail

The short version is in ROADMAP.md. The reasoning behind the harder calls is below, because "why not yet" is usually more useful than "not yet".

1. Android companion app — clip from a phone. Twitch, Kick and local video files only, to comply with Play Store policy.

2. Remote rendering — hand the rendering work to another machine, so a long stream doesn't tie up the computer you're using.

3. Automated posting (possible future plan) — channel monitoring, scheduling and auto-upload are coded in the repo but dormant and not exposed in the UI. The upload path hasn't been tested end-to-end against a real server, because it needs your own API credentials and Google's API audit to post publicly. Posting to TikTok and Instagram belongs here too — export alone adds little, since the work is in the posting, and that needs a server this app deliberately doesn't have yet.

4. Gaming and reaction layouts (possible future plan) — a dedicated layout for gameplay-with-facecam and for reaction videos, composing the creator's webcam and what they're reacting to into one vertical frame.

   Prototyped and set aside on purpose. Automatically telling which region is the webcam, which is the game, and which is chat is not reliable enough on real footage to ship: every creator's layout is different and many change it mid-stream. Marking the regions by hand works, but that cost lands on the user for every single video.

   The core pipeline — talking-head, IRL, gym, podcast — is what this app is for, and it's kept free of that complexity. If there's real demand, this returns as a self-contained mode that cannot affect the standard path.

5. Voice cloning for dubbing (last on this list on purpose) — dubbing today uses a preset local voice. Speaking translations in the creator's own voice needs a cloning model, and every credible local one pulls in its own PyTorch build: on a machine set up for clipping that downgrades torch to a CPU-only build and silently strips GPU acceleration from tracking and transcription. Breaking clipping to add dubbing is a bad trade.

   Realistically this waits for consumer hardware to catch up, or ships as a separate optional install with its own Python environment so the clipping one is never touched. Model licences need checking too — several of the best-sounding ones are non-commercial, and this app's users monetize their videos.

License

GNU AGPL-3.0 — see LICENSE, and NOTICE for what that means in practice and what the installer bundles.

If you use the app, this changes nothing for you. Install it, clip your streams, post the clips, earn from them. The AGPL binds people who distribute the software or run a modified copy as a network service, not people who use it. Your footage and your clips are yours.

If you modify and share it, your changes go out under the same licence. That is the point: improvements to a tool built for creators stay available to those creators.

Still built to be modified: swap models, tune prompts, add platforms.