Skip to content

What it looks like

The interface is deliberately plain. It borrows GNOME's shape — a header bar, a sidebar, boxed lists, no menu bar — because that shape is familiar, quiet, and well understood by the people who will contribute to this project.

A clickable prototype of every screen was agreed before any of this was written. The screens below are the result.

The header bar

There is no title bar. It said the name of the application above a header that says where you are, which is a row of pixels spent on something the task switcher already knows. The window draws its own frame instead: minimise, maximise and close sit at the right end of the header, dragging the bar moves the window and a double-click on it maximises, a press at any edge resizes, and the status strip carries a grip in its corner for the hand that wants something to pull — six dots in the line colour, the quietest ink the theme has, pinned to the corner itself and brightening under the pointer, rather than the diagonal scratches Qt's own grip draws in ink no theme chose. The move and the resize are handed to the window manager rather than followed by hand, which is what keeps snapping, tiling and the shadow under the window working; where a platform refuses to take the drag, the bar moves the window itself, so there is never no way to move it.

How wide the window is, is yours. It opens at 1100 by 720 or at whatever the screen has room for, whichever is smaller — a window born wider than the screen puts one of its edges out of reach, and this one has no title bar to drag it back by. After that nothing inside it may push it wider: what does not fit is cut to the room it has, with an ellipsis where the rest went. The status line, a page title and a podcast's name in the sidebar each used to ask for room for every word, so opening a podcast with a long name, or a plugin saying something long in the status line, grew the window past the edge of the screen and left it there.

The corners are cut round, twelve pixels, which is what the desktop cuts its own windows by. A frameless window is a bare rectangle, and a bare rectangle among rounded ones reads as a window whose decorations have gone missing. The cut is an erasure over the whole window rather than a shape painted behind it: anything at all can be in a corner — the header, the status strip, a plugin's panel in the open drawer — and rubbing out whatever is there asks nothing of any of them. It was a mask, which is one bit per pixel: in or out, so the curve came out as a staircase, and on a screen at 1.25x or 1.5x a staircase is what you saw. The wedges are rubbed out with an antialiased brush instead, so a pixel the curve half covers keeps half its alpha, which is the whole of what makes a curve look like one. A maximised window is square again; there is no desktop in its corner for the cut to show.

Minimise, maximise and close are three circles, as they are in GNOME's own windows.

A browser's shape, because it is the one every reader of this screen already knows. On the left, the ways through the work: the sidebar toggle, the workflow strip's toggle beside it, back, forward, home, and the pages you have been on. In the middle, where you are. On the right, what belongs to the application rather than to any podcast: the bookmarks, the Settings cog, and the hamburger. The middle is the Prompt, which is both of the first two things at once.

The hamburger is back. It was taken away once, and the two things that lived only on it — About, and editing the workflow — went with it. They are commands now, so the menu is built from what the window can do rather than being the only way to reach any of it, and it holds what has no button of its own: editing the workflow, the Log, About, and Quit. Nothing that has a button elsewhere is repeated in it; a thing in two places is two things to keep in step.

Forward is new. Going back used to be a one-way trip, so a step opened by mistake cost the way back to where you had been. It is spent once used, and going somewhere new abandons it — the pages ahead of you are the ones you walked back through, as in every browser.

Where you are is a trail, beside the back button rather than centred, each part clickable, with the subtitle under it. A trail says where you are and what you are inside, and the back button is the other half of that question; centred text could only ever say the last part.

The trail is the whole path down to the page: the podcast, the step of the podcast's workflow you are in, the episode when that step is its episodes, and the step inside the episode —

Ondes Courtes › Episodes › Episode 4 › Transcribe

A step of the podcast's own ends the trail where it sits, because it is not inside an episode: Ondes Courtes › Describe the show, even with an episode open.

What it is not is the walk. It used to be added to on every step opened, so a morning's work read Ondes › Episode 4 › Import audio › Chapters › Metadata: five crumbs in a hierarchy two deep, wider than the bar, and saying nothing about where the page sat.

The walk is the history, under the button beside Back, and each row there is the whole trail as it read at the time — Ondes Courtes › Episodes › Episode 4 › Import audio, not Import audio. One row per place, the most recent of each: working on an episode means going between its steps and its form a dozen times, and the older of two identical rows goes nowhere the newer one does not. The list itself is kept whole underneath, because the back button walks the way you actually came.

Where you have been is the history, in a menu under the button beside Back, most recent first. Each entry is the trail as it read at the time — Ondes Courtes › Episodes › Episode 4 › Import audio — because "Metadata" six times over is a list of six identical rows, and which podcast and which episode is what tells them apart. Choosing one goes there and drops what came after it, so the back button keeps walking backwards rather than into a list of places already left.

Buttons are disabled rather than hidden when they do not apply: one that comes and goes moves the ones beside it, and the title with them.

The sidebar

The podcasts, and nothing else. Episodes are not in the sidebar: a show can have hundreds, and the Prompt finds one faster than a tree ever will. Neither are Tasks, the Log and whatever is wrong: those are tabs on the drawer along the bottom of the window, whose handle is on screen whatever you are doing — an entry here would be the same button twice, two corners apart. Settings is not here either — it is the cog in the header, where a browser keeps it, and Plugins is a section of it. Bookmarks have gone to the top corner, for the same reason a browser puts them there: down here they competed for height with the podcasts themselves, and a short window showed four of them and no podcasts at all.

There is one sidebar, not two. A page that brings a list of its own puts it here while it is open — Settings does, with its sections — and the podcasts come back when you leave.

A podcast is drawn with its own cover, square and small, at the head of its row — which is what a podcast is recognised by, and what the home page and the Prompt have always shown. One without a cover yet, and anything else in the sidebar, carries a mark instead: a list for the library, a microphone for a podcast. The mark is painted in the row's own ink rather than set as an icon, so the row you are on draws it in the colour of its highlight and a show whose folder has gone draws it faint; a cover is a picture and is drawn as it is. It is read at the size it is drawn at rather than loaded whole and shrunk, because a cover is a three-thousand-pixel JPEG and this is fifteen pixels of it.

Bookmarks

They live under the ribbon in the top corner, in a list: the name, with the episode it points into and the moment inside it in its tooltip, and a button under them that removes the one you have picked. A list rather than a menu, because a bookmark is all three of those things and a menu row can only ever be the first — and because removing one needs somewhere to put the control. It is filled when it is opened, so it says what the show says now.

A bookmark can be an episode or a moment inside one. "Pickup to re-record" points at a position in the audio, not merely at a file. It is named by hand, and what the dialog offers to start with is where you were: "Ondes Courtes / Episode 3 / Import audio" — the podcast, the episode by its number, and the step. An episode's title on its own said neither which podcast the bookmark belonged to nor what you were doing when you made it, which is what a list of a dozen of them needs to say.

Home

The page Podlibre opens on, and what the house button goes back to. A browser's home page, in the shape that works for one: the mark, the one or two things worth doing, the podcasts you were last in as a wall of cards, and a line of advice taken at random from four. The field above it is empty, so what it shows is its own invitation — Type a command, or ask…

A card is what there is to know about one podcast, three to a row and fewer in a narrow window:

  • its cover, because a picture is how somebody recognises the thing they keep coming back to, cropped square from the middle and taken in at the corners;
  • its name, and the description it carries in its own metadata, cut to two lines;
  • how many episodes it has and which was the last of them;
  • a mark for every step of that episode's workflow that something can serve, in order, across the foot of the card: the step's own icon in the colour of the state it is in — green for done, the accent for what can be started now, faint for what cannot start yet. Which step a mark stands for, and how it is going, is on its tooltip. The steps nothing installed can do are left off: the strip draws them because it is a map of the work, and a card is a glance at one podcast.

Pressing a mark opens that step — that podcast, or that episode, at the work the mark stands for. The marks say where the work has got to, so the thing to do with one is the work it stands for, and reading a row of them and then hunting for the step in the strip was two jobs for one thought. A card built without the launcher has no step to open and draws them as a picture.

It was the first seven marks, a +4, and a line reading Next: with a step named under it. Seven of the eleven the workflow had then is a card that makes you open the podcast to find out what is left, and the state's own glyph drawn eleven times says how far the work has got and nothing about what the work is. The marks run under the cover and the words rather than beside them, because that is where there is room for all of them.

A home page that lists names tells you what you already knew, which is which podcasts are yours. This one says what has happened in each of them since you were last there.

A podcast with no cover yet gets Podlibre's own mark in grey: a stand-in says there is no picture here where a gap says something went wrong, and the mark in its own pink would read as a podcast belonging to Podlibre.

What a card says is read from the show file rather than from the library, which knows only names and paths. The reading is a read-only glance that migrates nothing — a page that listed six podcasts must not rewrite six show files as a side effect of drawing itself — and the steps, which need more than a glance, are worked out only for a show already at this build's version. An older one shows everything but its steps until something opens it properly.

The episodes under them

A podcast is where the work lives; an episode is where it is done, so the page offers both. Under the podcasts are the episodes worked on most recently, across the whole library, newest first: the podcast's cover, the episode's title, which podcast it belongs to, and the same row of marks a podcast's card carries — for that episode rather than for the podcast's latest. Pressing one opens the podcast at that episode, not at whichever step of whichever episode came first.

It is the one list neither the sidebar nor a podcast's own page can give, because each of those knows about one podcast at a time, and the thing somebody wants at nine in the morning is usually the episode they had open at six last night. Each show file is opened once however many of its episodes are on the page.

Before there is anything in the library the cards are simply absent, and what is left is GNOME's status page: a mark, a sentence, and somewhere to start. One page either way, rather than a welcome screen that is replaced by a library screen the moment it has served its purpose.

Across the top, in one band as wide as the cards below it: the mark, the name with which build this is beside it, the project's own baseline — the same sentence the About window carries, rather than a line written for this screen alone. Neither making a podcast nor importing one is here: both are steps of the application's own workflow, on the strip above the page, with every other step of every other workflow. It was a column down the middle — a logo, four centred sentences and a button stacked above the podcasts, with two thirds of the window empty either side and the cards pushed under the fold. Sideways it says the same things in a quarter of the height.

Under it, a band of its own, is what the project has to say about this build — "not production ready, use it for testing, come and write a plugin" at the time of writing. That message is read from the repository, not written into the application: a build somebody installed in March should stop saying what was true in March. The copy that ships is what a first run with no network draws, the last one fetched is drawn the instant the page opens, and the repository is asked once per launch on a thread of its own. Nothing is sent but the request. Nothing is said to the user when it fails, because there is nothing they could do about it.

The web addresses in it are links, opened in the reader's own browser. They are found in the text and made into links here rather than written as markup in the file: those words arrive over a network, and nothing that arrives over a network gets to decide how a label is drawn — or to write a link that says one address and goes to another. What a link in the notice says is where it goes, always. The box itself is quiet, a note at the top of a page: a yellow border and a warning sign made "come and write a plugin" look like an error somebody had to do something about.

Under the cards are Settings, Plugins and Documentation. Settings is behind the cog and Plugins is a section inside Settings, so what is plugged in was three clicks from the page you land on — and on a build where the missing piece is a transcriber, that page is exactly where you are standing when you go looking for one. They are down here rather than beside Create a new show: the band at the top is what to do with a podcast, and these three are about Podlibre. The manual has a button of its own rather than a link inside the notice: a link in the notice is one you have to read the notice to find, and the notice is written in the repository and can say anything, so the way to the documentation would come and go with the message.

At the foot of the page is one tip, taken at random, in a box of its own with a bulb beside it. As a grey line under a grey line it was read by nobody: the two quietest things on the page were the only two that had something to say. The box is as wide as the wall of cards above it, not the narrow column the sentences at the top are set in: under three cards a short box read as one that had failed to fill. With no cards there is no wall, and it keeps the column.

A podcast's card also carries a plus, which starts an episode in it: the thing somebody comes to a podcast to do, and it used to be behind opening the podcast first. An episode's card has no plus — an episode has no episodes of its own.

Each card has a pin and a cross in its corner, which appear under the pointer. The cross takes that podcast off the page — off the page, not out of the library: the sidebar still has it, the folder is untouched, and opening it puts it back, because asking for a thing is the clearest statement there is that it belongs here. The pin keeps it on the page and first in the order, however much else is opened; a pinned card keeps its pin showing, because being able to see which things are pinned is the whole point of pinning them. The same two buttons are on an episode's card and mean the same things.

What is remembered — what was opened when, what is pinned, what has been taken off — is kept in Podlibre's own settings rather than in a show file: it is about this person's window, and copying a podcast folder to another machine should not carry somebody else's home page with it.

The cards are asked for when the page is opened, so a podcast made two screens ago is on it when you come back — and what is on them counts as well as which podcasts they are, so describing a show or finishing a step redraws its card. An episode made or opened counts too, although neither touches the library: a new episode is the one thing somebody will certainly come looking for here, and it used to appear only the next time Podlibre was started. The page scrolls, because a library is as long as it is and a window is whatever size it was dragged to; the mark at the top of it used to be the first thing a short window clipped.

First run

Create a podcast, open one that is already on this machine, or import one you already publish. All three are steps of the application's own workflow, on the strip above the page rather than buttons inside it: the home page is not in a podcast, so the level the strip has to show there is the one above every podcast. A podcaster with an existing feed is working inside a minute, which is the whole argument for the bundled RSS import — and switching that plugin off takes its step off the strip rather than leaving a control that cannot do anything.

An import that stopped is finished from the same page. A back catalogue is gigabytes, so stopping one is ordinary: the import page says how many episodes of the open podcast have no audio yet and offers to fetch the rest. It names the podcast, because the page is reached from the home page and is about whichever podcast is open rather than anything on screen there.

Opening one is pointing at its folder, because a show is a folder — copied from another machine, restored from a backup, or taken off the home page. Nothing is imported: the library is a list of where podcasts are and nothing else.

Making a podcast and importing one each had a primary button in the band as well, which made them the two things on the screen offered twice. One place for every step of every workflow is worth more than a second route to some of them.

A show, and an episode

Two levels, and the difference matters because everything else follows from it.

A show has files and episodes. Its folder, its own metadata — title, author, description, the feed it came from — and the episodes in it. The show's own page is what it holds, where it lives on disk, and the way into each episode. Making a new episode belongs here, because an episode belongs to a show — and it is made on the spot, numbered, with nothing asked. The title is the last thing a podcaster decides, usually after there is a recording to name, so a dialog demanding one first stands between the user and the work with nothing to offer. It is an ordinary field afterwards, edited in the form or by the rename command.

A show has a workflow of its own as well: describe the podcast, work through its episodes, publish it. The strip above shows its phases wherever you are in the show, and the workflow page shows the three steps with their state, exactly as it does for an episode.

Opening either one opens the first step of its workflow, not the list of its steps: a podcast opens on describing it, an episode on bringing its audio in. The list is a map, and a map is what you consult, not where you stand — the strip's tab and the breadcrumb both go to it.

An episode has fields and a workflow. Its own metadata as rows in the model, and the sequence of work to be done on it.

Podlibre was briefly built without the first of these — a library of shows, and an episode's workflow, and nothing in between — so opening a show had nowhere to land and dropped the user into whichever episode came first. That is not what opening a show means, and the shape of the data says so plainly.

The workflow is the episode's home

An episode's work is grouped into phases — Prepare, Transcribe, Edit and Enrich — with each step's state beside it. Publishing is not among them: one feed covers every episode and the folder the files go in is a field on the show, so it belongs to the podcast — and laying the episodes out as files is part of publishing rather than a step before it, so one click does both. What an episode's own work ends with is its metadata. A podcaster with six episodes recorded wants six files, not six visits to six pages. Finished steps stay visible, and so do the steps no installed plugin can serve: they are drawn faded, each saying which plugin it is waiting for. What is installed, and what can be switched on, is the Plugins screen's business, and clicking such a step offers to take you there.

Every step, wherever it is drawn, says which of six states it is in with a mark before its name. A mark as well as a colour, because colour alone does not say done to every reader — and the colour is in the mark and nowhere else: a strip of coloured grounds reads as a row of warnings, so what varies between steps is the smallest thing on the row rather than the largest.

State Colour Mark When
Waiting faint grey an empty ring something it needs does not exist yet
Ready purple a play triangle it can be started
Started pink a pencil its page is open in front of you, and it is not finished
Ongoing red a turning arrow a task is running for it right now
Done green a check the data says so, or you said so
Needs a plugin darker grey a plug nothing installed, nor the shell, serves it

The red is the one a studio puts on the door, not the one an error is written in: the step is busy, not broken. Started is the only state Podlibre cannot read from the show file — the file knows what is finished and what is running, and only the window knows what you have open — so a step that runs itself is never Started: nobody is filling it in.

Above the page, a strip shows every step, a chip each, in the shape a browser gives its bookmark bar: a mark and a name, one line of them, always there and never in the way. It is the whole of the work readable without leaving the page you are on, and clicking a step goes to it. The phases are the headings between the runs of steps rather than chips of their own — they group, they are not somewhere to go. A chip for a phase meant one click for whichever step in here can be opened, which is a guess made on the user's behalf that the steps themselves make unnecessary.

The step you have open is ringed in the accent colour and its name set in full-strength bold, while its mark goes on saying how the work is going — so where I am and how this is going stay two signals rather than one fighting the other. A step nothing can serve yet says so in the status line rather than going quiet, and opens a box naming the plugin it is waiting for, with two buttons: Close, which leaves you where you were, and Plugins, which is where that can be put right. The chip's tooltip says the same thing and adds what a click will do; the box does not, because a dialog that tells you to click is one you have clicked.

The strip has no scrollbar. More steps than fit is the ordinary case — the shipped workflow has sixteen — and a bar under the chips drew a line the width of the window across the header, with a handle nearly that wide, heavier than the steps above it. It is moved by the wheel instead, whichever way the wheel turns, and it brings the step you open into view by itself, so the step you are on is on screen however you got to it.

An arrow at each end, for the mouse that has no wheel — and because nothing else on the strip says it can be scrolled at all. Each sits at the end it moves towards, the one pointing back before the first step, and each is there only while there is something that way to reach: at the left-hand end of the row there is no going back, so there is no arrow back. Each moves by exactly one step, leaving that step flush against the edge: a strip that begins with half a word reads as a strip that is broken, and a windowful at a time left a different name cut off at each end on every press. The far end is the exception, where what is flush is the row's own right-hand edge.

An arrow that goes keeps its place while the strip still scrolls. Giving the space back widens the row, which lowers how far the row can be scrolled, which drags it back from the end it has just reached — press on at the last step and the strip would come to rest short of it, every time. The space reads as the margin the strip would want anyway; a row that shifts under the pointer does not. Both leave for good when the whole workflow fits.

The strip is shown and hidden by a button in the header beside the sidebar's, because it is the same kind of control: furniture of the window rather than anything to do with the podcast on screen. Both are checkable, both are pressed while the thing they show is there, and both remember how they were left. Ctrl+Shift+B does it from the keyboard, beside the sidebar's Ctrl+B. The strip used to carry a handle of its own, hanging from the header's lower edge with a + or a − on it: it said nothing about what it would fold, and it disagreed with itself, because the strip also hides itself whenever it has no steps and the handle was never told.

The strip shows both levels of a podcast at once: the podcast's steps, then the open episode's after them, with a double rule between —

✓ Describe the show | (✓ Episodes) | ▸ Publish locally ‖ ✎ Import audio | ✓ Metadata

Making a podcast is working through its episodes, so one level at a time was always half the picture: inside an episode there was nothing on screen about the podcast it belonged to. The step the episode hangs off — Episodes — is drawn in brackets, because it is not a step you are in so much as the way you came. The join is two hairlines the height of the row, with air around them: it was a » set half again as large as the names around it, which is a lot of ink for a join — and the tallest thing on the strip, so the strip was as tall as the punctuation. Two rules rather than one because one is a divider like any other, and this is the one place the row stops being about the same thing. The home page is the exception and shows one level, the application's own workflow: make a podcast, open one, import one. There the workflow menu is absent, because the application's workflow is builtin and the same for everybody.

Going back to one of the podcast's steps closes the open episode, and its steps come off the strip with it. Those steps are one click away from inside an episode, and clicking one used to leave the episode open underneath: the strip went on carrying its steps under the step you had gone back to, which is the strip saying you are in two places at once. The strip is not titled. It said WORKFLOW before the first step, which is a word spent on what the row of steps under it plainly is, on the side the eye starts from.

At the far end of the strip is the workflow's own menu: it says which workflow this podcast is being made with — Full, Quick, one a plugin brought, one you made — and opens on Edit this workflow followed by every other workflow there is to use instead, the one in use ticked. It was a pencil that opened the editor and nothing else, so which workflow was in use was written nowhere on the screen and changing it meant going to the editor to find out there was a choice. It belongs to the workflow rather than to the header, where it would have nothing to act on, and it sits away from the steps because it is the one control there that does not take you to one of them. It is drawn like the steps are, for the same reason: a bordered box in a row of chips reads as the one thing on the strip that is not part of the workflow. A workflow every step of which needs a plugin nobody has is not in that menu at all: it would draw as an empty strip and go nowhere.

There was an arrow on the strip as well, the way out of the level you were on. It has gone with the second level being drawn: what it went up to is now on screen as the steps themselves, and clicking one of them is the way back that it was there to be.

The steps nothing can serve are drawn, and that has been round the houses. They were drawn greyed, on the argument that a workflow hiding what you cannot do is no longer a map of the work; they were taken off, because a row of controls that do nothing — five of eight on a fresh install — teaches a first-time podcaster that most of this application is broken; and they are drawn again, because a strip that shows three steps of eight is not the shape of making a podcast, and hookspecs promised they would be there.

What was missing the first time was everything around them. Each is dimmed rather than greyed into the background, each says which plugin it is waiting for and whether that plugin is switched off or absent, and clicking one opens a box that says so with Plugins to go to. None of them counts towards the progress under the strip: a step nobody can serve is not work outstanding.

One editor, not four

Four workflow steps — edit the audio, insert music, correct the transcript, mark the chapters — open the same screen with a different pane in focus. Tracks and their waveforms on top, chapters on the same timeline, the transcript below as a document.

The transcript behaves like a word processor, not a table of rows. The caret follows playback and playback follows the caret. Every edit in this screen can be made from the keyboard:

Key Does
Ctrl Space play / pause
Tab jump to the next correction suggestion
Alt S change the speaker of this turn
Ctrl ↵ chapter at the playhead
Ctrl ⇧ S split the clip at the playhead
F2 rename the chapter

Editing metadata

A show's fields and an episode's fields are forms, reached from the workflow — Show metadata and Metadata are steps like any other, served by Podlibre itself.

The forms are generated from the field catalogue, not written out by hand: the catalogue already knows each field's target, type, permitted values and owner, so a hand-built form would be a second list of the same thing — and the one that goes stale, because a plugin can add a field at runtime. A plugin that declares a field therefore gets an editor for it, grouped under its own name, without writing any interface at all.

Fields are grouped — the standard (iTunes) fields first because they are what every directory reads, then Podcasting 2.0, then each plugin's own. Each type gets the control that suits it: a line, a paragraph, a number, a date, a list, a choice, a switch, a file to browse for.

An episode's length is read, not typed. It is a fact about the audio, written by whatever imported or mixed it, so it is drawn as a value with no box around it — 1:02:03, or Taken from the audio while there is no audio yet. A box to type it into is an invitation to a number that contradicts the file, and the feed would then carry the typing rather than the recording.

An image field draws the image, under the path and the Browse button, with its real size in the tooltip. A path is the one kind of value you cannot check by reading it: the wrong file, or the right one scaled to 300 pixels, looks exactly like the right one written down — and the size is what a directory refusing the cover will have looked at.

Every file picker has a way back out. Browse can only ever put a path in, so beside it is a button that takes one out again, off until there is something to take. It empties the field and nothing else: the file stays where it is, because a form that deleted somebody's artwork because they picked the wrong one is a form nobody would dare use. The same holds on the plugins' pages that choose files rather than fill in a field — Import audio will take the recording off the episode again (and delete the copy it made in the episode's folder, after asking, leaving the recording it was copied from alone), and Publish to a folder will forget the folder you chose and go back to publishing inside the podcast's own.

A field no podcast directory will accept a feed without — the show's title, description, language, artwork, categories and explicit mark, and an episode's title — is marked with a red asterisk, labelled Required for anyone who does not see the colour. It is a mark, not a gate: a half-filled show is a normal state to be in while the work is going on, and a form that refuses to be left is worse than a feed one directory complains about. Which fields they are is read from the vocabulary this build ships rather than from the show file, so a podcast made last year is held to this year's rules.

There is no Save button. A value is saved as you leave the field, because the workflow's completion is derived from the values: a step ticks itself the moment its field has something in it, and a Save button would put a second, losable step between typing and that happening.

The workflow editor

Which workflow this show uses, and what is in it. Two lists — the steps in use, in order, and the steps available to add — and the order is drag-and-drop, because the order is the workflow.

Since a plugin appears as the steps it declares, adding a step adds a plugin to the way you work and removing one takes it out without uninstalling anything. Neither a shipped workflow nor one a plugin offers can be deleted; saving changes to either makes a copy of your own, so the originals are always there to go back to.

Settings

What Podlibre itself looks like, what language it speaks, and what is plugged into it: a list of sections down the left and a pane beside it, the way every settings screen on every desktop is built — and the way a browser puts its extensions behind the same list. Appearance and language is four cards and, at the foot, the one button that forgets them; Plugins is a screenful on its own, which is why they are sections rather than one long column.

Resetting every setting is a first run again: the theme, the language, the text size, how large the window is, where Podlibre opens, the home page's order and its pins, the sidebar, which plugins are switched off, and whatever each plugin kept for itself — an address or a key among it. The question names all of that rather than saying "settings", because a plugin's own section is in the same file and nobody expects a key to go with a preference. The library goes with them, so the home page starts empty, as it did on the first run — and removing is not deleting: no folder is opened, let alone written, and a podcast comes back by pointing at its folder again. Everything a reset touches is something Podlibre remembers; the recordings are the work.

It takes effect where you are standing rather than at the next launch — the light theme in English, the sheet drawn again at the default size, the window back to the size a first run opens at and on the home page, the sidebar back and empty, a plugin that was switched off loaded on the spot. A maximised window is let go first and takes its size when the window manager says it has let go: un-maximising is a request, and the geometry that comes back is the window manager's, so a size set before that answer arrives is overruled by it. The question has a third answer for the one thing a running window cannot undo about itself: Reset and quit forgets the lot and leaves without writing down how large the window was, so the next launch is a first run in every way. The three read least to most, left to right — Cancel, Reset, Reset and quit — and Cancel answers both Return and Escape, because none of the other two can be undone. A reset that emptied a file while the window went on drawing what was in it would be the kind of setting people stop trusting.

There is one sidebar. The list of sections is not a second column beside the podcasts: it is drawn in the sidebar while Settings is open, and the podcasts come back when you leave. Two columns of choices down the left of one window is one column too many.

The window builds the page with Plugins in it, and whoever knows the themes on disk adds the appearance pane: that way the cog always opens something.

The cog is the way out as well as the way in. Pressing it while Settings is open goes back to the page you came from — changing a theme and then having to find the episode you were halfway through is the kind of small thing that makes a window feel like somewhere you can be lost. With nowhere to go back to it goes to the home page, because a cog that does nothing on the second press reads as a cog that is broken.

Plugins

One card per plugin found — switched on or off, loaded or not. Each says what it is, who wrote it, its version and date, what steps it provides, what fields it adds, and what it says it does, from a fixed vocabulary: network, files, audio, models, processes.

The whole page scrolls, heading and caveat and all, rather than the cards scrolling inside a frame with those held still above them: a card is a dozen lines tall, and with a third of the screen standing still and the drawer open at the foot, six plugins were read through a letterbox. The caveat is still the first thing on the page, which is when it is read.

A card also says what the plugin waits for, and which plugin provides it. Plugins never import one another, so the only dependency one can have on another is a field its steps require and another declares — and a plugin stuck waiting for one looks broken when it is merely alone. The four audio filters spent a whole milestone saying nothing about why they would not start. Where the plugin that provides it is installed but switched off, the card says that too, because that is the answer rather than a dead end.

Above the list, the thing that matters most: those claims are declared by the plugin, not enforced by Podlibre. A plugin shares this application's process and can do anything you can do. The screen says so in full rather than implying a sandbox that does not exist.

Adding one is a button rather than a folder to find: a zip file or the folder itself, copied into the user's own plugin directory, switched on and loaded on the spot — one that arrived only at the next launch would look like one that had not arrived. Installing a new version of one that is running puts the old one down first, because Python hands back the module it imported the first time: without that, the update would be on disk and the old code would go on running. Two buttons, because a plugin travels as a zip and is written as a folder and no file dialog offers both at once. The id is the folder's name wherever it comes from, so a zip is read for one: the single folder inside it, the archive's own name when the files sit at the root, or the plugin folder inside an archive of a whole repository. Anything that is not a plugin is refused in front of the user and named — a folder with no Python in it, a name Python cannot import, an archive with a path reaching outside its own folder — and a plugin of the same name is replaced only when the user says so, which is how one is updated. Because installing is the gesture that gives a plugin this application's own reach, the card over the buttons says so before they are pressed.

Each card has a switch, and switching one off takes effect immediately: it stops hearing events, its page goes, and its steps read Needs a plugin again. A plugin the user installed also has Uninstall at the foot of its card, which asks first and then deletes its folder and forgets its section of the settings — an enabled: false left behind would switch the same plugin off again the next time it was added, with nothing on screen to say why. A plugin Podlibre ships has no such button: its folder is part of the application, and switching it off is what there is. The card keeps its size either way, so switching one off does not send the rest of the list jumping under the pointer that just clicked. Where two plugins provide the same step, each of their cards names the one currently serving it.

A plugin that will not load is listed here with the file and the reason, rather than disappearing: one that fails is skipped so that Podlibre still starts, which means it fails quietly, and this is the only place to find out. A plugin that gives a homepage gets a link to it.

The Prompt

One field, where a browser keeps its address bar, and it does the same two jobs: it says where you are until you type in it, and what you type is how you get somewhere else. The trail is its text — Ondes Courtes › Episodes ‹ Le son du silence › Metadata — and the star at its right edge bookmarks what it is showing. Ctrl K from anywhere puts the cursor in it; Escape, or clicking away, puts the trail back.

The field is a pill, the shape a browser gives the one that does this job.

The cursor landing in it empties it. What it was saying is where you already are; what is wanted is the next thing, and the placeholder is what offers it — Type a command, or ask…. Nothing is lost by it: the trail comes back the moment the field is left.

The trail used to be a row of buttons, each one a way back up. Back, up and the sidebar are all within reach of the same hand, so the field has one job here instead of two.

Ctrl K from anywhere. It searches three things at once: the features — every action and every page in Podlibre is a command, Home and Settings and the documentation among them — the podcasts in the library by name, and the episodes of the open podcast by title, ranked with recency so yesterday's episode comes before last year's. Typing nothing lists what you were last working on, under the field.

All three are matched the same way: letters in order, anywhere, the way an editor does it, so lsds finds Le son du silence. Each group keeps a share of the list, because a shell with eight commands in it would otherwise push every episode out of sight.

The group that answered best is drawn first, and a group whose letters are merely scattered through it goes when another holds them as they were typed. Both halves of that rule are the same fix for the same fault: typing pieds put the podcast called Les Pieds sur Terre under five commands with p, i, e, d and s somewhere in them, and typing home offered Rename this episode. The scattered matches earn their place when nothing else answers — xprt finds Export locally — and are noise beside a real match. A command can also carry words it is not named by, which is how help finds Documentation and help.

Asking is the other half of the name. Under whatever matched, the last row offers to ask what you typed — and when nothing can answer, that row says what would make it work: install a plugin with a language model. A feature nobody can find is a feature nobody enables, and a field that silently answers nothing is worse than one that says why.

A plugin answers by implementing one hook, podlibre_answer(question). The first plugin to return something wins, because the user asked once; returning nothing is how a plugin says not mine. It runs on a worker thread as a task with its own row in Tasks — a model on this machine takes seconds — and the answer appears under the field, where it was asked. Podlibre ships no model: they arrive with the milestone that funds them.

The Prompt is not a shortcut for experts bolted onto a menu system. It is the primary way to reach anything, and the menus are a second view of the same registry.

Keyboard

Every command the Prompt lists shows its keystroke beside it, which is how people stop needing it for the things they do constantly.

Key Does
Ctrl+K Put the cursor in the Prompt. Ctrl+Shift+P does the same
Ctrl+B Show or hide the sidebar
Ctrl+Shift+B Show or hide the workflow strip
Ctrl+D Bookmark the episode on screen
F11 Full screen
F12 Show or hide the drawer at the foot of the window
Ctrl+Q Quit

Ctrl+P is deliberately not the Prompt: it stays Print, which is what it is everywhere else.

The drawer, and what is in it

What is running, what is wrong, what has been said, and the episode playing are not places you go: they are things you glance at, or listen to, while you are somewhere else. They live in a collapsible panel along the foot of the window, opened and closed without leaving the work and without counting as somewhere you have been — the back button does not walk through it. As full screens they took the work off the screen to show you a list, and coming back was a navigation step.

Four tabs, and no more: Tasks, Errors, the Log and the Player. Settings is not glanced at — it is read and changed — so it is a page of its own, behind the cog.

The Player is where an episode plays: its artwork, its name, play and pause, thirty seconds back and on, the position across the whole episode, the volume and ×1 / ×1.5 / ×2. An episode is several clips and a player plays one file, so they are a queue and the next starts when one ends — the order the exporter writes them in. One bar for the whole episode, drawn from the lengths already in the show file, so nothing is decoded to draw it; when the decoder disagrees with a length, its answer replaces the guess. Opening an episode hands it to the player. Leaving one empties it, because a player going on playing an episode you have left says you are somewhere you are not. A page with a Play button on it — Import audio is the one that ships — hands the episode over rather than playing it itself: there is one player in the window, and two of them playing at once is two recordings at once.

The artwork is the episode's own, or the podcast's. Its own first, because an episode that has a picture has it for a reason; the podcast's when it has none, which is the usual case, since most feeds never fill the episode's.

It is as tall as the drawer, up to 280 pixels, with the name and the controls as one block beside it. At 56 it was a bullet point beside the name, with the title at the top of three hundred pixels of drawer and the controls at the foot of it — which is what a layout looks like when nothing in it was asked to fill the room. The square gives its width up before the window does: a label with a picture in it reports that picture as the smallest it can be, and a cover this size would otherwise be a width the window could not be dragged below.

Its handle is the status line: the words along the bottom, the progress of whatever is running, and a button per tab. Clicking a tab opens the drawer on it; clicking it again shuts it, and so does the cross at the end of the strip, which is there only while there is a drawer to shut. A tab is what opens one — the row of them says what is in there — so the sign that opened whichever was last was a second way in with nothing of its own to say.

The handle rides on top of the drawer when it is open and goes back to the foot of the window when it shuts. A tab belongs above what it opens: with the row left underneath, the eye went down past a page of tasks to find the word Tasks below it. The line the strip carries moves with it — above when it is the floor, below when it is the lid. The grip for resizing the window is on it only while it is the floor, and it is pinned to the corner rather than carried at the end of the row: a corner to pull that is not in the corner is a corner to pull by mistake, and it had been sitting in the middle of the strip with the tabs to the right of it. Carried in the row it was tidy but wrong — the row is twelve pixels in from the window's edge and five up from its foot, which left the dots floating inside the corner rather than sitting in it. The row keeps the width anyway, so the status line never runs under them.

Tasks. Everything slow is listed, with its progress and a Stop button. Each card says when the work started and how long it has been going — Started 14:32:05 · 1:32 so far, and took 1:32 once it is over, because a number that goes on growing after the work has finished is not a duration. The list redraws itself once a second while anything is running: work that reports no progress reports nothing at all, and a clock that only moves when it does is a stopped clock. The handle carries a bar and a percentage for whatever is running — unless the Tasks tab is the one open, because each task carries its own bar there and the same number twice on one screen is what this panel exists to stop. When nothing is left running the line keeps the work's own last word — "3 episodes published to /home/you/podcast" — rather than going back to saying nothing, and the bar goes, because there is nothing left to be a fraction of.

A percentage is only shown when the work is measured. A task that has not said what it is counting gets a bar that sweeps and no number: nothing rather than nought, because a bar reading 0% through work that is half done is the lie this is here to replace. Where the number comes from is the work's own business, and it is worth choosing well — the folder publisher counts milliseconds of audio rather than episodes, because counting episodes left a podcast with one episode at 0% for half a minute and then 100%, and it weighs encoding four times as heavily as reading, which is what they actually cost.

Errors is everything wrong at once, because it is one question — why can I not get on? — and the answer used to be in three places: the fields a feed cannot be published without, the plugins that would not load, and the work that failed. A failed task says what failed and what it means — "The server answered 404. The episode imported without its audio." — not an error code.

Each kind sits under its own heading, and the panel is headed What is wrong rather than Before you publish: only the fields have anything to do with publishing, and a heading about publishing over a plugin that would not load is a lie. The tab says how many — Errors (2) — because a refused publish is the only thing that opens this tab by itself, so a failed task and a plugin that would not load sat in it unseen. The handle is on screen whatever you are doing, which makes a number on it the whole of the telling.

The Log is everything Podlibre has said since it started, oldest first, each line stamped with the time and with what said it. Whoever reports a problem is asked for the log, and there was none to give: the status line says one thing at a time and forgets it, the Errors panel holds what is wrong now rather than what happened, and a windowed build has no terminal behind it to go and read — on Windows there is no console at all.

It opens with the session's own facts, which are the half of a report nobody thinks to ask for: the build and whether it was packaged or run from source, the versions of Python, PySide6 and Qt, the system, the desktop and whether that desktop is Wayland or X11, the language, the theme, and how many podcasts are in the library. What loaded follows a line or two later, as the plugins are loaded — one line per plugin with its version and the steps it serves, one naming anything installed and switched off, and one for anything that would not import. Between them those answer the questions every report used to begin with, including why is this step not on the strip.

After them comes the session: every page opened and the step it was opened at, which podcast and which episode, both ends of every task with how long it took, and every failure with its stack. Work that went well was once worth no line at all, which left a log able to say what had failed and never what was being done when it did; and a failure was kept as its message alone, so the stack — the half a maintainer reads — reached nothing anywhere. Each thing the application announces in the status line is kept with them, and so is anything the libraries underneath log for themselves.

What is not kept is the tally the strip rewrites as work moves — Nothing running, 2 tasks running — because five hundred lines of that is a log with nothing in it.

It is held in memory, not written to a file: it exists to be copied into an issue, and a log nobody can find is a log nobody sends. It also means it goes when Podlibre goes, which is the right trade for a list that holds whatever was typed into a form. The last five hundred lines are kept — long enough that what caused the trouble is still in it, short enough to paste without apology.

A Copy button sits under the Log and under Errors. It puts the panel's contents on the clipboard under three lines saying which build, which Qt and which machine — the half of a bug report that a user would otherwise have to go and find, and usually does not. What Errors copies is built from the data rather than read off the labels, so it is the three groups as they are, not whatever was on screen when the language last changed.

Before you publish

A directory refuses a feed that has no description, no language, no artwork or no category, and the podcaster finds out days later from the submission rather than from Podlibre. So the publishing step is refused while any of those is empty, and the drawer opens on Errors with a list of what is missing under Before you publish: one row per field, named by what it belongs to — "Ondes Courtes · Categories".

It is a panel rather than a window, because the point of it is to go and fill the fields in: a window of its own went behind the main one the moment the file chooser for the artwork opened, and the user came back from picking a cover to a list that had gone. Clicking a row opens the form the field lives in, scrolls to it and puts the cursor in it. A row leaves the list the moment its field has something in it, and when the last one goes the drawer shuts itself and Podlibre goes back to the step it refused. An unticked checkbox is never on the list — explicit is written either way, so asking somebody to fill it in would be asking them to agree with it.

Categories are tags in one field, completed from Apple's own list rather than typed from memory: the names are exact and long, a category spelled any other way matches nothing, and a subcategory is written into the feed nested inside its parent, which is the only shape a directory reads. Typing finds the names, Return makes a tag, backspace in the empty field takes the last one back, and the field stops accepting them at three, which is how many a directory reads. It was three drop-downs side by side, which said it badly: an empty slot looks like a thing that has to be filled in.

A field with a handful of fixed values — a show is episodic or serial, an episode is full, a trailer or a bonus — is a row of radio buttons, with Not set first because every one of them is optional and a form that cannot be put back to empty decides for you. A drop-down hides every option but the chosen one and takes two clicks to change it; with three options there is nothing worth hiding. Beyond four there is: a row wider than the form is worse than the drop-down it replaced, so medium's seven stay in one.

Where Podlibre opens

The home page, which is the page that says what to do next — or where you left off, for somebody who works on one podcast for a week and wants it in front of them. The choice is in Settings, beside the theme and the language, as a pair of buttons of which exactly one is filled in: it is one choice, not two switches, so choosing the other option takes the fill with it.

Whichever is chosen is where a launch lands, however full the library is: it used to land on All shows the moment there was anything in it at all, and the setting only chose whether a podcast was then opened on top of that — so choosing the home page did nothing.

The window opens as large as it was left, and where it was left, which on a second monitor is half the answer missing if only the size comes back. Qt's own record of the geometry is what is kept, because it carries the size, the place, the screen and whether the window was maximised, and nothing shorter puts all four back. A record Qt will not read — a settings file edited by hand — opens the window at the size a first run has rather than refusing to open it.

Where you left off means the podcast or the episode you last opened, and the page you were on inside it. Anything that has gone since — a folder deleted, a drive not plugged in this morning, a page this build no longer has — is a home page, which is where Podlibre opens by default anyway. A podcast named on the command line wins over both: asking for one by name is asking for that one.

Themes and language

One light theme and one dark, the light one unless somebody chooses otherwise; following the desktop's own preference is not written yet. Six languages at launch: English, French, German, Dutch, Italian and Spanish.

Both are remembered, like the text size and where Podlibre opens: chosen on the Settings page, applied on the spot, and drawn the same way at the next launch. --theme and --language on the command line are for one run — they are read ahead of the remembered choice and do not overwrite it.

How large the text is, is a setting: Small, Normal, Large or Larger — nine, ten, twelve or fourteen points. Ten is what the rest of the design is drawn against and too small for some readers, which is reason enough for it not to be a constant. Every size in the stylesheet is a multiple of it, so the headings and the quiet lines grow with the words: a body font that catches up with its own captions is not larger text, it is a page that has lost its order. Four named sizes rather than a number to type, because a size somebody types is a size that can be wrong. It applies as it is chosen and is remembered for the next launch.

A scrollbar is drawn where there is more than fits, in both themes, and it can be seen: it used to be four pixels of the line colour, which on the light theme is near-white on white, so a list of eight plugins looked like a list of two with nothing on screen to say otherwise. The handle is now drawn in the faint text colour, which stands out from the page behind it — there is a test that measures exactly that, on each shipped theme, rather than trusting the stylesheet to say so.

What drops down is drawn here too. The hamburger's menu, the history, the workflow's own list, the one the sidebar offers instead of a button nobody with a keyboard can reach, and the context menu on any text box were all left to Qt, which draws them from the palette the application starts with: the desktop's, and light whatever the theme says. The dark theme put its own pale text on a white box, which is text nobody can read. They are small cards now — the theme's surface, a rounded edge, rows that light up the way a list's rows do. A rounded menu has to stop painting where its border does or the corners fill straight back in, so every menu Podlibre drops is made in one place, which sets the same translucency the window uses for its own corners — and takes the same bargain, since a desktop with nothing to composite with draws them black.

A choice field drops a list rather than a menu. The hundred and ten podcast categories were a column eight hundred pixels tall with a two-pixel arrow at either end to scroll it by; as a list it is a box of ten rows with the scrollbar everything else here uses. The value in force is filled with the accent rather than the soft ground a menu row lights up with: that row is the answer to the question the list was opened to settle, not a note of where the pointer is.

Icons come from three places, in order: the desktop's own icon theme, so Podlibre looks like the rest of a GNOME session and follows whatever the user has chosen; PodcastFont, for the things only podcasting has — the Podcasting 2.0 tags, a chapter, a transcript; and shapes painted by Podlibre for anything the first two do not have, which is the path Windows and macOS take, since neither ships an icon theme. Symbolic icons are tinted to the current text colour, because a theme that changes the background does not recolour them by itself.

One mark comes from neither: Podlibre's own squid, drawn from ico.svg — the logo simplified to a single shape with no colour in it, so it is filled with whatever ink it is asked for and reads at the size an icon is drawn at. It used to be a glyph in PodcastFont, which is somebody else's drawing of this project's own mark.

Every workflow step carries its own glyph on its row, drawn quietly beside its name. They come from PodcastFont rather than from the desktop even where the desktop has something close: a column of steps drawn half in Adwaita and half in PodcastFont is a column in two different hands, and these are podcasting's own concepts anyway. Metadata is the exception, and takes the desktop's: the font's nearest glyph was a product's logo, and putting somebody else's brand on one of our own steps says the step belongs to them. Its tag-* glyphs are the Podcasting 2.0 tags, one pictogram each, so there was no plain label or form to use instead. The font therefore ships with Podlibre rather than being a nicety — a build without it is a workflow with no icons on it at all.

A step that names no glyph of its own — a plugin's, since every step Podlibre ships names one — is drawn with a generic mark rather than a blank, which in a column of marks reads as a step with something wrong with it. The same marks are carried by the two columns of the workflow editor, so that moving a step between them is recognisably the same step.

The same holds for the three marks down the sidebar, and for the same reason it holds a size as well as a hand. A desktop symbolic icon is drawn to fill its box top to bottom, so the desktop's bookmark stood half as tall again as the capitals in the name beside it, in a column whose other marks come from PodcastFont and sit well inside theirs. That one is painted here instead, no taller than the words it belongs to.

Every button carries one too, in the shell and on a plugin's page alike — a button that is only a word has to be read, where one with a mark beside it is recognised. Two kinds are deliberately left as words: the crumbs in the trail, which are a path of names and whose last part is not a button at all, and the option pills in Settings, where the same mark six times over would say nothing about which language is which.

What colour an icon is drawn in is decided in one place rather than by each screen, which is what made them stay in the old theme's ink after it changed. An icon takes the text colour, the accent's own text colour on a primary button — whose ground is the accent, on which the ordinary ink is close to invisible — or whatever colour the caller names for a mark that is there to be recognised rather than read. Every icon is handed a faint version of itself for being switched off, so a button that goes dead greys itself without whoever switched it off having to know; and a theme change walks the window and draws the lot again.