Plugins & clients

The deck is the server. These are the things that talk to it.

Anything speaking the ListenBrainz Core API already works with a URL and a token. A plugin exists where that isn't enough — where a player knows something the wire format has no field for: the output device, the real signal path, the file that was actually decoded.

Every status below is honest. Some of it works today, plenty of it does not yet, and the page says which is which.

Shipped Player plugin

fooyin-tapeout

by abalajiksh

A native Tapedeck plugin for fooyin, so the player reports what the ListenBrainz wire format has no field for. Pairs with a code rather than a pasted token, obeys the deck's own scrobble threshold instead of guessing at one, and can preview exactly what a listen would resolve to before it counts. Early but working — listens, skips, now-playing and an offline queue that survives a restart have all been exercised against a real fooyin 0.12.6 and a live Tapedeck, on one configuration: Fedora 44 (Sway), x86-64.

What it adds: Measured audio quality, the output device, real skips, loves from your ratings, the MusicBrainz work, release-group, release-track and album-artist ids a generic scrobbler drops — and the words and cover art your own files already carry

Navidrome plugin

by a contributor

A plugin on the Navidrome side, rather than Tapedeck polling it from outside. Navidrome is already supported as a polled source today; this is the tighter integration.

What it adds: Push instead of poll, and metadata the Subsonic surface doesn't expose

Coming soon Player plugin

SONE

TIDAL player for Linux

Scrobbling support for the SONE TIDAL client on Linux. Not started — listed because it is next in the queue rather than because there is code to look at.

What it adds: TIDAL playback with its real delivery format attached

In development Analysis

Audio analysis plugin

Plex · Jellyfin · OpenSubsonic

Computes multidimensional features from the actual audio files, next to your library, and hands the coordinates back to the deck. This is what replaces the Every Noise placeholder behind the Genre Map and Playlist Lab.

What it adds: Per-recording sound coordinates instead of per-artist ones

In development Sonic sidecar

AudioMuse-AI

by NeptuneHub

A separate application that points at your media server and works out how each recording sounds, using learned audio embeddings — the one thing Tapedeck cannot derive from its own data, because it never hears the audio. Tapedeck can connect to it, test it, and measure how much of your history it could ever cover. Nothing reads the vectors yet.

What it adds: Per-recording sound coordinates from learned embeddings, where the first-party plugin takes the pure-DSP route

Tapehead

first-party

The Android, Fire TV and iOS client: browse the history and the shelf on the phone, scan a record onto the shelf by its barcode, and put the words for whatever is on the deck up on the TV. Kotlin Multiplatform with Compose, Android first. Foundations only so far — the build and a Tapedeck API client generated from the deck's own OpenAPI document exist; there is no app to install yet.

What it adds: Later, a scrobbler that reads AudioDeviceInfo — USB DAC vs Bluetooth vs speaker — straight onto the chain ladder's device rung

Pano Scrobbler

kawaiiDango

The primary ingest client and the inspiration for a good deal of this. Add a custom ListenBrainz server, paste a token, and it covers Walkman, Android and desktop Linux via MPRIS.

What it adds: Nothing to install on the Tapedeck side — it already speaks the API

Web Scrobbler · multi-scrobbler · mpdscribble

third-party

All work today over the ListenBrainz-compatible endpoints. Issue one token per app and give each a default chain; attribution then costs the client no configuration at all.

What it adds: Browser, aggregator and MPD listening, chained by token

Shipped Site integration

Hugo now-playing shortcode

ships in the repo

Drop it in your static site and it renders whatever is on your deck, fetched from the reader's browser against the one opt-in public endpoint. Degrades to nothing when the server is down or the deck is empty.

What it adds: A live badge on your own site with none of your credentials in it

Writing one? A plugin is any client that submits to /1/submit-listens with Tapedeck's extended fields — tapedeck_audio, tapedeck_device, tapedeck_chain. The whole shape is in the API docs, and every running instance serves its own spec at /api/openapi.yaml.

In development

Analysis that reads the music, not just the metadata.

The Genre Map and Playlist Lab today are built on Every Noise at Once, which places artists. That is a real map and a useful one, but it means every track by one artist shares the same six sound coordinates — the four listening axes are all that separate them. Tapedeck has always said so rather than dressing it up as per-recording audio analysis.

They are a placeholder. The replacement is an analysis plugin that computes multidimensional features from the actual audio files, reaching them through the library you already run — Plex, Jellyfin and the OpenSubsonic API. The server keeps the coordinates; the plugin does the decoding, near the files, where the bandwidth already is.

When it lands, a track gets its own position rather than inheriting its artist's, and "similar" stops meaning "by someone adjacent".

Where the coordinates come from

Today Six axes from Every Noise, through the artist. Four from your own listening — era, familiarity, hour of day, recency.

Next Per-recording features computed from the file itself, via a plugin sitting beside your Plex, Jellyfin or OpenSubsonic library.

Tracks with no place on the map are dropped and counted, never parked in the middle. That rule survives the change.

One server of record, many ways in.

Tapehead, on Android, Fire TV and iOS, is a client for your deck. The desktop and Apple TV apps are planned as both a client and a standalone instance in their own right. Several instances can share users and secrets and merge — but the self-hosted server stays the ultimate source of truth. Anything else is a cache with a nice screen on it.

Planned

macOS

A client for your deck, or a standalone instance on that machine. Same UI, same data model.

Planned

Windows

As above — the desktop apps share one core rather than each reimplementing the screens.

Planned

Apple TV

For the room the hi-fi is actually in. Reading the deck, the shelf and the reports on a screen across the room.

In development

Android

Tapehead: history, stats and the shelf on the phone, with a record added by scanning its barcode — and, later, scrobbling with the output device attached. Foundations only so far.

Planned

Fire TV

Tapehead again, as its own TV app: what is on the deck and its lyrics, across the room. Pairs with a code, so nobody types a password with a remote.

Planned

iOS

A Tapehead companion for the history and the shelf, from the same Kotlin Multiplatform code as the Android app.

In development

Docker

A container image for the server, for hosts the Linux packages do not cover — and for anyone who would rather run a container than a service.

On the roadmap

In rough order of how close each one is.

In development Docker deployment A published container image. The Linux packages already spare openSUSE, Fedora, Debian, Ubuntu and Arch a Rust toolchain; this is for everywhere else.

In development Audio analysis plugin Multidimensional features from real files, via Plex, Jellyfin and the OpenSubsonic API — replacing the Every Noise placeholder behind the Genre Map and Playlist Lab.

In development Player plugins fooyin (Tapeout) works today on Fedora and wants reports from other platforms, a Navidrome plugin is under way, SONE for TIDAL on Linux is queued.

In development Tapehead, the Android app The build and a generated API client exist; next are sign-in, the history, stats and loves, then the shelf and barcode scanning, then Fire TV, then a scrobbler contributing the one thing only Android can: which output device the audio actually left through. iOS follows as a companion.

Planned Desktop and Apple TV apps macOS, Windows and Apple TV — each usable as a client or as a standalone instance, with users and secrets shared between instances and the self-hosted server as the source of truth.

Planned Federating outward Actors, WebFinger, outbox and a signature-verifying inbox already serve. Sending is what remains, and identity has to be right before anyone caches a copy of it.

Planned Spotify as a source OAuth and a recently-played backfill. Its history endpoint reports when a track ended, so the duration has to be subtracted on read.

Planned Network streamers One discovery layer over SSDP/UPnP AVTransport, OpenHome, Google Cast and vendor APIs — so a streamer works because open protocols are supported, not because someone wrote a driver for that exact box.

Building something that should talk to a deck?

The API is documented by the binary that serves it, and the extended fields are stable. To get listed here, add a folder to this site's plugin registry and open a pull request — no site code to touch.

List your plugin Codeberg API docs