zwfm-babbel: Babbel: The Broadcast API That Turns News Selection, Voice Branding, and Loudness Into One Pipeline
A Go service for radio stations that chooses stories fairly, mixes them with station-specific jingles, normalizes them to broadcast standards, and serves the result as cached audio for playout systems.
- Babbel is best understood as broadcast infrastructure, because it turns editorial choice, station branding, and loudness control into one deterministic pipeline.
- Its most distinctive logic is a fair rotation system that prioritizes breaking news, avoids repetition, and resets cleanly at midnight.
- The audio engine is doing real broadcast work, not simple file concatenation, by mixing jingles and voices to EBU R128 standards.
- The public API is designed for legacy playout software, so modern auth and error handling sit behind a very old-school download model.
Babbel does not behave like a content app. It behaves like a machine that produces something a station can air without a human staying up to babysit it. That difference matters, because in radio the hard part is rarely “make audio.” It is “make the right audio, in the right order, at the right loudness, with the right station identity, every time.”
The thing Babbel actually makes
The output is a finished news bulletin. Stories are selected, voiced, branded, mixed, and written out as audio that playout software can fetch on demand. In other words, the repository is not selling creation in the abstract. It is selling readiness.
That framing explains the entire codebase. The service layer, audio layer, scheduler, and public automation endpoints all point toward one job: convert editorial intent into a file a station can trust unattended.
Why radio news is a software problem
Radio sounds simple from the outside. In practice it is a sequence of constraints. Bulletins need to stay current, avoid sounding repetitive, keep a station’s sonic identity intact, and sit at a loudness level that does not jar listeners when they move from music into speech.
Babbel encodes those constraints as rules. That is the important move. The software is not just producing speech. It is preserving a broadcast format.
How Babbel decides what listeners hear
The selection hierarchy is straightforward: breaking news first, then stories not yet used today, then least recently used fallback. That is a small algorithm with a big editorial effect. It avoids the failure mode every repetitive bulletin system eventually hits, where listeners hear the same three items until the station starts to feel stuck.
The midnight reset is the quiet detail that makes the whole system work. Without it, the day’s rotation would harden into a dead end. With it, the service gets a clean slate and can start fresh without manual intervention.
How the bulletin gets built
Babbel’s audio path is closer to broadcast engineering than to a typical media workflow. It combines spoken stories with station jingles, manages mix points, and normalizes the final file to EBU R128 loudness standards so the bulletin sits naturally in a broadcast chain.
That is a meaningful distinction. Concatenating clips is easy. Making them sound like a station product is the actual work.
story selection -> voice render -> jingle mix -> ducking at mix points -> EBU R128 normalization -> cached WAV output
The structure suggests a pipeline that is built for repeatability. A bulletin is not assembled by a human editor clicking around a UI. It is rendered from stored inputs, using deterministic rules, into a standardized audio artifact.
Why the API looks modern but serves legacy systems
The public surface is modern enough for enterprise use. Authentication and role control sit behind OIDC and RBAC. Errors can be returned as structured Problem Details. The automation endpoint, though, is deliberately old-school in the way playout systems expect: give me a URL, and let me fetch a WAV file.
| Capability | Babbel | Generic CMS | TTS-only service | Media renderer |
|---|---|---|---|---|
| Selects stories by editorial rules | Yes | Sometimes | No | No |
| Applies station-specific branding | Yes | Rarely | No | Sometimes |
| Produces broadcast-ready audio | Yes | No | Sometimes | Yes |
| Supports fair rotation and midnight reset | Yes | No | No | No |
| Caches output for playout software | Yes | No | Sometimes | Sometimes |
| Uses modern auth for admin access | Yes | Sometimes | Sometimes | Sometimes |
| Normalizes loudness to broadcast standards | Yes | No | No | Sometimes |
That split is the point. The management layer is modern, but the consumption layer respects the reality of radio automation: legacy software wants stable files, predictable URLs, and minimal surprises.
What makes Babbel different from adjacent tools
A CMS manages content. A TTS service speaks text. A media renderer transforms files. Babbel sits across all three layers, but only where radio needs them to meet: story choice, station identity, and playout reliability.
| Tool category | Primary job | What it misses | Babbel's advantage |
|---|---|---|---|
| CMS | Store and organize stories | Does not produce broadcast audio | Knows how to choose and render a bulletin |
| TTS service | Generate speech | Does not manage station logic or delivery | Keeps the station-specific pipeline intact |
| Media renderer | Mix and export audio | Does not decide what should play | Wraps editorial rules around the render step |
| Playout helper | Serve files to automation | Does not solve content or branding | Combines caching, selection, and audio standards |
That combination makes the project feel less like a media toy and more like a vertical utility. It is opinionated in exactly the places radio operators care about.
The operational edge
The boring parts are where unattended systems live or die. Babbel has schedulers for story expiration and bulletin cleanup, which matters because audio files are large and stale cache files are a very real failure mode in broadcast automation.
This is the kind of plumbing that never gets applause until it fails. Then it becomes the whole story.
What this project hints at next
The ElevenLabs integration points toward a familiar next step: more synthetic voices, less human recording, and a stronger separation between editorial input and voiced output. The architecture is already prepared for that future because the bulletin is treated as a render target, not a live performance.
That does not mean radio becomes generic. It means the station’s identity moves further upstream, into the rules that choose stories and the audio logic that shapes the final bulletin.





