circuitpython-synthtools 0.6.0__tar.gz → 0.8.0__tar.gz

{circuitpython_synthtools-0.6.0 → circuitpython_synthtools-0.8.0}/.gitignore

@@ -50,6 +50,13 @@ _build
 
 # todstuff
 tmp
+# scratch. Also what keeps `reuse` off it: that hook is pass_filenames:false,
+# so .pre-commit-config.yaml's exclude never reaches it, but REUSE skips
+# whatever git ignores.
+temp/
 
 # not ready for tracking/CI yet
 docs/diagrams/
+
+# regenerable render-harness output (FINDINGS.md is tracked)
+tests/render/out/

{circuitpython_synthtools-0.6.0 → circuitpython_synthtools-0.8.0}/.pre-commit-config.yaml

@@ -19,4 +19,4 @@ repos:
     rev: v6.2.0
     hooks:
       - id: reuse
-exclude: 'docs/.*|tests/.*'
+exclude: 'docs/.*|tests/.*|temp/.*'

{circuitpython_synthtools-0.6.0/circuitpython_synthtools.egg-info → circuitpython_synthtools-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: circuitpython-synthtools
-Version: 0.6.0
+Version: 0.8.0
 Summary: CircuitPython helper library to do help doing synthio
 Author-email: Tod Kurt <tod@todbot.com>
 License: MIT
@@ -125,16 +125,17 @@ Usage Example
 What's Included
 ===============
 
+* ``Patch`` -- inert, JSON-able patch data; save/load with
+  ``save_patches()`` / ``load_patches()``
 * ``Synth`` -- synth engine base: shared voice, patch, and modulation handling,
-  with ``mono`` mode for a single-voice synth with ``glide_time``  portamento
+  complex filter & pitch envelopes, and a ``mono`` mode for a single-voice
+  synth with ``glide_time``  portamento
 * ``SubtractiveSynth`` -- subtractive two-oscillator synth w/ detune
+* ``WavetableSynth`` -- wavetable-playback with adjustable LFO for wave_pos
 * ``FMSynth`` -- two-operator phase-modulation voice: a carrier waveform
   pre-rendered from ``sin(theta + fm_index*sin(fm_ratio*theta))``.
   ``fm_ratio`` must be an integer; ``fm_index`` is PM depth in radians,
-  0 = plain single-oscillator. (Not a live audio-rate bend modulator --
-  synthio's Math/LFO blocks only update every 256 samples, too slow for
-  that; see the module docstring for why.)
-* ``WavetableSynth`` -- wavetable-playback with adjustable wave_pos
+  0 = plain single-oscillator. (Not a full FM synth, see module for details)
 * ``BasslineSynth`` -- TB-303-style acid bassline: monophonic, one
   oscillator, a decay-only filter sweep, per-step slide and accent. Can
   own its own filter/distortion/echo effects chain via ``fx_*`` patch
@@ -144,23 +145,23 @@ What's Included
   ``tracking_filter()`` builds extra filter stages that follow the synth's
   own cutoff and resonance for a steeper slope (needs ``audiofilters`` in
   the build)
-* ``Patch`` -- inert, JSON-able patch data; save/load with
-  ``save_patches()`` / ``load_patches()``
+* ``Waves`` -- waveform factory (saw, square, sine, triangle, noise, and
+  "analog" variants)
 * ``Wavetable`` -- loads a wavetable WAV file and lerps between frames
 * ``AHREnvelope`` -- shared-block attack/release envelope, used for both
   the filter and pitch envelopes
-* ``Waves`` -- waveform factory (saw, square, sine, triangle, noise, and
-  "analog" variants)
 * ``Arpeggiator`` / ``StepSequencer`` / ``TrigSequencer`` -- poll-based
   sequencers with on/off callbacks
-* ``Param`` / ``ParamSet`` -- knob-pickup and scaling for UIs with fewer
-  knobs than parameters
-* ``ParamScaler`` -- proportional ("scale") knob takeover for a single
-  control, when you are not using ``ParamSet``
-* ``GaugeCluster`` -- a bar-graph display of a parameter page
 * ``Glider`` -- a standalone pitch-slide block for hand-built
   ``synthio.Note`` graphs (the engines above have their own portamento,
   via ``mono`` + ``glide_time``)
+* ``Scale`` / ``chord`` -- scales and diatonic/chromatic chords for
+  mapping pads and MIDI onto pitch
+* ``Param`` / ``ParamSet`` -- (UI) knob-pickup and scaling for UIs with fewer
+  knobs than parameters
+* ``ParamScaler`` -- (UI) proportional ("scale") knob takeover for a single
+  control, when you are not using ``ParamSet``
+* ``GaugeCluster`` -- (UI) a bar-graph display of a parameter page
 * ``RollingAverage`` -- moving-average smoothing for noisy knob reads
 
 Documentation

{circuitpython_synthtools-0.6.0 → circuitpython_synthtools-0.8.0}/README.rst

@@ -105,16 +105,17 @@ Usage Example
 What's Included
 ===============
 
+* ``Patch`` -- inert, JSON-able patch data; save/load with
+  ``save_patches()`` / ``load_patches()``
 * ``Synth`` -- synth engine base: shared voice, patch, and modulation handling,
-  with ``mono`` mode for a single-voice synth with ``glide_time``  portamento
+  complex filter & pitch envelopes, and a ``mono`` mode for a single-voice
+  synth with ``glide_time``  portamento
 * ``SubtractiveSynth`` -- subtractive two-oscillator synth w/ detune
+* ``WavetableSynth`` -- wavetable-playback with adjustable LFO for wave_pos
 * ``FMSynth`` -- two-operator phase-modulation voice: a carrier waveform
   pre-rendered from ``sin(theta + fm_index*sin(fm_ratio*theta))``.
   ``fm_ratio`` must be an integer; ``fm_index`` is PM depth in radians,
-  0 = plain single-oscillator. (Not a live audio-rate bend modulator --
-  synthio's Math/LFO blocks only update every 256 samples, too slow for
-  that; see the module docstring for why.)
-* ``WavetableSynth`` -- wavetable-playback with adjustable wave_pos
+  0 = plain single-oscillator. (Not a full FM synth, see module for details)
 * ``BasslineSynth`` -- TB-303-style acid bassline: monophonic, one
   oscillator, a decay-only filter sweep, per-step slide and accent. Can
   own its own filter/distortion/echo effects chain via ``fx_*`` patch
@@ -124,23 +125,23 @@ What's Included
   ``tracking_filter()`` builds extra filter stages that follow the synth's
   own cutoff and resonance for a steeper slope (needs ``audiofilters`` in
   the build)
-* ``Patch`` -- inert, JSON-able patch data; save/load with
-  ``save_patches()`` / ``load_patches()``
+* ``Waves`` -- waveform factory (saw, square, sine, triangle, noise, and
+  "analog" variants)
 * ``Wavetable`` -- loads a wavetable WAV file and lerps between frames
 * ``AHREnvelope`` -- shared-block attack/release envelope, used for both
   the filter and pitch envelopes
-* ``Waves`` -- waveform factory (saw, square, sine, triangle, noise, and
-  "analog" variants)
 * ``Arpeggiator`` / ``StepSequencer`` / ``TrigSequencer`` -- poll-based
   sequencers with on/off callbacks
-* ``Param`` / ``ParamSet`` -- knob-pickup and scaling for UIs with fewer
-  knobs than parameters
-* ``ParamScaler`` -- proportional ("scale") knob takeover for a single
-  control, when you are not using ``ParamSet``
-* ``GaugeCluster`` -- a bar-graph display of a parameter page
 * ``Glider`` -- a standalone pitch-slide block for hand-built
   ``synthio.Note`` graphs (the engines above have their own portamento,
   via ``mono`` + ``glide_time``)
+* ``Scale`` / ``chord`` -- scales and diatonic/chromatic chords for
+  mapping pads and MIDI onto pitch
+* ``Param`` / ``ParamSet`` -- (UI) knob-pickup and scaling for UIs with fewer
+  knobs than parameters
+* ``ParamScaler`` -- (UI) proportional ("scale") knob takeover for a single
+  control, when you are not using ``ParamSet``
+* ``GaugeCluster`` -- (UI) a bar-graph display of a parameter page
 * ``RollingAverage`` -- moving-average smoothing for noisy knob reads
 
 Documentation

{circuitpython_synthtools-0.6.0 → circuitpython_synthtools-0.8.0/circuitpython_synthtools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: circuitpython-synthtools
-Version: 0.6.0
+Version: 0.8.0
 Summary: CircuitPython helper library to do help doing synthio
 Author-email: Tod Kurt <tod@todbot.com>
 License: MIT
@@ -125,16 +125,17 @@ Usage Example
 What's Included
 ===============
 
+* ``Patch`` -- inert, JSON-able patch data; save/load with
+  ``save_patches()`` / ``load_patches()``
 * ``Synth`` -- synth engine base: shared voice, patch, and modulation handling,
-  with ``mono`` mode for a single-voice synth with ``glide_time``  portamento
+  complex filter & pitch envelopes, and a ``mono`` mode for a single-voice
+  synth with ``glide_time``  portamento
 * ``SubtractiveSynth`` -- subtractive two-oscillator synth w/ detune
+* ``WavetableSynth`` -- wavetable-playback with adjustable LFO for wave_pos
 * ``FMSynth`` -- two-operator phase-modulation voice: a carrier waveform
   pre-rendered from ``sin(theta + fm_index*sin(fm_ratio*theta))``.
   ``fm_ratio`` must be an integer; ``fm_index`` is PM depth in radians,
-  0 = plain single-oscillator. (Not a live audio-rate bend modulator --
-  synthio's Math/LFO blocks only update every 256 samples, too slow for
-  that; see the module docstring for why.)
-* ``WavetableSynth`` -- wavetable-playback with adjustable wave_pos
+  0 = plain single-oscillator. (Not a full FM synth, see module for details)
 * ``BasslineSynth`` -- TB-303-style acid bassline: monophonic, one
   oscillator, a decay-only filter sweep, per-step slide and accent. Can
   own its own filter/distortion/echo effects chain via ``fx_*`` patch
@@ -144,23 +145,23 @@ What's Included
   ``tracking_filter()`` builds extra filter stages that follow the synth's
   own cutoff and resonance for a steeper slope (needs ``audiofilters`` in
   the build)
-* ``Patch`` -- inert, JSON-able patch data; save/load with
-  ``save_patches()`` / ``load_patches()``
+* ``Waves`` -- waveform factory (saw, square, sine, triangle, noise, and
+  "analog" variants)
 * ``Wavetable`` -- loads a wavetable WAV file and lerps between frames
 * ``AHREnvelope`` -- shared-block attack/release envelope, used for both
   the filter and pitch envelopes
-* ``Waves`` -- waveform factory (saw, square, sine, triangle, noise, and
-  "analog" variants)
 * ``Arpeggiator`` / ``StepSequencer`` / ``TrigSequencer`` -- poll-based
   sequencers with on/off callbacks
-* ``Param`` / ``ParamSet`` -- knob-pickup and scaling for UIs with fewer
-  knobs than parameters
-* ``ParamScaler`` -- proportional ("scale") knob takeover for a single
-  control, when you are not using ``ParamSet``
-* ``GaugeCluster`` -- a bar-graph display of a parameter page
 * ``Glider`` -- a standalone pitch-slide block for hand-built
   ``synthio.Note`` graphs (the engines above have their own portamento,
   via ``mono`` + ``glide_time``)
+* ``Scale`` / ``chord`` -- scales and diatonic/chromatic chords for
+  mapping pads and MIDI onto pitch
+* ``Param`` / ``ParamSet`` -- (UI) knob-pickup and scaling for UIs with fewer
+  knobs than parameters
+* ``ParamScaler`` -- (UI) proportional ("scale") knob takeover for a single
+  control, when you are not using ``ParamSet``
+* ``GaugeCluster`` -- (UI) a bar-graph display of a parameter page
 * ``RollingAverage`` -- moving-average smoothing for noisy knob reads
 
 Documentation

{circuitpython_synthtools-0.6.0 → circuitpython_synthtools-0.8.0}/circuitpython_synthtools.egg-info/SOURCES.txt

@@ -38,8 +38,6 @@ docs/_static/favicon.ico
 docs/_static/favicon.ico.license
 examples/REUSE.toml
 examples/arpeggiator_demo.py
-examples/step_sequencer_bassdemo.py
-examples/step_sequencer_demo.py
 examples/synth_setup.py
 examples/synthinst_code1.py
 examples/synthinst_fenv_demo.py
@@ -47,11 +45,16 @@ examples/synthinst_pad_demo.py
 examples/synthinst_pitch_demo.py
 examples/synthinst_wave_demo.py
 examples/synthtools_ahr_envelope_bend.py
-examples/synthtools_bassline_demo.py
+examples/synthtools_bassline_accent_demo.py
+examples/synthtools_bassline_filter_demo.py
+examples/synthtools_bassline_fx_demo.py
 examples/synthtools_fm_demo.py
+examples/synthtools_harmony_demo.py
 examples/synthtools_midi_demo.py
 examples/synthtools_simpletest.py
+examples/synthtools_stepsequencer_demo.py
 examples/synthtools_swarm_demo.py
+examples/synthtools_wavetable_chords.py
 examples/synthtools_wavetable_simple.py
 examples/trig_sequencer_demo.py
 examples/ui/synthtools_gaugecluster_test.py
@@ -75,6 +78,7 @@ synthtools/bassline_synth.py
 synthtools/blocks.py
 synthtools/fm_synth.py
 synthtools/gauge_cluster.py
+synthtools/harmony.py
 synthtools/param_scaler.py
 synthtools/paramset.py
 synthtools/patch.py
@@ -95,16 +99,28 @@ tests/test_arpeggiator.py
 tests/test_audio_fx.py
 tests/test_env_shapes.py
 tests/test_fm_synth.py
+tests/test_harmony.py
 tests/test_mono.py
 tests/test_param_scaler.py
 tests/test_paramset.py
 tests/test_patch.py
 tests/test_pytest_smoke.py
 tests/test_swarm_synth.py
+tests/test_trig_sequencer.py
 tests/test_wiring.py
 tests/hw/run_on_device.py
 tests/hw/test_device.py
 tests/hw/test_display_cost.py
+tests/hw/test_trig_sequencer_timing.py
+tests/hw/test_wavetable_cost.py
+tests/render/FINDINGS.md
+tests/render/README.md
+tests/render/analyze_renders.py
+tests/render/check_wavetable.py
+tests/render/check_wavetable_synth.py
+tests/render/render_chords.py
+tests/render/run.sh
+tests/render/wavhdr.py
 tests/stubs/synthio.py
 tests/stubs/ulab/__init__.py
 tests/stubs/ulab/numpy.py

{circuitpython_synthtools-0.6.0 → circuitpython_synthtools-0.8.0}/conftest.py

@@ -14,4 +14,6 @@
 #     alongside their sibling modules, not run from this tree.
 #   - tests/hw/test_device.py needs a real synthio: it only runs on
 #     actual hardware (see tests/README.md).
-collect_ignore_glob = ["examples/*", "tests/hw/*"]
+#   - tests/render/* imports synthio/ulab and runs under a CircuitPython unix
+#     build via tests/render/run.sh, never pytest.
+collect_ignore_glob = ["examples/*", "tests/hw/*", "tests/render/*"]

{circuitpython_synthtools-0.6.0 → circuitpython_synthtools-0.8.0}/docs/api.rst

@@ -82,6 +82,12 @@ Waves
 .. automodule:: synthtools.waves
     :members:
 
+Harmony
+=======
+
+.. automodule:: synthtools.harmony
+    :members:
+
 Arpeggiator
 ===========
 

circuitpython_synthtools-0.8.0/docs/examples.rst

@@ -0,0 +1,90 @@
+Simple test
+------------
+
+Simple bass synth showing Patch and SubtractiveSynth
+
+.. literalinclude:: ../examples/synthtools_simpletest.py
+    :caption: examples/synthtools_simpletest.py
+    :linenos:
+
+Synth filter envelope demo
+--------------------------
+
+Show how to use Synth's complex filter envelope using AHREnvelope
+
+.. literalinclude:: ../examples/synthinst_fenv_demo.py
+    :caption: examples/synthtools_fenv_demo.py
+    :linenos:
+
+Synth pitch modulation demo
+---------------------------
+
+Show how to use Synth's pitch modulation features
+
+.. literalinclude:: ../examples/synthinst_pitch_demo.py
+    :caption: examples/synthtools_pitch_demo.py
+    :linenos:
+
+Wavetable synth demo
+--------------------
+
+Demonstrate Wavetable use with an LFO on wave position
+
+.. literalinclude:: ../examples/synthtools_wavetable_simple.py
+    :caption: examples/synthtools_wavetable_simple.py
+    :linenos:
+
+Swarm synth demo
+----------------
+
+Like the Dewanatron Swarmatron: eight oscillators on one pitch, pulled apart
+and back under a held drone.
+
+.. literalinclude:: ../examples/synthtools_swarm_demo.py
+    :caption: examples/synthtools_swarm_demo.py
+    :linenos:
+       
+
+FM synth demo
+-------------
+
+A bright DX-style FM bell using FMSynth, with a live fm_ratio / fm_index sweep
+
+.. literalinclude:: ../examples/synthtools_fm_demo.py
+    :caption: examples/synthtools_fm_demo.py
+    :linenos:
+
+Acid bassline demos: filter/envelope/decay, accent/slide, fx
+------------------------------------------------------------
+
+Monophonic TB-303-style bassline using BasslineSynth, sweeping filter
+cutoff, envelope depth (envmod), decay time, and the oscillator waveform
+
+.. literalinclude:: ../examples/synthtools_bassline_filter_demo.py
+    :caption: examples/synthtools_bassline_filter_demo.py
+    :linenos:
+
+The same bassline, sweeping the two per-step 303 flags: accent and slide
+
+.. literalinclude:: ../examples/synthtools_bassline_accent_demo.py
+    :caption: examples/synthtools_bassline_accent_demo.py
+    :linenos:
+
+The same bassline again, through BasslineSynth's owned effects chain:
+an extra filter stage, distortion, and a tempo-synced echo
+
+.. literalinclude:: ../examples/synthtools_bassline_fx_demo.py
+    :caption: examples/synthtools_bassline_fx_demo.py
+    :linenos:
+
+Harmony demo
+------------
+
+Walk scales and play diatonic chords with harmony.Scale, cycling through a
+short chord progression
+
+.. literalinclude:: ../examples/synthtools_harmony_demo.py
+    :caption: examples/synthtools_harmony_demo.py
+    :linenos:
+
+ 

{circuitpython_synthtools-0.6.0 → circuitpython_synthtools-0.8.0}/examples/synth_setup.py

@@ -5,6 +5,8 @@
 # part of todbot circuitpython synthio tutorial
 # 10 Feb 2025 - @todbot / Tod Kurt
 #
+import sys
+
 import analogio
 import audiobusio
 import audiomixer
@@ -15,6 +17,11 @@ import synthio
 SAMPLE_RATE = 22050
 CHANNEL_COUNT = 2
 BUFFER_SIZE = 2048
+if sys.platform == "RP2040":
+    SAMPLE_RATE = 22050
+    CHANNEL_COUNT = 1
+    BUFFER_SIZE = 4096
+
 
 # what we have plugged into the breadboard or pico_test_synth
 button_pins = (board.GP28,)
@@ -40,7 +47,7 @@ audio.play(mixer)
 
 # plug the synth into the first 'voice' of the mixer
 mixer.voice[0].play(synth)
-mixer.voice[0].level = 0.25  # 0.25 usually better for headphones, 1.0 for speakers
+mixer.voice[0].level = 0.35  # 0.25 usually better for headphones, 1.0 for speakers
 
 # more on this later, but makes it sound nicer
 synth.envelope = synthio.Envelope(attack_time=0.0, release_time=0.6)

circuitpython_synthtools-0.8.0/examples/synthtools_bassline_accent_demo.py

@@ -0,0 +1,219 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 Tod Kurt
+# SPDX-License-Identifier: MIT
+#
+# synthtools_bassline_accent_demo.py -- acid bassline: the two per-step
+# 303 flags, accent and slide.
+#
+# Plays one 16-step pattern over and over, changing a single knob every few
+# bars and printing what it changed, so you can hear each one on its own.
+# One of three focused demos split out of a single, too-broad one; see
+# synthtools_bassline_filter_demo.py (filter/envmod/decay) and
+# synthtools_bassline_fx_demo.py (distortion/echo) for the rest, including
+# why the patch fields below are set the way they are.
+#
+#   slide   glide the pitch into this step from the one before
+#   accent  a louder, brighter, more resonant step
+#
+# A slide TIES the two steps into one held note, as the original does: the
+# pitch glides and the envelopes keep running. That needs the gate held, so
+# the loop below skips its note_off() whenever the NEXT step slides. Being
+# monophonic, the synth steals its own sounding voice otherwise, so the loop
+# still never has to track what is playing.
+
+import microcontroller
+
+# 200 MHz, up from the 125 MHz boot default. The main loop shares the CPU
+# with the audio renderer, so the headroom shows up as steadier step
+# timing, not just as spare cycles. Set BEFORE synth_setup is imported:
+# rp2040's I2S clock is derived from sys_clk, so changing it afterwards
+# would move the sample rate out from under the audio that is already
+# running. Same placement as synthtools_wavetable_chords.py.
+microcontroller.cpu.frequency = 200_000_000
+
+import time
+
+from synth_setup import mixer
+from synth_setup import synth as engine
+
+from synthtools import BasslineSynth, Patch
+
+try:
+    from supervisor import ticks_ms
+except ImportError:  # desktop CPython, for a syntax check
+
+    def ticks_ms():
+        """stand-in for supervisor.ticks_ms"""
+        return time.monotonic_ns() // 1_000_000
+
+
+# --- the patch: same acid preset as synthtools_bassline_filter_demo.py --
+patch = Patch(
+    name="acid",
+    synth_type="bassline",
+    wave="SAW",
+    filt_type="LPF",
+    filt_f=1200,
+    # filt_q up at 4.0: on this engine resonance also drives how DEEP an
+    # accent sweeps and how fast it arrives, and at 1.8 the lag is ~9ms
+    # and inaudible. accent_cutoff is scaled to match: the accent boost is
+    # multiplied by (0.35 + 0.65*resonance), so 5268 at this filt_q lands
+    # the same Hz that a flat 4000 used to.
+    filt_q=4.0,
+    envmod=0.75,
+    # Decay far longer than a step, so the level is essentially flat for as
+    # long as the gate is open. That is the stock 303 (its VCA envelope
+    # decay is fixed near 3.5s, untouched by the Decay knob) and it is what
+    # keeps a TIED note audible through its second step; at 0.25s a slide
+    # landed on a note that had already faded out.
+    amp_env=[0.003, 3.5, 0.0, 0.05],
+    fenv_attack=0.09,
+    fenv_release=0.05,
+    fenv_curve=3,
+    # what an accented step gets, on top of the resting patch above
+    accent=0.6,
+    accent_cutoff=5268,  # Hz added at full accent
+    accent_q=0.8,  # resonance added at full accent
+    amp_level=0.75,  # un-accented level, so accents have room to be louder
+    slide_time=0.09,
+    transpose=0,
+)
+
+synth = BasslineSynth(engine, patch)
+# synthio directly, no fx chain: this demo is about the two per-step
+# flags. The other two set fx_hpf_f and play synth.output instead.
+mixer.voice[0].play(synth.synthio)  # replaces synth_setup's direct hookup
+
+# --- the pattern --------------------------------------------------------
+# (midi_note, slide, accent), or None for a rest.
+PATTERN = (
+    (36, False, True),
+    (36, False, False),
+    (48, True, False),
+    (36, False, False),
+    (39, False, True),
+    (36, True, False),
+    (43, False, False),
+    (36, False, False),
+    (36, False, True),
+    (41, True, True),
+    (36, False, False),
+    (48, False, True),
+    (36, True, False),
+    (34, False, False),
+    (36, False, False),
+    (43, False, True),
+)
+
+BPM = 110
+STEP_MS = int(60_000 / BPM / 4)  # sixteenth notes, in ms
+# GATE also has to leave the filter sweep room: the envelope only runs
+# while the note is held, so GATE*step must stay LONGER than `decay` or the
+# sweep is cut off partway and envmod does less than its number suggests.
+GATE = 0.9  # fraction of a step a note is held for
+
+# note_on() re-aims the shared glide node on EVERY note-on, slide or not
+# (a non-slide step passes glide=0.0, which snaps in ~1ms), so slide_time
+# can never exceed roughly one step (~136ms here) and be heard in full: the
+# next note-on always cuts it off first. The "lazy slide" CHANGES entry
+# below needs actual room, so it widens step_scale for its own window
+# instead of raising slide_time past that ceiling. A mutable single-element
+# list so the CHANGES closures can rebind it; the main loop reads it fresh
+# every step.
+step_scale = [1.0]
+
+
+def _lazy_slide_on():
+    synth.slide_time = 0.3
+    step_scale[0] = 3.0  # ~409ms/step: room for a slide_time of 0.3 to finish
+
+
+def _lazy_slide_off():
+    synth.slide_time = 0.09
+    step_scale[0] = 1.0
+
+
+# Each entry is (label, function), applied for BARS_PER_CHANGE bars each.
+BARS_PER_CHANGE = 2
+CHANGES = (
+    ("accent 0.0, accented steps stop standing out", lambda: setattr(synth, "accent", 0.0)),
+    ("accent 1.0, and now they really do", lambda: setattr(synth, "accent", 1.0)),
+    ("accent 0.6", lambda: setattr(synth, "accent", 0.6)),
+    (
+        "slide_time 0.005, slides become almost instant",
+        lambda: setattr(synth, "slide_time", 0.005),
+    ),
+    (
+        "slide_time 0.3, step time x3: room for a real lazy slide",
+        _lazy_slide_on,
+    ),
+    ("slide_time 0.09, step time normal again", _lazy_slide_off),
+)
+
+print("bassline accent/slide demo: %d steps at %d bpm" % (len(PATTERN), BPM))
+
+# The loop schedules off monotonic_ns and ACCUMULATES the step interval
+# rather than sleeping for it. Sleeping drifts: the note_on/note_off work
+# (~5.7ms on an rp2040) lands on top of every sleep, so a 113ms step ran at
+# 119ms, about 5% slow, and nothing ever caught it back up. Accumulating
+# step_at absorbs the work instead. The 1ms sleep keeps the poll from
+# spinning flat out and competing with the audio render.
+#
+# It also has to be one flat loop rather than a for-loop over PATTERN: a
+# step that TIES into the next one holds its gate open past its own step,
+# so the note-off has to be scheduled independently of where the sequence
+# has got to.
+
+# Timing follows the house sequencer idiom (trig_sequencer.py): poll as
+# fast as possible on ticks_ms, accumulate the step interval so the work
+# in a step is absorbed rather than added to it, and RESYNC if a stall put
+# us a whole step behind instead of burst-firing to catch up.
+#
+# ticks_ms, not time.monotonic_ns: past boot monotonic_ns exceeds 2**30, so
+# every call allocates a bigint -- measured 21us and ~0.5 bytes a call
+# against 13us and none, which at poll rates is real GC churn, and a GC
+# pause lands as a late step.
+#
+# It also has to be one flat loop rather than a for-loop over PATTERN: a
+# step that TIES into the next one holds its gate open past its own step,
+# so the note-off has to be scheduled independently of where the sequence
+# has got to.
+
+bar = 0
+i = 0
+sounding = None
+gate_off_at = None
+next_step = ticks_ms()
+
+while True:
+    now = ticks_ms()
+
+    if gate_off_at is not None and now - gate_off_at >= 0:
+        synth.note_off(sounding)
+        sounding = gate_off_at = None
+
+    if now - next_step >= 0:
+        step_millis = int(STEP_MS * step_scale[0])
+        if i == 0:
+            if bar % BARS_PER_CHANGE == 0:
+                label, apply = CHANGES[(bar // BARS_PER_CHANGE) % len(CHANGES)]
+                print("  %s" % label)
+                apply()
+            bar += 1
+
+        step = PATTERN[i]
+        if step is not None:
+            note, slide, accent = step
+            synth.note_on_step(note, slide=slide, accent=accent)
+            sounding = note
+            # A slid step TIES to the one before it, and can only do that
+            # while that one is still sounding. So hold the gate open across
+            # the whole step whenever the NEXT one slides; releasing would
+            # leave the tie with nothing to tie to and it would retrigger.
+            nxt = PATTERN[(i + 1) % len(PATTERN)]
+            hold = nxt is not None and nxt[1]
+            gate_off_at = None if hold else now + int(step_millis * GATE)
+
+        i = (i + 1) % len(PATTERN)
+        next_step += step_millis
+        if next_step < now:  # a stall put us a whole step behind: resync
+            next_step = now + step_millis