Automatic subtitle generator with faster-whisper, for Windows. International, GPU-accelerated, one EXE. Free for everyone, at home or at work — open source under the GPLv3. Subtitles appear only while someone is speaking — no subtitles stuck on screen during silence.
Powered by faster-whisper and FFmpeg, which do the actual speech recognition and audio work. SuperSubtitler is the automation, language logic and safety layer around them.
⬇️ Download the latest release · 🌐 Website · 🔏 Code signing policy · ☕ Buy me a coffee
🇩🇪 Auf Deutsch: tech.burnersen.de/tools/supersubtitler
SuperSubtitlerGUI at work: a German film being translated to English — progress per file and on the taskbar, every option one click away.
💜 Using SuperSubtitler and happy with it? A ⭐ on GitHub is the easiest way to let me know, and it does more than you'd think: stars are how small projects like this one qualify for free code signing, which makes the Windows warning go away for everyone. Or tell me what you use it for, I read every message. Thanks for being here!
- Download
SuperSubtitler.exe, a single file with nothing to install — and, if you prefer a window,SuperSubtitlerGUI.exeinto the same folder. - Drag a video or audio file (or a whole folder) onto it.
- Done. You get a
Movie.<lang>.srtnext to it and aMovie.subbed.mkvwith the subtitle track built in (or aMovie.subbed.mp4with-mp4).
On first run SuperSubtitler sets itself up automatically: it downloads FFmpeg, a self-contained Python, the faster-whisper engine and the speech models — no installs, no PATH fiddling, no Python knowledge needed. Every download shows its progress (MB, speed); -setup does all of it in one go without processing a file. After that, everything runs offline and locally; your audio never leaves your machine.
- 🔇 No "sticky" subtitles. A voice-activity filter means a line shows up only when someone actually speaks and disappears in the silence — no caption frozen on screen through a quiet scene. This was the whole reason this tool exists.
- 🌍 International by default. Every track is transcribed in its own language (German stays German, Spanish stays Spanish…). Add
-translateto translate everything to English instead. - 🔤 Subtitles in your language.
-to:de(or-to:fr,-to:de,es…) adds the subtitles in another language as a second track and.srt, same timing, set as the default track: an English film gets German subtitles. Done locally by MADLAD-400 3B (Google, Apache 2.0), which translates between some 400 languages; chosen by measurement against human translations (FLORES-200, checked by CI on every change). A 3 GB one-time download; quick on an NVIDIA card, very slow on the processor alone. Machine translation is good, not perfect. - ⚡ GPU-fast, CPU-safe. Runs on your NVIDIA GPU via auto-installed CUDA libraries (a 1h45 film in ~80 seconds on a modern card), and falls back to the CPU automatically if there's no GPU. Without an NVIDIA card it notices that up front: the 1.3 GB of CUDA libraries are not even downloaded.
- 🗨️ Who is speaking? With
-speakersa new subtitle starts when the speaking voice changes, and a quick exchange shares one subtitle as-lines, the way professional subtitles show dialogue. It looks only for the moment the voice changes (pyannote segmentation 3.0, which judges every second about nine times) — that is what subtitles need, and it is far better at quick replies than telling voices apart across the whole film. Measured on hand-labelled debates and news (VoxConverse, 1–11 speakers) and checked by CI on every change: 74 % of all changes and 59 % of the quick ones found, 73 % of the found ones real; a 2-hour film takes about 2 minutes on the processor, while the GPU already works on the next file. Not perfect — quick replies are the hardest case for any system — and if it ever fails, you still get the subtitle, just without the marks. - 🎚️ Multi-track aware. A file with several audio tracks (e.g. German TrueHD, German AC3, English DTS, a commentary) is listened to track by track first, and the best-understood track of every language is suggested — measured by how sure the speech model is of what it hears, with commentaries and audio descriptions left out. You confirm or change the choice; each track becomes its own language-tagged subtitle track in one MKV.
- 📦 MKV or MP4. MKV by default (keeps every track);
-mp4(orcontainer=mp4in the INI, or the choice in the window) writes an MP4 that plays on more TVs, phones and browsers. If a file has tracks an MP4 cannot hold — Blu-ray/DVD picture subtitles, ASS styling, fonts, TrueHD or PCM audio — it becomes an MKV anyway and you are told exactly why. Nothing is ever dropped behind your back. - 🧩 Merge mode. Drop one video together with extra audio and/or subtitle files and it offers to mux them into one
.joined.mkv(lossless copy). The result is never silent — if you don't add audio, the video keeps its own. - 📐 Subtitles built right. Word-level timing, two-line wrapping, sensible characters-per-second, minimum/maximum duration and anti-flicker gaps — close to professional (Netflix/BBC) guidelines.
- 🧹 SRT cleaner. A plain-text term list strips ads and hallucinated junk lines (you control every term; nothing is hard-coded).
- 🛡️ Resilient by design. Stall watchdog against frozen GPU/engine, per-file crash isolation, output validation, and a Windows Job Object so killing the tool kills every helper it started — no orphan processes.
SuperSubtitlerGUI (in gui/) puts all of this behind buttons: drag and drop, tick boxes for audio tracks, one-click language questions, live progress per file and on the taskbar, Merge and Split pages, and a Settings page built from the config file itself (with "Restore defaults"). It drives the unchanged SuperSubtitler.exe — same engine, same results.
A fresh install used to take the newest of everything — and one day a new PyAV release broke every new installation. Now SuperSubtitler installs one tested set, the same for every user, written into the EXE (runtime.json):
- Exact versions of Python (3.12.10), pip, FFmpeg (8.1.2), faster-whisper, CTranslate2, PyAV, every other package and the CUDA libraries — pip installs them offline with
--require-hashes, so nothing unlisted slips in. - Speech models at an exact revision (large-v3-turbo, large-v3), and the small pyannote segmentation 3.0 model (6 MB) for
-speakers— fetched the first time it is used (or by-setup). - Every file is checked against its SHA-256 before it is used; a damaged or changed download is refused.
- Everything from the own mirror: Python, pip, every Python package, FFmpeg and the speech models come from this project's
runtime-v1release first and only then from their original source — a renamed or deleted upstream repository cannot break an install. (Files over 2 GB are stored in parts and joined while downloading.) - Own FFmpeg: a lean build made here from the official, signed FFmpeg 8.1.2 source — only FFmpeg's own code plus zlib, LGPL, 25 MB. SuperSubtitler only reads audio, mixes channels and copies streams into MKV, so it needs no external codec libraries. The exact sources and the build script are in the same release.
- Checked for real: CI installs exactly this set on Windows and subtitles a test clip on every change.
Updating is deliberate: raise the versions in runtime.json, CI green, release. Existing installs switch to the new set automatically on their next start. Experts can still set their own engine_spec or models in the INI — that is installed as written, without the guarantee.
- Default: the spoken language of each track is detected (a sample is taken, split into windows and majority-voted) and the subtitles are written in that language.
-translate: translates everything to English (the only target Whisper translates to). Uses the large model, which is required for translation.-lang:XX: skip detection and force a source language, e.g.-lang:de,-lang:es,-lang:fr.- Mismatch? If a file's language tag disagrees with what the audio actually is, you're asked which to trust (pressing Enter keeps the detected language).
- All questions up front. Track choice and language questions are all asked at the start, before the long transcription part begins — once the progress bars appear you can walk away. With
-autonothing is asked at all.
SuperSubtitler.exe [flags] [files/folders]
Drag files or folders onto the EXE, or pass them as arguments. Flags and files may be given in any order.
| Flag | Effect |
|---|---|
| (none) | Subtitle every dropped video/audio file in its own language |
-translate |
Translate every track to English |
-lang:XX |
Force the source language (ISO code, e.g. -lang:de); skip detection |
-track:N |
Use audio track N (1-based) instead of asking/auto-selecting |
-channel:N |
Isolate physical channel N (0-based) of the chosen track |
-srtonly |
Write only the .srt, no video file |
-mp4 |
Write an MP4 instead of an MKV (also for merges); falls back to MKV, with the reason, when a track does not fit |
-mkv |
Write an MKV (the default; overrides container=mp4 from the INI for one run) |
-lean |
In the video file keep only video + the subtitled audio + the new subtitles (often lets a Blu-ray rip fit -mp4) |
-novad |
Disable the silence filter (transcribe everything, pauses included) |
-lowmem |
Smaller compute type (less video memory, a bit slower) |
-to:XX |
Also write the subtitles in language XX (-to:de, -to:de,fr …): own subtitle track (the default one) and .srt |
-speakers |
Mark speaker changes: a new subtitle per voice, - lines for quick exchanges |
-split |
Export each audio channel as a WAV to find the speech; skip transcription |
-auto |
Never ask: the best audio track of every language, the detected language, merge = yes |
-force |
Redo files that already have subtitles (overwrites the old results) |
-out:FOLDER |
Write the .srt/.mkv/.mp4 results into FOLDER instead of next to the source |
-nowait |
Don't wait for Enter at the end (for scripts and shortcuts) |
-setup |
Download and install everything, speech models included, then exit |
-nomerge |
Never offer the merge mode; subtitle every dropped file |
-json |
Machine-readable events on stdout, one JSON line each (for front-ends) |
-version |
Print the version and exit |
-help |
Show the banner and full options list |
Supported input — Video → .subbed.mkv (.subbed.mp4 with -mp4): mkv mp4 mov m4v avi ts m2ts webm mpg wmv flv 3gp · Audio → .srt only: m4a mp3 wav flac aac ogg opus m4b
Drop one video together with one or more audio and/or subtitle files, and SuperSubtitler offers to mux them into <video>.joined.mkv (with -mp4: <video>.joined.mp4) — losslessly, no re-encode:
- Audio: the dropped audio file(s). If you don't drop any, the video keeps its own audio (the result is never silent).
- Subtitles: the dropped subtitle file(s). If you don't drop any, the video keeps its own.
- Dropped tracks are language-tagged from their file names (
Movie.de.srt→ German) when recognisable — so SuperSubtitler's own.<lang>.srtoutputs slot back in perfectly.
Two plain-text files are created next to the EXE on first run:
SuperSubtitler_Config.ini— models, the silence-filter settings, lead-in, surround handling, all subtitle formatting limits (chars per line, CPS, min/max duration, …), how sure a speaker change must be and the video file to write (container=mkvormp4). Invalid values reset the file to its documented defaults.SuperSubtitler_SRTCleaner.txt— one term per line to delete from results (ads, junk). A line starting with=only matches when the whole subtitle equals it exactly. Nothing is hard-coded; you decide every term.
- Windows 10/11 x64
- An NVIDIA GPU makes it much faster (CUDA libraries are auto-installed); without one it automatically falls back to the CPU (slower, but works)
- FFmpeg, Python and the speech models are downloaded automatically on first run (a few GB, once, cached next to the EXE)
- First run reaches
github.com(this project's runtime mirror); only if the mirror is unreachable alsopython.org,pypi.organdhuggingface.co
Windows or your antivirus may warn you the first time you run SuperSubtitler.exe. The honest reason: the EXE is not code-signed yet. Signing certificates cost hundreds of euros per year, and this is a free hobby project with zero income. Free code signing through the SignPath Foundation is planned and already prepared, as soon as SuperSubtitler is known well enough to qualify; see the code signing policy. Until then, unsigned Go binaries are frequent false-positive targets, and all I can do is be transparent.
Every release is built by GitHub Actions from this repository (release workflow), never on a private PC.
You don't have to trust me blindly:
- Scan it: upload the EXE to VirusTotal before running it.
- Read it: the complete source code is right here in this repository.
- Build it yourself: clone, run
build.bat, done. Every release page also offers the exact source of that version as a download.
If SmartScreen blocks the start: click "More info" → "Run anyway".
build.bat
The window lives in gui/ and has its own gui/build.bat (writes SuperSubtitlerGUI.exe next to SuperSubtitler.exe).
Releases are built by the release workflow on GitHub. It also writes name and version into the file properties of both exes (from winres/winres.json and gui/winres/winres.json) and, once code signing is switched on, has them signed: see .signpath/README.md. "Run workflow" with "dry run" ticked builds and checks everything without publishing.
build.bat runs go mod tidy and compiles SuperSubtitler.exe (Go 1.22+). The only external dependency is pterm. The EXE is written to the parent folder, ready to run next to its downloaded FFmpeg/Python/models.
SuperSubtitler is a personal hobby project. I wanted subtitles that behave: text when there's speech, nothing when there's silence — no caption stuck on screen through a quiet scene. Once that worked, it grew into a proper international, multi-track tool. It started as a tool just for me, but if it fits your workflow too, all the better.
SuperSubtitler is a hobby project, free for personal use. If it saved you hours of typing:
- ⭐ Star this repo — fame is the currency here
- ☕ Buy me a coffee — keeps the project going:
Found a bug? Open an issue with the console output.
SuperSubtitler is free hobby software, provided "as is", without any warranty or condition of any kind. It was built and tested with care, but you use it at your own risk. As far as the applicable law allows, the author is not liable for any damages or data loss arising from the use of this software. See sections 15 and 16 of the license.
SuperSubtitler — the console tool and the window in gui/ — is free software under the GNU General Public License, version 3 — that version only (GPL-3.0-only).
- Use it: Anyone may use SuperSubtitler free of charge, at home or at work, and read, change and share its source code.
- The one condition: Whoever passes on SuperSubtitler or parts of it — unchanged, changed or built into a program of their own — must include the complete source code and pass everything on under the same license. A closed, paid product with SuperSubtitler inside is therefore not possible.
- Free of charge: SuperSubtitler is and stays free. The official source is github.com/burnersen/SuperSubtitler — anyone asking money for SuperSubtitler is selling you what you can get here for free.
Versions up to and including 0.1.0 were released under the PolyForm Noncommercial License 1.0.0; from 0.2.0 on, SuperSubtitler is under the GPLv3.
What is signed, who approves it and what SuperSubtitler downloads (the runtime on first run, and the window's update check): code signing policy. Your videos never leave your PC. To uninstall, delete the folder; nothing is written to the registry.
The exes are built with these Go libraries. Each keeps its own license, and all of them are compatible with the GPLv3:
- MIT License: pterm with atomicgo/cursor, atomicgo/keyboard and atomicgo/schedule, gookit/color, lithammer/fuzzysearch, mattn/go-runewidth, rivo/uniseg, xo/terminfo; for the window Wails and its libraries
- Apache License 2.0: containerd/console
- BSD 3-Clause License: the Go standard library and golang.org/x/sys, x/term, x/text
Their copyright notices and full license texts are in the repositories linked above.
SuperSubtitler does not bundle these; it downloads or invokes them:
- faster-whisper — speech recognition engine by SYSTRAN (MIT), installed via pip on first run. It runs OpenAI's Whisper models (MIT).
- FFmpeg — all audio/video processing. SuperSubtitler uses its own lean build of FFmpeg 8.1.2 (LGPL 2.1 or later), compiled by
.github/scripts/build_ffmpeg.shfrom the unmodified, signature-checked FFmpeg source plus zlib; both source archives are in theruntime-v1release next to the build. FFmpeg is a separate work by the FFmpeg project under its own license and is invoked as an external program. This software uses code of FFmpeg licensed under the LGPLv2.1. - Python — the official python.org Windows embeddable build, downloaded on first run to host the engine.
- MADLAD-400 3B — translation (
-to); model by Google (Apache 2.0), in a CTranslate2 conversion, run with CTranslate2 (MIT). - pyannote segmentation 3.0 — finds the speaker changes (
-speakers); model by pyannote (MIT), in the ONNX conversion of sherpa-onnx, run with onnxruntime (MIT).
Python, pip, the Python packages, the Whisper and speaker model files and the FFmpeg build are mirrored in this repository's runtime-v1 release. Their licences allow that (PSF, MIT, BSD, Apache 2.0, LGPL with the source alongside; the NVIDIA CUDA libraries under NVIDIA's licence, which allows redistribution with applications); the notices are listed there.