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
Shipped Server plugin

Tapedeck for Navidrome

by princefred

A plugin on the Navidrome side, pushing each user's plays to their own deck rather than Tapedeck polling from outside. One Navidrome can feed several instances — user A to server X, users B and C to server Y. It carries what the plain ListenBrainz path has no field for: the decoded format from Navidrome's own metadata, the client app, a now-playing playhead that honours pause and resume, Navidrome's id for the played file so cover art works, and optionally the lyrics sitting in your files. Built against Navidrome 0.64.2 and Tapedeck's v0.125 API; the deck's half of the path, plugin mode, shipped in v0.125.0.

What it adds: The decoded format, bit depth and lossless verdict, the player app for chain attribution, a playhead that follows pause rather than guessing, and the song id that makes cover art and the library pages work
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 Audio analysis

Vafthrudnir

first-party

A C++ companion that reads your own files and measures how each one sounds — rhythm, key, spectrum, structure, dynamics — then hands the coordinates back to the deck. Pure DSP and no machine learning anywhere in it, so it runs on the kind of hardware Tapedeck itself runs on. This is what replaces the Every Noise placeholder behind the Genre Map and Playlist Lab. There is an architecture and there is no code: the repository is empty and nothing is installable yet.

What it adds: Per-recording sound coordinates instead of per-artist ones — and an AcoustID fingerprint for the 57% of a history that carries no recording MBID
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
In development Mobile

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
Shipped Scrobble client

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
Shipped Scrobble clients

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 Vafthrudnir, a pure-DSP companion that measures rhythm, key, spectrum, structure and dynamics 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 companion 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". There is an architecture for it and no code yet — the repository is empty, and the page says so.

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 Vafthrudnir, the audio analysis companion Rhythm, key, spectrum, structure and dynamics measured from your real files, via Plex, Jellyfin and the OpenSubsonic API — pure DSP, no machine learning — replacing the Every Noise placeholder behind the Genre Map and Playlist Lab. There is an architecture and no code yet.
In development Player and server plugins Tapedeck for Navidrome is released and pushing from inside the server; fooyin (Tapeout) works today on Fedora and wants reports from other platforms; SONE for TIDAL on Linux is queued. The gap left in both is transcode detection — neither yet says whether the file was degraded on the way out.
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 Radio beyond German public broadcasting The nine ARD broadcasters work today, over RadioDNS and the stations' own streams. Commercial and worldwide stations are next. And an off-air feeder — RT+ over FM, DL+ over DAB, from an SDR on the Pi — is the exact source the internet stream currently stands in for; the air log already records which source each line came from.
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.