Changelog

All notable changes to Quill Radio are documented in this file.

The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.

Quill Radio runs the same radio code as QUILL from the shared quill package, so features and fixes land in both at once; this repository carries only the wrapper, installer, icon, and docs.

[Unreleased]

Testing rebuild: 3.2.0 (build 3). The packages have not been published yet.

• QUILL Lineups (Playback > Lineups…, Ctrl+U). A Lineup is a named list of anything Quill Radio and QUILL Cast can play: stations, saved places, podcasts and episodes, YouTube videos, playlists and channels, Local Media files and recordings, in an order you choose. Add things by hand with Add to Lineup… from Browse Stations, your favorites, Search Stations and Local Media (Ctrl+Shift+U), or give a Lineup rules: what to look for, where, which ones, in what order and how many, and, for every rule, how long its items stay (while they match, until finished, for some days, until finished or some days, or always). Your hands outrank the rules: Keep This Item (Ctrl+K) holds an item, Delete puts it in Removed Items and no rule brings it back, and moving changes the order but never how long it stays. Why Is This Here (Alt+Enter) names the rule or your hand and the time left; Recently Left records what the rules let go and why, and Bring Back returns anything. Play This Lineup (Ctrl+Alt+P) plays mixed kinds straight through, says what it skips and when it ends, and tells you how to move on from a live station. Seven ready-made examples, Import and Export Rules, and Start Here (Ctrl+Alt+H) to open Quill Radio in a Lineup. Lineups are shared with QUILL Cast through one file both apps can edit at once, and Cast hands Radio anything it cannot play itself. Rules read only what is on your computer and run while the Lineups window is open. New user guide chapter (Chapter 17, QUILL Lineups), PRD section 23, and the tutorial Build a lineup that fills itself.
• Saved places in Favorites survive a restart. A genre, country or other browse place saved to Favorites disappeared the next time Quill Radio started, because a place has no stream address and the favorites file refused anything without one. Saved places now come back, and remember which source they came from.
• Runs on Python 3.14, and older runtimes are cleaned up. The shared QuillVille runtime this build installs is Python 3.14. The installer then removes older runtimes (Python 3.13) that no installed QuillVille app uses any more; one that an app or a shortcut still points to is left alone. Portable copies carry their own Python and change nothing outside their folder.
• Record Key in Show and Hide Key. The key box has a Record Key… button (Alt+R): press the combination you want and it is written into the box for you. Typing it still works, and is the way for a key another program has already taken, which never reaches the window.

Carried over from build 2:

• Recordings opens or restores its existing window. This build includes the minimized-window fix described under 3.2.0 below: Record > Recordings… and Ctrl+Shift+R bring an already-open, minimized list back instead of silently leaving it in the taskbar. Native Windows regression tests now exercise the shared opener with empty and populated recordings folders, including restoration without creating a second window.
• Routine history saves run in the background. Preferences, station website corrections, favorites and related settings use detached snapshots on one ordered writer. Pending changes are coalesced, storage failures are reported, and shutdown records whether the final save was confirmed within its bounded wait instead of silently claiming success.
• Startup checks avoid an unnecessary settings write. Starting the existing background update check no longer synchronously writes the bookkeeping timestamp while the main window opens.
• HTTPS uses the Windows certificate store. Shared podcast requests and other Python HTTPS clients recognize trusted Windows and organization-managed roots while keeping hostname and certificate verification enabled. Invalid certificates still fail; podcast diagnostic reports include verification details without exposing feed credentials. Portable packaging also checks that the declared certificate-store backend and required Windows dependencies are included.
• Start Quill Radio with Windows is also in Preferences. The Preferences checkbox and Station-menu item use the same per-user startup entry and stay in sync. Preferences reports if Windows prevents a requested change. Portable copies leave Windows startup settings alone.
• Add or correct a station website locally. The Website button asks before adding a missing address; choosing Add Website with Don’t ask me again checked also disables the question in QUILL. Edit Website… is available on station rows in Browse Stations and Manage Favorite Stations. HTTP(S) addresses are checked for valid format without contacting the site; an empty edit removes the local correction and falls back to the station’s directory address.
• The installer is current-user only. It no longer offers an all-users install that requires administrator approval; the app and shared runtime go in your Windows profile.
• Internet Archive searches put the best matches first. A listener looked for the Yours Truly, Johnny Dollar half-hour series that Old Time Radio Researchers uploaded on 1 October 2026 and found only older releases: Find on an Internet Archive folder, and the libraries part of Search, took the first 40 results in alphabetical order of the Archive’s item names, and the new uploads start with “YTJD”. They now ask the Archive for its own relevance order; browsing a folder keeps its stable order so paging still works (quill/core/radio/internet_archive.py).
• Ctrl+Alt+Shift+R is Quill Radio’s alone, and four Radio keys work beside the other apps. QUILL’s Keymap Editor, QUILL Lite’s Keyboard Manager, QUILL Cast’s Restore from a Backup and Audio Studio’s Resume Last Book on Launch sat on Radio’s system-wide show and hide key and have moved. Quill Weather, Inkwell, the Media Player and Converter no longer take a show and hide key by default, so Restore from Backup (Ctrl+Alt+Shift+W), Recording Settings (Ctrl+Alt+Shift+I), Recent Problems (Ctrl+Alt+Shift+P) and Choose Columns (Ctrl+Alt+Shift+C) fire while those apps run (quill/core/family_chords.py).
• CBC podcasts work again, and every request says who is asking honestly. Quill Radio, QUILL Cast and QUILL now send one shared User-Agent, <app>/<version> (+https://www.quillforall.org) – for this app, Quill Radio/<version> – and podcast requests add that they come from a podcast app: Quill Radio/<version> (podcast app; +https://www.quillforall.org). CBC’s servers stall the bare crawler shape the old one had, so every CBC podcast timed out (quill/core/http_client.py).
• Podcasts you have just imported do not arrive as hundreds of new episodes. The first time Quill Radio’s podcast check reads a show it has no episodes for, it takes that as a starting point and says nothing is new; the episodes are still saved. Podcast failures are written in plain words, a web page or an empty feed is no longer read as a podcast, and an OPML file’s empty folders are kept on import (shared podcast code; see QUILL Cast’s changelog for the full list).

[3.2.0] - 2026-10-03

Everything 3.1 was going to be, and the two things that stopped an update from arriving. Check for Updates now reads the version this computer actually installed instead of the version the shared runtime happens to carry, so it stops offering an update you already have; and Install and restart survives the launcher closing, so a one-click update installs instead of quietly doing nothing. It was prepared as 3.1.1 and never published under that number, so it ships as 3.2.0 (see below). Five new things, and fourteen fixes. Quill Radio checks your subscribed podcasts on its own and tells you what arrived, in the way each podcast asks for; there is a list of everything you have been told; you can leave yourself a note on any station or podcast; and Ask QUILL Radio answers questions about what is playing, on the ChatGPT plan you already pay for; and a Website button beside Play and Stop opens the station’s own site. Then: the sound card switches, or says why it cannot and puts the setting back; Windows Media gets a route to a device of its own; Preferences names only the engines this copy has; a minimized window comes back when its menu item or key asks for it; a stale “start with Windows” entry is repaired by the installer rather than waiting for a launch; Preferences opens in a blink instead of two seconds; and four smaller things that came in the same week. Also in 3.2.0: Apple’s podcast categories fill up and the Podcast Index says why when it cannot; browsing long lists stays smooth; Preferences has Find a setting; Undo History lists the last ten things you can take back; and a few choices can be shared with your other Quill apps.

• Local Media: your own music, audiobooks and video, in playlists (Station > Local Media…, Ctrl+O). A peer window (Window menu, Ctrl+Tab) with your playlists and their items, and a second Browse Stations branch right under Favorites. Add Media Files (Ctrl+O), Add a Folder (Ctrl+Alt+O, recursive, in natural order, and the playlist follows the folder for new files), New Playlist, and Import or Export M3U/M3U8/PLS. With nothing added yet the window opens on a sentence and the Add Media Files button. Enter plays from an item and carries on; the playing row says playing or paused, and a file that moved says missing, with Locate and Remove Missing Items. Shuffle (Ctrl+H) is one stable order until Shuffle Again (Ctrl+Shift+H), repeat (Ctrl+R) is off, all or one, and Play Next, Add to Up Next, Stop After This Item and Continue Where I Left Off come with it. Next and previous are Ctrl+Right and Ctrl+Left in the window, and the chapter keys (Ctrl+Shift+. and Ctrl+Shift+,) in every window; Where Am I adds the place in the playlist. Alt+Shift+Up, Down, Home and End move items and say where they landed; Ctrl+X then Ctrl+V (or Ctrl+Alt+V) moves them further; Insert and Shift+Insert add files before or after an item; Delete removes from the playlist, never from the disk; Ctrl+Z undoes; Sort Playlist sorts once. Every verb is on the Applications key. Playlists are kept as paths and tags in a versioned radio-local-media.json, and nothing is sent anywhere (quill/core/radio/local_media*.py, quill/core/radio/browse_local_media.py, quill/ui/radio/local_media_*.py).

• Play files from File Explorer, and make Quill Radio your media player. Julie asked whether she could pick a song on her external drive and choose Quill Radio to play it, as you would choose VLC. The installer now registers Quill Radio in Open with for music, audiobooks, video and playlists (MP3, M4A, M4B, AAC, Ogg, Opus, FLAC, WAV, WMA, AIFF, MKA, MP4, MKV, WebM, MOV, M3U, M3U8, PLS), and in Settings > Apps > Default apps, without ever taking a type over; uninstalling removes every key. Preferences > Windows and your files > Make Quill Radio My Media Player… (also in the Command Palette) registers a portable copy for your account and opens Windows’ Default apps page for Quill Radio, where you choose – the same shared command, words and registration as the editors’ Make QUILL My Text Editor. quill-radio <file> ... plays the files; when Quill Radio is already running they go to that copy through its single-instance queue and play without pulling the window in front. Several files at once (Explorer starts the app once per file) become one Opened files list in Local Media that plays from the first, so Next and Previous work; the next files opened replace it unless Save as Playlist… (Ctrl+S in the Local Media window, or on its Browse menu) keeps it. What is playing is said once; a missing or unplayable file is one plain sentence. A folder plays like Add a Folder, and an M3U or PLS is imported into Local Media once and played. Two right-click verbs on every supported type: Play with Quill Radio and Add to Quill Radio Playlist. (quill/core/windows_media.py, quill/core/windows_installer_lines.py, quill/core/radio/opened_files.py, quill/ui/radio/opened_files_ui.py, quill/ui/radio/media_player_registration.py, standalone/radio/installer/quill-radio.iss.)

• Release channels, safe ways back (2026-10-03). Coming back to Stable goes straight back when Stable can read everything you have saved; otherwise wait for Stable or put back the copy saved when you joined. Beta and Dev download updates in the background (never installing without asking; held on metered connections, in Quiet Hours and while recording), get their own copy of the shared engine (about 335 MB), and an update that does not start undoes itself and says so. Updates come from a signed list, with downloads checked against it and resumed.

• Choose Stable, Beta or Dev (Help > Release Channel…, no key, and a Preferences button). One shared window for every channel app: the choices only explain as you arrow, Beta and Dev ask first in plain words and need “I understand” checked, and a copy of your favorites, history and settings (a .qrbackup, no recordings) is saved before anything moves. Quill Radio shares the QuillVille engine with QUILL Lite and QUILL Cast, so for now they join Beta together. Coming back never installs an older version: Quill Radio waits for Stable to catch up and says so. Check for Updates honours the channel, picks the newest by version rather than by GitHub’s list order, and reads 100 releases a page. Update History is one button away (quill/core/updater/, quill/ui/updates/).

• Activity (Help, Shift+F9) and Repeat Last Result (F9). Everything the radio told you this session, newest first, each with its next actions – Retry, Open Folder, Copy Details – and one key that says the newest result that mattered again. A settings file that could not be saved is said once, with the reason, and offers Retry and Open Folder in Activity; a later save that works is said too (quill/core/activity.py, quill/ui/activity_window.py, quill/core/persistence_outcome.py).

• Check for Updates knows which version you installed. A listener reported that Check for Updates kept offering an update after that update was installed. Every QuillVille installer ships the shared QuillVille Runtime, and the runtime carries one frozen copy of every app’s code and every app’s version number – so the version Quill Radio reported was whichever runtime was newest on the computer rather than the Quill Radio the installer put there, and the comparison against the published release was against the wrong number. It can be wrong in both directions: an update offered again and again when you already have it, or “you are up to date” when you are not. Now the installer writes the version it installed into the app’s own folder (quill-app-version.ini, beside QuillRadio.exe), Quill Radio looks for it there rather than in the shared runtime’s folder, and Check for Updates and Help > About read it; About names the runtime’s code version beside it only when the two differ, which is exactly what support needs to see. A portable copy carries its own code, so there its own number is the truth (quill/core/app_version.py, standalone/radio/installer/quill-radio.iss).

• Install and restart installs. Choosing Install and restart closed Quill Radio and then nothing happened at all – no installer, no error, and no log to look in. The QuillVille launcher runs the app inside a Windows Job Object that kills everything left in it when the launcher exits, and the small update helper the app starts was inside that job: the helper waits for the app and the launcher to close before it runs the installer, and Windows killed it mid-wait. The helper is now started outside the job (CREATE_BREAKAWAY_FROM_JOB, and through Windows’ own process service when a launcher already installed forbids breakaway), the new launcher permits breakaway, and the folder the helper logs to is created before it writes there. A refusal is reported instead of swallowed, so the app stays open and Open folder still works (quill/core/self_update.py, quill/native/launcher/launcher.c).

• This one update is by hand, once. A copy of 3.0.4 or earlier still runs the old helper, and that helper is what this release replaces – so Install and restart cannot install 3.2.0 from 3.0.4. Download Quill-Radio-Setup-Shared-3.2.0.exe and run it, or unpack the portable zip over your copy, this once. Every update after this one installs itself.

• Backups say what they hold, and name anything they leave out. A listener about to reset two computers, with recordings and backups in a OneDrive folder, heard that some items were skipped and nothing about which. That was Export My Setup, which is shared with QUILL Cast and counted the Cast stores a Radio-only computer has never made as “skipped”; nothing was lost, but nothing said so. Now every backup, restore, Export My Setup and Import My Setup that leaves anything out says how many and offers Show what was left out, and why? – one row per item with its reason (stored only in OneDrive, in use by another program, a path too long for Windows, could not be read) and what to do – and a backup also writes the list to Recent Problems. Back Up Stations and Settings (Ctrl+Shift+U) now carries everything a Radio listener builds: the podcasts you follow and where you are in each episode, notes, tags, bookmarks, Go To, reminders, recording settings and more, where it used to carry only favorites, settings, the wake-up timer, the recording schedule and tags. If your favorites, settings or podcasts cannot be read the backup fails and says why, rather than saving one without them, and the finished file is read back before success is announced. Recordings come from the folder Recording Settings names – the backup used to look in the default Music folder whatever you had chosen – and a recording stored only in OneDrive is downloaded as it is copied, with progress, unless there is not room for it. Backups in the recordings folder are not copied into the next one, and a restore leaves a recording that is already there alone (quill/core/radio/backup.py, quill/core/radio/backup_recordings.py, quill/core/skipped_files.py, quill/ui/radio/skipped_items_dialog.py).

• Portable copies start from a folder whose name has a space in it. A portable copy unpacked to a folder such as C:\portable\Quill Radio said it did not start, with “can’t open file …pythonw.exe”. The QuillVille launcher passed its own path to Python unquoted, so Python read it as two words. The same mistake split a file opened from File Explorer out of a folder with a space in its name, which Play with Quill Radio depends on. Every 3.0 release had it (quill/native/launcher/cmdline.c, quill/native/launcher/launcher.c).

• Why 3.2.0, straight from 3.0.4. This release was prepared as 3.1.1 (and before that 3.1.0) and never published under either number, so there was never a public 3.1 and the next published version is 3.2.0. It also settles the old muddle: Quill Radio’s number sat at 3.1.0 in the shared source for four days while QUILL Lite 1.1 was released, so the runtime Lite installed carries a Quill Radio that calls itself 3.1.0; 3.2.0 is above anything a runtime can already claim, so every copy is offered it (scripts/check_sibling_versions.py fails a release build that would repeat this).

• A Website button beside Play and Stop. A listener asked for a way to reach Double Tap Live’s schedule. The main window now has Website (We&bsite, Alt+B) right after the Play/Stop button in Tab order. It opens the website of the station that is playing, or of the selected favorite when nothing is playing, in your browser, and says which site it opened; a station that gave no website is said so (“Mystery FM did not give a website.”) rather than opening anything (quill/ui/radio/station_website_button.py, tests/unit/ui/radio/test_station_website_button.py).

• Ask QUILL Radio (Community menu, Ctrl+Shift+8): a conversation that knows what is playing, on your own ChatGPT plan. The radio’s own assistant, and the first AI in Quill Radio. It runs on the ChatGPT subscription you already pay for – Use My ChatGPT Subscription (Alt+F5) opens your browser on OpenAI’s own sign-in page, you allow “QUILL Radio” to use your plan, and you come back signed in; no key, no per-question bill, and nothing through QUILL’s servers – and it knows one thing ChatGPT on the web does not: the station and the title the stream is announcing go with every message (it works from that text alone: it never listens to the stream, records or transcribes). “What is this song, and who made it?”, “tell me about this station”, “what was the news story they just mentioned” need no names typed, and Ask About What’s Playing asks for you. A Quick questions list offers nine prepared questions: six about what is playing, and three that attach something you keep – your favorites, the songs logged on this station, or the stations you have played recently – each saying exactly what and how many before you press Enter, so nothing about you leaves the computer unless you choose it. It is a peer window on the Window menu with the transport keys live, replies are read aloud as they arrive, and the model is your plan’s own list. Allow web search is off until you check it. Only a refresh token is kept, in the credential store under Quill Radio’s own name; Sign Out (two presses) revokes it at OpenAI and forgets it here, Forget on This Computer forgets it here only, and neither button exists until you are signed in. Deliberately absent: QUILL’s free AI service and an API-key route – it is your plan, or nothing, and the window says so. Off in Safe Mode (quill/core/ai/chatgpt_account.py, quill/ui/radio/ask_radio_window.py, quill/ui/radio/ask_radio_wiring.py).

• The portable copy has the Windows Media engine too. A stick copy of an early 3.1 build offered only “Windows Media (classic)” in Preferences and could not change the sound card, though an installed copy could: the modern engine’s Windows components (the pywinrt wheels) were frozen into the shared runtime the installer ships and were never listed for the portable build. The portable now carries them, so Audio > Output Device, the now-playing card and the modern engine behave the same way in both downloads (standalone/studio/scripts/build_portable.py).

• Double Tap Live, in Browse Stations. Double Tap – the daily show where blind people talk tech, from Steven Scott and Shaun Preece at Accessible Media Inc. – launched a 24-hour radio channel on 30 September 2026: talk, tech, music and the best of the podcast, around the clock. It is its own branch directly under ACB Media, one station, listed with no network call and playing from the station’s own Radio.co stream; What’s Playing reads what the stream announces, and it can be favorited, recorded and scheduled like any station (quill/core/radio/double_tap.py).

• The sound card switches, live, or says why it cannot and gives the setting back. A listener reported that choosing a device in Audio > Output Device did not move the sound. libmpv switches devices at runtime and on reload (probed on a real machine with two cards, watching mpv’s own audio-output log), and Quill Radio handed it the device before every load – so the sound stayed put in exactly one case: the mpv engine could not open the chosen device (a Bluetooth or USB headset asleep, a device another program holds, an id Windows changed), the load failed, and the station was quietly rescued on Windows Media, which plays on the device Windows gives the app. Nothing was said, nothing was logged, and the setting kept naming a device that was not in use. Now: a playing mpv station switches device live, with no reconnect and no gap; a load that fails with a device chosen is retried once, still on mpv, on the device in use before the choice, the listener hears which device could not be opened and what the setting is now, and the setting itself goes back (“… could not be opened, so the output device is back to System default”); a saved device that will not open at start-up is given back the same way; and a rescue that lands on Windows Media with a device chosen is said out loud instead of hidden. Every decision is logged (quill/ui/radio/output_device_guard.py; the mpv client now reports a refused property instead of swallowing it).

• Windows Media plays to the sound card you choose. Quill Radio’s Windows Media engine is Windows’ modern media player (Windows.Media.Playback.MediaPlayer, quill/ui/audio/winrt_engine.py), and it takes a device, so Audio > Output Device moves the sound whichever engine you are on – live, with no reconnect. A device that will not open is named and the setting goes back rather than pointing at something you cannot hear. The engine choice itself is left alone: an earlier draft of this release switched the engine to Automatic to get around the old limitation, and it does not – the engine is yours. On a machine without the modern player Quill Radio falls back to the classic wx.media control, which has no device API at all; there, and only there, choosing a device says so in one sentence and opens Windows’ own Sound settings, where under Volume mixer every app has its own output device and the choice sticks across restarts – no question first. This is the answer QUILL Cast already gives (quill/ui/media/output_device.py), now shared with the radio.

• Preferences offers only the playback engines this copy has. With mpv present the rows are Automatic (recommended, uses mpv), Windows Media and mpv; without it there is no mpv row and Automatic reads “Automatic (uses Windows Media; mpv is not installed)”, and a saved mpv preference lands on Automatic, which is what it resolves to. The Windows Media row reads “Windows Media (classic)” only on a machine without the modern player, so the name says which one this copy has. A row for an engine that is not installed was a choice that did nothing (quill/core/radio/playback_engine_choices.py).

• Ctrl+T says the title every time. What’s Playing said station, title and artist the first time and only the station after that, though Copy still copied all three (reported by John). Each press was closing the Now Playing window and opening a fresh one, and a screen reader reads a brand-new window once; a replacement with the same title and the same focused field got the title bar and nothing else. A second press now refreshes the window that is open, brings it forward and speaks the text (quill/ui/radio/now_playing_dialog.py, now_playing_commands.py).

• Enter in Preferences presses OK. After changing a dropdown, such as the playback engine, Enter did nothing: the dropdown kept the key instead of handing it to the default button. Enter now presses OK from anywhere in the dialog except a button, which is its own answer, and a multi-line box, where it is a new line (quill/ui/app_preferences_dialog.py, shared by every app’s Preferences).

• Delete on a source branch hides the source. On a top-level branch such as Podcasts, Delete used to explain that there was nothing to delete and point at Hide This Source on the context menu, although in earlier versions the key itself hid the source. It does again, through the same function the menu uses, so the two cannot disagree; Reset Sources to Default is the way back and the announcement names it (quill/ui/radio/browse_delete.py).

• Quill Radio checks your subscribed podcasts and tells you what arrived. Set how often in Preferences, or on one podcast in its own settings – Manually only through Once a day, and both Quill Radio and QUILL Cast read the one setting now, so turning it on in either turns it on. (They used to read two, which meant setting it in one app did nothing in the other; a cadence you had already chosen in Radio is carried over once.) Per podcast, Check this feed for new episodes can say Manually only while the rest keep their cadence, and Refresh on a row always asks whatever it says. Nothing subscribed, or everything set to never, and no check happens at all – no thread, no request (quill/core/podcasts/episode_alerts.py).

• What happens when something arrives is yours to set, globally or per podcast. Notify me shows a desktop notification and plays a short new sound. Quietly adds it to Notifications and says nothing at all – which is what makes a daily show bearable, because nine new episodes is something you want to be able to find rather than something you want announced nine times. Not at all records nothing. Quiet is the default: an app that starts putting notifications over what you are reading has made a decision that was yours. Quiet hours hold back the notification and the sound and deliberately not the list entry – being quiet about something is not the same as never having been told.

• Notifications… (Ctrl+Alt+Shift+F3, Help menu): everything the apps have told you. A desktop notification is a good way to be told something and a terrible way to remember it – it appears over what you were reading, leaves on its own schedule, and if your screen reader was mid-sentence it may never have been read at all. So the notification is not the record; this list is. One line per item, newest first, unread marked with the word “New” rather than a colour or a bullet so it survives being read aloud. Enter opens what it was about. It is a shared list, so a notification Quill Radio raised is one QUILL Cast can show you (quill/core/notifications.py, quill/ui/notification_center.py).

• A note to yourself on any station or podcast. Note to Self… on any row, beside Set a Reminder. Whatever you write is read back in the details pane the next time you arrow onto that row – which is the point: a note you have to open a window to see is a note you have to remember you wrote. “The morning show is the good one.” “Only worth it on Sundays.” Emptying the box removes the note, and it is kept against the station’s address rather than its name, so it survives a rename or a catalogue refresh (quill/core/radio/item_notes.py).

• Find a station by what is known about it: the team it carries, and your own tags. Listeners asked to store what they know about a station – which team it carries – and find it that way. Edit Station Tags… on every live station’s row menu (Browse and Search rows, Search Stations results, the main window’s favorites and the Favorites Manager) and, for the station on air, Edit Tags for the Playing Station in the Command Palette: one labelled box for your tags, comma separated, with the directory’s tags shown read-only below it. A favorite keeps its tags in the favorites file, so they ride along in backups and Export My Setup; any other station’s tags go in radio-station-tags.json, which both carry too. Your tags appear in Station Details and the details box beside the directory’s. Quill Radio also ships a hand-checked list of English-language radio flagships for MLB, NFL, NBA, WNBA, NHL and MLS teams (quill/data/sports_flagships.json, a public source recorded for every team; teams that only stream or could not be confirmed are left out). Search Stations, Search All Sources and the Favorites filter now match station names, directory tags, your tags, and the flagship list’s team names, aliases, leagues and sports, so Tigers, Detroit baseball and MLB all find WXYT, and a row found that way says why (“carries the Detroit Tigers”, “has your tag Red Wings”). The list holds call signs, never stream addresses: a match is turned into a playable row from the local station catalog first, and from Radio Browser’s ordinary name search only when the catalog has nothing, a few times per search at most (quill/core/radio/station_tags.py, sports_flagships.py, station_lookup.py, quill/ui/radio/station_tags_dialog.py, station_lookup_lane.py).

• Windows can say what Quill Radio is playing. The now-playing card on the volume flyout and the lock screen – one per app, and Quill Radio’s was blank – now carries the station with the song underneath. The screen reader reads that flyout when it opens, so the machine can answer “what is playing?” rather than only the app knowing. It claims none of the media keys: those are already the app’s through RegisterHotKey, which works from the tray and without focus, so every SMTC button flag is switched off deliberately and a test asserts they stay off. It also says nothing out loud – the reader reads the card, and saying it again is the over-announcing GATE-13 exists to stop. Live radio additionally asks Media Foundation for latency over smoothness (real_time_playback), and a transport control the engine says cannot work is now disabled rather than enabled-and-silent (quill/ui/audio/now_playing.py).

• Preferences opens at once instead of after two seconds. Reported: “why is it taking two seconds or longer to bring up preferences?” The output-device list behind that window asked Windows for every device on the computer and then picked the sound cards out in Python – on the reporter’s machine, 4,048 devices in 2.4 seconds, to find 2. pywinrt will not take DeviceInformation.find_all_async’s overloads positionally (both spellings raise “Invalid parameter count”), which is why the first version swept everything; it names its overloads instead, and find_all_async_device_class returns the real sound cards in 8 milliseconds. The family list ran that sweep twice and hit its own five-second timeout, so the device list could also come back empty. The machine-wide sweep is kept as the fallback for a runtime without the named overload – slow, never broken (quill/ui/audio/winrt_engine.py).

• Running from a source checkout finds the mpv it already has. Reported: “why is mpv not working when running the run-quill-radio script from the d:\quill folder? I only see automatic and windows media.” The engine list was right – this release offers no row for an engine this copy does not have – but the search for libmpv looked at every shipped location (the QUILL_LIBMPV override, an Offline Edition’s tools\mpv, the runtime folder, the downloaded engine pack) and never at the repository’s own build\deps\mpv, which is exactly where the installer scripts stage it. A source run now looks there too, and a frozen build never does – a shipped app must load only what was shipped with it (quill/ui/audio/mpv_engine.py).

• A “start with Windows” entry an older build wrote is repaired by the installer. A listener who had set Quill Radio to start with Windows met PyInstaller’s “Unhandled exception in script” box at every login instead of the radio – “Failed to execute script ‘runtime_launcher’… ‘NoneType’ object has no attribute ‘write’” (reported 2026-09-29). Builds between the shared-runtime move and 3.0.1 wrote the entry as the bare QuillVilleRuntime.exe, which is the engine rather than an app; run with no module it printed an explanation, and a windowed process has no console to print to, so writing it was the crash. 3.0.2 fixed both halves – the runtime’s streams, and a bare launch starting the installed app – and Quill Radio has repaired the entry at every launch since. That repair needed a launch, which is the one thing the broken entry prevented: nothing told the listener that opening the radio by hand would cure their login. The installer now repairs the entry as it stages the new build, before the next login, and names this copy’s own QuillRadio.exe so the entry survives the next runtime upgrade. An app you never asked to start with Windows stays absent, a portable copy is left alone, and a locked-down registry costs the repair and not the install (quill/core/runtime_cli.py, installer/shared-runtime.iss).

• A minimized window comes back when its menu item or key asks for it. A listener reported that the recordings list was out of reach: Record > Recordings… and Ctrl+Shift+R did nothing, though the folder itself was fine. Since 3.0 every big surface – Recordings, Browse Stations, Search Stations, Favorites, the player – is a window of its own, and every opener asks the WindowManager to raise one that is already open rather than build a second copy. activate() called Show() then Raise(), and on Windows neither restores an iconized frame: a window minimized from the taskbar, Windows+M or Windows+D counted as open and stayed minimized, the opener returned None, and the command went silent with nothing said. activate() now restores an iconized frame first, for every peer window, then brings it forward with focus on the control it was left on (WindowManager.activate in quill/ui/window_menu.py).

• A portable copy’s Yes to “copy my favorites” now copies them. A 3.0.0 portable that had been opened once had a favorites file with nothing in it, and the import skipped every file the bundle already had – so the question was asked, answered Yes, remembered as done, and nothing arrived. A favorites file with no favorites is replaced; everything else the bundle has is still left alone (quill/core/radio/portable_migration.py).

• Apple’s podcast categories fill up, and the Podcast Index says why when it cannot (2026-10-03). A category or subcategory under Podcasts (Apple) now lists Apple’s own top shows for that category, up to 200. It used to filter the storefront’s overall chart by category, which left History with four shows and most subcategories with none; History and Comedy Fiction are full lists now (quill/core/podcasts/apple_genre_charts.py). A Podcast Index folder that cannot load now says why instead of “Nothing in here”. With no Podcast Index key, the branch shows one row, Add a Podcast Index Key…, which opens the Podcast Index Credentials window; a free key comes from api.podcastindex.org/signup, and a key entered in Quill Radio or QUILL Cast works in both. A key the service rejects is reported as not accepted, not as “could not be reached” (quill/core/radio/browse_failure.py, browse_podcast_index.py, quill/core/podcasts/podcast_index.py).

• Smoother browsing in long lists. Arrowing through a long list such as Top Podcasts no longer loads every show you pass. Quill Radio waits until you stop on one, so the list stays responsive with a screen reader, and a big folder fills in one go (quill/ui/radio/browse_prefetch.py).

• Find a setting in Preferences. A box at the top of Preferences: type a word, press Down to reach the matching settings, and Enter goes to one. Ctrl+F returns to the box, and searching never changes or saves a setting. It is the same box QUILL Cast and QUILL Lite have (quill/ui/preferences_search.py).

• Undo History (Edit menu, Ctrl+Alt+Shift+A). The last ten things you can take back, newest first, each with Undo This One, so a mistake from three steps ago can be undone without losing what came after. Ctrl+Z still takes back the newest, and the one before when pressed again. QUILL Cast has the same list (quill/core/undo_last.py, quill/ui/undo_history_dialog.py).

• Share these choices with my other Quill apps. A Preferences checkbox, off until you turn it on. With it on here and in another Quill app, Announce dialog transitions stays the same in both, and Quill Radio says when it picks up a choice from another app. Nothing about keys, focus or the screen reader is shared (quill/core/family_preferences.py, quill/ui/family_sharing.py).

• Each app keeps its own ChatGPT sign-in. Signing in to QUILL Cast, QUILL Lite or QUILL no longer overwrites Quill Radio’s sign-in, and signing out of one leaves the others signed in. Use My ChatGPT Subscription (Alt+F5) says when another app on this computer is already signed in, so signing in here is one Allow in the browser (quill/core/ai/chatgpt_state.py).

• Recordings and exports are kept in Activity. A recording that finished or failed, and a file you exported, is a row in Activity with Open Folder, so F9 can say it again and the file is one key away.

• Search YouTube for videos, playlists and channels (Station > Search YouTube…, Ctrl+Shift+6). Asked for by a listener. Search Stations only ever found YouTube videos (yt-dlp’s ytsearch); this asks YouTube’s own results page once per type with the type filter its Filters menu applies (sp=EgIQAQ%3D%3D videos, EgIQAw%3D%3D playlists, EgIQAg%3D%3D channels), flatly and at the same time, and answers in Browse Stations’ Search Results branch. Every row says what it is first – “video, 12 minutes, Rick Steves”, “playlist, Rick Steves”, “channel, 1.2 million subscribers” – and the count is said once. A video plays, a playlist opens into its videos, and a channel opens into Uploads, Live (live now first, then past broadcasts) and its playlists. Also the first row under YouTube in Browse Stations, and on the Command Palette. YouTube’s results page carries no video count for most playlists, so a playlist row names one only when YouTube does (quill/core/radio/youtube_search.py, quill/ui/radio/youtube_search_ui.py).

• Read Comments for a YouTube video (Video > Read Comments…, Ctrl+Shift+7, and on every YouTube video row). A peer window: one row per comment, “author: first line … (likes, when)”, replies right after the comment they answer and saying whose it was, the selected comment in full in a read-only box, Search comments filtering as you type with the count said once after a pause, Top comments or Newest first, Load More a hundred at a time up to a thousand (yt-dlp walks a thread from the start, so each page asks again with a higher max_comments), and Copy Comment. Escape closes it and focus goes back where it was; a failure is one sentence and a Recent Problems entry (quill/core/radio/youtube_comments.py, quill/ui/radio/youtube_comments_window.py).

• Follow a channel in Quill Radio, or subscribe on YouTube. Every channel row – search results, My YouTube, the ones you follow – offers Follow This Channel in Quill Radio (the existing local list, no account) or Stop Following This Channel, and Subscribe on YouTube…, which says what will happen and opens the channel’s own ?sub_confirmation=1 page in the browser, where YouTube asks you to confirm. Quill never calls YouTube’s subscribe endpoints itself; that page is also where YouTube’s own bell lives.

• Notify Me About New Videos, on a followed channel. Quill’s own bell, mirroring Notify Me About This Podcast: off for every channel until you turn it on, checked on the podcast schedule (the same timer, the same launch check, one channel at a time, a flat listing of the five newest uploads), the first look a baseline rather than news, and each new upload one Notifications entry, “New on :