Skip to content

Roadmap

Podlibre is funded by the NLnet Foundation and Ad Aures, and built in six milestones. Each one is a set of line items, and every line item is either done or it is not — there is no partial credit here, because a half-built plugin helps nobody.

Live status, with every line item as an issue you can follow or claim, is on the milestones page.

The order is deliberate. The first milestone is the foundation everything else plugs into, and from there each milestone is a group of plugins written against the same public API that anyone else can use. Nothing after Milestone 1 is privileged: if the architecture is right, a stranger could have written any of it.

Milestone 1 — Core System

The backbone: a show file, a workflow, a plugin architecture on pluggy, six languages, and a binary for each platform. Done.

Line item What it means
Database Stores podcast and episode data, for easy backups and migrations ✅
Core system Workflows and plugin integration — the backbone of the application ✅
Plugin architecture Modular customisation for the various podcasting tasks ✅
Internationalisation Multiple languages, so it is usable worldwide ✅
Linux packaging Straightforward installation ✅
macOS packaging Straightforward installation ✅
Windows packaging Straightforward installation ✅
Documentation Written before the code, and kept true to it ✅

What Milestone 1 delivers, in detail.

Milestone 2 — Audio Filter Plugins

Making a recording sound like a broadcast: four filters, one step of the workflow, one plugin. Four steps meant four whole copies of the episode on disk and an order the user had to know — see Audio.

Line item What it means
Audio noise reduction Reduces background noise for cleaner sound
Audio compression Keeps the volume consistent
Audio normalisation Balances levels for clarity
Loudness normalisation Brings loudness to the broadcast standards
Documentation

Where this stands: the four filters are written and tested against the EBU's own conformance signals — see Audio — and ship as one plugin, now reachable: the bundled Local audio plugin imports a recording into an episode, which is the step they were all waiting for.

Milestone 3 — Transcription Plugins

Transcription that runs on your own machine, and an editor worth using on what it produces.

Line item What it means
Automatic transcription Text from audio, locally, with no third-party service
Manual transcription correction An efficient interface for fixing what the machine got wrong
Documentation

Milestone 4 — Audio Editing Plugins

Line item What it means
Audio editing Cutting, rearranging and refining audio
Music insertion Adding music tracks to an episode
Documentation

Milestone 5 — Metadata Plugins

Line item What it means
Chapter editing Chapters, for navigating an episode
Metadata editing ID3 tags, RSS data and Podcasting 2.0 tags in one place
Documentation

Where this stands: metadata editing arrived with Milestone 1, because it cost almost nothing once the field model existed — the forms are generated from the field catalogue, so every shipped field and every field a plugin invents is editable without an interface being written for it. See editing metadata. Chapter editing is the part still to come.

Milestone 6 — Export Plugins

Getting the finished episode out, to a disk or to a host.

Line item What it means
Export locally Save an episode to a drive
Publish to Castopod
Publish to Funkwhale Decentralised podcast hosting
Publish to Faircamp
Documentation

Where this stands: the bundled Publish to a folder plugin arrived with Milestone 1, because the smallest thing that is actually a podcast needs somewhere for the audio and the feed to go. It mixes each episode down and writes the whole show into one folder — the RSS, every exported episode, and every file the feed points at, each one addressed for wherever the folder is uploaded — which is a drive, a sync folder or a bucket's worth of static files. The three hosts are what is left, and each is the same shape: the worked Castopod example is written out in full.

After that

The plugin architecture exists so the list does not have to end here. Posting to social networks such as Mastodon, local language models for metadata and chapters, and publishing to other hosts are all plugins somebody could write — including somebody who is not us. That is the point of there being no private API.