"No tracking" appears in a lot of app descriptions. In CLAUDIO it isn't a marketing promise but a consequence of the code. This post looks behind the scenes: how a NAS share becomes a row in your library, why the app only ever talks to the servers you pick yourself, and how it puts you back exactly where you left off.
Up front: I build CLAUDIO on my own - and use it myself every day. So this is not a polished case study but notes from the workbench, written by someone who treats privacy as a default, not a selling point.
A source becomes a library row
CLAUDIO plays from wildly different places: local files, iCloud Drive, a NAS over SMB, Jellyfin, Navidrome/Subsonic, WebDAV, SFTP, Audiobookshelf, DLNA and podcast feeds. From the outside that looks like one library. From the inside, every source is its own sealed little world.
Each remote source follows the same trio: a service for the connection (credentials live in the Keychain, never in plain text), a service that reads the directory tree, and a service that keeps the last view as an offline snapshot. Local sources run through their own file-and-bookmark service. None of these layers even knows there is a library or a user interface - each one cares only about its own transport.
To keep the app from drowning in special cases, a thin adapter layer sits between source and library. It boils every source down to exactly two operations: "show the last snapshot right now" (works offline, no network needed) and "scan live now". The library only ever sees those two verbs, never the concrete source behind them. Adding a new source doesn't mean rebuilding half the app - it means plugging in another module while the rest stays put.
The payoff is something you feel every time you open the app, even if you'd never name it: the library is there instantly, from the snapshot, and refreshes in the background afterwards. No empty screen waiting on a slow server. Large libraries now keep scanning even after you leave the app, and CLAUDIO reads SMB shares up to ten times faster than before.
Privacy here is architecture, not marketing
The simplest way to collect no data is to never build the tools for it in the first place. CLAUDIO ships no analytics SDK, no telemetry, no crash reporter quietly logging things "anonymously". That isn't a switch you can flip - there is simply no recipient. Library, playback history and subscriptions live on the device. It has a pleasant side effect, too: every third-party SDK you don't embed is one less black box phoning home on someone else's schedule.
Network traffic happens only where someone set it up themselves: your own Jellyfin server, your own NAS, an RSS feed, the Apple Podcasts search, a connected Last.fm or ListenBrainz account, the lyrics lookup once you turn lyrics on. There is no CLAUDIO server in the middle for anything to pass through, because that server doesn't exist. The App Store label "Data Not Collected" is not a bold claim, just the boring truth about an app with no back door.
Some things now flow back to your own servers. Favorites sync both ways with Navidrome, Jellyfin and Audiobookshelf: a heart on a track, an album or an audiobook lands on the server, and whatever is marked there shows up in the app; on Navidrome, ratings of four stars and up count as favorites. Navidrome and other Subsonic servers count the music you play, once per play, and Jellyfin learns what you listened to. All of that runs over the login you already have on your own server - no CLAUDIO account involved. The favorites sync requires Ultra or Pro+, and reporting plays to the server can be switched off in the settings.
Picking up exactly where you left off
For audiobooks and podcasts one thing matters more than any detail of sound quality: resuming exactly where you stopped. CLAUDIO has exactly one source of truth for "where am I in the track right now". The chapter display, the sleep timer, the synced lyrics, scrubbing, progress saving, the Now Playing screen in the car - they all read the same value. That sounds obvious but isn't: the moment several places keep their own idea of the position, they drift apart and you resume a few seconds off.
That single value resolves in a fixed order: first a live reading straight from the audio engine, then the last valid reading, and only as a fallback the marker where the current segment started. It's that middle step that lets CLAUDIO keep the position even when the output drops abruptly - say, when the ignition goes off in a car before the system has even said so.
And one more design decision that looks like a bug but isn't: when the output drops, CLAUDIO pauses - and does not restart on its own. Plugging headphones back in or reconnecting CarPlay does not start playback automatically. Unexpected audio in a car or in your ears is worse than a silent app waiting for a deliberate tap on play. That's on purpose, not an oversight.
Since version 14 there are also widgets for the Home Screen and Lock Screen and controls in Control Center (with Pro, on iPhone and iPad, not on the Mac). They run in an extension of their own that only reads: whenever the state changes, the app drops a small snapshot into a shared App Group, holding that position, the time it was taken and the playback speed. From that the widget works out the position by itself, so the app only has to write again on a real change, not for every second of progress.
Computing on the device, not in the cloud
Several features in CLAUDIO share one trait: they run on the device, not on someone else's server.
The headphone equalizer tunes itself to over 6,000 models. The curves come from the open AutoEq measurement data and are applied on the device - CLAUDIO doesn't need to know which headphones you own to make them sound right.
The taste profile that feeds Home and Smart Shuffle is built on the device as well, without asking any server. It keeps track of artist, genre and rough era rather than individual tracks, so Home can also suggest albums from your own collection that have never been played. You can view it and reset it.
The lyrics work through a chain of sources: first whatever the file carries itself (embedded lyrics, a .lrc file next to it), then the Jellyfin server, then Subsonic, and only at the very end an online database. In the player they have a view of their own: synced text follows along line by line, text without timestamps is shown as plain text.
And read-along for downloaded audiobooks and podcasts takes the same idea to its conclusion: in the supported languages, transcription runs with a local speech model (Parakeet TDT v3 via CoreML) right on the iPhone, turning the spoken word into scrolling text - word by word or sentence by sentence - without any file ever leaving the device. It has been on the App Store since version 11; if the download is still missing, CLAUDIO offers it right there.
Why the app is built the way it is
A lot of this would have been decided differently by a team chasing growth. An analytics SDK would be "in there anyway", because you need data, right? The elaborate split between sources and library would be skipped until the first rebuild hurts.
CLAUDIO is a solo project, and that shapes every one of these calls: no company, no investors, no pressure to squeeze revenue out of attention. I build the app for myself first - I listen to music, audiobooks and podcasts with it every day, and every detail that annoys me lands on the list. That's also why development doesn't stall. An app that works and leaves you alone isn't a niche - it's the whole point.
Sources
- App Store: CLAUDIO - description, pricing and privacy label
- FluidAudio (Apache-2.0) - Swift bindings for on-device transcription with Parakeet TDT v3
- LRCLIB - open lyrics database, the last stage of the lyrics chain
- Signalsmith Stretch - time-stretching for speed changes without pitch shift
Read on
Three players, three philosophies? → CLAUDIO vs. Plexamp vs. VLC
CLAUDIO is a solo project by Tobias Reithmeier. A question or a bug? support@nerdwana.net - I read it myself. What the app does and what it costs? → CLAUDIO at a glance