The Return of the Radio Drama: Building an Offline AI Audio Engine in 200 Lines of Python

J. Rogers, SE Ohio

https://github.com/BuckRogers1965/AudioReaderWithSoundEffects

We are living in the golden age of generative AI, but we are also living in the age of subscription fatigue.

If you want to create an audio drama, a narrated RPG campaign, or a custom audiobook using premium tools like ElevenLabs or OpenAI, you are looking at a mounting bill for every character you generate. Furthermore, most Text-to-Speech (TTS) tools do exactly what they say on the tin: they turn text into speech. But speech isn’t a story.

A story has atmosphere. It has background music swelling at the emotional climax. It has the sound of rain against the window or a laser blast interrupting a monologue.

I recently built a lightweight Python engine called Open VML (Voice Markup Language) to solve this. It’s 100% offline, free, and lets you script "Old Time Radio" style productions using a simple text file.

Here is how it works, and why it is the perfect weekend project for creative developers.

The Stack: Local, Fast, and Free

The engine relies on three core technologies that work beautifully together:

1. Piper: A fast, neural text-to-speech system that runs locally. It sounds surprisingly human, supports multiple voices, and doesn't cost a dime.

2. Pydub (FFmpeg): A python library that treats audio like math. It lets us add, subtract, fade, and overlay audio tracks programmatically.

3. Python: The logic layer that parses a script and conducts the orchestra.

Because Piper runs on ONNX (Open Neural Network Exchange), you don’t need an NVIDIA H100 GPU to run this. It runs comfortably on a laptop or even a Raspberry Pi.

Scripting the Performance

The magic of this tool isn't the code; it's the Voice Markup Language (VML). Instead of feeding the engine raw text, we feed it a script that looks like a director's screenplay.

Here is what a source file looks like:

[bgm:music/noir_jazz.mp3]
[bgm_volume:0.4]

[voice:Detective_John]
[rate:140]
The city looks different at night. 

[pause:1.5]
[sfx:sound/rain_heavy.wav]
[sfx_volume:0.8]

[voice:Femme_Fatale]
[rate:160]
Maybe you're just looking too hard, John.
  

When the Python script parses this file, it does more than just read lines. It starts the jazz music, fades it to 40%, speaks in a gritty male voice, pauses for dramatic effect, overlays the sound of rain, and then switches to a female voice model for the response.

The result isn't a computer reading a file; it’s an audio drama.

Infinite Extensibility

The beauty of writing your own renderer in Python (rather than using a closed-source app) is how easily you can hack it to fit your specific niche. The core logic is under 300 lines of code.

Here are just a few ways you could extend this over a weekend:

1. The RAG/LLM Connection

Since the input is just text, you don't have to write the script yourself. You could hook this up to a local LLM (like Llama 3).

• Prompt the LLM: "Write a scary campfire story using VML tags. Include thunder sounds when the monster appears."

• Pipe the output: Send that text directly to the renderer.

• Result: An infinite, AI-generated, fully voiced radio station that runs entirely on your local server.

2. Spatial Audio

Right now, the script produces a standard stereo mix. With a simple change to the Pydub logic, you could introduce panning tags:

• [pan:left] for a whisper in the left ear.

• [pan:right] for a door slamming on the right.

• This creates a 3D soundstage perfect for horror stories or ASMR content.

3. Dynamic Sound Effects

If you use [sfx:footsteps.wav] ten times, it sounds repetitive. You could easily modify the script to look at a folder of footsteps and pick a random file every time the tag is called, or slightly randomize the pitch of the sound effect to keep the audio fresh.

Why Local Matters

We are getting used to renting intelligence and creativity from the cloud. But there is something powerful about owning the stack.

With this script, your data never leaves your machine. You can generate sensitive reports, personal journals, or experimental creative writing without worrying about API limits or privacy policies.

We have the tools to bring the quality of 1940s radio dramas into the AI age. All it takes is a little Python and a creative spark.