- The shelf is revealed in place: the decks don't stretch or squeeze as
the window parts.
- The DJ button is the top row's last box (where bpm was), so it stays
put; bpm moved under it.
- Tempo, vocals and the crossfader snap to their middle and show it. The
vocals slider has icons, lined up with its ends and middle.
- Sync sticks: a synced deck follows the other's tempo, glows and says
Synced until its own tempo fader moves. The ½×/1×/2× switch re-syncs,
and the BPM line says when it's counted half or double.
- A back-to-the-start button per deck.
- The air horn is a real recording (CC0): tap for the phrase, hold to
stretch the first blast.
- The zoomed waveforms ease out while a deck is paused or held.
- DJ audio follows a change of output device instead of going silent.
- A new playlist folder is named in place, scrolled into view.
- Visualizer bars: choose how many, 1 to 1024 (one per pixel at most).
- The volume slider is as tall as the scrubber.
- Preferences › DJ: vocals model (Best / Balanced / Fast) and gentle CPU
use (a quarter of the cores, lowest priority — measured only ~20%
slower). Splits are cached per model; a deck uses the best one.
- Prepare for DJ on a playlist or songs: BPM and vocals ahead of time.
- Each deck: a volume fader on the outer edge, labelled beside Tempo; a
½×/1×/2× switch for half/double-time counting.
- Drag a waveform to scrub (backwards too).
- Crossfader: a handle twice as tall, a middle line, a snap to centre;
narrower. "calculated, saved" is gone from the BPM line.
- Keep pitch shows a checkmark. An air horn to hold.
- The visualizer draws the mix; the sidebar art hides in DJ mode.
- The Library button has the transport buttons' 8 px corners.
Return or a double-click on a song started the regular player behind the
decks, with its controls greyed out and no way to stop it. DJ mode now
suspends the player. Sync to other track was only re-enabled when its own
deck changed, so loading the other deck afterwards left it grey; it's now
enabled whenever its deck has a song and explains what it can't do.
View > DJ Mode (or the turntable button under BPM) parts the window under
the transport boxes and opens a dark shelf: a record per deck (drag a song
on to load it; drag the record to scratch), play/pause and Sync to other
track beside it, a ±8% speed fader on each edge, Keep pitch, the two
waveforms stacked around one playhead, a vocals/instrumental slider and
the crossfader. Deck A is blue, Deck B orange; loaded songs are tagged in
the lists.
Its own engine (lintunes/dj): whole-song decode, tempo refined to 0.01
BPM plus the first beat (exact on synthetic kicks), WSOLA time-stretch or
varispeed, a QAudioSink on its own thread. Sync matches tempo and, while
both play, nudges the beats into line. A missing BPM is calculated and
saved. Vocals come from Demucs, run once per song in the background and
cached; Demucs lives in its own venv.
Now Playing: tap the art for it full screen, the title or artist line
for its album; shuffle, repeat and a new speakers button are icon pills.
The main menu is a list (Now Playing on top, Settings at the bottom, six
rows to a screen). The speakers button lists this Rabbit plus every
AirPlay speaker and Chromecast on the Wi-Fi: AirPlayRemote is the
desktop's RAOP sender in Java (verified from the R1 against
shairport-sync), CastRemote speaks the Cast protocol directly to the
Default Media Receiver and serves the file over HTTP (not yet tried on a
real Chromecast).
Held is now PRESSED_DARKER 125 (between Material 3 and GNOME), sunk, on
every button. Transport boxes no longer carry the face themselves (a
QFrame has no pressed state): each button does, so shuffle, repeat and
bpm sink while held and the play box's tiles act as separate buttons with
no grey hover patch. Scrollbar thumbs darken further while dragged. The
seek bar's groove and knob are twice as tall. The album art meets a 1 px
line in the lists' grey, without the pale blend that doubled it.
AirPlay: when LinTunes' own sender can't connect (or airplay_backend is
"cli"), Music Assistant's cliairplay is downloaded once, refused unless
its SHA-256 matches the pinned one, and streamed through.
The playlist list gets the panels' 8 px corners. The empty album-art panel
pops up as a plain button under the cursor and sinks darker while held.
The big art window keeps the art's shape after a resize and paints the
art to cover, so it never shows a background.
pyatv's handshakes play nothing on a WiiM; Music Assistant's cliairplay
plays on it through libraop's RAOP client. airplay/raop.py reproduces that
client's behaviour on the wire: one RTSP session with auth-setup, an
AppleLossless ANNOUNCE and RECORD carrying RTP-Info, OPTIONS keepalives,
a 2 s buffer, NTP-locked timestamps, a start that sends the first two
seconds at once, the timing responder and resends. Non-Apple speakers
stream through it; pyatv only finds them. Verified against shairport-sync
(decoded tone, flush on pause/seek, volume, metadata). Round 88's pyatv
compat hooks are gone.
- Typing in the library search now also narrows the playlist list to names
containing every word; folders stay when they or something inside match,
open while filtering, and clearing puts back the folders you had open.
- AirPlay: an unreadable /info reply no longer fails the stream (pyatv died
on shairport-sync's).
- Transport: a repeat button (off / all / one) between shuffle and the
visualizer. Repeat-all wraps the walk (a shuffled one is reshuffled per
lap); repeat-one replays a song that finishes, Next/Previous still move.
BPM button and the now-playing minimum shrink to make room.
- Clicking the streaming tile to stop casting/AirPlay no longer also opens
the big visualizer (the release after the stop counted as a click).
- AirPlay: pyatv's AirPlay 2 session is silent on a WiiM, and its AirPlay 1
pairs then talks plaintext, which the WiiM hangs up on. Non-Apple
speakers now get cliraop's handshake: auth-setup, no pairing, ALAC
(uncompressed frames). airplay_protocol "2" keeps pyatv's AirPlay 2.
tiat.place connects but stays silent; pyatv streams to it with its AirPlay 2
path, which the fake receiver never exercised. Log every stream's start,
first audio and outcome; config.json airplay_protocol (auto/1/2) forces a
version and airplay_debug turns on pyatv's own debug log.
Every song is decoded by the ffmpeg CLI and streamed over RAOP, so ALAC
and AIFF play too (only FairPlay is refused). pyatv has no pause or seek
for RAOP, so both restart the stream at the heard position. The picker
lists every AirPlay device on the network, greyed with the reason when
LinTunes can't stream to it (video-only TVs, PIN pairing). Casting and
AirPlay are mutually exclusive; the visualizer tile shows the AirPlay glyph
and a click there stops it. Needs: pip install -e . (adds pyatv).
The cones move only on the plugin's own 25 fps frames again: driving them
from fresh audio every refresh made bass-heavy songs twitch (a jump on 84%
of refreshes against 41%). The continuous turn, texture crossfade and the
GPU big window stay.
The tile: a click opens it big (and it stays blank while big); hovering
shows a colour wheel (colour / gray / off) and up/down arrows (previous /
next visualizer). No more double-click or click-to-cycle. The big album
art closes on a click or Esc, like the big visualizer.
The plugin still steps at its own 25 fps, frame for frame; between frames
the turn continues, textures crossfade, and the cone follows a preview of
the newest audio, so beats land a refresh sooner. The big window replays
the original's GL calls through OpenGL (QPainter took ~40 ms a frame at
1080p); without GL it falls back. Gray mode is only the gray-mode colour on
the panel background. The sync slider goes to -50 ms (sooner).
Reverse-engineered from its PowerPC binary and checked against the original
running under emulation: textures byte for byte and every triangle, over
3,600 frames. 25 fps like the plugin; its colour maps and wave images are
extracted from its own code; tests/kaleidostrobe_golden.npz was recorded
from the original.
Measured once per file with ffmpeg's ebur128 (cached on this machine),
applied as a gain on the output volume; the next songs are measured
ahead and an unmeasured one glides to its level. Toggle in Controls and
Preferences → General.
Export Web Mix gets an 'Upload to web server' box: the mix is built in a
cache staging folder and mirrored with rsync --delete into <path>/<slug>/
on the host set in Preferences → Integrations → Web Server (config.json,
this machine only). An ssh check asks before replacing an existing mix;
a status window follows check, export and upload. The web player gains a
shuffle button (and the S key).
With no art, the sidebar's art widget moves out of the playlist list's
frame onto the window below it, so the panel is set into the gray like the
visualizer rather than into a white box. A tall debossed panel is now
shaded along its top and bottom exactly as the 62 px visualizer is, flat
in the visualizer's color between, instead of one gradient stretched over
its whole height, which read as gray. The scrollbar thumb is shaded the
same way, like a button.
The sidebar's art square, when a track has no art, is now the list's own
background with a rounded panel set into it, debossed like the visualizer
and the now-playing panel. paint_deboss takes its rims in pixels when
asked, so a panel as tall as the sidebar is recessed as much as a short
one rather than fading over 16 px.
The app style now paints the scrollbars itself: the trough runs the full
length with no arrow buttons, and the thumb gets the buttons' 4 px corners
and emboss, with rims as tall in pixels as a button's however long the
thumb. Bar thickness moved from QSS to the style's pixel metric, since any
QSS rule on a scrollbar part makes Qt draw the whole bar, arrows included.
Ctrl+C (and Cut) on selected songs now also puts plain text on the
clipboard — one "Artist - Title" per line, in the order the table shows —
so a whole playlist pastes into a message or a document. Pasting back into
a playlist still reads the songs themselves, as before.
The headings were set with setFont, which the app's own style sheet
(theme.apply_theme) overrides on re-polish — bold in a bare dialog, plain
in the running app. A style sheet on the heading itself wins. The test now
applies the theme first, as the app does.
Get Info has a Volume slider (−100%…+100%): iTunes' own per-song volume
adjustment, which the library already imported but never used. It scales
the volume slider while that song plays; a boost can't pass full volume.
Works on one song or several (Mixed when they differ), and undoes.
Get Info's Previous/Next buttons are gone: since the combined multi-song
editor they were always disabled (and blank in some themes).
The laser settings draw the rig — speaker and mirror, laser, beam, and the
screen at its distance and angles — as a small textbook line drawing that
labels distance, angles and dot size in place of the sliders' numbers.
Preferences section headings are bold and 2 px larger than the text.
Each visualizer style's settings page has a Preset drop-down and a
"Save as Preset…" button. The drop-down lists the built-in Default, your
presets, and "Edit Presets…" (rename in place, delete); it reads "Custom"
whenever the settings match no preset. Presets sync with the preferences;
the per-machine sync delay is never part of one.
Laser: a two-handle "Speaker range" sets what the speaker under the mirror
plays (36 dB/octave edges; the noise floor is measured per range so treble
alone still shows). Bass-only gives clean loops; treble-only is a shimmer
along one line, as a membrane far above its resonances really draws.
The afterimage is now a phosphor buffer, dimmed each frame and rounded
down so it always fades to nothing — constant cost however long the fade
(drawing every past sweep ran the big window past a frame).
Line width is a number box stepping by 0.5; radial dots have a size slider.
Sync: decoding runs ahead of the speakers — by up to ~0.8 s after a GUI
stall, when buffers arrive in a burst — and the visualizer drew the newest
audio. It now keeps timestamped history and draws what the player says is
playing, plus a per-machine Sync delay (config.json) for latency Qt can't
see, like Bluetooth.
Every style has one Fade slider (0 = off); bars now leave fading steps.
Laser: afterimage time, line width down to 1 px, glow on/off, tip dot
on/off and size (a resting beam always shows its dot), and an oscilloscope
dot grid under the beam. Visualizer sliders run the full window width.
Highlight: click a swatch for a full color picker; the color picked
replaces that slot (right-click restores it).
Laser: the screen's distance, pitch, yaw and roll are sliders (the beam ray
is intersected with the turned screen; the drawing shrinks only when a
steep screen would push the figure out of view), and the afterimage can be
turned off. The membrane is now a slack 50 Hz balloon whose split rocking
pairs land in the bass, so it draws loops ~60% of the time instead of ~25%.
Radial: fading trails can be turned off; the number of frequency bands and
volume steps are sliders; ghosts fade from the dot's own color into the
background; a 4096-point FFT and interpolation end the flat bass arcs; and
"Even out bass and treble" takes the song's overall tilt out so the dots
sit on a circle.
Preferences → Appearance → Visualizer picks Bars (as before), Radial dots
(the EQ in a circle: angle is frequency, radius is volume, moving dots
leave light-gray ghosts that fade over a set time), or Laser (a mirror on
a speaker membrane bouncing a beam onto a screen: simulated membrane
modes, D·tan(2θ) reflection, dwell-weighted brightness). Double-clicking
the panel opens it big; a click closes it.
No identify dialog pops up mid-download any more: songs are looked up
quietly as they land and reviewed together once the last one is in, as
rows in the app's columns. Songs that are one album get the album-wide
fields once, unified, plus a cover from the album-art search. Ticked
rows apply as one undo step; unticked ones get the ordinary dialog
after. Popups wait for LinTunes to be the app in front.
A Spotify track, album or playlist is read off Spotify's public embed
page, each song found on YouTube by the result closest to Spotify's
length, downloaded with the song flags, tagged with Spotify's
artist/title/album/track number, then imported and identified.
Pasting a song from a YouTube Mix (watch?v=…&list=RD…) imported song
after song: yt-dlp takes the whole list by default, and a Mix runs to
thousands of rows and loops back on itself, so the linked song came in
again and again with nothing on screen saying why.
Now anything but a plain song link is listed first (--flat-playlist,
streamed into the dialog). One song goes straight through. Several become
a checklist: a song-in-a-list link ticks only its song and offers Just
This Song without waiting, and a playlist link ticks everything. Rows are
de-duplicated by id. The chosen songs download by their own pages, never
the list link, and more than one gets a per-song progress window (Hide
keeps downloading; the status-bar line brings it back).
The play journals keep running totals per track, which is enough for "most
played ever" and nothing a Wrapped asks: top songs of this year, minutes
listened, which month, what time of day, what got skipped. Those all come
from one timestamped line per listen, so LinTunes now keeps that, while
Preferences -> General -> "Keep a play history for my yearly Wrapped" is on.
history/<machine>/<YYYY-MM>.jsonl, one writer per folder like the journals:
local start time with its offset, ms actually heard (Player adds position
steps under 1.5 s, so seeks and pauses don't count), how it ended, where it
played and from what, and a name/artist/album snapshot that outlives a
delete. Under 5 s is noise and never written.
andTunes 0.3.0 writes the same lines on the Rabbit when sync says the
desktop wants them, and sync copies each month home when the device's copy
is longer. "Share this year's play history with friends" puts a trimmed
copy (no ids, playlists or devices) in each friend's cassette folder, daily
in November and December and monthly otherwise.
Spectral-flux onsets + autocorrelation in numpy, decoded by the ffmpeg CLI;
no new dependency. Runs on a worker with the status-bar progress bar, for
one track or many, and the batch is one Ctrl+Z.
On Wayland Qt paints the title bar through its adwaita decoration plugin,
which hardcodes pure white in light mode and ignores the palette. Every
window now goes frameless and gets an app-drawn bar in the palette's Window
color, so it follows the Background setting. Buttons follow GNOME's
button-layout; moving, snapping and edge resizing still go through the
compositor. Windows grow by the bar's height so their contents keep the
size they had.