Inguiotar/ABChapterize

Correct chapter marks for your audiobooks — by actually listening to them.

ABChapterize is a command-line tool that scans audiobook files (.m4a, .m4b, .mp3, .opus, .mka) for spoken chapter announcements ("Chapter Seven", "Kapitel 12", …) using Whisper speech recognition and writes proper chapter marks directly into the file. No splitting, no sidecar files, no server — the audio itself stays untouched, only the chapter metadata is rewritten.

If you have ever bought an audiobook whose chapter marks were missing, misplaced, or pure fantasy (looking at you, Audible), this tool is for you.

Finding the chapters is only half the job. ABChapterize's mission is getting each mark to land in the right place — something most other tools treat as an afterthought, dropping the mark wherever the nearest silence happened to be, or a fixed handful of seconds off. Here, a found chapter mark is re-listened to in order to pin down where the announcement actually begins, jingles are located with a voice-activity model rather than guessed at from the waveform, and the mark is placed relative to what the narrator is doing rather than to the file's byte positions. Skipping ahead should land you on the chapter announcement (or - if you prefer - on the start of the chapter's lead-in jingle), not two sentences into the previous chapter's ending.

Prebuilt binaries for Windows and Linux are available on the Releases page — no build tools required. The full documentation is online at abchapterize.anetos.de, published with each release.

• Finds chapters by listening — it detects the narrator's actual chapter announcements, not just gaps in the audio, by first probing short candidate windows at silences and jingles and only falling back to transcribing a full suspicious region when that isn't enough — keeping the time-consuming Whisper work to a minimum.
• Writes marks in place, safely — chapters are written by stream-copy remuxing into a temporary file that is verified before it atomically replaces the original. Your audiobook cannot be lost, even without --backup.
• Jingle-aware probing, by default — a bundled voice-activity model (Silero VAD) finds jingles (music stings) even when they abut speech with no silence on either side, which a plain amplitude scan would miss entirely, and Probe gives each one a probe of its own aimed at where the announcement behind it will be. --mark-before-jingle anchors the written mark to the jingle/silence itself instead of the default fixed offset before the phrase.
• Self-healing — when the detected chapter numbers have gaps (e.g. chapter 12 was announced without a pause before it), the stretch the missing chapter has to be in is gone over again: first by listening more closely and at shorter pauses than the run was willing to probe, and only then by transcribing it in full.
• Zero setup for models — the Whisper model is downloaded automatically on first use, and checked against pinned SHA-256 and SHA3-256 digests before it is used — a compromised or tampered-with download is rejected rather than silently loaded.
• GPU accelerated — uses CUDA or Vulkan when available, falls back to CPU. On a laptop or desktop with both an integrated and a discrete GPU, the discrete one is picked automatically (left alone, the Vulkan runtime may well grab the integrated one, which is dramatically slower), and the GPU in use is named in the startup line. Override with --use-gpu <name>; --list-gpus shows the names.
• One file at a time, with the whole machine behind it — the scan that opens every run spreads a single book across all your cores, which takes most of that pass off the clock without changing a single thing it finds. Thread counts default to your physical core count; --vad-threads and --whisper-threads override them.
• Batches survive being interrupted — name as many files and folders as you like in one command; each folder quietly keeps track of what is already done while it is being worked on, so a run stopped by Ctrl+C, a crash or a power loss picks up where it left off when you run it again. A run that finishes normally cleans up after itself.
• Detects the language automatically — by default, each file's language is detected from a short clip before transcription and used just for that file (falling back to English when the detection is inconclusive), so a mixed-language collection just works with no --lang at all. Pin it to one language with --lang de if you'd rather skip per-file detection, or name several — --lang no,da,sv — to keep the per-file detection but let it choose only between those. A file that fits none of them falls back to the first language you named rather than to English, so put your shelf's most likely language first.
• Thirteen languages of number recognition out of the box — English, German, French, Spanish, Italian, Dutch, Turkish, Portuguese, Polish, Swedish, Danish, Norwegian and Czech. Whisper likes to write numbers out as words ("twenty-one", "einundzwanzig", "vingt et un", "veintiuno", "ventuno", "eenentwintig", "yirmi bir", "vinte e um", "dwadzieścia jeden", "tjugoett", "enogtyve", "tjueen", "dvacet jedna"), and ABChapterize understands them all; other languages work with a custom phrase/regexp. Ordinal announcements are understood too, before or after the phrase — "Erstes Kapitel", "2. Kapitel", "chapitre premier", "Birinci Bölüm" — and --lang localizes the chapter phrase and title defaults (per-file when auto-detecting), so a German audiobook alone finds and writes "Kapitel" with no options at all. Missing your language? Adding one is a contained, well-signposted job — see doc/adding-a-language.md.
• All chapter-capable audio formats — MP4 audiobooks (.m4a/.m4b), MP3, Opus and Matroska audio (.mka). (.ogg and .flac are out, through no fault of their own: ffmpeg cannot write chapter marks into those containers — but --abs takes them anyway, since there the marks go to the server.) .m4b is recommended: .m4a and .m4b are identical containers, but players may pick their exact behavior based on which extension they see, and chapters in .mp3/.opus files are honored by comparatively few players.
• Works straight off an Audiobookshelf server — with --abs, books are named by library, series, collection or title instead of by path: each one is fetched, marked, and its chapters sent back to the server, with the temporary copy deleted afterwards. Nothing on the server changes but the chapter list. This mode takes any format ffmpeg can decode, .flac and .ogg included, because the marks are going into the server's database rather than into the file. For a shelf you keep here and serve from Audiobookshelf, marks travel in both directions: --abs-push marks the local files as usual and tells the server too, --abs-push-only sends marks a book already has, and --abs-pull takes the server's list and puts it into the file. Pull and push together reconcile a shelf — each side ends up with the same chapters, and running it twice does nothing the second time.
• Windows and Linux, single self-contained executable. Linux ARM64 and Apple Silicon build from source as well, untested and unreleased — see Building from source.

ABChapterize uses ffmpeg/ffprobe for audio decoding and chapter writing. If you don't have it yet:

• Windows: download a build from ffmpeg.org (e.g. the gyan.dev "essentials" zip) and unpack it. ABChapterize finds it automatically in PATH, in an ffmpeg folder in the current directory, next to the exe or in your user profile, in Program Files, or wherever FFMPEG_DIR points — at the unpacked folder or at the binaries themselves, either works.
• Linux: sudo apt install ffmpeg (or your distribution's equivalent).
• macOS: brew install ffmpeg (or MacPorts' sudo port install ffmpeg).

Download the archive for your platform from the Releases page and unpack it anywhere you like. Keep the runtimes folder next to the executable — it contains the native Whisper libraries.

abchapterize "My Audiobook.m4b"

That's it. On the first run, the speech model is downloaded automatically (about 465 MB for the default model — one time only, with a progress display; the 1.6 GB upgrade model follows later, and only if a file actually needs it). Then the audiobook is scanned and the chapter marks are written:

Whisper model "small" loaded (Vulkan backend on NVIDIA GeForce GTX 1070, auto language detection), upgrade model "turbo" (loaded on first use), 1 file(s) to process.
My Audiobook.m4b: 24 mark(s) written (23 chapter(s) 1-23, 1 named), language: en (p=1.00)

Want to be extra careful on the first try? Use --backup — the original file is kept as My Audiobook.m4b.bak, and abchapterize --revert restores it if you don't like the result.

# A whole audiobook collection, subfolders included, keeping backups:
abchapterize --recurse --backup "D:\Audiobooks"

# Several folders and single files in one go, in the order given. If this run
# is interrupted, repeating the command resumes it instead of starting over:
abchapterize --recurse "D:\Audiobooks" "E:\New arrivals" "F:\one-off.m4b"

# A mixed-language collection: no --lang needed, each file's language is
# detected automatically and localizes "Kapitel"/"Chapter"/etc. per file:
abchapterize --recurse "D:\Audiobooks (mixed languages)"

# Pin a fixed language instead of auto-detecting per file (skips detection,
# slightly faster): the chapter phrase and title default to "Kapitel"
# automatically with --lang de:
abchapterize --lang de buch.m4b

# The publisher plays a jingle before each chapter announcement — jingle-aware
# probing (and the VAD pre-pass) run by default, no flag needed:
abchapterize hoerbuch.m4b

# ...want the mark anchored to the jingle/silence itself instead of the
# default fixed offset before the phrase?
abchapterize --mark-before-jingle hoerbuch.m4b

# Redo files that already have (wrong) chapter marks:
abchapterize --force badly-marked.m4b

# Books on an Audiobookshelf server, by library, series, collection or title.
# Check what a selector actually picked before committing to the downloads:
export ABCHAPTERIZE_ABS_URL=books.lan:13378 ABCHAPTERIZE_ABS_KEY=...
abchapterize --abs --no-op --summary "library:Discworld"
abchapterize --abs "series:Tiffany Aching"

# Mark your own files as usual, and put the chapters on the server as well:
abchapterize --abs-push --recurse "D:\Audiobooks"

# Books you already marked locally, whose chapters the server has not got:
abchapterize --abs-push-only --recurse "D:\Audiobooks"

# The other direction: chapters the server has, put back into the files:
abchapterize --abs-pull-only --recurse "D:\Audiobooks"

# Or both at once - detect what neither side has, and leave them agreeing:
abchapterize --abs-pull --abs-push --recurse "D:\Audiobooks"

# The same with every mark checked against the audio on the way through:
abchapterize --abs-sync --recurse "D:\Audiobooks"

# Marks that should be one per numbered chapter (say, from an earlier run),
# but you're not sure they all landed right? Check each against the audio;
# only the ones that don't check out get redone:
abchapterize --recurse --verify "D:\Audiobooks"

# Not sure a --filter regexp actually matches the files you mean? List them
# without touching Whisper, ffmpeg or any file:
abchapterize --no-op --filter "/brandon sanderson/" --recurse "D:\Audiobooks"

# Happy with the results? Sweep up the backups, logs and name tags the runs
# left behind (it lists what it would do and waits for a "yes"):
abchapterize --cleanup --recurse "D:\Audiobooks"

# See what would be detected without writing anything:
abchapterize --dry-run "My Audiobook.m4b"

# Retry only the files a previous run couldn't fully chapterize (tagged
# "<name>.missing-marks-<n>-<n>-....<ext>" - see the manual's troubleshooting
# section): running over them again resumes automatically, re-probing only
# the still-tagged gap(s) - no extra flag needed, and the rest of a big
# collection is left untouched either way:
abchapterize --recurse --filter "/\.missing-marks-/" "D:\Audiobooks"

# ...or discard that partial work and start such a file over from scratch:
abchapterize --recurse --force --filter "/\.missing-marks-/" "D:\Audiobooks"

# Batch run: quiet, but with a summary at the end:
abchapterize -rqs "D:\Audiobooks"

# Detect, write, and also save a sidecar for manual review/correction:
abchapterize --export "My Audiobook.m4b"

# ...fix a chapter title in My Audiobook.m4b.chapters.ffmeta, then apply it
# without re-running Whisper:
abchapterize --import --force "My Audiobook.m4b"

# Run your own commands around each file - here: normalize it first, then file
# the backup away afterwards. "$99" is the file's whole path, "$1" its name;
# names with spaces are quoted for the shell for you:
abchapterize --recurse --backup \
             --run-before "abnormalize $99" \
             --run-after "mv $99.bak ~/archive/$1" \
             ~/audiobooks

# Files are processed one at a time, each with the whole machine. Leave a few
# cores free for whatever else the machine is doing:
abchapterize --recurse --vad-threads 6 --whisper-threads 6 "D:\Audiobooks"

Run abchapterize --help for a quick reference, or see the manual for the full story — including exactly what is kept and what is stripped when chapters are written. The same manual is at abchapterize.anetos.de, split into pages with a navigation column — the friendlier way to read a document this long. Grouped below exactly as --help groups them:

File selection

Audiobookshelf

Detection tuning

Phrases & titles

Detection safety nets

Output & review

File & backup management

Logging & display

Performance

Info

Short options without parameters can be collapsed (-rb = -r -b). Decimal values accept either separator (-n 2.5 = -n 2,5); printed numbers always use ., whatever the machine's locale says.

• Analyze — ffmpeg finds every pause quieter than --noise-floor (normally −35 dBFS) in one quick pass, keeping the short ones as well as the long — marks are placed and refined against the whole list. --min-silence-length (default, and starting point with auto: 1.5 s) then decides which of them are probed.

• The VAD pre-pass, part of Analyze and always run: a bundled voice-activity model (Silero VAD) scans the whole file for speech vs. non-speech. A jingle is music, which reads as non-speech to a speech detector just like silence does — so this catches jingles the amplitude-only silence scan misses entirely: one that abuts the narration with no detectable gap on either side. Every jingle it finds becomes a probe candidate of its own; a pause that merely leads into one is then left alone, since the jingle hears the same announcement from a better place.

• Probe — a short stretch of audio is transcribed with Whisper at each candidate and matched against the chapter phrase. Where the window opens and how far it runs follows from what made the place a candidate: after a pause the announcement comes within seconds, behind a jingle it is the first speech after the music, and a jingle with a sound inside it may be hiding the announcement in there, so the window covers the music too. The chapter number is parsed from digits, Roman numerals, or numbers written out as words (0-999, cardinals and ordinals alike), whether it follows the phrase ("Chapter Seven") or precedes it ("Erstes Kapitel", "2. Kapitel", "Birinci Bölüm"). By default (--min-silence-length auto), starting from the second mark found (the silence before the first mark is usually the intro/title silence, often longer than the breaks between chapters, so it's not used to tighten), the probing threshold sits at 75% of the shortest chapter-break silence observed so far — set once, then only ever lowered — so shorter in-chapter pauses stop being probed once real inter-chapter breaks are established. Only chapters found at a pause teach it: the hush in front of a jingle measures the run-up to the music rather than the break between two chapters. Where that measurement comes out below the 1.5 s probing started at — a narrator whose chapter breaks are simply shorter than the default assumes — a gap in the numbering reaches down to it, and once Probe is done the gaps still open are swept for those short pauses as well, down to 0.8 s. That sweep runs off the gap rather than off the measurement, so a book of jingles — which measures nothing — gets it too. An explicit --min-silence-length value disables all of this and probes every silence at or above it instead, and nothing below it. A sequence gap sends the whole stretch between the two chapters back for a second look: every pause and every jingle in it, including the ones the first look ruled out and the ones too short to have been probed at all, each read in a slightly different framing rather than a wider one — and since that retry knows both ends of the hole it's filling, only the numbers actually missing from it can be right there. A number that can't be right — one leaving more than three chapters missing at once, one below the chapters already found, or one outside the hole being searched — is read again before it's believed: with --upgrade-model if that's the better model, then from two differently framed windows. The new reading only counts if it fits the sequence there, so a book that genuinely skips numbers keeps its own. An announcement heard with no readable number at all goes down the same road, with the same rule deciding what may be believed — which is the only thing that can rescue one sitting past the last chapter found, where there's no gap for a later pass to notice. A stretch that yields nothing while VAD did hear someone speak inside its jingle is read once more from a shorter window, through a heavier --upgrade-model where one is named: Whisper reads audio in 30-second chunks, and a lone announcement can drop out of a window that crosses one.

• J-probe and S-probe — a book that announces every chapter after a jingle is probed in two halves instead of one sweep — every jingle first, then the pauses, and only those that can still be carrying something: anywhere the numbering has a hole, everything before the first chapter found, everything after the last. The pauses between two chapters whose numbers already run consecutively are skipped, since nothing else can be announced there — no number is left for a chapter, and a prologue and an epilogue both belong elsewhere. On a book of that shape those pauses number in the thousands and can only confirm what the music already said. A file takes this shape by itself with at least one jingle per hour, unless a --custom mapping of yours may fall between two chapters; --jingle-first asks for it regardless.

• SD-probe — a book with no chapter music has the same problem from the other side: it announces its chapters after its pauses, and it has a hundred pauses that announce nothing for every one that does. So its pauses are skimmed once through longest first, purely to find out roughly where the chapters are, and SC-probe behind it then reads the file in order as always but passes over every pause lying between two chapters whose numbers already run consecutively. Nothing read during the skim is read again. The skim stops as soon as the pauses get too short to be this book's chapter breaks, and on a file that announces nothing it gives up having spent no more than --early-abort would have. It decides only which pauses are worth reading — every chapter is still recognised, numbered and placed by the pass behind it, reading the file in order.

• Mark refinement (skip with --quick-marks/-Q) — for the mark that still lands on the wrong spot — usually a jingle whose music briefly fools the voice-activity detector into sounding like speech — every mark is double-checked by re-transcribing short, isolated clips of the stretch the phrase was heard in, closing in on the announcement a few checks at a time until one hears the phrase first; its own beginning is then measured to within a tenth of a second and the mark set just ahead of it. A mark none of those clips can confirm is searched for once more through a heavier --upgrade-model, where one is named, before it is left at its estimated position. Costs a handful of extra transcriptions per chapter, which is what --quick-marks trades away for speed. Those clips are also the best look at the chapter number anything in the run gets — the same announcement can read as "chapter forty" from a 45-second window and "chapter fourteen" from every window under seven — so when they agree with each other, disagree with the number in hand, and offer one the sequence can hold, the mark is filed under theirs. That costs nothing extra; the clips were transcribed either way.

• Sequence reconciliation — chapter numbers rise through a book, so when Probe is done and one mark's number contradicts the marks around it, that mark gives way — not the rest of the book. Before it's given up, its neighbours get a say: between a chapter 13 and a chapter 15 there's exactly one number the mark can carry, so it's renumbered outright; where they leave several, the audio is read once more and held to that range. Running it here rather than during Probe is the point — the chapters that settle the question are often found long after the misreading.

• Re-probe — a cheap second opinion, only with a heavier --upgrade-model: most gaps aren't unprobeable audio, just a number the probe model misread with the announcement sitting right there in the window. So before Scan commits to transcribing whole regions, the same quick probes are simply run again over the gap with the bigger model, which can close it without transcribing the region at all. Not a free bet, though: the probing cost grows with how many candidate silences the gap holds, so on a dense region it can approach the cost of the full transcription it's trying to avoid — and if it finds nothing, Scan still runs afterward. A gap that survives that gets one more try aimed at the other explanation, that nothing ever probed there: the pauses just short of --min-silence-length are swept a tenth of a second at a time, longest first, down to half a second under the setting, stopping as soon as the missing chapters turn up — which is what saves a book whose narrator's chapter break happens to land right on the limit. Only ever happens when --upgrade-model names a better model than Probe's, which by default it does: small probes, turbo gets the second opinion.

• Scan — only if needed: if the chapter numbers found so far have sequence gaps, the regions where the missing chapters must be hiding are transcribed completely, in roughly 10-minute chunks. Scan can use a different model than Probe (--upgrade-model). A chapter missing after the last one found leaves no such gap — nothing above it to notice its absence — which is what the trailing scan below is for.

• Re-scan — a gap that survives being transcribed end to end is a misreading, not unread audio — every second of it was read. The likeliest misreading is framing: Whisper decodes in 30-second windows, and an announcement landing on a window border can drop out of the transcript entirely while the sentences either side of it come through perfectly, so the text reads as though nothing were missing. Each remaining gap is therefore read once more with every decode shifted by half a window, putting whatever sat on a border as far from one as it can get. Runs unless --upgrade-model names a lighter model than --model — the one setting that says outright the stragglers aren't worth more time. The trailing scan below is read once only either way: it already runs on every file, and reading audio nothing suspects twice would double that standing cost. If a gap still remains after all that, the chapters that were found are written and the file is renamed with a .missing-marks-… tag listing the still-missing numbers, rather than discarded. Running the tool again over such a file resumes it automatically: the committed chapters are trusted as-is, and only the still-tagged gap(s) get their own Probe/Scan, exactly as after a failed --verify. The file is renamed back to its original name once every chapter is found, or re-tagged with the (possibly shorter) remaining list otherwise; --force bypasses this and redoes the whole file from scratch. More than ten missing chapters are left out of the tag (just .missing-marks), and such a file is not resumed automatically — a gap that wide wants a look by hand first, usually starting with --max-chapter-number. However it is eventually redone, any run that ends with a complete chapter sequence takes the tag back off (and, with --debug, brings the log beside it along, replacing the earlier run's).

• The trailing scan, the Scan pass's last job: everything after the last chapter found is transcribed too, on spec, because that is the one place a missing chapter leaves no trace. A gap is spotted as a hole in the numbering, and a hole at the very end has nothing above it to be a hole in — so without this the file is written out looking complete. It costs a final chapter's worth of transcription on every file and can never stop early, having no expected numbers to satisfy; --no-trailing-scan buys that time back for a library already known to be sound, and --chapter-count replaces it with a search that knows what it is looking for. Skipped when no chapter was found at all, and after an --early-abort or --expected-start-chapter abort.

--custom "phrase:Title;..." adds marks for anything else a book announces — an interlude, a timeline, a cast list. Such a phrase may be a /regexp/ whose capturing groups the title writes out (${name}, ${number}), and is matched at any point in the file and as often as it occurs. It must be announced, though, exactly as a chapter phrase must: a passing mention in the narration gets no mark.

--ignore-chapter-numbers keeps chapter detection running but stops it reasoning about the numbers — no sequence, no gaps, no missing chapters, with whatever number was spoken still going into the title. For books whose numbering the tool cannot make sense of — an omnibus of several novels, or one that announces "Chapter" and simply reads on. A book that merely restarts its count in every part needs no option: that is recognized by itself, and its chapters are titled "Part 2 - Chapter 1" (see --part-title).

Alongside the numbered chapters, a "Prologue" and an "Epilogue" mark are detected the same way (localized by --lang, renamed with --prologue-title and --epilogue-title, re-worded with --prologue-phrase and --epilogue-phrase, switched off with an empty phrase). A prologue only counts before the first numbered chapter and an epilogue only after the last one, at most one of each per file. For a section between two chapters — an omnibus whose inner parts each end with one, say — use --custom, which is bound by no position.

A synthetic "Intro" mark (localized by --lang, customizable with --intro-title) covers everything before the first detected mark (audiobooks usually start with title/credits), so the first real chapter keeps its exact position.

• Speed: by default (-n auto), the silence threshold self-tightens as real chapter breaks are found, without having to guess a fixed value. If your audiobook's pauses vary too much for that to help, an explicit threshold like -n 2.5 still works — far fewer Whisper probes, much faster run, but chapters go missing if it's set too high.
• Jingles: Probe costs one probe per jingle whatever its length, and every window is cut to its own candidate, so a book of long jingles is no slower than a book of short ones. On a book whose every chapter opens with music, -n 0 is the real saving: it drops the ordinary pauses as candidates and leaves only the jingles.
• Accuracy vs. speed: the default pairing is -m small -M turbo, and it is not the compromise it looks like. The model named by --model listens to short windows a few seconds long, and the large models are worse at those than small is: they tend to hand back the whole window as one run-on sentence with the announcement missing from it, which on one French audiobook cost six of twenty-five chapters. --upgrade-model handles the long transcriptions, where the usual ranking does hold, so turbo is kept in reserve for the chapters small could not resolve — and is loaded only if that happens. The small model is also several times faster, so this is not a trade at all.
• When to reach for something heavier: -M large for one last, best-effort attempt at a book that keeps losing chapters. Raising --model itself is worth trying on a book whose narrator is hard to make out, but check the result rather than assuming it improved. Going below small is not advisable for real audiobooks: detection stands or falls with catching a single short phrase, and tiny in particular mishears or drops chapter announcements so often that it is supported mostly for completeness (quick experiments, toy examples).
• Memory: a model needs somewhat more memory to run than its download size — whisper.cpp's own figures are ~852 MB for the default small, ~2.1 GB for medium and ~3.9 GB for large, with turbo landing around 2.2 GB (loaded alongside it only once Re-probe or Scan actually runs). (Figures quoted for OpenAI's Python implementation are two to three times higher; they do not apply here.) It comes out of video memory on a GPU backend and out of system RAM on a CPU backend, and only ever one copy of it: files are processed one at a time. The voice-activity pre-pass wants some of its own on top, growing with --vad-threads. Nothing is checked up front; if the memory isn't there you'll hear it from the model loader, not from ABChapterize. See memory requirements for the details.
• Absurd chapter numbers: if a run reports a chapter number far beyond anything the book has (and then a long list of "missing" ones below it), Whisper misheard a number — smaller models do this now and then. Cap it with --max-chapter-number set to roughly the real chapter count.
• Unusual announcements: --chapter-phrase accepts a regexp between slashes, e.g. -c "/part ()/", where () stands for the chapter number in any notation the language has. Several alternatives may be given at once, and a ^ or $ asks for a pause around the announcement — see the manual.
• Diagnosis: run with --verbose to see processing details as log lines, or --verbose-transcripts (-T) to also see every Whisper transcription — what the recognizer actually heard, and the confidence it had in each. Chapter marks below 50% confidence are flagged in the per-file result line (even without --verbose) as worth a manual spot-check.

Requires the .NET 10 SDK.

dotnet publish -c Release                 # Windows build -> bin/publish/win-x64
dotnet publish -c Release -r linux-x64    # Linux build   -> bin/publish/linux-x64
dotnet test tests/ABChapterize.Tests        # run the unit tests

Two more targets build from source. Neither is released, and neither has ever been run by anyone here — they are offered on the understanding that you are the one finding out whether they work.

dotnet publish -c Release -r linux-arm64  # -> bin/publish/linux-arm64
dotnet publish -c Release -r osx-arm64    # -> bin/publish/osx-arm64

Linux ARM64 (a Raspberry Pi or similar acting as a small home server) is CPU-only: the GPU backends have no ARM64 build, so the existing CUDA → Vulkan → CPU fallback simply lands on CPU. Expect it to be slow rather than broken, and prefer a small model. Unlike the Mac it can be cross-published from any machine and copied over. Details, including an Alpine trap that builds cleanly and then cannot transcribe, are in Building on Linux ARM64.

Apple Silicon has more caveats than fit here, including one that will stop you before you start — build it on the Mac itself, not from another machine. They are all in Building on macOS. Intel Macs are out of scope permanently, for a reason spelled out there.

MIT. The bundled native Whisper libraries come from Whisper.net / whisper.cpp (MIT), and the speech models are OpenAI's Whisper models (MIT). The bundled jingle-detection model is Silero VAD (MIT, Copyright (c) 2020-present Silero Team), and the bundled speech denoiser is LavaSR's (Apache-2.0) in the ONNX conversion by LavaSR-ONNX. Both of those run on ONNX Runtime (MIT, Copyright (c) Microsoft Corporation) — see THIRD-PARTY-NOTICES.md for the full notices. ffmpeg is used as an external program and is not part of this project.