Skip to content

Milestone 1 — Core System

Podlibre is funded by the NLnet Foundation and Ad Aures, across six milestones. Milestone 1 is the foundation every later milestone plugs into: the database, the core system, the plugin architecture, internationalisation, packaging for three platforms, and documentation.

What this version delivers

Deliverable What it means here
Database One SQLite file per show, beside its audio, with the layered field model
Core system The workflow engine, the command registry, and the task registry
Plugin architecture The plugin API, the hooks a plugin implements, and a template to start from
Internationalisation Six languages from gettext catalogues; plugins translated independently
Packaging Built and verified on all three platforms: one file on Linux and Windows, an application bundle on macOS
Documentation This site, written before the code

Plus four plugins written end to end against the public API: RSS import, which makes a podcast out of a feed somebody already publishes, keeps its own copy of every file that feed points at, and goes back for whatever an import that was stopped did not finish; Local audio, which brings a recording into an episode and plays it back; Audio filters, milestone 2's four filters; and Publish to a folder, which mixes an episode down and writes the whole podcast as a folder: the feed and every file it points at, addressed for wherever it is uploaded. None is in milestone 1's own description. They earn their place by proving the plugin API carries real work — between them they make the smallest thing that is actually a podcast: bring one in or start one, import audio, describe it, publish it. The importer proves two things the other three do not: that a plugin can serve a step of the application's workflow, where there is no podcast open yet and making one is the point, and that the network claim is more than a word on the Plugins screen.

Where packaging actually stands

All three are built and verified on a real machine of that kind. The same script checks each binary rather than the source: the entry point, every catalogue, both themes, the icon, that a show opened in it is still in the library after a restart, and that nothing writable sits beside the executable.

Each platform turned up a fault the others could not have shown, which is the argument for building on all three rather than trusting one.

Linux also ships a desktop entry, org.podlibre.Podlibre.desktop. Without one the window announces itself as whatever started it — python3, from source — so the desktop cannot match the window to the thing it launched: no icon in the dock, and a launcher whose cursor spins until it gives up waiting for a window it never recognises.

Windows starts a windowed build with stdin, stdout and stderr set to None. Every print() raised and --help printed nothing. Worse, the handler meant to report that wrote to stderr and failed identically, so the application answered with a modal exception dialog, which is the one thing a window must never do. The streams are now rebuilt from the operating system's own handles before anything can print — which also matters for a plugin author, because running Podlibre from a terminal is how a plugin that will not import is read.

macOS needed a bundle rather than a single file. A one-file build took about fourteen seconds on every launch, the process blocked inside dyld while the system re-checked each freshly unpacked library; the bundle takes under a second after the first run. A bare executable also shows a generic icon and opens Terminal when double-clicked. It is built for Intel and Apple Silicon together. And because APFS treats the two Unicode spellings of an accented folder name as one folder, a show reached by either spelling was listed twice — the file system decides now, so Linux, where those really are two folders, is unchanged.

The check itself was wrong on macOS, which is the finding worth keeping: there is no timeout command there, so every timed run failed with "command not found" and still counted as a pass, because the script only looked for error words in output that was never produced.

Unsigned builds remain unsigned. macOS shows "Apple could not verify…" with no Open button until the user goes to System Settings, and removing that needs a paid Apple Developer account and notarisation — a decision rather than a task.

What it does not deliver

Transcription and language models have their place in the workflow and no implementation at all. Their steps are named in it and drawn faded, saying which plugin they are waiting for, rather than appearing to work — which is what a stub would mean in practice. Installing the plugin that serves one wakes the step where the workflow named it.

The engines arrive in Milestone 3 and after, where the project description funds them. Naming their seams now is what stops the architecture being rewritten to accommodate them later; writing hollow versions of them now would only be a way of appearing further along than we are.

The same applies to the editor's deeper features (Milestone 4), chapter editing (Milestone 5) and publishing (Milestone 6). Each is an activity the workflow already names, and draws once its plugin exists.

Metadata editing is here, ahead of its milestone, because it cost almost nothing once the field model existed: the forms are generated from the catalogue, so every shipped field and every field a plugin invents is editable without an interface being written for it.

Decisions on the record

  • Plugins run inside the application, on pluggy. An earlier design ran each in a process of its own, behind a gate that asked the user to grant what it touched. It was replaced: the isolation it promised could not be delivered — a plugin that may edit your audio and reach the network has, in practice, your permissions — and the cost was a protocol between the window and every feature in it. What replaced it says the truth instead: a plugin shares this process, it declares what it does as a claim rather than a permission, and the Plugins screen says so in full.
  • A show is a folder with one database file, so it can be moved and copied.
  • The model is data. iTunes tags, Podcasting 2.0 tags and plugin-invented fields are rows in one table, so adding one needs no release.
  • The workflow is the centre, and the Prompt in the header is how everything is reached.
  • PySide6 rather than PyQt6 — Qt under the LGPL rather than the GPL, which is the kinder licence for anything a community might later want to reuse.
  • Completion is derived, never stored. Asking the data is slower than reading a flag and always true; a flag can lie after a file is deleted or a show is copied.
  • uses is a claim, not a permission. A plugin says what it does — the network, your files, your audio, a model, other programs — from a fixed vocabulary, and nothing enforces it, because nothing can: a plugin is Python running as you. It is for reading a plugin before trusting it. Saying so plainly, on the screen where the user decides, is part of the design.
  • Previous technical choices may be reused; no code is. This branch shares no history with the earlier implementation.
  • The tutorial is executed, not proof-read. The script for the plugin screencast is a working document rather than part of this site, and the test suite pulls it apart, assembles the plugin it dictates and runs it. A script that would waste a recording session fails on the machine where the recording is prepared.