1-bit

1-bit 2.0, Unfinished Symphony

Fri, 18 Sep 2026 00:00:00 GMT

1-bit 2.0 is on the App Store. Same URL, new build, free update, and a new icon.

It is the largest release since the app launched, and the first one that changes what the app is rather than what it can do. Until now 1-bit was a player for files on a server you run. It still is. It can now also be a player for files on a server we run, if you would rather not keep a computer switched on at home. That is the headline, and it is the first thing in the app that has ever needed an account. Everything else still works without one.

The in-app What’s New sheet, which lists the same six things as this post.

What’s new

1-bit Cloud (beta)A private 1-bit bridge that we run for you. Sign in with Apple, drop music in through your library’s web page from any computer, and it turns up in Sources like any other bridge, with the same bit-exact playback. 20 GB is included free. It is yours alone: nothing is shared, scanned or matched across accounts, it is stored in Switzerland, every file is downloadable back bit-exact, and one button deletes the lot. We never see your email address. It is labelled beta because it is three weeks old and I would like more libraries than mine to have lived on it.

LyricsTap the artwork on Now Playing and it becomes the lyric sheet. Synced lyrics follow the music line by line, and word by word where the file carries word timing. They come from the file’s own tags first, then a sidecar beside it, then your bridge, and only if you switch it on, from an online source. That last one is off by default because it sends the title and artist somewhere, and the app should not do that without asking.

DSD on any outputDSD used to refuse anything that was not a wired DAC, and the refusal was the honest answer while the only alternative was to pretend. It now plays on AirPods, AirPlay, CarPlay and the speaker, converted to PCM on the phone, and every screen that describes the signal says so: a neutral tier in Signal Path, a card naming the reason, a converter in the pipeline diagram. A wired DAC that takes the rate still gets the untouched DoP path. Set it to Never in Settings and you get the old refusals back, word for word.

SACD rips and compressed DSDAn SACD .iso now opens into ordinary per-track rows that play, download and sit in playlists like anything else, with the disc’s own track names. DST-compressed DSDIFF, which the app used to refuse outright, decodes as it plays, gaplessly, through a port of the ISO reference decoder. Both were on the “parked, too expensive” list for a year. They came off it because the decoder turned out to run comfortably faster than real time on an iPhone 13, and because nothing in the bit-exact path had to change for either.

DSD256, and a wizard for your DAC

For most of the app’s life the DSD ceiling on iOS was believed to sit at DSD128, on the strength of a confident answer nobody had measured. So I measured it. On an iPhone 13 through a Lightning adapter into a Chord Hugo 2, DSD256 over DoP negotiates its 705.6 kHz carrier and reaches a real DoP lock. There is no iOS ceiling below 768 kHz. Whether DSD256 works is a question about your DAC’s USB descriptors, never about the phone, and the rate sweep in Diagnostics now probes those carrier rates so you can find out for yourself.

Which is why 2.0 also has Profile my DAC under Diagnostics. It runs the same measurements the curated profiles came from, asks you the two things iOS cannot measure (what you heard, and whether the DAC has its own volume control), and hands you an email to support with a paste-ready profile draft. Two DACs are already in the app because someone ran it. If yours is not on the list, that is how it gets there.

Built for iOS 27

On iOS 27 the Lock Screen, Control Center and CarPlay controls run on Apple’s new Now Playing session, including shuffle, repeat and the Favorite heart, which the old command centre could not carry once a session owned the slot. Tracks stored on the device that carry no loudness tag get an on-device loudness estimate, so ReplayGain can level them along with everything else. All of it is gated: on iOS 26.1 the app takes the same path it always has, and there is a single switch in Settings that turns every iOS 27 path off at once if one of them misbehaves.

The parts nobody asks for but everybody notices

The floating player arrives on iPad. On a wide screen it becomes a single bar with the scrubber inline, and the expanded deck gets an Up Next column. The library gains a flat Tracks list. Now Playing was redesigned, with a proper light design for the first time rather than a dark one with the lights on, and an action tray that folds the secondary controls into one button. Settings can be searched. Files on the device give up their tags and embedded artwork more reliably, including FLAC covers iOS never surfaced. And a bridge can now convert DSD ahead of time into a compact rendition for CarPlay and wireless, or a faithful one for a wired DAC that cannot take the file’s rate, so the phone streams a fraction of the size instead of pulling a 794 MB file to convert it locally. The original is always one tap away.

1-bit Cloud, plainly. It is the same bridge software you can run yourself, on a machine we rent in Switzerland. Creating a library switches on playlist backup, favourites and listening history for it, because a hosted library that forgets your playlists is not much use, and the intro sheet says so before you sign in. All of it is switchable afterwards and exportable in one file. Revoking the app in your Apple ID settings suspends the library rather than deleting it; only the in-app delete destroys anything, and it asks you to sign in a second time before it does.

The privacy policy has a section that lists exactly what the service holds, and there is a terms page for the first time, because a free service with accounts needs one.

Same audio path, with one honest addition

On a wired DAC nothing has changed. No transcoding, no resampling, no mixer in the path. DSD goes out as DoP and PCM goes out at the file’s own sample rate, and with everything left at its defaults the bytes that reach your DAC are the bytes in your files. What is new is that the app no longer refuses to play DSD where that path does not exist. It converts, and it tells you. Bit-exact was never the point; knowing what you are hearing was. How DSD playback is handled →

2.0 runs fine against an older bridge. The wire protocol is still v1 and no re-pairing is needed. The renditions and the bridge-side lyrics simply do not appear until you update it.

If you have 1-bit installed: open the App Store and tap update. Your shares, bridge pairings, folders, playlists and settings carry over. The full list is on the changelog, and if anything seems off after updating, write to support@1-bit.app. A big thank you to everyone who sent feedback and reports over the summer. Much of this release traces back to those messages.

1-bit 1.9, The Long Day Is Over

Tue, 25 Aug 2026 00:00:00 GMT

1-bit 1.9 is on the App Store. Same URL, new build, free update.

It is the biggest release the app has had. 290 commits, 532 files, which is more than 1.8, and unlike 1.8 a good half of it is new machinery rather than fixes. Two of the four headline features are switches you have to go and turn on yourself, which is roughly how I want this app to behave.

What’s new

Spatial audio (beta)A binaural renderer that lifts the stereo image out of your skull and puts it in front of you, with head tracking on AirPods that report it: turn left, the band stays where it was. It is PCM only. Put on a DSD file and it steps aside completely, and Signal Path tells you it did. My first attempt used a mathematical head model and sounded like a party trick. What made it work was swapping in the MIT KEMAR measurements, an actual dummy head with silicone ears, measured in 1994 and still the reference. It is labelled beta because the width and room settings underneath it need a lot more ears than mine.

Live audio metersOpen Signal Path on any track and there is now an Analyzer tab: a real-time spectrum, left and right peak bars, true peak, dynamic range, bandwidth, estimated key and tempo. This is the feature I have wanted since 1.0. Every player on the store claims bit-perfect. Very few will let you watch. The tap sits at the decoder output and only ever reads; it cannot alter a byte on the way past. With the switch off there is no tap installed at all, which is why it ships off.

FavoritesLong overdue. Tap the heart on a track or an album, from the row, the long-press menu, the mini-player or the Now Playing header, and everything collects in a new Favorites section in the library. If you run a bridge you can switch on backup and they follow you to your other devices. One detail worth knowing: enabling backup against a bridge that already holds favorites merges the two lists. Nothing gets thrown away because you happened to turn it on second.

Composers and GenresTwo new sections in the library, sitting in the same chip row as Artists and Albums. They read the tags you already have and write nothing back. The classical handling is the part I care about: “Beethoven, Ludwig van” and “Ludwig van Beethoven” are one composer, not two, and genre tags that stack several values into one field get split properly instead of producing a genre called “Jazz; Vocal; Big Band”. Both work in search, and Siri will take a genre request now.

Is this file actually what it says it is

This one started as a question I could not answer about my own library. I have files that were sold as hi-res. Some of them almost certainly are not.

On a v0.1.9 bridge, Signal Path now shows a measured true peak, a dynamic range score, and an estimated key and tempo for each track. Alongside those, two checks that are less flattering and more useful. FLAC files carry a checksum of the audio written by the encoder, so the app compares it against what actually decodes; a mismatch means the file has been altered since it was made. It is a flag rather than a verdict, since plenty of tag editors rewrite a FLAC without updating that checksum. And the bandwidth reading answers the hi-res question directly: if a 96 kHz file has nothing above 21 kHz in it, you are looking at an upsample wearing a nice sample rate.

DSD deliberately gets no verdict at all. Its noise shaping puts so much energy above the audible band that the same measurement cannot separate a genuine 1-bit master from a converted one. I would rather the app say nothing there than say something confident and wrong. The analyzer works the same way: a reading that is physically impossible gets thrown away rather than displayed, because a meter that occasionally lies is worse than no meter.

Two switches, both off

Spatial audio and the live meters both live in Settings, Audio, and both ship off. Spatial is a processing stage, so it belongs to the same family as crossfeed and ReplayGain: if you want the file untouched, leave it alone. The meters are off for a different reason. Off means the measurement tap does not exist, rather than existing and being ignored, and I would rather that be the shipped state than a promise in a footnote.

Head tracking asks for Motion & Fitness the first time you use it. Decline and the spatial effect still works, it just stays fixed in place instead of following your head. That motion data is read on the audio path and never stored, never uploaded, and never leaves the phone. One more honest note: spatial plays about 6 dB quieter than bypass. That headroom is what stops the renderer clipping on loud material, and Dirac and Sonarworks do the same thing for the same reason. Do not A/B it by ear alone and conclude the bypass sounds better; it sounds louder.

The parts nobody asks for but everybody notices

Waveforms no longer need a bridge. In 1.8 the drifting dust field behind the progress bar only appeared for tracks your bridge had analysed. Now the phone will do it itself when the source has none, DSD included, so SMB shares, UPnP servers and folders on the device get real waveforms too.

The first sync got a lot lighter. My own library pulled 1.78 GB the first time it ran, and 1.3 GB of that was cover art the bridge was handing over at full size for the phone to immediately throw most of the pixels away. The bridge now right-sizes covers once, on the server, and the app stops re-fetching what it already has. Sync also reports honest progress instead of claiming to be done and then carrying on.

Renaming or moving a file on your server used to make the track vanish until a full rescan, taking its playlist slot and its download with it. The scanner now recognises it as the same track in its new home and carries all of that across. Offline, playback moves on to the next downloaded track instead of stopping dead at the first one you do not have. And a playlist can no longer claim to be fully available offline when it is not, which it could, and did.

If you have no server at all, Sources, +, Add Demo Bridge pairs a small read-only public library in one tap so you can try the whole thing before setting anything up.

And on the bridge side

Bridge 0.1.9 does the measuring behind the analysis above, and got a fairly serious pass of its own.

Metadata matching used to compare titles byte for byte, so a curly apostrophe against a straight one, or ”&” against “and”, threw away a match the server had already returned. That is fixed, and a lot of albums that sat there unmatched for months resolved on the next scan. It also serves one copy of each duplicated track instead of three, adds acoustic fingerprinting for files whose tags are useless, and stores favorites for the app.

As always, none of it is required. 1.9 runs fine against an older bridge, the wire protocol is still v1, and no re-pairing is needed for any of this. The analysis columns simply do not appear.

Same audio path

No transcoding. No resampling. No mixer in the path. DSD still goes out as DoP to your USB DAC and PCM still goes out at the file’s own sample rate. Spatial audio is a stage you choose, it never touches DSD, and the app says so in Signal Path when you have it on. The analyzer reads and does not write. The measurements come from a pass the bridge ran hours earlier on another machine. With everything left at its defaults, the bytes that reach your DAC are the bytes in your files. How DSD playback is handled →

The down-to-earth version

If you already have 1-bit: open the App Store and tap update. Your shares, bridges, folders, playlists and settings carry over, and there is nothing to re-pair. Favorites, Composers and Genres appear in the library on their own. Spatial audio and the meters wait for you in Settings, Audio. If you run a bridge, update it too and the analysis columns fill in after the next scan.

If you are new: it is a free download, iPhone or iPad, iOS 26.1 or later. Bring a NAS, a bridge, a UPnP server, or just a folder of files on the phone. A USB DAC if you want DSD. Or tap the demo library and borrow mine for an evening.

A lot of this release came out of messages from people using it. The favorites, the composer handling and half the sync work were all somebody else’s idea first. Thank you, and keep them coming.

1-bit 1.8, Steady State

Fri, 31 Jul 2026 00:00:00 GMT

1-bit 1.8 is on the App Store. Same URL, new build, free update.

This is the biggest release since 1.0 — 236 commits, 364 files — and yet almost none of it is a new mechanism. Half of those commits are fixes.

What’s new

Your music, where it already livesUntil now, “on-device library” meant files you had copied into 1-bit. If you already had 40 GB of FLAC on the phone, you needed 80. Now you can pick a folder — anywhere on the device or on a drive plugged into the USB-C port — and the app scans and plays it in place. It’s the standard file picker, so iOS grants access to that one folder and asks for no new permission. This feature came straight from an App Store review note on 1.7, which is a nicer origin story than most features get.

A timeline made of dustThe scrubber used to draw fake bars from a seed. Now, for tracks your bridge has analysed, it draws the real peak envelope — and it stopped being a chart. It’s a field of motes shaped by the track’s own loudness, with a playhead bloom that swells with the music. All of it comes from a curve computed on the bridge hours earlier; there is no meter tapping the audio and nothing new on the render thread. Tracks from SMB, a UPnP server, your own folders, or any DSD file keep the old synthetic bars.

Album bookletsLiner notes, finally. When your bridge has a PDF booklet for an album, a small badge appears on the artwork and opens it full-screen — the essay, the credits, the photographs, the bit of the record that never made it into a tag. Albums on a bridge without them look exactly as they did before.

Appears OnAn artist’s page used to show only the records where they got the headline. Now there’s an Appears On section for the ones where they’re a guest, a session player, a “with” credit — and those names turn up in search instead of vanishing because someone else’s name was on the sleeve. This is built entirely from the credits already in your tags, on-device.

The part that’s off by default

1.8 adds two ways for the app to fetch music without being asked: Prefetch upcoming tracks on Wi-Fi pulls down the next few tracks in your queue so a slow link can’t stall you, and Cache smart mixes overnight asks iOS to wake the app and download your Home mixes while you sleep. Both run only on Wi-Fi while the device is charging — never on cellular, never in Low Power Mode. The overnight one is a background task, so iOS decides if it gets a turn at all; it can go days without one.

Turning either on also enables a small automatic cache so recently-played and upcoming tracks start instantly. It lives in its own subtree, reclaims its own space oldest-first, and cannot touch the downloads you chose deliberately. With both toggles off, nothing is ever written to it. And none of this is a new destination: the bytes come from the same bridge or share the app was already streaming from.

And on the bridge side

Bridge 0.1.8 is what makes two of the four features above possible — same v1 wire protocol, everything is added additively.

It serves the peak waveform behind that new timeline, plus R128 loudness and an estimated key and tempo — all decoded offline on your own host with sox, reading the samples and never altering the bytes it later hands your phone. It serves the PDF booklets. And the admin console was rebuilt into five tabs, with Docker down to a single command for NAS and container hosts. If you’d rather not upgrade the bridge, don’t: 1.8 runs fine against an older one — the waveforms and booklets simply don’t appear.

Same audio path

No transcoding. No resampling. No mixer in the path. DSD goes out as DoP to your USB DAC; PCM goes out at the file’s native sample rate. The waveform is a picture drawn from a curve computed hours ago on another machine; a booklet is a PDF; a folder you picked is read where it sits. None of them sit between the file and the DAC. There’s also a new read-only card in Settings → Audio that tells you the settings your particular DAC was tuned for — it advises, and it changes nothing on its own. The bytes that reach your DAC are the bytes in your files. How DSD playback is handled →

The down-to-earth version

If you have 1-bit installed: open the App Store and tap update. Your SMB shares, bridge pairings, folders, and Settings carry over. The waveforms and booklets show up on their own once you’re on a 0.1.8 bridge with analysis on; the offline caching stays off until you go and turn it on. One thing you will notice without asking: the five-icon picker is gone, replaced by a single icon that follows your system appearance — gold in light, teal in dark.

If you’re new: it’s a free download, iPhone or iPad, iOS 26.1 or later. Bring a NAS, a bridge, or just a folder of files on the phone, a USB DAC for DSD, and music you actually like.

1-bit 1.7, First Light

Sat, 04 Jul 2026 00:00:00 GMT

1-bit 1.7 is on the App Store. Same URL, new build, free update.

The easter-egg card in Settings → About drops back to a single line this release, after the little poems of 1.4 and 1.5. This one just reads “First Light.” Two things in 1.7 earn it: 1-bit can finally hear you — say “play … on 1-bit” and Siri takes it from there — and it wakes up to a Home screen of mixes your own bridge has quietly assembled from what you’ve been listening to.

What’s new

Siri — “play … on 1-bit”Ask for an album, an artist, a playlist, or your downloads by name — at home, on the Lock Screen, or in the car — and 1-bit plays it from your own library. Apple does the listening; the app only ever receives the resolved request (which record you asked for) and starts the music. No voice data comes to me, and nothing about what you play is handed back to Siri.

A Home screen that mixes itselfHeavy Rotation, Drive Mix, Wind Down, an Auto Mix that sequences by musical key, a mix that shifts with the time of day. They’re built by your own bridge, once a day, from the listening history you chose to share back in 1.5 — server-side, on hardware you run, never touching a machine of mine. The Home tab only shows up when there’s something in it.

Performer creditsThe tag parser now reads performer and involved-people frames — the session players, the engineer, the “with” line — not just the headline artist. If your files carry the credits, the people behind the record finally show up in the metadata. All parsed on-device from tags you already have.

CarPlay recents & a new DACCarPlay keeps your recent searches and recently-played albums and playlists on the home screen, so you pick up where you left off without digging — kept on the phone, never uploaded. And the profiled-DAC list gains a Mytek Brooklyn DAC+, with its own curated resync timing and DSD ceiling.

A quieter addition: richer artwork and artist notes

1.7 also adds an optional way to get richer metadata. Turn on Atlas for a bridge and 1-bit can pull higher-resolution square cover art, artist biographies, and short album descriptions for whatever you’re looking at. It’s off by default, you flip it on per bridge, and it only ever fetches public music information.

Let me be straight about it, because it’s a first for this app: Atlas is a small service I run — the first server in the whole 1-bit story that’s actually mine, after two years of the app only ever talking to hardware you own. When it’s on, the app proves it’s a genuine, unmodified install (Apple’s App Attest) and sends nothing but the MusicBrainz ID of the album or artist on screen. To keep it from being abused, Atlas holds a minimal record — an attestation key and the IP it last saw — that isn’t tied to your identity, is never used for tracking, and keeps no log of what you looked up. It’s deletable on request, and the service is self-hostable if you’d rather it never leave your own boxes.

The one visible consequence of all this: because Atlas can be switched on, this release’s App Store privacy card now lists an Identifiers item — used only for app functionality and fraud prevention, not linked to your identity, not used for tracking. With Atlas off, which is how it ships, 1-bit still collects nothing at all. The privacy policy spells out every line of it.

And on the bridge side

Bridge 0.1.7 ships alongside — same v1 wire protocol, with the new endpoints added additively.

Three themes. Smart Mixes are the rotating, server-generated playlists behind that new Home screen — rebuilt once a day from your opt-in listening history and the analysis below, served only to your own paired devices. On-device audio analysis lets the bridge decode your tracks locally (with sox, ffmpeg as a fallback) to compute a peak waveform for the iOS scrubber, R128 loudness, and an estimated key and tempo — all of it on the bridge host, nothing about your audio going anywhere. And the optional Atlas path: by default your app fetches the richer metadata and hands it to the bridge to cache for your other devices, with a bridge-direct bulk-harvest mode for big libraries — both off by default. Full release notes on the bridge releases page.

Same audio path

No transcoding. No resampling. No mixer in the path. DSD goes out as DoP to your USB DAC; PCM goes out at the file’s native sample rate. Siri only tells the app what to play; the mixes are lists of your own tracks; Atlas only ever touches metadata, never the audio. The bytes that reach your DAC are the bytes in your files. How DSD playback is handled →

The unromantic version

If you have 1-bit installed: open the App Store and tap update. Your SMB shares, bridge pairings, and Settings carry over. Siri asks permission the first time you use it; the Home mixes appear on their own once you’re running a bridge with Smart Mixes on; Atlas and everything else new stays off until you decide to turn it on.

If you’re new: it’s a free download, iPhone or iPad, iOS 26.1 or later. Bring a NAS or a bridge, a USB DAC for DSD, and music you actually like.

1-bit has a new home

Tue, 09 Jun 2026 00:00:00 GMT

1-bit now has a place of its own on the web: 1-bit.app.

When I launched it back in April, the whole thing lived in a few pages tucked under ars.md/1-bit/. That was fine for a launch — one app, a couple of pages, no reason to overthink it. But it kept growing. A desktop bridge. Support docs and an FAQ. A privacy policy. A changelog that needed somewhere to live. At some point a product sharing a roof with my personal blog started to feel less like a feature and more like clutter.

So I gave it its own address.

What’s at 1-bit.app

Everything about the app, now under one roof:

The app — what it is, what it plays, and the App Store link.
The bridge — the little desktop companion that serves your library to the app.
Support — setup, settings, and the FAQ.
Changelog — every release, in one place.
Privacy — the short version: it doesn’t phone home.

What stays here

The writing. ars.md is where I think out loud, and a lot of that thinking is about 1-bit — so the per-release notes and the how-tos stay right here on the blog:

Update, September 2026: they have since moved here, to 1-bit.app/blog — the personal site keeps only the essays. The why is in Pruning the garden.

Those are me figuring things out in public, not product copy. They belong with the blog, not the storefront — and new release posts will keep landing here too.

Nothing breaks

Every old ars.md/1-bit/… link now 301-redirects to its new home on 1-bit.app. Bookmarks, search results, links from these very posts — they all land in the right place. You don’t have to do anything.

The app itself hasn’t changed: same bit-exact audio path, same promise that what goes in comes out untouched. It just has a better address now.

See it at 1-bit.app.

Cable or 2Go? Two ways to feed a Hugo 2 from an iPhone

Fri, 05 Jun 2026 00:00:00 GMT

If you own a Chord Hugo 2 and an iPhone, there are two good ways to get music from one into the other. You can run a USB cable straight from the phone to the Hugo 2. Or you can bolt a Chord 2Go onto the back of the Hugo 2 and have the phone send music to it over your network. People ask me which is better often enough that it’s worth laying out properly — including the part where the honest answer is “it depends, and not for the reason you’d guess.”

I build 1-bit, the iOS player I’ll use for the walkthrough, and it does both paths. So I’ve spent a lot of time A/B-ing them on my own Hugo 2. Here’s what I’ve found.

The thing nobody points out

Both paths end at the same input on the Hugo 2.

The Hugo 2 is the DAC in both cases — it does the decoding, the conversion to analogue, all the parts that make a Chord sound like a Chord. And the 2Go doesn’t bypass any of that. The 2Go is a transport: it pulls a file off your network and feeds the Hugo 2 over the very USB input your cable would otherwise plug into. Same DAC, same digital input, same decoding.

So the question was never “which sounds better, the Hugo 2 or the Hugo 2.” It’s narrower and more interesting than that: what should be driving that input — your phone, or the 2Go? That’s the entire decision.

Path A — the cable: phone as transport

The simplest version. A USB cable from the iPhone to the Hugo 2, and 1-bit sends the audio straight down it, bit-exact, DSD wrapped in DoP if that’s what you’re playing. I wrote the full how-to for this in How to play DSD on an iPhone — the cable rig is exactly that setup.

What’s good about it:

It works anywhere. No network, no bridge, no setup. Plane, train, hotel, a friend’s couch — if the phone and the Hugo 2 are in the same bag, you have a full hi-fi.
It’s rock solid. There’s no discovery, no multicast, no router to misbehave. You plug in and it plays.
It’s genuinely portable. This is the rig the Hugo 2 was arguably designed for — a battery DAC and a phone, untethered from the wall.

What’s not:

The phone is in the audio path. It’s the transport now, which means it has to stay physically attached, it drains its battery doing the work, and it ties up the only port you’ve got.
The phone is electrically noisy. It’s a general-purpose computer full of radios and switching supplies, and the cable couples some of that to the DAC. Hold that thought — it’s the whole case for the other path.

Path B — the 2Go: phone as remote

Now the network version. The 2Go is attached to the Hugo 2 and joined to your Wi-Fi. Your music lives on a 1-bit bridge somewhere on the same network. In 1-bit you pick the 2Go as the output and press play. The full click-by-click is in Setting up a Chord 2Go with an iPhone, but here’s the part that matters for this comparison:

The phone never touches the audio. It hands the 2Go a link to the file on your bridge, and the 2Go fetches and plays it itself. The phone drops out of the path entirely and becomes a remote control.

What’s good about it:

You can walk away. Lock the phone, leave the room, let the battery sit at 100%. The 2Go keeps playing because it’s the one doing the playing.
The DAC is isolated from the phone. This is the real audiophile argument for the 2Go, and it’s a fair one: the noisy general-purpose computer is no longer galvanically tied to your DAC. The transport feeding the Hugo 2 is now a purpose-built, battery-powered streamer instead of a phone.
It’s a tidy home rig. Once it’s set up, the experience is “open app, press play” from anywhere in the house.

What’s not:

It needs your network and a bridge. The music has to live on a bridge for the 2Go to have something to fetch — on-device files and SMB shares can’t be cast this way. And the whole thing depends on your LAN behaving.
It can have network gremlins. Multicast quirks, client isolation, a flaky mesh node — none of it fatal, all of it covered in the 2Go guide’s troubleshooting, but it’s complexity the cable simply doesn’t have.

The bits are identical — so set your expectations

Here’s the part the format wars won’t tell you: both paths are bit-exact. The cable sends the original file’s bits down USB with no resampling. The 2Go fetches the original file and plays it untouched. DSD works on both — over the cable it goes as DoP, and the 2Go receives the whole .dsf and hands it to the Hugo 2 intact.

So the same album, played both ways, arrives at the Hugo 2 as the same data. Anyone promising you a dramatic sound-quality leap from switching is selling something. If there’s a difference, it lives entirely in that one remaining variable — electrical noise from the transport — and how audible that is on any given system is a genuinely contested question. I can hear myself wanting to hear it, which is exactly when I trust it least.

Where they actually differ

Strip away the bits, which are equal, and you’re left with this:

The phone’s job. Cable: it’s the transport, tethered and working. 2Go: it’s a remote, free to lock and pocket.
Isolation. Cable: phone noise reaches the DAC. 2Go: a purpose-built transport sits between them.
Dependencies. Cable: none. 2Go: your network, plus a bridge holding the library.
Reliability. Cable: as reliable as plugging in a cable. 2Go: as reliable as your Wi-Fi.
Where it shines. Cable: on the go. 2Go: a settled home system.

So which is optimal?

The non-cop-out answer: they’re optimal for different lives, and most people who own both end up using both.

At home, the 2Go is the nicer way to live. The phone is free, the battery’s full, the DAC is fed by a dedicated transport instead of a pocket computer, and “press play and walk off” is just a better daily experience than being leashed to a cable. If you have a fixed listening spot and a network you trust, this is the one to set up.

On the move — or any time you want zero failure points — the cable wins, and it gives up nothing on the bits to do it. It’s the more reliable path and the only portable one. When the Hugo 2 is in a bag rather than on a shelf, there’s no contest.

What I’d gently steer you away from is buying a 2Go expecting it to sound better than a clean USB cable into the same Hugo 2. That’s not what you’re paying for. You’re paying for the phone to leave the audio path — for the freedom and the isolation, not for a different stack of bits. If those are worth it to you, it’s a lovely upgrade. If you mostly listen on the go, save the money and keep using the cable; you already own the bit-exact path.

The reassuring thing about a Hugo 2 is that you can’t really get this wrong. Cable or 2Go, the DAC at the end is the same and the bits reaching it are the same. Pick the path that fits where you listen, and let the Chord do the part it’s good at. If you haven’t set up either yet, start with the DSD-over-cable guide — it’s the five-minute version — and graduate to the 2Go when you want the phone out of the loop.

Setting up a Chord 2Go with an iPhone

Thu, 04 Jun 2026 00:00:00 GMT

The Chord 2Go is a lovely, slightly fiddly little network streamer. Getting an iPhone to send music to it — the real bit-exact version, not some down-sampled AirPlay copy — is one of those tasks that’s simple once you know the path and baffling until you do. This is the path I use.

Fair warning up front: I make 1-bit, and version 1.5 added the feature this guide leans on. The networking ideas apply to any DLNA setup, but the click-by-click is 1-bit plus its bridge. If you run a different player, skim for the concepts and ignore my screenshots-in-prose.

What the 2Go actually is

It’s a network streamer. It pulls music off your network (or an SD card) and feeds a Chord DAC — it bolts onto a Hugo 2, or works with other DACs through the 2Yu adapter. It speaks several protocols: Roon, AirPlay, DLNA/UPnP, MPD. The one we want is DLNA/UPnP, because it can move your files bit-for-bit with no re-encoding on the way.

Why not just AirPlay?

You can AirPlay to a 2Go, and for background listening it’s fine. But AirPlay re-clocks and caps the stream — it isn’t the bit-exact path you bought a Chord for. DLNA is different in a subtle but important way. With AirPlay, the phone pushes a stream to the 2Go. With DLNA, the phone just tells the 2Go where the file lives, and the 2Go fetches and plays the original itself. The phone stops being in the audio path. That’s the part that makes it bit-exact.

What you need

A Chord 2Go on your network (with a Hugo 2, or via 2Yu with another DAC)
An iPhone with 1-bit 1.5 or newer
A 1-bit bridge running on your network, with your library on it
All three on the same LAN — same Wi-Fi, same subnet

One thing to get clear before you start: this is a bridge feature. The 2Go plays by fetching a file from a URL, so the music has to live on a bridge for it to have something to fetch. Tracks on an SMB share or sitting on the phone itself can’t be cast this way — there’s no address for the 2Go to pull from.

Step 1 — Get the 2Go onto your network

Use Chord’s GoFigure app to join the 2Go to your Wi-Fi (or wire it in). That part is Chord’s territory and their docs cover it well, so I won’t re-tread it. Just confirm the 2Go is actually on your network and reachable before going further — most of the “it doesn’t work” emails I get are really “the 2Go was never online.”

Step 2 — Run a bridge with your library

The 1-bit bridge is the free, open-source companion server — Mac, Windows, Linux, or a Raspberry Pi next to your music drive. Point it at your library, pair your phone with the QR code from the admin console, and you’re set. If you already listen to 1-bit through a bridge, you’ve done this step and can move on.

Step 3 — Turn on the bridge’s DLNA MediaServer

This is the piece that makes the whole 2Go path exist, and it’s off by default. Switch it on and the bridge advertises your library on the LAN as a DLNA server that the 2Go can read.

One thing worth saying plainly: UPnP has no authentication. While that MediaServer is running, anyone on your network can browse and stream that library. So it only ever binds your local network — never a public address — a public-mode bridge refuses to start it at all, and you should only turn it on for a network you trust. Leave it off on café or shared Wi-Fi.

Step 4 — Pick the 2Go in 1-bit

Open Now Playing, tap the output picker, and the 2Go shows up as a renderer. Other DLNA control apps you might already use — mconnect, BubbleUPnP, Linn Kazoo — work the same way; the 2Go is just the one I built this against. Select it.

Step 5 — Press play

Here’s what happens under the hood: 1-bit hands the 2Go the track’s metadata and a link to the file on your bridge. The 2Go fetches the audio itself over your LAN and plays it, bit-exact, into your Chord DAC. Nothing routes through me or any server I run — at that point the phone is basically a remote control, and you can lock it and walk off while the music keeps going.

DSD works too, by the way. Because the 2Go receives the original file rather than a stream from the phone, a DSD track arrives intact and your Chord setup decodes it the way it always does. The 2Go does the work; the phone is just pointing at the bytes.

When the 2Go won’t show up

Check that everything is on the same subnet. Guest networks and a router setting usually called “client isolation” or “AP isolation” will hide your devices from each other. This is the number-one cause, by a wide margin.
Confirm the DLNA MediaServer is actually on in the bridge admin console.
Mind multicast. DLNA discovery uses SSDP, which rides on multicast, and some mesh Wi-Fi systems drop multicast between bands or nodes. If discovery is flaky, getting the phone and bridge onto the same band or node often fixes it.

When it shows up but won’t play

The track has to live on the bridge. If you’ve selected the 2Go but you’re playing from an SMB share or on-device files, there’s nothing for it to fetch. Add (or move) the music to the bridge and try again.

Chord spent years of firmware getting the 2Go to this point; it took me one release to plumb the iPhone side into it. And the reward for all of it is that the setup disappears: open the app, pick the 2Go, press play. That’s the bar for gear like this — once it’s working, you should never have to think about it again.

How to play DSD on an iPhone

Thu, 04 Jun 2026 00:00:00 GMT

Some version of this lands in my inbox most weeks: “I put my DSD files on my iPhone and nothing plays them right. What am I doing wrong?” Usually the answer is nothing. The iPhone just doesn’t play DSD the way you’d expect, and a lot of apps cover for that in a way that quietly defeats the point.

I build 1-bit, an iOS player that plays DSD properly, so I’ve spent more hours in this corner than is strictly healthy. Here’s the whole picture in plain terms — what you need, what trips people up, and how to check you’re actually hearing DSD and not a polite imitation of it.

What DSD actually is

DSD is Direct Stream Digital — the format behind SACD. Instead of the 16 or 24 bits per sample that PCM uses (CDs, FLAC, most of what you own), DSD stores audio as a single bit, sampled millions of times a second: 2.8 MHz for DSD64, 5.6 for DSD128, 11.2 for DSD256. It’s a different way of describing the same sound. On disk it usually shows up as a .dsf file, occasionally .dff. If you want the longer version of why it exists, I wrote about it when 1-bit launched.

The catch nobody mentions

iOS has no built-in DSD playback. Apple Music won’t do it. The Files preview won’t do it. Out of the box, the iPhone is a PCM device, full stop.

So every app that claims to “play DSD” on iOS is doing one of two things. Most convert it to PCM first — easy, works everywhere, and sounds fine to almost everyone. A few wrap it in something called DoP and send the untouched bits to a DAC built to decode them. The second one is what you’re actually after, and it needs specific hardware.

What you need

An iPhone — USB-C (15 or newer) makes life easier; Lightning works with a camera adapter
A USB DAC that supports DSD over DoP
Your DSD files (.dsf) somewhere the app can reach
A player that sends DSD as DoP without converting it

You need a real DAC — the phone can’t do this alone

DSD has to be decoded by hardware made for it. The built-in output, Bluetooth, AirPlay — none of them carry a true DSD stream. Bluetooth and AirPlay are lossy or PCM by the time they reach the other end, so “DSD over Bluetooth” isn’t DSD anymore; it’s a conversion with extra steps.

What works is a USB DAC that lists DSD or DoP support. DACs from Chord, iFi, FiiO, Topping and the like generally handle it — check the spec sheet for the words “DSD” or “DoP” before you buy. And to be clear: a cheap USB-C-to-headphone dongle is a DAC, but a PCM-only one. It’ll play your music; it won’t lock to DSD.

What DoP is, and why you keep seeing it

DoP stands for DSD over PCM, and it’s the trick that makes any of this possible. iOS won’t hand a raw, native DSD stream to a USB DAC. So the whole industry does the same workaround: take the 1-bit DSD stream, pack it inside PCM-shaped frames, and add a little marker that tells the DAC “this looks like PCM but it isn’t — it’s DSD wearing a coat.”

The DAC reads the marker, unwraps the frames, and decodes the original bits. Nothing is lost in the wrapping; it’s the same data, just couriered in a container iOS is willing to carry. The only requirement is that your DAC understands DoP. Most modern USB DACs do.

The trap: “playing” a file vs actually playing DSD

This is the part that fools people, including careful ones.

An app can play your DSD album, show the right title, scrub through it like normal — and be silently converting it to 48 kHz PCM the entire time. It plays. It just isn’t DSD anymore. That’s the default behaviour of a surprising number of iOS players, because conversion is the path of least resistance.

Here’s how to know which one you’ve got: look at the DAC, not the app. A DAC decoding real DSD lights up a DSD or DoP indicator, or shows the rate outright — DSD64, say. If it reads PCM 44.1 or PCM 48 while you’re “playing” a DSD file, you’re hearing a conversion. The DAC is the honest witness here. The app’s screen will tell you whatever the app wants to tell you.

Doing it, step by step

Since 1-bit is my app I’ll use it for the walkthrough, but most of these steps apply to any player worth using.

Plug the DAC into the iPhone. USB-C to USB-C on a 15 or 16. On older Lightning iPhones, you need Apple’s Lightning-to-USB Camera Adapter.
Put your DSD files where the app can see them — an SMB share or NAS, a 1-bit bridge, or dropped straight into the app’s folder over Finder or Files.
Play a DSD album. 1-bit reads the .dsf, wraps it in DoP, and sends it to the DAC with no mixer and no resampling in the way.
Check the DAC. It should report a DSD/DoP lock — DSD64, DSD128, whatever the file is. That’s the whole game. If you see that, you’re done.

A word on Lightning, USB-C, and power

On USB-C iPhones a plain cable usually just works. On Lightning iPhones the bare Camera Adapter is fine for low-power DACs, but a hungrier desktop DAC may pull more than the phone wants to give — that’s when you want the version of the adapter with the extra Lightning power port, so the DAC isn’t running off the phone. If a DAC connects and then drops out a few seconds later, suspect power before anything else.

When it doesn’t work

No sound at all. Either the DAC doesn’t do DoP, or your cable is charge-only (a classic — swap the cable first).
It plays, but the DAC says PCM. The app is converting. Look for a “bit-exact” or “no resampling” setting, or switch to a player that doesn’t convert in the first place.
The DAC won’t lock, or clicks between tracks. Some DACs — Chord’s FPGA-based ones especially — need a moment to re-lock. A good player builds that settling time in so you don’t hear it.
The app says “no DAC” or doesn’t recognise your gear. That’s almost always iOS hiding the DAC’s identity from the app, not an actual fault. I went down that whole rabbit hole in a separate post.

Do you even need DSD?

Honest answer, since someone always asks: the gap between DSD and good high-res PCM is smaller than the format wars make it sound. If you have DSD files — SACD rips, native DSD recordings — play them as DSD; there’s no reason to throw bits away converting them. If you don’t have any, you’re not missing some hidden tier of sound by listening to clean FLAC.

The point of all this was never that DSD is magic. It’s that if you went to the trouble of owning it, your phone ought to play it exactly as it is. Get the three things right — a DAC that speaks DoP, files the app can reach, a player that doesn’t quietly convert — and the iPhone makes a genuinely good DSD transport.

1-bit 1.5, the one with Chord 2Go support

Wed, 03 Jun 2026 00:00:00 GMT

1-bit 1.5 is on the App Store. Same URL, new build, free update.

The easter-egg card in Settings → About keeps the multi-line habit it picked up in 1.4. This release’s verse is “One hundred three commits are past, / The music breathes, unfettered, vast. / Pure bit-perfect sound takes flight, / To fill the room with deep delight. / Let every note and chord revive, / In beautiful version 1.5.” That fifth line is doing double duty — the headline feature is playing to a Chord 2Go.

What’s new

Play to a Chord 2Go (and other DLNA renderers)Cast a track to a DLNA / UPnP renderer on your network — the Chord 2Go is the target I built this for, and generic renderers (mconnect, BubbleUPnP, Linn Kazoo) work too. Pick it from the Now Playing output picker. The app hands the renderer the track metadata and a link to the file on your own bridge; the renderer fetches and plays the audio itself, bit-exact, over your LAN. Nothing routes through a server I operate.

Playlist backup to your bridgeOff by default, per bridge. The playlists you build in the app can now back up to the bridge you run, so they survive a reinstall or a re-pair. They go only to your bridge — never to me, never to a third party. Tracks that come from another bridge or from local / SMB storage stay as opaque references.

Listening history to your bridgeOff by default, per bridge. Turn it on and the app reports each play — track, when, how long, codec, and where available the output device and DAC sample rate — to your own bridge. It’s your data: it lives on the bridge host, shows up on the admin console’s new Data page (histograms, most-played, export), and the bridge never forwards it anywhere.

On-device diagnosticsA small daily performance summary — CPU/energy, memory, playback runtime — pulled from Apple’s on-device MetricKit and surfaced in the in-app diagnostics screen. It never leaves your phone. Handy when something feels off and you want to see whether the app is the culprit.

A note on the Chord 2Go path

DLNA casting is a bridge feature, not a standalone one. The renderer pulls the audio straight from your bridge over the LAN, so the track has to live on a bridge — an SMB share or the on-device library can’t be cast this way, because the renderer needs a URL to fetch from. And one thing worth saying plainly: UPnP has no authentication. While the bridge’s DLNA MediaServer is on, any device on your LAN can browse and stream that library. So it’s off by default, it only ever binds your local network (never a public IP), and a public-mode bridge refuses to start it at all. Turn it on for a network you trust, and leave it off on shared Wi-Fi.

And on the bridge side

Bridge 0.1.5 ships alongside — 45 commits since 0.1.4, iOS wire protocol unchanged at v1.

The big one is the DLNA / UPnP MediaServer that makes the Chord 2Go path possible: an All Tracks list plus a Folders hierarchy with free-text search, bit-exact audio, cached upscale variants surfaced as alternate streams. Then the two storage features that land on the bridge: per-device playlist backup and an opt-in listening history, both viewable on the admin console’s new Data page with JSON / CSV export. Plus a public-mode pairing-QR fix (the QR now carries the served Let’s Encrypt cert fingerprint and the public dial URL, so phone pairing no longer trips the TLS pin), a sudo bridge update fix for FUSE-mounted libraries, and honest variant accounting across the admin views. Full release notes on the bridge releases page.

The data we collect is still none

Two of the new features move your data off the phone — but only to a server you run, and only if you turn them on. Playlist backup and listening history are off by default and go solely to your own bridge. DLNA playback stays on your LAN. When backup or history is enabled, the app mints a random per-device identifier (stored in the Keychain, not linked to your Apple ID or any ad identifier) so the bridge can keep each device’s backups separate. The MetricKit summary never leaves the device. No new third-party services, and aside from the multicast capability that SSDP discovery needs, no new permissions. The privacy policy spells all of it out, and the App Store nutrition label stays “Data Not Collected”.

Same audio path

No transcoding. No resampling. No mixer in the path. DSD goes out as DoP to your USB DAC; PCM goes out at the file’s native sample rate; and when you cast to a DLNA renderer, the renderer fetches the original bytes from your bridge and does its own job. The phone moves bytes and metadata; the hardware does the rest. How DSD playback is handled →

The unromantic version

If you have 1-bit installed: open the App Store and tap update. Your SMB shares, bridge pairings, and Settings carry over. DLNA casting, playlist backup, and listening history are all off by default — you turn them on if and when you want them. To play to a Chord 2Go, enable the DLNA MediaServer on your bridge first, then pick the renderer from Now Playing.

If you’re new: it’s a free download, iPhone or iPad, iOS 26.1 or later. Bring a NAS or a bridge, a USB DAC for DSD (or a Chord 2Go on the network), and music you actually like.

1-bit 1.4, the one that goes in the car

Tue, 26 May 2026 00:00:00 GMT

1-bit 1.4 is on the App Store. Same URL, new build, free update.

Last release I shipped a codename that lied about the version. This time I went the other way. Open Settings → About in 1.4, tap the easter-egg card, and instead of a single-line codename you get a small poem: “One hundred three commits deep, while the tired engineers sleep. Offline downloads finally stand, CarPlay grids across the land. Tap the text and clear the view, version 1.4 is ready for you.” The two main features are right there in the verse, so I’ll keep the writeup short.

What’s new

CarPlayBrowse, search, tap-to-play, and a Now Playing view on a CarPlay head unit — reading the same on-device library that’s on your phone. Uses Apple’s CarPlay Audio entitlement, so it’s a real CarPlay app, not a screen mirror. DSD is hidden from CarPlay because DoP markers can’t survive head-unit playback; everything else plays.

Offline downloadsPick a track, an album, a playlist, save it to the iPhone. Files live in app-private storage, are hidden from Files, and are excluded from iCloud backup (so they don’t quietly fill your iCloud quota). Delete the download, delete the share, or uninstall the app — they’re gone.

Diagnostic logs in SettingsA rolling buffer of recent log lines lives at Settings → Logs. The logs stay on the device. A Share button is there for the rare case I ask you to send them — never automatic, never on by default.

DSD-domain DSP (Beta)An optional on-device chain — decimator, sigma-delta modulator, volume stage — that stays in the DSD domain instead of converting to PCM first. Off by default. Beta because thermal headroom on older iPhones can still surface the odd crackle, and I’d rather call that out than pretend it’s settled.

And on the bridge side

Bridge 0.1.4 ships alongside — 44 commits since 0.1.3, wire protocol unchanged at v1.

Two big themes. Public-mode hosting: bridge init —public spins up a bridge intended for a small VPS, with native Let’s Encrypt provisioning via autocert, a single-user admin auth layer, and an endpoints filter so the public listener only exposes /v1/health and the /v1/share/… family. CarPlay-optimized variants: a new optimize-… variant class and a two-channel priority queue so on-demand CarPlay transcodes don’t sit behind a lifetime Upscale backlog. Plus a tile-grid Library Inspector, a Prometheus /metrics endpoint on the admin listener, and a background orphan-sidecar GC sweeper. Full release notes on the bridge releases page.

What got refined

A small carve-out in the iOS pinning policy: bridges deployed with a custom domain and a public Let’s Encrypt cert are now ATS-trusted, while LAN, Tailscale-magic-DNS, IP-literal, and mDNS hosts still pin against the fingerprint captured at pairing. The shape of what the app sends — paths, byte ranges, MusicBrainz IDs — is identical. The Settings screen got an IA pass to make room for the v1.4 surfaces. The deployment target is now iOS 26.1.

Same audio path

No transcoding. No resampling. No mixer in the path. DSD goes out as DoP to your USB DAC; PCM goes out at the file’s native sample rate. The phone moves bytes; the DAC does the DAC’s job. How DSD playback is handled →

The unromantic version

If you have 1-bit installed: open the App Store and tap update. Your existing SMB shares, bridge pairings, and Settings carry over. Offline downloads, the DSP chain, and the log viewer are all off by default — you turn them on only if and when you want them. CarPlay shows up the moment you plug into a head unit.

If you’re new: it’s a free download, iPhone or iPad, iOS 26.1 or later. Bring a NAS or a bridge, a USB DAC for DSD, and music you actually like.

1-bit 1.3, the one where we forgot to change the codename

Sat, 16 May 2026 00:00:00 GMT

1-bit 1.3 is on the App Store. Same URL, new build. Update on your iPhone and it’ll be there.

Open Settings → About in the new version and tap the easter-egg card. You’ll find: Version 1.3, codename “Too Late, Too Soon”. Which was 1.2’s codename. The release checklist has a step for this — three sites in AboutView.swift that have to move together every release — and the checklist quietly didn’t get run this time. Once a build is uploaded to App Store Connect, the easter-egg version is frozen in the binary; the only fix is a fresh build and a re-submission, which is not what 1.3 needed. So the codename slip ships as-is, and the iOS repo’s CLAUDE.md now opens the release-checklist section with this exact story so the next release doesn’t repeat it. Honest changelog: a codename that lies about the version, fixed in 1.4.

The actual shape of 1.3 is the boring kind of release: the scanner becomes less demanding of your attention, the library starts understanding music that isn’t pop-rock, and a Listening Tips guide collects the things that make this app sound the way it should.

What’s new

Opportunistic background scanYour first scan of a big library can keep going after you background the app. iOS schedules a one-shot task; the work runs only when the device is charging, idle, and on Wi-Fi. The whole thing stays on your phone — no traffic beyond the SMB or bridge connection you’d already authorised. Off-switch in Settings → Refresh.

Classical metadataComposer, conductor, and work fields land in the library. Opera, symphonic, and concert recordings group the way the music does instead of being flattened against ALBUMARTIST. Bridge 0.1.3 extracts the same fields server-side; SMB sources read them out of the file tags directly.

Listening tips, in one placeA new in-app guide collects the things that make 1-bit sound the way it does: which DAC, what DoP actually is, why DSD pre-caches by default, when gapless does and doesn’t work, when to bypass crossfeed. Open from Settings → Listening Tips.

Long-press a folderHold any folder in the browser to play it, queue it next, append to a playlist, or jump to its album — without leaving the browse view. Small thing; surprising how often you reach for it once it’s there.

And on the bridge side

Bridge 0.1.3 ships alongside — 62 commits since 0.1.2, wire protocol unchanged at v1, every change additive. The headline:

A new Library Inspector in the admin console: folder-first browse, FTS5 search, cursor-paginated virtualized scroll, inline metadata edit, per-track variant management, a stats drawer, and a Jobs page for upscale runs. Classical extractors (composer / conductor / work / original year / BPM) across FLAC, MP4, AIFF, WAV, DSF, and DFF. Multi-value ARTIST / ALBUMARTIST preserved on FLAC and MP4 instead of being collapsed. ALAC source bit depth read from the MP4 alac atom rather than inferred. A configurable upscale.variantsDir with source-mirrored layout plus a bridge upscale move CLI. And a Tailscale Let’s Encrypt cert-expiry warning at startup so the iOS ATS 398-day re-pair cliff stops being a surprise. Full release notes on the bridge releases page.

What got refined

The v1.2 per-share cellular gate now also stops the next-track preloader from quietly reaching for cellular when you’ve picked Warn before streaming or Wi-Fi only, and Low Power Mode is honoured the same way. Artist Detail filters orphan albums so the view doesn’t show ghosts of moved files. Stale albumID / artistID on tracks are canonicalised on the next access, so a re-scan that re-grouped an album doesn’t leave the queue pointing at the old ID. Album headers gain a mixed-format subtitle (“FLAC 24/96 · DSF DSD64”) for compilations that mix encodings.

Same audio path

The unromantic version

If you have 1-bit installed: open the App Store and tap update. Your existing SMB shares keep working. Your existing bridge pairings keep working. The cellular default stays Always allow; the background scan is on by default but iOS still controls whether and when it runs. Nothing else changes until you say so.

If you’re new: it’s a free download, iPhone or iPad, iOS 18.6 or later. Bring a NAS or a bridge, a USB DAC, and music you actually like.

1-bit 1.2: too late, too soon

Sat, 09 May 2026 00:00:00 GMT

1-bit 1.2 is on the App Store. Same URL as before, new build. Update on your iPhone and you’ll see it.

Too late: 1.2 took a beat longer than planned. Too soon: there’s already more I want to ship. The shape of this release is the gap between the two — the pieces that had to land together, the ones that proved themselves on TestFlight, the ones that didn’t make the cut and roll into 1.3.

The headline: a more honest bridge you can actually feel safe handing to other people on your network, and a per-share cellular gate so DSD doesn’t quietly torch your data plan.

What’s new

Admin-approved pairingBridges can now require explicit operator approval before a new device pairs. The authorized-device list lives on the bridge you run, not on a server I operate. Pairings now feel like the front door of your house — you decide who walks in.

Discover on networkA new tap-to-pair sheet finds nearby bridges, fires the join request, waits for approval, and persists the share automatically. No tokens to type, no QR scanning if you don’t need it.

Optional upscaled variantsBridges can generate optional upscaled PCM variants on request. Generation runs locally on your bridge and never leaves the network you control. Toggle per share; switch source ↔ upscale per track from the Now Playing wand.

Per-share cellular controlPick Always allow, Warn before streaming, or Wi-Fi only. The gate covers bridge and SMB equally — Tailscale-fallback hosts can still reach cellular, so this is the right knob to refuse a 5 GB DSF file on a metered link.

What got quieter

A fully lock-free render path (no syscalls during the audio callback). Hardened DSF parsing (the sort of belt-and-braces that only matters when something corrupted breaks through). Smoother variant switching mid-track. PCM gap recovery on long screen-off / sleep cycles. Same bit-exact output, fewer edges to catch on.

Same audio path

The unromantic version

If you have 1-bit installed: open the App Store and tap update. Existing SMB shares keep working. Existing bridge pairings keep working. The cellular default is Always allow, so nothing changes until you say so.

If you’re new: it’s a free download, iPhone or iPad, iOS 18.6 or later. Bring a NAS or a bridge, a USB DAC, and music you actually like.

1-bit 1.1, from the heart

Wed, 29 Apr 2026 00:00:00 GMT

1-bit 1.1 is live on the App Store — same URL, new version. Update on your iPhone and you’ll see it.

Most of 1.1 doesn’t show up in a bullet list. It’s the rough edges from launch week — pairing flows that didn’t quite hold, scanner behaviour on bigger libraries, the long tail of small fixes you only find once real people start using the thing. The headline addition on top of all that polish: the 1-bit bridge — a free, open-source companion server that gets your library off SMB and onto a transport designed for the app.

What’s new

1-bit bridge, properly launched. A free, open-source companion server you can run on a Mac, a Windows PC, a Linux box, or a Raspberry Pi sat next to your music drive. Pair an iPhone in three steps with a QR code from the admin console, and the phone talks to your library over HTTPS instead of SMB. It’s noticeably faster than SMB — first scan after pairing finishes in seconds — and unlike SMB, it works over Tailscale or WireGuard, so your library is reachable from anywhere your phone has signal. Same bit-exact audio path on the iPhone side: the bridge ships bytes; the phone still owns DSD, DoP, gapless, all of it. Bridge page has the details.

Bonjour for bridges. Nearby bridges show up automatically in the Add-Source sheet. Type the bearer token (or scan the QR) and you’re paired.

The unglamorous half of 1.1. The launch-week fixes that don’t make a feature list — an app-quits-on-launch trace pinned to root services rebuilding on every parent re-eval, a first-launch mass-delete trap on libraries larger than ~500 albums or artists, and auto-revive when iOS 26 silently stops AVAudioEngine ~600 ms after a tap with a USB DAC attached. Settings also got a proper home: theme override, alternate app icons, ReplayGain on PCM (DSD always stays bit-exact), Bauer crossfeed for headphones, a defer-next-track-preload toggle to quiet shuffle and repeat clicks, and a per-DAC resync-delay override for unknown hardware.

A privacy policy that’s actually been audited. Three documents now move together — the in-app screen, the web policy, and the bridge’s own privacy page. Zero personal data collected, by design — which inherently complies with the GDPR (EU), the Swiss FADP, and the CCPA. The policies and the code are checked against each other before every release.

Same audio path. No EQ, no loudness, no resampling, no dithering, no funny business. DSD goes out as DoP to your USB DAC; PCM goes out at the file’s native sample rate. The phone moves bytes; the DAC does the DAC’s job.

The unromantic version

If you already have 1-bit installed: open the App Store and tap update. Your existing SMB shares keep working. Your scan history keeps working. Your Now Playing keeps working. The bridge is additive — you only opt in if you want it.

If you’re new: it’s a free download, iPhone or iPad, iOS 18.6 or later. Bring a NAS, a USB DAC, and music you actually like.

1-bit is out

Tue, 21 Apr 2026 00:00:00 GMT

Today I shipped 1-bit, an iOS music player for people who care how their music sounds.

Why “1-bit”? Because that’s the number that matters. DSD — Direct Stream Digital, the format behind SACD — encodes audio as a single-bit stream sampled millions of times a second, instead of the 16 or 24 bits per sample you get from PCM (think CDs, FLACs, most of Apple Music). It’s a different way of thinking about digital audio, and it’s what 1-bit is built around.

The name is also a promise. The app doesn’t resample, doesn’t remix, doesn’t touch your audio on the way to your DAC. What goes in comes out — bit for bit.

What it does

Point it at an SMB share on your home network — a Synology, a QNAP, a Mac running File Sharing, whatever you already have — and 1-bit scans your library, reads the tags, pulls the artwork, and builds a browseable catalog of your albums and artists. Plug in a USB DAC and hit play.

If you don’t run a NAS, drop files into the app’s Documents folder via Files or Finder over USB and it works the same way.

No accounts. No cloud. No streaming service. Your music, your network, your DAC.

Bit-exact, and what that actually means

For PCM, 1-bit sends samples straight from the file to the audio engine to your DAC, bypassing the iOS system mixer entirely. For DSD, it reads DSF files and packs the 1-bit stream into DoP (DSD over PCM) frames for the DAC to decode natively.

This matters most if you own something like a Chord Hugo 2, a Mojo 2, or one of the many USB DACs that can lock to a native DSD carrier. Those DACs sound their best when software gets out of the way. 1-bit gets out of the way.

It also handles the fiddly parts that trip up most iOS music apps:

Sample-rate renegotiation when you jump from a 44.1 kHz FLAC to a DSD128 album
PLL settling time on FPGA-based DACs (the Chord family needs roughly 700 ms to re-lock cleanly — Hugo 2 will go silent without it)
Gapless playback when consecutive tracks share a format
DoP marker-phase continuity across track transitions, so your DAC never flickers mid-album

Who it’s for

If you have a NAS full of FLACs and DSFs, a good DAC, and a pair of headphones or speakers you actually listen to — this is for you. It’s not trying to replace your streaming service. It’s trying to be the nicest possible way to listen to the music you already own.

1-bit is on the App Store now, for iPhone and iPad running iOS 18.6 or later.

Just press play.