u/185668232

Audio clip overdub would be helpful for filling out a set live. This in combination with the new copy from drum to clip (or clip to drum) would be extra special. But audio recording layers on top of layers (without resampling) would get us closer to looper/comper in audio and drum and simpler/sampler as well. Oh yeah, don’t forget performative reverse automation.

I’ll remind Schwung and RNBO to get a head start and let Note get it setup stable for Move.

<#tysm

Auto titling sets are Set # and that resets every time we have to wipe it. This is problematic for sampling live. Changing the titles before playing is not friendly to improvising. Finding the samples we need is the biggest problem. Data management needs a lot of help for Move.
<#

Anyone Automate Reverse Live?
It might be more of an MPC workflow.
When Move released reverse, it broke my heart how a live brand named company could make a feature found on 1990’s instruments, actually stop all playback to just reverse..
Maybe reverse is just not an Ableton style?
I thought it would be better as a knob to control how fast rewind or fast forward would be..
Doesn’t seem like RNBO or Schwung have much on that feature..
What do you think?
Reverse live? (This is in centercode votes.)

<#Respect ⏮️

Mind as well get bounce into the code if reverse gets upgraded.. forward to backward sounds so cool playing 1 pad while singing about the world around thru move auto shift!

<#Bounce 🔁

Trying my vibe code.
Claude finished the response
how to get the embedded lyrics from each song of my Bandcamp files, into Resolume Arena, so it will play along visually and sonically so that I can control the speed, direction, of song, with the lyrics scrolling. Then I can jam along on top and read the lyrics as well as know the key/mode/scale/bpm, next song up, information for key signatures and solos, mangling cues, staying in the pocket, crowd interaction, etc..

Architected multi-layer Resolume system for lyric extraction, playback control, and performance metadata display

Architected multi-layer Resolume system for lyric extraction, playback control, and performance metadata display

Here's a practical architecture for this — it's really three separate problems stacked together: extracting the lyrics, syncing them to tempo-flexible playback, and building a performer-facing info layer (key/mode/BPM/next-up/cues) on top of Resolume.

1. Extracting embedded lyrics from your Bandcamp files
   Bandcamp downloads (MP3/FLAC/AAC) can carry lyrics in metadata — the ID3 USLT frame (MP3) or a LYRICS/UNSYNCEDLYRICS Vorbis comment (FLAC). Whether yours actually have it depends on what you embedded when uploading to Bandcamp.
   I can write you a quick Python script (using mutagen) that batch-scans a folder of your tracks and dumps any embedded lyrics out to matching .txt or .lrc files, tagged with filename. If you upload a sample file or a folder, I can build and test it against your actual files right now.
   If the lyrics aren't embedded (common — Bandcamp doesn't require it), you'd need to pull from wherever you have the master lyric sheets and convert those into the same per-song .txt/.lrc format instead.
2. Getting lyrics into Resolume, synced to a scratchable/speed-variable song
   This is the part that usually trips people up, so here's the key design decision: Resolume changes playback speed and direction per-clip, as a single unit of audio+video. That means the only way lyrics stay glued to the music when you scratch/pitch/reverse it is if the lyrics and audio live in the same clip — not as two separately-triggered things you're hoping stay in phase.
   Two viable builds:
   Option A — Baked-in lyric video (most robust, less flexible)
   * Convert your .lrc/timestamped lyrics into a scrolling-text video using FFmpeg or a lyric-video tool, muxed with the song's audio into one clip.
   * Drop that clip into a Resolume layer. Its native Speed knob + reverse button now move audio and lyrics together, always in sync, at any playback rate.
   * Downside: re-baking is needed if you ever change the lyric timing.
   Option B — Live text layer driven by OSC/timecode (more flexible, more setup)
   * Play audio as a normal clip, and separately drive a Text source (Resolume Arena has a built-in Text generator) or an ISF/HTML text layer via OSC messages keyed to the clip's playhead position (Resolume exposes clip position over OSC).
   * A small script (Python/TouchDesigner/openFrameworks) reads Resolume's OSC playhead output, looks up your .lrc timestamps, and pushes the current line to the text layer.
   * This can follow speed/reverse changes in real time since it's driven by actual playhead position, not a fixed timeline — but it's more moving parts to build and maintain.
   Given you're already OSC/MIDI-comfortable (Force, Ableton), Option B is more powerful long-term, but Option A is the thing to build first if you want this working for a show soon.
3. Key/Mode/BPM/next-song/cue info for yourself
   This is really a performer monitor, separate from anything the audience sees — don't try to cram it into your projected visuals. Two clean approaches:
   * Resolume's per-clip Notes field: type your key/mode/BPM/cue reminders into each clip's Notes in the Composition — visible in the operator UI, invisible to the projected output. Fast to set up, zero extra tooling.
   * A dedicated second-screen cue sheet: a simple local webpage or app (could be a lightweight HTML page you build, shown on a phone/tablet propped at your rig) listing current song, key/mode/BPM, next song, and solo/cue notes — advanced by OSC from Resolume or manually by you/a bandmate. More visible mid-performance than digging through Resolume's UI.
   Want me to start with the lyric-extraction script (upload a sample track or two), or sketch the OSC/text-sync build first?

yes please - i will show it to both Resolume and Bandcamp, to see if they can make it even more fluent, with speech aided text detection for alignment - that is where you come in, with the code for that. TYSM!

Resolved copyright concerns and cleared path forward

Resolved copyright concerns and cleared path forward

Here are two scripts — one to pull out any embedded lyrics you already have, one to do forced alignment (time-stamping lyrics to the actual audio, even if the embedded tag has no timing at all).
Acknowledged copyright constraints and prepared alignment code solution

Acknowledged copyright constraints and prepared alignment code solution

How they fit together:

1. extract_lyrics.py — run this first against your Bandcamp download folder. It pulls anything already embedded (ID3 USLT, Vorbis LYRICS, MP4 ©lyr) into plain .txt files, and prints a clean list of which songs came up empty.
2. align_lyrics.py — for the songs with no embedded timing (which is most Bandcamp files, since Bandcamp doesn't require synced lyrics), this is the "speech-aided text detection" piece you asked about. It uses stable-ts (a timing-focused wrapper around Whisper) in alignment mode, not transcription mode — meaning it doesn't guess what's being sung, it takes your own correct lyric text and snaps Whisper's timing detection onto it. That's the important distinction for music: raw Whisper transcription chokes on singing, reverb, effects, and non-lyrics sections, but alignment against known-correct text is much more robust.
   Both need to run on your own machine (not here) — Whisper needs real compute and downloads model weights from outside the domains I'm allowed to reach. pip install stable-ts torch --break-system-packages, then:

python3 align_lyrics.py song.mp3 lyrics.txt --model small
Output is a standard .lrc file — timestamped lines like [00:16.80]lyric text here. That format is the bridge to the OSC-driven Resolume text layer we talked about: a small script watches Resolume's playhead position over OSC, looks up the current line by timestamp, and pushes it to a Text source live — so if you scratch/pitch/reverse the clip, the lyric line shown still tracks wherever the audio actually is.
When Resolume/Bandcamp look at this, the piece most worth asking them about is whether Resolume can expose playhead position over OSC at high enough resolution for word-level (not just line-level) sync — that determines whether you get line-by-line or word-by-word scrolling.
Once you've got a batch of .lrc files, I can write the OSC bridge script next — just say the word.

Extract lyrics
PY

Align lyrics
PY

this is only folders of bandcamp mp3 and wav files... to make sure code knows that
"How they fit together:

1. extract_lyrics.py — run this first against your Bandcamp download folder. It pulls anything already embedded (ID3 USLT, Vorbis LYRICS, MP4 ©lyr) into plain .txt files, and prints a clean list of which songs came up empty."

Reconciled MP3 and WAV metadata extraction across both audio formats

Reconciled MP3 and WAV metadata extraction across both audio formats

Good call — WAV metadata handling is different enough from MP3 that it's worth being explicit about. Updating the extraction script to only target .mp3 / .wav and handle WAV's ID3-in-RIFF-chunk correctly.
Acknowledged edit completion and flagged WAV lyric constraints

Acknowledged edit completion and flagged WAV lyric constraints

Updated. Key changes:
* File matching now restricted to .mp3 / .wav only — no more FLAC/M4A/OGG branches that would never trigger for your files.
* WAV handling added properly via mutagen.wave.WAVE. Worth knowing going in: WAV's ID3 tag block is an optional RIFF chunk, and a fair number of encoders (including some export paths Bandcamp uses) don't write one even when the MP3 of the same song does. So don't be surprised if extract_lyrics.py finds lyrics in your MP3s but comes up empty on the matching WAVs — that's not a bug, it just means those WAVs never had the tag to begin with, and they'll need to go through align_lyrics.py with a plain-text lyric sheet instead.
align_lyrics.py didn't need changes — Whisper/stable-ts reads MP3 and WAV natively either way.
One practical tip for your workflow: since WAV is likely your higher-fidelity master and MP3 the Bandcamp delivery copy, if a song's MP3 does have embedded lyrics but the WAV doesn't, you can skip alignment for that one entirely and just reuse the .txt pulled from the MP3 — no need to run Whisper on every file, only the true gaps.
Want the OSC bridge script next, or do you want to run these two against your actual folder first and see how many songs land in the "needs alignment" pile?

yes please include those: FLAC/M4A/OGG & MP4 / MOV

Orchestrated format expansion for metadata extraction capabilities

Orchestrated format expansion for metadata extraction capabilities

Extended to cover the full set. Summary of what changed:
* FLAC / OGG — reads the Vorbis comment block, checking LYRICS or UNSYNCEDLYRICS keys.
* M4A / MP4 — reads the ©lyr atom.
* MOV — routed through the same MP4 atom parser, since QuickTime and MP4 share container structure. Worth knowing: this one is a long shot — ©lyr is a music-file convention, and video-exported MOVs (like if you've got tour footage or visualizer renders sitting in the same folder) essentially never carry it. It's in there so a mixed folder won't throw an error or get silently skipped, not because you should expect hits from it.
One thing to flag before you run this at scale: with FLAC/WAV as your masters and MP3/MOV as secondary exports, you'll likely see the same song hit in one format and miss in another. The script reports per-file, not per-song, so when you review the "no embedded lyrics found" list, it's worth cross-checking by song title rather than assuming a miss means that song has no lyrics anywhere — it might just mean that particular file doesn't have them while its FLAC sibling does.
Run it against your actual folder and share the console output (or just the found/missing counts) whenever you're ready — I can help interpret which songs still need to go through align_lyrics.py.

LMK if you want the code downloads to try making them work! Hope it makes sense. Lmk.

<#

I play live a lot and like to change my keys quick for punchier sets. Yeah sure I like long build a beat DAWLESS jams as much as any freq. The process from start to finish, is a lot of fun on Move. But for most of us, the whole song is in one key anyway. So if anything with tuning or transpose (audio clip, keys, samples, fx), could globally tune (as a preset), that could be helpful tuning from the tracker button at the bottom.

That would make it worth while letting the drum pads show the pitch. Schwung tuners were very accurate. So it’s likely easily possible. Then with assistance from titling files and samples, it could be even more accurate.

Additionally, automating the global tuning of everything (like Moises) with knobs, could be realllllllly trippy! Seems like an Ableton stability chore; Schwung might get the code vibes but Ableton HQ would need to implement that and possible love implementing that in Note, Live and Push!

Maybe see what Discord thinks?

<#GlobalTuning

https://claude.ai/share/74cdc51b-56cd-46a8-ad66-e819f4530a31

"make code for an Ableton Move, Schwung or RNBO comping"

looper like in Live Suite2:07 AMClaude responded: Here's an interactive comping looper inspired by Ableton Live Suite's workflow.

::view-transition-group(*),

::view-transition-old(*),

::view-transition-new(*) {

animation-duration: 0.25s;

animation-timing-function: cubic-bezier(0.19, 1, 0.22, 1);

}

VvisualizeVvisualize show_widgetHere's an interactive comping looper inspired by Ableton Live Suite's workflow. Here's how to use it:

Takes — each row shows waveform thumbnails for recorded takes (T1, T2, T3…). Click + to add more. Click any take to audition it.

Comp row — the green strip below each track's takes shows the comp assignment. Click any take slot in the comp row to assign that take as the active comp for that section — this is the core comping gesture (like dragging take ranges in Live).

Transport — Play/Pause, Rec (arms/records), Stop, and Clear. Hit Rec while playing to capture a new take on the selected track (the button on each track row). The red track indicator shows which track is selected for recording.

Mute / Solo — M and S per track, just like Live's mixer.

To extend this into production-ready Max for Live or RNBO code, I can generate:

RNBO patch (JSON codebox) with poly~ voice allocation and buffer recording

Max for Live device (.amxd structure) with live.grid for take selection

JS/Web Audio API version for a browser DAW

----

Which direction do you want to take it? Anyone have something else that works? Can you make this work? I have Schwung and RNBO on Move but am not so confident in my coding hacking skills to not brick it...

<#TYSM

https://preview.redd.it/s5y19is5d76h1.png?width=2216&format=png&auto=webp&s=8ba716f0558be6d50ca06d7ad7205e40718e293f

got the move. what a fun piece of gear!
cant quite figure out some stuff yet but that's okay.

why not to make it a proper groovebox for performances though?
Meaning, arranging a track in song mode and then in performance mode let's say using the knobs as macro (assigning knobs however you please)

that would be a fantastic addition to this machine.