[shakibbinkabir]

The Mac's Mochi bounces at 112 beats a minute whatever plays. On Windows the app can hear what the computer plays, so it can find the song's tempo and where its beats fall, and he lands on them. Off by default, one switch in Settings.

Recorded from the running app. So that three tempi sit side by side, the page was handed the three states by hand, in the shape the listener reports them; the live reading is further down.

Builds on #374 (the Spotify pill on Windows), which is not merged yet: the first two commits here are that PR's, unchanged. The two that are new are 595d993 and d142479. Once #374 is in, this is those two.

What the user sees

Nothing, until they ask: Settings → Integrations → Spotify → Dance to the song's beat. The row sits under "Announce new songs", built from the same row and hint as its neighbours, and is offered only where the song can be heard (Windows).

Before (as in #374)	After

With it on, a song starts on the Mac's 112, and about ten seconds in the bounce takes the song's tempo and lands on its beats. A pause or a seek keeps the tempo; where the beats fall is found again in a few seconds. Another song starts from scratch. Nothing else on screen changes: no new view, no new element in the island or the card.

How it works

Step	Where
What the default output plays is read through a WASAPI loopback, a tenth of a second at a time	beat.rs, tap
The sound is reduced, as it comes, to "how much just started": a hundred numbers a second. The sound itself is never held	taktus.rs, Ear
A follower reads those until two readings agree, settles on sixteen seconds, then rests and only looks again now and then (10 s, 20 s, 40 s, 60 s apart). The tap is closed while it rests	taktus.rs, Follower
The listener, the thread that already sleeps on Windows' media session in #374, tells the page a tempo and the time of one beat	spotify.rs, Ears, tell_beat
The dance counts from that beat at that tempo. Given none, it is the 112 it was, bit for bit	mochi/engine.ts, DanceClock

He dances between 80 and 160: a tempo read outside that is danced at half or double (dance_tempo).

Only while a Mochi is seen dancing. The page knows when one is (the compact island, Spotify's card in front, or Mochi on the desktop) and tells Rust when that changes (spotify_dancing). With the island hidden and nobody on the desktop, or the app paused, or the choice off, the tap is closed, no timer runs, and the thread sleeps on its channel exactly as in #374.

What it costs

Measured on the installed build (Windows 11, i7-1260P), on the listener's own thread (coucou-spotify, by thread times, 15.6 ms resolution):

	Processor used by the thread
Two minutes of playback across a song change, the busiest stretch (a new song is listened to for its first sixteen seconds)	125 ms, 0.10% of one core
One minute paused, the choice still on	0 ms (what wakes it then is Spotify updating its timeline, as in #374)

The engine by itself (its bench, same machine): 0.26 ms to hear a second of sound, 0.27 ms for a reading of sixteen seconds, and about a quarter of a song listened to. It holds about 9 KB while it listens.

Privacy

• Off by default. The row says what turning it on does: "Mochi listens to what the computer plays, a few seconds at a time, to find the song's tempo. Nothing is recorded or sent."
• Nothing of the sound is stored, written or sent. Each tenth of a second is turned into onset values and dropped; the follower keeps at most sixteen seconds of those numbers, and none while it rests.
• No network: the engine is std only and opens nothing, and nothing is added to the app.
• It is the whole output that is heard, not Spotify alone: Windows' plain loopback does not separate apps. That is why it is a choice, and why the row says "what the computer plays".

The engine in the tree

The listening is taktus, a tempo and beat engine. I am its author; I published it as 0.1.0 while writing this, so judge it as you would any new code. It is here as one file, windows/src-tauri/src/taktus.rs, so that the app takes on no dependency:

• One file, std only, no unsafe, no allocation while listening. 571 lines of code.
• Exactly the published source. Left out: the page of documentation at its top (its examples would run as this crate's doctests) and its tests, which live in its repository. The header says so. To check that nothing else differs (prints nothing):

  curl -sL https://raw.githubusercontent.com/shakibbinkabir/taktus/v0.1.0/src/lib.rs \
    | sed -n '/^use std::sync::LazyLock;/,/^\/\/ ── Tests/p' | sed '$d' \
    | diff -B --strip-trailing-cr - <(sed -n '/^use std::sync::LazyLock;/,$p' windows/src-tauri/src/taktus.rs)

• Licence. Apache-2.0, inside an MIT repository: the two go together, and what Apache asks is that its notice stays with the file. It is in the header, with the credit line. Nothing else is asked.
• How good it is, measured on the five sets the field uses (Ballroom, GTZAN, Giantsteps, Hainsworth, SMC), with the tempo counted right within 4% at the beat, or at twice, three times, half or a third of it (the field's "Accuracy2"): 99.0, 95.1, 95.9, 88.7 and 48.4% (the last is a set chosen for being hard: rubato, no drums). When the follower says it has a beat, it is right 95 to 99 times in 100 on the first four. The README has every figure, ten other libraries on the same files, and what the numbers do not show; taktus.thisissbk.com reads a song dropped on the page.

If you would rather have it as a crate (taktus = "0.1", which has no dependencies of its own), or would rather not have the file at all, say so and I will reshape this.

Against the repo's rules

• No third-party dependency: none added. Cargo.toml gains one feature of the windows crate already in use (Win32_Media_Audio_Endpoints).
• No telemetry, no network call: none.
• 0% CPU when the island is hidden: the listening is tied to a Mochi being seen dancing, not to music playing (measured above).
• Never restyle what ships: one row and one hint added to Settings, with the existing classes (screenshots above). No other view is touched.
• Pill IDs, Keychain, bundle identifier: untouched. settings.json gains danceToBeat, false when absent.
• Swift / macOS / iPhone: untouched. Linux compiles and tests the same code and keeps the 112: it has no tap yet.
• Not a release: no CHANGELOG section, no version change. windows/README.md gains a paragraph under what differs from the Mac.

Tested

• npx tsc --noEmit, npm test (379 pass), cargo test --workspace --locked (253 pass), on Windows 11.
• New tests, page side (tests/spotify.test.mjs): the bounce keeps any tempo it is given and is the Mac's when given none; the song's beat is danced to only when asked for, and no longer the moment it is not; Rust is told that somebody dances only when asked, once per change, through the island hiding, Mochi on the desktop, a pause, the app paused, and another pill's card in front.
• New tests, Rust side: the tempo he dances at for a beat read at any level (beat.rs); a drum fed as the app feeds it is followed to its tempo, with a beat within 40 ms of a drum and rests in between (beat.rs); a settings file from before reads with the choice off (settings.rs); the player's state carries no tempo until one is heard (spotify.rs).
• Live, on the installed build with a song playing in Spotify: the app was started mid-song, had no beat 8 seconds after launch and had one by 21 seconds, at 135.1 beats a minute; the next three looks said 134.86, 134.78 and 134.74, then it rested.
• The tap opens on this machine and hears nothing when nothing plays (cargo test -p coucou the_tap_hears_what_plays -- --ignored --nocapture).

Not tested, and known limits

• Bluetooth output. The loopback hears the sound before the device's own delay. On speakers and wired headphones that is a few tens of milliseconds; over Bluetooth he would land early by the device's latency. Not measured.
• Another app playing sound while Spotify plays blurs the reading (see Privacy). Windows can tap one process instead; a note in beat.rs says what it would take.
• Windows 10, a machine with no output device, and an output in exclusive mode: the tap fails to open and the song is left at 112 by construction, but none of the three was run.
• Whether a tempo is the beat or its double is partly convention, and the engine reads some songs at twice or half what a listener would tap. The dance hides most of that by folding into 80 to 160.
• Linux and macOS: nothing to test beyond the build and the tests, which are the same code.

Commits

1. 595d993 taktus in the tree. The file, and nothing that uses it.
2. d142479 Mochi dances to the song's own beat. Everything else. Needs the commit before it, and Windows: the Spotify pill through the system's media session, and an opt-in new-song announcement #374.

🤖 Generated with Claude Code

https://claude.ai/code/session_01NBruuRH1qTWSvSpxoV6mKT