🚨 PLEASE READ BEFORE DOWNLOADING (Early Beta & Manage Your Expectations): This is v0.12.0 — an early, experimental beta, and I really don't want to overpromise here! Please only download this if you enjoy testing raw, early software and fully expect that things might fail or not work on your setup.
- Your mileage WILL vary: While I had successful test runs on my own discs, a lot of the matching logic (especially the subtitle comparison) is still heavily based on theory. Just because it worked on my test rips does not mean you will automatically get the same results on yours!
- USE AT YOUR OWN RISK — NO GUARANTEES: Even though the renamer has an undo journal, DO NOT run this on video files you don't have a backup of (or can't easily re-rip). Always test on a backup copy first! I take zero responsibility for mangled filenames or broken MKV headers.
Identify every episode in your MakeMKV rips — with evidence, not guesswork.
EpisodeMatch is a Windows desktop tool for a very specific, very annoying problem:
when you rip a TV-season Blu-ray or DVD with MakeMKV, you get anonymous files named
after the disc's playlists (title_t00.mkv, title_t01.mkv, …) — and the playlist
order on the disc is almost never the episode order of the show.
EpisodeMatch tells you which file is which episode (SxxExx - Episode Title) with a
confidence score and a transparent, human-readable justification for every decision —
then renames the files into Plex/Jellyfin/Emby layout (with an undo journal), writes
episode titles into the MKV header, and optionally cleans tracks or queues the results
for AV1 encoding.
Status: early public beta (v0.12.0). The Disc DB, Subtitles and Title-card OCR pillars are ready for testing and are what the tool is built around (the OCR pillar assigns 70–90 % of episodes when the show displays its episode titles on screen). Everything else (Audio/Whisper, LLM arbiter, the Visual Verify and Post-Processing pages) is explicitly not ready and marked as such inside the app. See Status.
| Workspace | Settings |
|---|---|
![]() |
![]() |
git clone https://github.com/episodematch/episodematch
cd episodematch
python -m venv .venv
.venv\Scripts\pip install -e .[gui]Standalone executables (no Python needed to run them) can be built with
scripts\build_exe.py — see Standalone executables.
EpisodeMatch needs two API keys to do its job. Both are free:
| Key | Required? | Where to get it | Env var |
|---|---|---|---|
| TMDB | yes — without it nothing runs (episode titles, plots and credits come from TMDB) | themoviedb.org (free account) | EPISODEMATCH_TMDB_API_KEY |
| Subtitle provider | yes for the Subtitles pillar | SubDL (recommended) or OpenSubtitles | EPISODEMATCH_SUBDL_API_KEY / EPISODEMATCH_OSDT_API_KEY |
| LLM | no (pillar not ready) | BigModel GLM, DeepSeek, … | EPISODEMATCH_LLM_API_KEY |
Keys are stored in data/config.json (gitignored) or set via environment variables.
All of them can be entered in the GUI's Settings page.
| Component | Status | What it does |
|---|---|---|
| Disc DB (TheDiscDB fingerprint) | ✅ ready | Maps every file to its episode from the disc's playlist structure |
| Subtitles (extract + reference matching) | ✅ ready | Extracts the file's subtitles, matches the dialog against reference subtitles |
| Rename / MKV tagging | ✅ ready | Plex-layout renaming with undo journal, mkvpropedit title writing |
| Audio / Whisper | 🚧 not ready | Local Whisper transcription of two audio windows |
| Title-card OCR | ✅ ready (v0.12.0) | Reads title cards / credits from keyframes and matches them against the TMDB guide — assigns 70–90 % of episodes when the show displays its episode titles on screen |
| LLM arbiter | 🚧 not ready | Sends all evidence to an LLM for a global assignment |
| Visual Verify page | 🚧 beta | Synchronized frame comparison across all files |
| Post-Processing page | 🚧 beta | Track cleanup + SVT-AV1 encoding queue |
The two ready pillars are described in detail below — everything else is present in the code and the UI but marked not ready / beta and should be treated as a preview.
The DiscDB pillar answers "which physical disc is this, and which playlist on it is which episode?" using the community database TheDiscDb/data (MIT licensed — the same source that powers thediscdb.com).
For each .mkv in the folder, EpisodeMatch probes (ffprobe + a native EBML reader)
and collects:
- the MakeMKV MPLS name (e.g.
00800.mpls— usually stored in the MKV title tag), - the exact duration,
- the exact byte size,
- the MakeMKV title index from the file name (
…_t07.mkv→ title 7).
TheDiscDB disc entries (data/series/<Series (Year)>/<release>/discNN.json) were created
by contributors who scanned the exact same disc with MakeMKV. Every title there carries
the playlist's SourceFile (the same MPLS name), SegmentMap, Duration, Size and the
episode mapping (Season, Episode, Title) — including extras and menus.
Fastest way: paste the disc URL from thediscdb.com into the GUI (or --discdb-url):
https://thediscdb.com/series/south-park-1997/releases/seasons-6-10-blu-ray/discs/season-06-disc-01
That loads exactly one disc instead of every release of a 21-season series.
Every disc title is scored against your file's fingerprint:
| Signal | Weight | Why |
|---|---|---|
| MPLS name match | +0.60 | Near-conclusive — the strongest identifier |
| MakeMKV title index matches disc entry index and the duration agrees | +0.25 (up to +0.90 with a pinned disc URL) | The index identifies the title — but only when the runtime corroborates it |
| Duration within ±2 s — unique on the whole disc | +0.70 | An individual episode runtime is near-conclusive |
| Duration within ±2 s (shared by several entries) | +0.20–0.35 | Equal-length episodes can't be told apart by runtime alone |
| Size within ±2 % | +0.10 | Weak — ripped MKVs are usually smaller than the on-disc playlist (stripped audio, container overhead) |
| Segment count match | +0.05 | Minor corroboration |
Two safety rules were learned from real discs:
- An index match without a matching duration is ignored — different MakeMKV versions enumerate playlists differently, so bare index collisions produced wrong assignments (Castle Rock S1D2: the contributor's Episode 6 sits at Index 4, the rip's title 6 collided with Index 6 = Episode 8).
- A duration/size coincidence below 45 % without an MPLS or index identifier is discarded as noise (it otherwise breeds cross-season ghost matches).
With a pinned disc URL this pillar resolves whole discs correctly even in the hard cases: a South Park disc where MakeMKV wrote the disc label instead of the MPLS into the title tag and all nine episodes are exactly 22:06 long resolved 9/9 files at 100 % via the title index; a Castle Rock disc with individually different runtimes resolved 5/5 at 80 % purely via the unique-duration signal.
The subtitle pillar answers "which episode's dialog does this file actually contain?"
- Text tracks (SRT/ASS/VTT) are pulled with
mkvextract(fallbackffmpeg) and parsed natively (override tags, hearing-impaired markers and HTML stripped). - Blu-ray PGS tracks (image subtitles) are dumped as
.supand converted:- seconv fast path (recommended, auto-downloadable): SubtitleEdit's headless converter OCRs the full track with its nOCR engine, unattended.
- Native Python fallback: a complete PGS binary parser (segment container, PCS/WDS/PDS/ODS reassembly, RLE decoding, BT.601/709 palettes) decodes the bitmaps and local OCR reads them — strictly capped at the first 40 events, never a whole film in Python.
The reference is requested in the same language as the extracted track (a German
track is matched against German dialog; ISO 639-2 tags like ger are converted to the
API forms). Cross-language fallbacks are deliberately not attempted — they would be
discarded by the language guard and only burn download quota.
Two sources are built in and selectable in Settings → Subtitle source:
| Source | Free tier | Recommendation |
|---|---|---|
| OpenSubtitles | 5 downloads / 24 h | Precise API — but the download cap makes it impractical for whole seasons |
| SubDL | 2,000 requests + 300 downloads / day | Recommended — serves ZIP archives with SRTs, extracted automatically; cached locally for 14 days |
SubDL candidates are validated against the request (ISO language code, season, and the
episode field or episode_from/episode_end range) — whole-season subtitle packs are
used automatically when no per-episode SRT exists, so US/international shows work even
when only season packs are indexed. Transient SubDL rate-limit responses (429
"service_busy") are retried automatically.
Note: PGS→text conversion is a matching step only — on a Blu-ray the PGS track itself stays untouched in your file (authored at 1080p, it survives upscaling better than regenerated text). Converting image subtitles to text is a genuine improvement mainly for DVD/VobSub sources.
For each candidate episode, EpisodeMatch counts how many distinct reference lines of that episode's subtitle are confirmed (fuzzy ≥ 80) by at least one extracted line, relative to the reference's full unique line count:
- the true episode confirms ~100 % of its own reference dialog,
- wrong episodes only accumulate generic collisions and recap lines (~9–20 %),
- conclusive coverage floor: ≥ 85 % reference coverage sets a confidence floor of 0.93 — the extracted dialog literally matches the episode's subtitle.
The similarity matrix is computed with rapidfuzz.process.cdist (C++, parallel) — a
full film against a full reference stays fast. Everything is reported as evidence
("S01E04: 67 % text match … 100 % reference dialog covered") and feeds the solver.
All evidence is combined per (file, episode); a Hungarian-algorithm assignment
(scipy.optimize.linear_sum_assignment) distributes episodes globally so no episode is
assigned twice. Assignments below the confidence threshold are reported as unassigned
with their best guess instead of being guessed silently.
The title-card pillar answers "what does the video itself say about this episode?" Many shows print the episode title on screen (a title card right after the opening, typically around the end of the first chapter), and the credit rolls name directors, writers and guest stars. Both are read from keyframes and matched against the TMDB season guide.
The one requirement: the episode title must actually be displayed on screen. Shows that use title cards (most pre-2000 DVD productions, …) get the full benefit — in tests the pillar assigns 70–90 % of episodes on its own (9/11 files resolved from title cards alone, no DiscDB entry, no subtitle references). If a show never displays its episode titles, pillar 4 cannot discriminate the episodes by title — it can still corroborate through credit names (director/writer/guest matches) and confirm the series choice via main-cast cards, but a title-less show relies on the DiscDB and Subtitle pillars.
- Title window (first minutes of the file): a 2.5 s probe grid — densified to 1 s steps in ±10 s zones around every MKV chapter mark, because the title card typically sits right around the end of the first chapter. Scene cuts are always probed as well; the title window is never frame-capped, so a slow fade-in title is not lost.
- Credits tail: uniformly sampled across the rolling credits (the end credits name this episode's directors, writers and guest stars).
- Dual OCR backends: the OCR built into Windows (WinRT) plus
RapidOCR as the second engine — selectable
via
extraction.ocr_backendin the config. RapidOCR reads stylized/title fonts noticeably better (0.92–0.99 confidence where WinRT misread them). - Grayscale retry: a frame that reads empty or noise-only is re-OCRed on a grayscale-contrast variant before it is given up on.
- Episode title vs card text: normalized fuzzy match with four guards learned
from real discs — the series logo on every card is filtered out (it partial-matches
title-like episode names), next-episode teaser cards in the credit tail are ignored,
short titles need a near-exact full-line match, and OCR spacing quirks are
normalized (
"THE37'sandThe 37'sboth normalize to the same text). - On-screen names vs TMDB credits: directors, writers and guest stars are matched fuzzily; a name credited in many season episodes fades via a normalized season-IDF so showrunners credited everywhere cannot dominate the score.
- Series-cast hints: a main-cast name on a card (prints only last names like — "PICARDO") confirms the series choice as evidence, without contributing episode score.
- Every hit becomes timestamped evidence (
Title card 'PROTOTYPE' matches episode title (100 %)), so every assignment stays auditable in the evidence inspector.
- Workspace → enter the series name → Search TMDB → pick the show, set the season.
- Enter the rip folder (or Browse…), optionally paste the TheDiscDB disc URL.
- Pick the depth preset: Fast — DiscDB only, Medium — DiscDB + Subtitles (recommended), Deep — all five pillars.
- Scan folder → inspect the results table and the evidence inspector.
- Apply rename (with undo journal) and/or Write MKV titles.
:: recommended: fingerprint + subtitles, pinned to the exact disc
episodematch match "D:\Rips\SP S06D1" --series "South Park" --season 6 ^
--discdb-url "https://thediscdb.com/series/south-park-1997/releases/seasons-6-10-blu-ray/discs/season-06-disc-01"
:: machine-readable output / apply renamer / write MKV titles
episodematch match "D:\Rips\Show S01" --series "Great Show" --season 1 --json --rename --tag
:: environment check: tools, OCR backend, API keys
episodematch check-envEverything lives in data/config.json (created on first save from the Settings page);
environment variables take precedence:
| Setting | Config key | Env var | Default |
|---|---|---|---|
| TMDB API key | tmdb_api_key |
EPISODEMATCH_TMDB_API_KEY |
— (required) |
| OpenSubtitles API key | opensubtitles_api_key |
EPISODEMATCH_OSDT_API_KEY |
— |
| SubDL API key | subdl_api_key |
EPISODEMATCH_SUBDL_API_KEY |
— |
| Subtitle source | subtitle_source |
EPISODEMATCH_SUBTITLE_SOURCE |
opensubtitles (subdl recommended) |
| LLM API key / base URL / model | llm_* |
EPISODEMATCH_LLM_* |
BigModel GLM glm-4-flash |
| Preferred subtitle languages | preferred_languages |
— | ["ger", "deu", "eng"] |
| Naming template | naming.episode_template |
— | {series}/Season {season:02d}/… |
| AV1 preset / CRF | av1_preset, av1_crf |
— | 6 / 30 |
EpisodeMatch needs ffmpeg.exe, ffprobe.exe, mkvmerge.exe, mkvextract.exe,
mkvpropedit.exe and (for the PGS fast path) seconv.exe. They are searched in the
local ./bin/ folder, the system PATH and C:\Program Files\MKVToolNix\ — and
downloaded automatically by episodematch fetch-tools (ffmpeg from gyan.dev, MKVToolNix
from mkvtoolnix.download, SeConv from the SubtitleEdit GitHub releases).
.venv\Scripts\pip install -e .[gui,pack]
.venv\Scripts\python scripts\build_exe.py --smokedist\cli\episodematch\episodematch.exe— console CLIdist\gui\EpisodeMatch\EpisodeMatch.exe— the windowed Windows-11 GUI
Run them from a directory that contains ./bin/ and ./data/ (typically the project
root). Each bundle is ~255 MB. Prebuilt archives ship on the GitHub Releases page as
two separate ZIPs — one for the CLI, one for the GUI — each with the license texts
included (the GPL tools themselves are fetched by episodematch fetch-tools on your
machine, keeping the archives GPL-clean).
This is the early public beta (v0.12.0). Pillars 1, 2 and 4 are ready for testing and were validated against real rips (DVD test sets: 9/11 files assigned from title cards alone — no DiscDB entry, no subtitle references — plus stylized title fonts calibrated). For shows that display their episode titles, the title-card pillar assigns 70–90 % of episodes on its own; shows that never display titles rely on the DiscDB and Subtitle pillars. Everything else is present but not ready: Audio/Whisper and the LLM arbiter are marked not ready in the pillar checkboxes; the Visual Verify and Post-Processing pages are marked beta and show an in-page warning banner. Treat them as previews — do not rely on their results.
.venv\Scripts\pip install -e .[dev]
.venv\Scripts\python -m pytest tests\- TMDB: This product uses the TMDB API but is not endorsed or certified by TMDB. Free TMDB API keys are licensed for non-commercial use only.
- TheDiscDB: Disc fingerprint data is powered by the community project TheDiscDb/data (MIT License).
- Subtitles: Reference subtitle matching is supported via SubDL and OpenSubtitles (users must provide their own personal API keys and abide by the respective provider's terms of service and daily rate limits).
A few ML/heuristic-based engines (e.g. Arctic Wolf, Bkav Pro, SecureAge, Skyhigh) may flag the unsigned PyInstaller-built executables generically — a well-known false-positive pattern for this file type; signature-based engines (Microsoft Defender, Kaspersky, ESET, Bitdefender, …) detect nothing. Verify before running: compare the executable's SHA-256 against the hash published in the release notes, or build the executables yourself from this source.
Erkenne jede Episode in deinen MakeMKV-Rips — mit Belegen statt Ratesen.
EpisodeMatch löst ein konkretes Problem: Beim Rippen einer Serien-Blu-ray/-DVD mit
MakeMKV entstehen anonyme Dateien (title_t00.mkv, …), deren Reihenfolge auf der Disc
fast nie der Episoden-Reihenfolge entspricht. EpisodeMatch ordnet jede Datei der exakten
Folge (SxxExx - Episodentitel) zu — mit Confidence-Score und nachvollziehbarer
Begründung — und benennt sie anschließend Plex/Jellyfin/Emby-gerecht um (mit
Undo-Journal), schreibt den Episodentitel per mkvpropedit in den MKV-Header und kann
optional Spuren bereinigen oder für AV1-Encoding in eine Warteschlange stellen.
Status: frühe öffentliche Beta (v0.12.0). Die Säulen Disc DB, Subtitles und Title-card OCR sind bereit für Tests — die OCR-Säule ordnet 70–90 % der Folgen zu, wenn die Serie ihre Episodentitel einblendet. Alles andere (Audio/Whisper, LLM arbiter, die Seiten Visual Verify und Post-Processing) ist bewusst noch nicht fertig und ist im Programm entsprechend markiert.
| Key | Pflicht | Bezug |
|---|---|---|
| TMDB | Ja — ohne geht nichts (Episodentitel, Plots, Credits) | themoviedb.org |
| Untertitel-Quelle | Ja für die Subtitles-Säule | SubDL (empfohlen) oder OpenSubtitles |
| LLM | Nein (Säule noch nicht fertig) | BigModel GLM, DeepSeek, … |
Die Keys gehören in data/config.json oder als Umgebungsvariablen
(EPISODEMATCH_TMDB_API_KEY, EPISODEMATCH_SUBDL_API_KEY, EPISODEMATCH_OSDT_API_KEY,
EPISODEMATCH_LLM_API_KEY, …) — beides kann in der GUI unter Settings eingetragen
werden.
Die Community-Datenbank TheDiscDb/data (MIT) enthält pro Disc die Playlist-Struktur: SourceFile (MPLS-Name), SegmentMap, Duration, Size und die Zuordnung Titel → Episode — geschrieben von Leuten, die dieselbe Disc mit MakeMKV gescannt haben.
- Fingerprint: Für jede MKV sammelt EpisodeMatch MPLS-Name (aus dem Title-Tag),
exakte Dauer, exakte Größe und den MakeMKV-Titel-Index aus dem Dateinamen
(
…_t07.mkv→ 7). - Disc laden: Am schnellsten per Disc-URL aus thediscdb.com (GUI-Feld oder
--discdb-url) — dann wird genau eine Disc geladen statt aller Releases einer Serie. - Scoring: MPLS-Match +0.60; Titel-Index-Match nur mit bestätigter Dauer +0.25 (mit Disc-URL +0.90); eindeutige Dauer auf der ganzen Disc +0.70; Dauer (mehrfach vorhanden) +0.20–0.35; Größe +0.10 (schwach — gerippte MKVs sind kleiner als die Disc-Playlist); Index-Kollisionen ohne passende Dauer werden ignoriert (unterschiedliche MakeMKV-Versionen nummerieren Playlists anders — otherwise falsche Zuordnungen).
Live-verifiziert: South Park S6D1 — MakeMKV schrieb den Disc-Namen statt der MPLS in den Title-Tag und alle 9 Episoden sind exakt 22:06 lang → 9/9 korrekt @ 100 % über den Titel-Index. Castle Rock S1D2 — individuell unterschiedliche Laufzeiten, Contributor nummerierte die Playlists anders → 5/5 korrekt @ 80 % über die eindeutige Dauer.
- Extraktion: Text-Spuren (SRT/ASS/VTT) per
mkvextract/ffmpeg mit nativen Parsers. PGS-Bilduntertitel werden als.supgedumpt und über seconv.exe (SubtitleEdits headless Konverter, nOCR-Engine, wird automatisch geladen) in SRT konvertiert — vollautomatisch. Fallback: nativer Python-PGS-Parser- lokale OCR, begrenzt auf die ersten 40 Untertitel-Events.
- Referenz in der richtigen Sprache: Die Referenz wird in der Sprache der
extrahierten Spur angefragt (
ger→ deutsche Referenz) — bei OpenSubtitles oder SubDL (empfohlen: 2.000 Requests + 300 Downloads/Tag statt 5/24h). Referenzen werden lokal gecacht (Rescans verbrauchen kein Kontingent). SubDL-Kandidaten werden gegen die Anfrage validiert (ISO-Sprachcode, Staffel, Episoden-Feld bzw.episode_from/episode_end-Bereich) — wenn keine Einzel-Episoden-SRT verfügbar ist, werden automatisch Staffel-Pakete genutzt; flüchtige 429-Antworten („service_busy") werden automatisch wiederholt. - Coverage-Scoring: Es wird gezählt, wie viele eindeutige Referenzzeilen der Kandidaten-Episode durch die Extraktion bestätigt werden (Fuzzy ≥ 80). Die richtige Episode deckt ~100 % ihrer eigenen Referenz ab; falsche nur ~9–20 % (Generika + Recaps). Ab 85 % Coverage greift eine Confidence-Untergrenze von 0.93.
- Solver: Ein Ungarisches Verfahren (
scipy) verteilt die Episoden global — keine Episode wird doppelt vergeben; alles unter der Confidence-Schwelle wird ehrlich als unassigned mit Best-Guess gemeldet.
Viele Serien blenden den Episodentitel auf dem Bildschirm ein (Title-Card nach dem Opening, typischerweise um das Ende des ersten Kapitels), und der Abspann nennt Regisseure, Autoren und Gaststars — beides wird aus Keyframes gelesen und gegen den TMDB-Staffel-Guide gematcht.
Die eine Voraussetzung: der Episodentitel muss auf dem Bildschirm erscheinen. Serien mit Title-Cards (die meisten DVD-Produktionen vor 2000, …) bekommen den vollen Nutzen — live ordnet die Säule 70–90 % der Folgen allein zu (in Tests 9/11 Dateien aus Title-Cards allein, ohne DiscDB-Eintrag und ohne Untertitel-Referenzen). Serien, die ihre Titel nie einblenden, können über diese Säule nicht nach Episoden unterschieden werden — sie bestätigt dann nur die Serie (Hauptcast-Cards) und liefert schwache Credit-Hinweise; solche Shows verlassen sich auf die DiscDB- und Subtitles-Säulen.
Im Detail: Probe-Raster im Titel-Fenster (2,5-s-Raster, in ±10-s-Zonen um jede MKV-Kapitelmarke auf 1 s verdichtet), gleichmäßiges Sampling im Abspann; zwei OCR-Backends (Windows-WinRT + RapidOCR, wählbar; RapidOCR liest stilisierte Fonts deutlich besser) mit Graustufen-Retry bei leeren Frames; Titel-Abgleich mit vier Guards aus echten Discs (Serienlogo-Filter, Teaser-Card-Filter im Abspann, Kurz-Titel-Schutz, OCR-Abstands-Normalisierung); Credit-Namen mit Staffel-IDF (in vielen Folgen Genannte verblassen); Serien-Cast-Hinweise als Evidence ohne Episoden-Score. Jeder Treffer wird mit Timestamp als Evidence protokolliert.
- Workspace → Seriennamen eingeben → Search TMDB → Serie wählen, Staffel setzen.
- Rip-Ordner wählen, optional die TheDiscDB-Disc-URL einfügen.
- Depth wählen: Fast (nur DiscDB), Medium (DiscDB + Subtitles, empfohlen), Deep (alle Säulen).
- Scan folder → Ergebnisse prüfen (Confidence-Balken + Evidence-Inspector mit Begründungen).
- Apply rename (mit Undo-Journal) und/oder Write MKV titles.
🚧 Audio/Whisper und 🚧 LLM arbiter (in den Checkboxen als not ready markiert) sowie die Seiten 🚧 Visual Verify und 🚧 Post-Processing (beta in der Navigation
- Warnbanner). Vorhanden, aber als Vorschau behandeln — bitte nicht auf ihre Ergebnisse verlassen. ✅ Title-card OCR ist seit v0.12.0 reif für weitere Tests.
git clone https://github.com/episodematch/episodematch
cd episodematch
python -m venv .venv
.venv\Scripts\pip install -e .[gui]
episodematch check-env :: Tool-Status, OCR-Backend, API-Keys
episodematch fetch-tools :: lädt ffmpeg + MKVToolNix + SeConv nach .\bin\Benötigt wird: ffmpeg.exe, ffprobe.exe, mkvmerge.exe, mkvextract.exe,
mkvpropedit.exe und seconv.exe — gesucht in ./bin/, im PATH und unter
C:\Program Files\MKVToolNix\, fehlende werden automatisch geladen.
Fertige EXEs (ohne Python-Installation lauffähig):
.venv\Scripts\pip install -e .[gui,pack]
.venv\Scripts\python scripts\build_exe.py --smokedist\cli\episodematch\episodematch.exe— Konsole-CLIdist\gui\EpisodeMatch\EpisodeMatch.exe— Windows-11-GUI
Fertige Archive gibt es auf der GitHub-Releases-Seite als zwei separate ZIPs (CLI und
GUI), jeweils mit Lizenztexten — die GPL-Tools lädt episodematch fetch-tools selbst
nach, damit die Archive GPL-frei bleiben.
MIT — siehe LICENSE.
Einige ML-/heuristikbasierte Engines (z. B. Arctic Wolf, Bkav Pro, SecureAge, Skyhigh) können die unsignierten PyInstaller-EXEs generisch markieren — ein bekanntes Falsch-Positiv-Muster dieses Dateityps; die großen Signature-Engines (Microsoft Defender, Kaspersky, ESET, Bitdefender, …) melden nichts. Vor dem Ausführen prüfen: SHA-256 der EXE mit dem im Release angegebenen Hash vergleichen oder die EXEs selbst aus diesem Quellcode bauen.

