BakBeat Labs

Developing Truthful Software

Category: milestone

  • We Wrote a Track to a MiniDisc

    We Wrote a Track to a MiniDisc

    It finally happened.

    BakBeat successfully wrote a track to a MiniDisc in SP mode—and it plays back correctly on the device.

    No simulation. No partial success. No “almost there.”
    The device accepted the audio, wrote it, and plays it like it should.

    That’s been a long time coming.

    —

    What That Actually Means

    Getting to this point wasn’t just about sending data over USB.

    That write path depends on a bunch of things all working together:

    – Preparing audio in the exact format the device expects
    – Handling the NetMD transport correctly
    – Managing the device session and command flow
    – Sending a full, valid payload the device will actually accept

    If any of those pieces are wrong, the device either rejects it or produces garbage.

    So this isn’t just “we can write files”—it’s:

    > The pipeline is correct enough that a real MiniDisc player trusts what we’re sending it.

    —

    Everything Around It Got Rebuilt Too

    This didn’t happen in isolation.

    A lot of the recent work has been a full cleanup of how BakBeat handles devices and data.

    UI Structure

    We’ve been reworking the macOS app to be more consistent and predictable:

    – One shared structure for device views
    – Clear separation between mass storage devices and MiniDisc
    – No UI logic trying to guess device state

    The UI is back to doing what it should: rendering data, not inventing it.

    —

    MiniDisc Pipeline

    We also moved MiniDisc from “we can talk to it” to “we actually understand it.”

    There’s now a clean path:

    – Read the disc catalog (TOC)
    – Extract track-level data
    – Feed it through the CLI
    – Surface it in the UI

    That pipeline is shared—no duplicate parsing, no special cases.

    —

    Real Device Truth (No Guessing)

    A good example of that is recording mode.

    Instead of guessing based on duration or bitrate, we now read the actual encoding mode from the device for each track.

    Then we apply a simple rule:

    – If every track agrees → we show it
    – If anything is mixed or missing → we show nothing

    So when you see:

    json id=”2g0c9t” “mode”: “sp”

    …it’s coming directly from the device, not a heuristic.

    —

    Device Presence

    We also cleaned up device detection.

    Mass storage devices and MiniDisc used to share too much logic, which caused weird behavior. They’re now separate:

    – USB + mount for mass storage
    – Protocol-based detection for MiniDisc

    Merged at the end, not tangled together.

    Result:

    If the device is there, BakBeat sees it.
    If it’s not, it doesn’t pretend.

    —

    Where We Are Now

    MiniDisc support is in a much better place than it was even a few weeks ago:

    – Device detection is stable
    – Disc catalog reading works
    – Track metadata is coming through
    – Encoding mode is accurate
    – Disc-level mode is derived correctly
    – And we can write a track in SP mode end-to-end

    There’s still a lot left to do—especially around write UX, remaining time, and broader format support—but the hard part is no longer theoretical.

    It works.

    —

    Wrapping Up

    This wasn’t the most visible stretch of work.

    A lot of it was untangling systems, tightening boundaries, and fixing the kind of issues that quietly cause problems later.

    But this result makes it worth it:

    > BakBeat can now write to a MiniDisc and read it back with real, device-backed data.

    That’s a solid place to stop for the night.

    More soon.

  • Proof of life

    A small post, but an important one. We’ve spent alot of time on the foundations of BakBeat. DB models, application states, lots of REALLY dull back end pieces that, while critically important are not exactly flashy.

    But now we finally get to the fun. By no means a final UX, but it proves that our work was worth it.

    Here we have a iPod Nano 2G. One of many devices from bundles of random devices purchased from Ebay for our testing. We see. We can read it. We can see the artists, the albums, and the songs.

    Parsing the iTunesDB is no small feat, and it could not have been done without the work of many many people over the years who did a lot of work understanding it. Each device is its own special beast, so we’ll keep digging. But our foundation is solid. 

  • BakBeat Crossed a Line: The Audio Player Finally Feels Real

    For a long time, BakBeat had the hard part underneath it.

    It could scan libraries. It could read metadata. It had a growing CLI. It understood devices better than a normal music app ever needs to. It already had the bones of the thing.
    But “has the bones” and “feels like a real music player” are not the same.

    Over the last stretch of work, I did a full audio feature gap evaluation against the stuff people expect from a competent desktop music app. Not the fantasy roadmap version. The real one. Playlists. Repeat. Queue persistence. Ratings and favorites. Lyrics. Drag and drop. Mini player. Artwork. Sorting. Playback stats. Tag writing. The everyday stuff that makes a player usable instead of merely promising.

    And now, for the first time, BakBeat is on the other side of that line.

     

    What changed

    This pass closed a massive amount of ground.

    BakBeat now has a real playlist experience in the Mac app, backed by the same CLI-first system underneath it. Playback statistics are tracked. Favorites are first-class. Repeat modes persist. Queue state persists. Artwork shows up where it should. The app responds to media keys and publishes proper Now Playing info. Lyrics are visible. Drag and drop works. There is a proper mini player. Columns can be customized. Full-size artwork viewing is in.

    More importantly, those features were not bolted on as isolated UI tricks.

    They were implemented under the same rules the rest of the project uses:

    • CLI-first where it matters

    • explicit state over magic

    • deterministic behavior over silent background mutation

    • contract-first support claims instead of hand-wavy “probably works”

    That last one matters a lot.

     

    What BakBeat is not going to fake

    One of the clearest outcomes from this pass was confirming that some “expected” behaviors should stay out unless they can be done correctly.

    BakBeat does not auto-mutate your library because the filesystem changed behind your back. Scan and import remain explicit operations. Filesystem observation may inform the UI later, but it does not get to rewrite persisted library state on its own.

    That is not missing polish. That is the product rule.

    In the same category, gapless playback, crossfade, and EQ were intentionally moved into a later audio architecture review instead of being treated like quick checklist items. They depend on deeper engine decisions, and pretending otherwise would just create another pile of half-truths.

     

    Why this pass mattered

    A lot of software projects get stuck in the uncanny valley where the internals are impressive but the day-to-day experience still feels incomplete.

    This pass was about getting BakBeat out of that valley.

    It was about making sure the app can do the boring, normal, expected things that make people trust a player. The stuff users do constantly, not the fancy demo-path stuff.

    And because BakBeat is aimed at a stranger world than most players — old MP3 devices, MiniDisc workflows, explicit library state, CLI parity, future sync discipline — getting the standard player layer right matters even more. The weird stuff only works if the normal stuff is solid.

     

    What’s next

    This does not mean BakBeat is “done.” Not even close. It means the audio-player foundation is now much more believable.
    The next phase can be more honest and more focused:

    • deeper audio architecture work

    • expanded device flows

    • broader format and metadata support where proof exists

    • more refinement around the player experience itself

    That is a much better place to build from than “still missing half the obvious stuff.”

    BakBeat started as a dream of a modern iTunes for old hardware and honest libraries. After this gap pass, it finally feels less like a pile of promising subsystems and more like an actual player.

    And that is a big damn milestone.