YT Short Clipper v2: a Windows-only Tauri app that turns long YouTube videos into 9:16 clips

The problem YT Short Clipper v2 targets

Cutting a forty-minute interview into vertical clips is mostly mechanical labour. You scrub for the moment, you re-frame a 16:9 shot so the speaker's face survives the crop, you type captions by hand or wait on a transcription model, and you repeat. YT Short Clipper v2 compresses that loop into one desktop window: paste a URL, let a model pick the segments, and get MP4 files already sized for Reels, Shorts and TikTok.

The intended user is a solo creator or a small editor working on Windows who already has an OpenAI-compatible API key and does not want to upload source footage to a hosted editing service. The README is explicit that this is a local app, that you bring your own YouTube cookies, and that your API key sits in the app's local data directory rather than in the repository. Nothing about the design assumes a team, a render farm or a review workflow.

How the pipeline moves from URL to MP4

The architecture is three layers. The interface is React 19 with TypeScript and Vite. The shell is Tauri v2, which is Rust. The work happens in a Python sidecar, a frozen executable that bundles yt-dlp, FFmpeg and MediaPipe.

Data flows in one direction. yt-dlp fetches the video plus its original subtitle track. The subtitle transcript, not audio, is what the LLM reads, which is why the app needs no Whisper model and no transcription API. The model returns highlight segments, 58 to 120 seconds by default. Each segment is cut, reframed to 9:16, captioned from the same subtitle track, and written as an MP4. Upload to Repliz is a separate optional step.

The reframe has three modes and they are not equivalent. Face tracking runs MediaPipe per frame. The other two, centered on black bars and centered on a blurred fill, skip face detection entirely; the README states the centered modes are dramatically faster because of that. That is the clearest performance trade-off in the project and it is stated plainly.

AI direction is the second control surface. Left empty, the model selects on its own. Filled in, the direction outranks the built-in selection principles. An explicit clock range such as 2:00 - 2:50 is used exactly, that clip is exempt from the 58 to 120 second filter, and the run samples at a lower temperature. Array order becomes clip order. Custom system messages can position the direction with a {user_direction} placeholder; without it, the direction is appended at the end.

Installing YT Short Clipper v2 from source

There is no installer download in the README. Setup is a source build, and the prerequisites are Node.js v18 or later, Rust stable, Python 3.13 or later, and Windows 10 or 11 with PowerShell.

The four setup steps run in order. The fetch script downloads FFmpeg and Deno and skips files that already exist unless you pass -Force, and the sidecar build freezes the Python core into an executable.

npm install
py -m pip install -r requirements.txt
powershell -ExecutionPolicy Bypass -File scripts/fetch-deps.ps1
npm run build:sidecar

For a first real run, start the Tauri window rather than the Vite server alone.

npm run tauri dev

The README states that npm run dev starts the Vite dev server only; npm run tauri dev is what opens the Tauri window. Once it is open, paste a YouTube URL, upload your cookies.txt when the app asks you to continue, and configure a provider under AI Models. Anything OpenAI-compatible works, and the app ships presets for OpenAI, Google Gemini, Groq, ApiSmart, the maintainer's YTClip AI gateway, and a Custom/Local option for vLLM or Ollama.

The cookies step is not optional and it is not a one-time cost. Export cookies.txt with the Get cookies.txt LOCALLY extension while logged in on youtube.com, then upload it. A valid export contains SID, HSID, SSID, APISID, SAPISID and LOGIN_INFO. Logging out of YouTube after exporting invalidates the file, and frequent 403s mean the cookies went stale and need re-exporting. Treat the file as a password: it grants access to your Google account.

The sidecar rebuild trap and the FFmpeg build constraint

Two failure modes will cost an afternoon if you meet them without warning.

The first is the sidecar. src-tauri/binaries/ytclip-sidecar-*.exe takes precedence over the dev Python module, so edits under yt_short_clipper_core/ do nothing until you run npm run build:sidecar. The app keeps running the frozen copy without complaining. The README's workaround is to delete that binary so the app falls back to py -m yt_short_clipper_core.sidecar for fast iteration. Frontend and Rust changes hot-reload normally; Python does not.

The second is FFmpeg. It must be a GnuTLS build, and the fetch script pulls one from gyan.dev. Schannel builds hang forever on the byte-range requests used for section downloads. This is the kind of constraint that looks like a bug in the app when it is actually a property of the binary you supplied.

A related trap sits in the dependency floor. yt-dlp release 2026.06.09 raised its Deno floor to v2.3.0, and Deno drives remote_components for YouTube's JS challenges. An under-floor binary breaks extraction quietly, and fetch-deps.ps1 will not replace an existing deno.exe without -Force. The README's upgrade sequence is to upgrade the package, bump the floor in requirements.txt, and re-freeze.

Network calls, telemetry and what leaves the machine

The README publishes a table of every host the app contacts, and it is worth reading before you run it. YouTube and googlevideo receive your cookies through yt-dlp. Your configured AI provider receives the subtitle transcript, your prompt and your API key.

Separately, four endpoints under api.ytclip.org are contacted: a latest-version webhook, a notification webhook and a menu webhook on launch, and a success-log webhook after a clip renders. The payloads carry a random installation ID and the app version; the success log also carries clip duration. The README notes that some of this is the maintainer's own backend rather than a third party, which is the honest framing. It is still an outbound call on every launch, and an installation ID is a stable identifier. If your environment forbids that, this is the wrong tool and there is no documented opt-out.

Where YT Short Clipper v2 is the wrong choice

The platform lock is the first limit. The build scripts are PowerShell, the app ships as a portable zip with a WebView2 bootstrapper, and caption and hook rendering reads fonts from C:\Windows\Fonts. The README states plainly that nothing is macOS or Linux-ready today. A Linux user cannot work around that with a wrapper.

The second limit is the beta status. The README says to expect rough edges and breaking changes between releases, and the recent release history is a run of beta tags. For a personal channel that is fine. For a pipeline you depend on weekly, the interface is not a contract.

The third is the caption source. Captions are burned from YouTube's original subtitle track rather than generated. That keeps the app fast and removes a transcription dependency, but it also means a video with no usable subtitle track has no caption path. The README does not document a fallback, and requirements.txt lists an HTTP dependency annotated for a Whisper API that the described pipeline does not use.

Finally, the cookies requirement is a genuine operational burden, not a setup detail. It ties every run to a logged-in Google session you must keep alive and re-export when it goes stale.

How this differs from a hosted clipping service

The obvious alternative is a hosted service that accepts a YouTube link and returns vertical clips, with captioning and reframing handled server-side. The difference is not feature parity; it is where the work and the credentials live.

A hosted tool runs yt-dlp, FFmpeg and its own face detection on someone else's machines. You upload a URL, not cookies, and you never install Rust or Python. In exchange, your source video and transcript pass through a third party, output quality is whatever that service ships, and per-minute pricing is the usual model.

YT Short Clipper v2 inverts that. FFmpeg, MediaPipe and the cut all run locally, the provider is one you choose and configure with your own key, and the app is MIT licensed with a public repository. The cost is the setup described above and the Windows constraint. If you already run a local LLM through Ollama or vLLM, the Custom/Local provider option means the transcript never leaves your network at all, which no hosted service can offer.

A third path is the manual one: download with yt-dlp, cut in a non-linear editor, reframe by hand. That is slower per clip but has no dependency floor, no cookies expiry and no beta interface. For a creator publishing one clip a week, it may still be the cheaper option.

Maintenance, upgrades and the MIT licence

The last push to the repository was on 2026-08-21, and the most recent release listed is v2.0.6-beta from 2026-08-20. The repository is not archived.

Upgrade cost concentrates in three places. The yt-dlp floor moves as YouTube changes, and the README's sequence is to upgrade the package, bump the floor in requirements.txt, and re-freeze the sidecar. The Deno floor moves with it. And version bumping for a release touches four files, which BUILD_GUIDE.md documents rather than the README. The release command chains sidecar build, frontend build, Tauri build and packaging into one npm run release, producing a portable zip for new users and a smaller update zip for existing ones.

The licence is MIT, declared in package.json and present as LICENSE at the repository root. That permits commercial use and modification, and it comes with no warranty. It says nothing about the terms of the services you connect: your AI provider's acceptable use policy, YouTube's terms around cookie-authenticated downloads, or Repliz's own terms all apply independently. If you plan to sell clips produced this way, those are the agreements to read, not the MIT text.

Editorial conclusion

Adopt it if you run Windows 10 or 11, you are comfortable with Node, Rust, Python 3.13 and PowerShell on the same machine, and you want highlight selection and portrait reframing in one local app. Do not adopt it if you need macOS or Linux, if you cannot supply a logged-in YouTube cookies.txt, or if you expect a stable interface: the README labels the project beta and warns of breaking changes between releases. Before committing, verify three things in this order: that scripts/fetch-deps.ps1 pulls a GnuTLS FFmpeg build rather than a Schannel one, that your deno.exe meets the floor the current yt-dlp requires, and that your chosen AI provider accepts the transcript you intend to send it.

Frequently asked questions

Official sources

1. Issues
2. jipraks/yt-short-clipper on GitHub
3. License: MIT
4. README
5. Releases