v0.36.1: 7 new synths, 9 new demo moods

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

CHANGELOG.md

@@ -2,6 +2,60 @@
 
 All notable changes to PyTheory are documented here.
 
+## 0.36.1
+
+- **7 new instrument synths:** pedal steel guitar, theremin, kalimba/thumb
+  piano, steel drum/pan, accordion (musette reeds), didgeridoo (drone +
+  shifting formants), bagpipes (chanter reed)
+- **9 new demo moods** in ``pytheory demo``: Theremin Noir, Caribbean,
+  Accordion Waltz, Kalimba Dreams, Outback Drone, Highland, Nashville
+  Tears, Tabla Fusion
+- Improved existing songs with dedicated instrument synths
+- 41 synth waveforms, 26+ songs, 21 demo moods
+
+## 0.36.0
+
+- **Banjo synth** — steel strings on drum-head body, nasal twang,
+  fast decay with membrane resonance
+- **Mandolin synth** — paired steel strings (natural chorus from
+  doubled courses), bright body resonance
+- **Ukulele synth** — nylon strings, small mid-heavy body, shorter
+  sustain than guitar
+- **Cajón drums** — bass (woody box thump), slap (snare wire buzz),
+  tap (ghost note). 3 patterns: cajon, cajon rumba, cajon folk
+- **Vocal/formant synth** — LF glottal model, 5 Peterson & Barney
+  formant peaks, jitter/shimmer, consonant onsets, per-note lyrics.
+  Presets: vocal, choir
+- **Granular synthesis** — grain cloud engine with scatter, pitch
+  variation, Hanning windows. Presets: granular_pad, granular_texture
+- **Strum sweep** — subtle grace notes before chord hit for natural
+  strum feel on all fretboard instruments
+- Mandola preset, 34 synth waveforms, 26 songs
+
+## 0.35.0
+
+- **8.5x faster import** — dropped pytuning/sympy, lazy-load scipy.
+  `import pytheory` now takes ~50ms instead of ~480ms (#44)
+- **Proper shruti JI ratios** — 22 positions with 5-limit just intonation
+  (pure 3/2 fifths, 5/4 thirds), not 22-TET approximation
+- **Arabic maqam JI ratios** — Zalzalian 11-limit ratios.
+  Mi↓ (the Rast third) is exactly 27/22 from Do
+- **B#/Cb octave boundary fix** — B#4 = C5, Cb4 = B3 (#45)
+- **Int tone names** — `Tone(0, system=TET(22))` works alongside strings.
+  Wrapping: `Tone(22)` → tone 0, octave+1. `System.tone()` convenience.
+- **Timpani synth** — inharmonic membrane modes, felt mallet, copper kettle
+  resonance, cathedral reverb
+- **Saxophone synth** — conical bore, reed buzz, brass body warmth.
+  4 presets: saxophone, alto_sax, tenor_sax, bari_sax
+- **Part.roll()** — rapid repeated notes with velocity ramp for crescendo/
+  decrescendo rolls on any instrument
+- **Vibrato tuning** — all instruments reduced to 0.001 depth for cleaner
+  ensemble sound
+- **Granular synthesis** — grain cloud engine with scatter, pitch
+  variation, and Hanning-windowed grains. Two presets: granular_pad,
+  granular_texture.
+- 30 synth waveforms, 838 tests
+
 ## 0.34.0
 
 - **16 dedicated instrument synths** — physical modeling and specialized

docs/guide/sequencing.rst

@@ -620,6 +620,36 @@ Three bend types:
 - ``"late"`` — holds the starting pitch for 60%, bends in the last 40%.
   The classic blues "curl."
 
+Rolls
+-----
+
+Rapid repeated notes with a velocity ramp — perfect for timpani
+rolls, snare rolls, tremolo on any instrument. The velocity ramps
+from ``velocity_start`` to ``velocity_end`` for crescendo or
+decrescendo effects.
+
+.. code-block:: python
+
+   # Timpani crescendo roll
+   timp = score.part("timp", instrument="timpani")
+   timp.roll("C3", Duration.WHOLE, velocity_start=20, velocity_end=110)
+   timp.add("C3", Duration.HALF, velocity=127)  # big accent
+
+   # Snare roll with 32nd notes
+   snare = score.part("snare", synth="noise", envelope="pluck")
+   snare.roll("C4", Duration.HALF, speed=0.125,
+              velocity_start=40, velocity_end=100)
+
+   # Decrescendo (loud to quiet)
+   timp.roll("G2", Duration.WHOLE, velocity_start=100, velocity_end=30)
+
+Parameters:
+
+- ``velocity_start``: Starting velocity (default 40).
+- ``velocity_end``: Ending velocity (default 100).
+- ``speed``: Note subdivision (default ``Duration.SIXTEENTH``).
+  Use ``0.125`` for 32nd notes, ``Duration.EIGHTH`` for 8th notes.
+
 Tuning Systems
 --------------
 

docs/guide/synths.rst

@@ -1,7 +1,7 @@
 Synthesizers
 ============
 
-PyTheory includes 27 built-in waveforms and 10 ADSR envelope presets.
+PyTheory includes 30 built-in waveforms and 10 ADSR envelope presets.
 Every sound is generated from scratch -- no samples or external audio
 files needed.
 
@@ -390,11 +390,11 @@ Dedicated Instrument Synths
 --------------------------
 
 Beyond the classic and physical modeling waveforms, PyTheory includes
-14 dedicated instrument synths. Each one uses tailored synthesis
+17 dedicated instrument synths. Each one uses tailored synthesis
 techniques -- additive harmonics, formant shaping, body resonance
 modeling, and specialized envelopes -- to capture the character of a
 specific acoustic instrument. These are the waveforms that bring the
-total count to 27.
+total count to 30.
 
 Piano Synth
 ~~~~~~~~~~~
@@ -535,6 +535,58 @@ bridge, producing a shimmering, metallic sustain.
 
    sitar = score.part("sitar", synth="sitar_synth")
 
+Timpani Synth
+~~~~~~~~~~~~~
+
+Large kettle drum with definite pitch. Inharmonic membrane modes
+(1.0, 1.5, 1.99, 2.44), felt mallet attack, copper kettle resonance.
+Use ``Part.roll()`` for crescendo timpani rolls.
+
+.. code-block:: python
+
+   timp = score.part("timp", synth="timpani_synth")
+   timp.roll("C3", Duration.WHOLE, velocity_start=20, velocity_end=110)
+
+Saxophone Synth
+~~~~~~~~~~~~~~~
+
+Single reed through a conical brass bore. All harmonics with strong
+mids, reed buzz, and brass body warmth. Four presets: ``saxophone``,
+``alto_sax``, ``tenor_sax``, ``bari_sax``.
+
+.. code-block:: python
+
+   sax = score.part("sax", instrument="tenor_sax")
+
+Granular Synth
+~~~~~~~~~~~~~~
+
+Grain cloud synthesis — chops a source waveform into tiny overlapping
+grains (10-200ms), each windowed and optionally pitch/time scattered.
+Creates textures impossible with other synthesis: frozen tones,
+shimmering clouds, evolving pads, glitchy stutters.
+
+.. code-block:: python
+
+   # Atmospheric granular pad
+   pad = score.part("pad", instrument="granular_pad")
+
+   # Granular with filter envelope sweep + resonance
+   texture = score.part("texture", synth="granular_synth", envelope="pad",
+                        filter_amount=4000, filter_attack=0.5,
+                        filter_decay=1.5, filter_sustain=0.3,
+                        lowpass=600, lowpass_q=3.0,
+                        reverb=0.5, reverb_type="taj_mahal")
+
+Parameters (passed as synth kwargs):
+
+- ``grain_size``: Duration per grain in seconds (default 0.04).
+- ``density``: Grains per second (default 50). Higher = denser cloud.
+- ``scatter``: Random position jitter 0-1 (default 0.5).
+- ``pitch_var``: Per-grain pitch randomization in cents (default 12).
+- ``source``: Base waveform — ``"saw"``, ``"sine"``, ``"triangle"``,
+  ``"square"``, ``"noise"``.
+
 Analog Oscillator Drift
 ~~~~~~~~~~~~~~~~~~~~~~~~
 

docs/index.rst

@@ -77,7 +77,7 @@ What's Inside
   numbers), scale recommendation, modulation, voice leading
 - **Sequencing** — Score, Parts, arpeggiator, legato/glide, velocity,
   swing, humanize, tempo changes, song sections with repeat
-- **Synthesis** — 27 waveforms (including Karplus-Strong pluck, Hammond organ,
+- **Synthesis** — 41 waveforms (including Karplus-Strong pluck, Hammond organ,
   bowed string, and 14 dedicated instrument synths), 10 envelopes, 40+
   instrument presets, configurable FM, sub-oscillator, noise layer, filter
   envelope, velocity-to-brightness, analog oscillator drift, detune, stereo

examples/songs.py

@@ -1315,13 +1315,13 @@ def journey():
     # ── Drone — runs the entire piece ──
     tanpura = score.part("tanpura", synth="strings_synth", envelope="pad",
                           detune=3, lowpass=1000, volume=0.12,
-                          reverb=0.5, reverb_type=REV)
+                          reverb=0.6, reverb_type=REV)
     for _ in range(40):
         tanpura.add("A2", Duration.WHOLE)
 
     # ── Bars 1-8: Piano alone, then cello ──
     piano = score.part("piano", instrument="piano", volume=0.35,
-                        reverb=0.35, reverb_type=REV)
+                        reverb=0.6, reverb_type=REV)
     for notes in [
         ["A2","E3","A3","C4","E4","C4","A3","E3"],
         ["F2","C3","F3","A3","C4","A3","F3","C3"],
@@ -1336,7 +1336,7 @@ def journey():
             piano.add(n, Duration.EIGHTH, velocity=68)
 
     cello = score.part("cello", instrument="cello", volume=0.2,
-                        reverb=0.4, reverb_type=REV)
+                        reverb=0.55, reverb_type=REV)
     cello.rest(Duration.WHOLE)
     for note, dur, vel in [
         ("A3", 4.0, 55), ("C4", 4.0, 58),
@@ -1347,11 +1347,11 @@ def journey():
 
     # ── Bars 9-16: Harp + oboe + flute + djembe ──
     harp = score.part("harp", instrument="harp", volume=0.28,
-                       reverb=0.45, reverb_type=REV)
+                       reverb=0.6, reverb_type=REV)
     oboe = score.part("oboe", instrument="oboe", volume=0.22,
-                       reverb=0.4, reverb_type=REV)
+                       reverb=0.55, reverb_type=REV)
     flute = score.part("flute", instrument="flute", volume=0.18,
-                        reverb=0.4, reverb_type=REV)
+                        reverb=0.55, reverb_type=REV)
     for _ in range(8):
         harp.rest(Duration.WHOLE)
     for notes in [
@@ -1383,7 +1383,7 @@ def journey():
 
     # ── Bars 15-20: Sitar + tabla ──
     sitar = score.part("sitar", instrument="sitar", volume=0.2,
-                        reverb=0.35, reverb_type=REV)
+                        reverb=0.6, reverb_type=REV)
     for _ in range(14):
         sitar.rest(Duration.WHOLE)
     for note, dur, vel in [
@@ -1406,7 +1406,7 @@ def journey():
     # Total bars before EDM: 8 piano + 6 harp + 6 djembe + 4 tabla + 9 solo = 33
     edm_start = 33
     pad = score.part("pad", instrument="synth_pad", volume=0.18,
-                      reverb=0.45, reverb_type=REV,
+                      reverb=0.6, reverb_type=REV,
                       sidechain=0.6, sidechain_release=0.15)
     for _ in range(edm_start):
         pad.rest(Duration.WHOLE)
@@ -1551,6 +1551,267 @@ def journey():
     play_song(score, "Journey — Piano → World → Sitar EDM (Taj Mahal)")
 
 
+def epic_bhairav():
+    """Epic Bhairav — orchestral + choir + tabla with extended solo finale."""
+    shruti = SYSTEMS["shruti"]
+    score = Score("4/4", bpm=90, system=shruti)
+    REV = "taj_mahal"
+    T3 = 1.0 / 12.0
+    T9 = 1.0 / 9.0
+
+    ts = TonedScale(system=shruti, tonic=Tone("Sa", octave=4, system=shruti))
+    bh = list(ts["bhairav"].tones)
+    S, kR, G, M, P, kD, N, S2 = bh
+
+    NA = DrumSound.TABLA_NA
+    DH = DrumSound.TABLA_DHA
+    TT = DrumSound.TABLA_TIT
+    KE = DrumSound.TABLA_KE
+    GB = DrumSound.TABLA_GE_BEND
+    GE = DrumSound.TABLA_GE
+    DJB = DrumSound.DJEMBE_BASS
+    DJT = DrumSound.DJEMBE_TONE
+    DJS = DrumSound.DJEMBE_SLAP
+
+    # Tanpura
+    tanpura = score.part("tanpura", synth="strings_synth", envelope="pad",
+                          detune=3, lowpass=900, volume=0.14, reverb=0.4, reverb_type=REV)
+    tanpura_pa = score.part("tanpura_pa", synth="strings_synth", envelope="pad",
+                             detune=3, lowpass=1200, volume=0.1, reverb=0.4, reverb_type=REV)
+    sa = Tone("Sa", octave=3, system=shruti)
+    pa = Tone("Pa", octave=3, system=shruti)
+    for _ in range(34):
+        tanpura.add(sa, Duration.WHOLE)
+        tanpura_pa.add(pa, Duration.WHOLE)
+
+    # Timpani
+    timp = score.part("timp", instrument="timpani")
+    timp.roll(Tone("Sa", octave=2, system=shruti), Duration.WHOLE,
+              velocity_start=20, velocity_end=90, speed=0.125)
+    timp.add(Tone("Sa", octave=2, system=shruti), Duration.HALF, velocity=105)
+    timp.rest(Duration.HALF)
+    for _ in range(8):
+        timp.rest(Duration.WHOLE)
+    timp.roll(Tone("Sa", octave=2, system=shruti), Duration.WHOLE,
+              velocity_start=25, velocity_end=115, speed=0.125)
+    timp.add(Tone("Sa", octave=2, system=shruti), Duration.HALF, velocity=120)
+    timp.add(Tone("Pa", octave=2, system=shruti), Duration.HALF, velocity=115)
+
+    # Choir — bar 3
+    choir = score.part("choir", synth="vocal_synth", envelope="pad",
+                        detune=8, spread=0.4, reverb=0.4, reverb_type=REV, volume=0.2)
+    for _ in range(2):
+        choir.rest(Duration.WHOLE)
+    for tone, dur, lyric, vel in [
+        (S, 4.0, "ah", 60), (M, 4.0, "oh", 62), (P, 4.0, "ah", 68),
+        (S, 4.0, "ee", 65), (kD, 4.0, "oh", 70), (P, 4.0, "ah", 72),
+    ]:
+        choir.add(tone, dur, velocity=vel, lyric=lyric)
+
+    # Bansuri — bar 5
+    bansuri = score.part("bansuri", instrument="flute", volume=0.22,
+                          reverb=0.4, reverb_type=REV)
+    for _ in range(4):
+        bansuri.rest(Duration.WHOLE)
+    for tone, dur, vel in [
+        (P, 2.0, 58), (kD, 1.0, 50), (P, 1.0, 55),
+        (M, 2.0, 55), (G, 1.0, 50), (kR, 1.0, 48), (S, 4.0, 58),
+    ]:
+        bansuri.add(tone, dur, velocity=vel)
+
+    # Cello — bar 3
+    cello = score.part("cello", instrument="cello", volume=0.22, reverb=0.4, reverb_type=REV)
+    for _ in range(2):
+        cello.rest(Duration.WHOLE)
+    for name, dur, vel in [
+        ("Sa", 4.0, 55), ("Ma", 4.0, 52), ("Pa", 4.0, 58),
+        ("Sa", 4.0, 55), ("komal Dha", 4.0, 58), ("Pa", 4.0, 55),
+    ]:
+        cello.add(Tone(name, octave=2, system=shruti), dur, velocity=vel)
+
+    # Sitar — bar 9
+    sitar = score.part("sitar", instrument="sitar", volume=0.25, reverb=0.4, reverb_type=REV)
+    for _ in range(8):
+        sitar.rest(Duration.WHOLE)
+    for tone, dur, vel in [
+        (S, 1.0, 72), (kR, 0.5, 62), (S, 0.5, 68), (G, 2.0, 78),
+        (M, 1.0, 72), (P, 2.0, 82), (kD, 0.5, 65), (P, 1.0, 75),
+        (M, 0.5, 65), (G, 0.5, 68), (kR, 0.5, 60), (S, 2.0, 78),
+        (kR, 0.25, 62), (G, 0.25, 65), (M, 0.25, 70), (P, 0.25, 75),
+        (kD, 0.25, 70), (N, 0.25, 78), (S2, 0.5, 88),
+        (N, 0.25, 68), (kD, 0.25, 62), (P, 0.5, 68),
+        (M, 0.5, 62), (G, 0.5, 65), (kR, 0.5, 58), (S, 2.0, 80),
+    ]:
+        sitar.add(tone, dur, velocity=vel)
+
+    # Strings — bar 13
+    strings = score.part("strings", instrument="string_ensemble", volume=0.18,
+                          reverb=0.4, reverb_type=REV)
+    for _ in range(12):
+        strings.rest(Duration.WHOLE)
+    for name, dur, vel in [("Sa", 4.0, 58), ("Ma", 4.0, 62), ("Pa", 4.0, 68), ("Sa", 4.0, 72)]:
+        strings.add(Tone(name, octave=3, system=shruti), dur, velocity=vel)
+
+    # Harp — bar 14
+    harp = score.part("harp", instrument="harp", volume=0.15, reverb=0.4, reverb_type=REV)
+    for _ in range(13):
+        harp.rest(Duration.WHOLE)
+    for name in ["Sa", "komal Ga", "Pa", "Sa", "Pa", "komal Ga", "Sa", "Sa"]:
+        oct = 4 if name == "Sa" and harp.total_beats > 55 else 3
+        harp.add(Tone(name, octave=oct, system=shruti), Duration.EIGHTH, velocity=50)
+
+    # Drums
+    silence = Pattern(name="s", time_signature="4/4", beats=16.0, hits=[])
+    score.add_pattern(silence, repeats=1)
+    p_dj = Pattern(name="dj", time_signature="4/4", beats=8.0, hits=[
+        _Hit(DJB, 0.0, 45), _Hit(DJT, 1.0, 38), _Hit(DJT, 1.5, 32),
+        _Hit(DJS, 2.0, 42), _Hit(DJT, 3.0, 38),
+        _Hit(DJB, 4.0, 50), _Hit(DJT, 5.0, 42), _Hit(DJT, 5.5, 35),
+        _Hit(DJS, 6.0, 48), _Hit(DJT, 6.5, 32), _Hit(DJS, 7.0, 45),
+    ])
+    score.add_pattern(p_dj, repeats=2)
+    p_tab = Pattern(name="tab", time_signature="4/4", beats=8.0, hits=[
+        _Hit(DH, 0.0, 82), _Hit(TT, 0.5, 30), _Hit(NA, 1.0, 65),
+        _Hit(NA, 2.0, 60), _Hit(DH, 3.0, 82),
+        _Hit(DH, 4.0, 88), _Hit(TT, 4.25, 32), _Hit(TT, 4.5, 35),
+        _Hit(NA, 5.0, 68), _Hit(TT, 5.5, 30), _Hit(NA, 6.0, 65),
+        _Hit(DH, 7.0, 88),
+    ])
+    score.add_pattern(p_tab, repeats=3)
+
+    # Extended tabla finale — whisper → ghosts → call/response → blazing
+    p_f1 = Pattern(name="f1", time_signature="4/4", beats=8.0, hits=[
+        _Hit(DH, 0.0, 78), _Hit(NA, 2.0, 55),
+        _Hit(DH, 4.0, 82), _Hit(TT, 5.0, 30), _Hit(NA, 5.5, 52),
+        _Hit(DH, 7.0, 78),
+    ])
+    score.add_pattern(p_f1, repeats=1)
+    p_f2 = Pattern(name="f2", time_signature="4/4", beats=8.0, hits=[
+        _Hit(DH, 0.0, 95), _Hit(TT, 0.25, 35), _Hit(TT, 0.5, 38),
+        _Hit(NA, 1.0, 70), _Hit(TT, 1.25, 30), _Hit(NA, 2.0, 65),
+        _Hit(TT, 2.5, 35), _Hit(DH, 3.0, 90),
+        _Hit(DH, 4.0, 98), _Hit(TT, 4.25, 38), _Hit(TT, 4.5, 42),
+        _Hit(NA, 5.0, 75), _Hit(KE, 5.5, 40), _Hit(NA, 6.0, 70),
+        _Hit(KE, 6.5, 42), _Hit(DH, 7.0, 100), _Hit(GB, 7.5, 92),
+    ])
+    score.add_pattern(p_f2, repeats=1)
+    p_f3 = Pattern(name="f3", time_signature="4/4", beats=8.0, hits=[
+        _Hit(NA, 0.0, 112), _Hit(NA, 0.25, 58), _Hit(TT, 0.5, 40), _Hit(NA, 0.75, 105),
+        _Hit(GE, 1.0, 105), _Hit(GE, 1.25, 52), _Hit(GB, 1.5, 95), _Hit(GE, 1.75, 48),
+        _Hit(NA, 2.0, 115), _Hit(TT, 2.125, 32), _Hit(TT, 2.25, 38),
+        _Hit(NA, 2.5, 108), _Hit(TT, 2.625, 35), _Hit(TT, 2.75, 42),
+        _Hit(GB, 3.0, 115), _Hit(KE, 3.25, 52), _Hit(GE, 3.5, 70),
+        _Hit(DH, 4.0, 118),
+        *[_Hit(TT if i % 2 == 0 else KE, 5.0 + i * T9, 40 + i * 5) for i in range(9)],
+        _Hit(DH, 7.0, 120),
+    ])
+    score.add_pattern(p_f3, repeats=1)
+
+    # Part 3.5: polyrhythm — space and conversation, not density
+    T5 = 4.0 / 5.0
+    p_poly = Pattern(name="poly", time_signature="4/4", beats=16.0, hits=[
+        # Bar 1: single Dha, let reverb ring. Bayan answers.
+        _Hit(DH, 0.0, 95),
+        _Hit(GB, 3.0, 88),
+        # Bar 2: one 5-group phrase, then breathe
+        _Hit(NA, 4.0, 75), _Hit(TT, 4.0 + T5, 42),
+        _Hit(NA, 4.0 + 2*T5, 70), _Hit(TT, 4.0 + 3*T5, 40),
+        _Hit(DH, 4.0 + 4*T5, 88),
+        # Bar 3: bayan, pause, one floating 9-group
+        _Hit(GB, 8.0, 100),
+        _Hit(NA, 9.0, 62),
+        *[_Hit(TT if i % 2 == 0 else KE, 10.0 + i * T9, 35 + i * 4)
+          for i in range(9)],
+        _Hit(DH, 11.0, 105),
+        # Bar 4: simple question-answer into sam
+        _Hit(DH, 12.0, 100), _Hit(NA, 12.5, 62),
+        _Hit(GE, 13.0, 88),
+        _Hit(NA, 14.0, 72), _Hit(TT, 14.25, 40), _Hit(NA, 14.5, 70),
+        _Hit(DH, 15.0, 112), _Hit(GB, 15.5, 105),
+    ])
+    score.add_pattern(p_poly, repeats=1)
+
+    p_f4 = Pattern(name="f4", time_signature="4/4", beats=12.0, hits=[
+        *[_Hit(TT, 0.0 + i * T3, 38 + i * 2) for i in range(12)],
+        _Hit(DH, 1.0, 118), _Hit(GB, 1.5, 110),
+        _Hit(NA, 2.0, 112), _Hit(KE, 2.125, 48), _Hit(NA, 2.25, 108),
+        _Hit(KE, 2.375, 50), _Hit(NA, 2.5, 110), _Hit(KE, 2.625, 52), _Hit(NA, 2.75, 115),
+        _Hit(DH, 3.0, 120),
+        *[_Hit(TT, 3.5 + i * T3, 30 + i * 4) for i in range(18)],
+        _Hit(DH, 5.0, 122), _Hit(DH, 5.25, 118), _Hit(GB, 5.5, 115),
+        _Hit(GE, 6.0, 90), _Hit(GE, 7.0, 88),
+        *[_Hit(NA if i % 3 == 0 else TT, 6.0 + i * (2.0/9.0), 42 + (i%3)*15) for i in range(9)],
+        _Hit(DH, 8.0, 110), _Hit(NA, 8.25, 75), _Hit(TT, 8.5, 50),
+        _Hit(KE, 8.75, 55), _Hit(DH, 9.0, 105),
+        _Hit(DH, 9.25, 115), _Hit(NA, 9.5, 80), _Hit(TT, 9.75, 55),
+        _Hit(KE, 10.0, 60), _Hit(DH, 10.25, 110),
+        _Hit(DH, 10.5, 122), _Hit(NA, 10.75, 85), _Hit(TT, 11.0, 60),
+        _Hit(KE, 11.25, 65), _Hit(DH, 11.5, 127),
+        _Hit(GB, 11.875, 127),
+    ])
+    score.add_pattern(p_f4, repeats=1)
+    score.set_drum_effects(reverb=0.4, reverb_type=REV)
+
+    play_song(score, "Epic Bhairav — Orchestra + Choir + Tabla (22-Shruti JI)")
+
+
+def acoustic_ensemble():
+    """Acoustic Ensemble — guitar, ukulele, mandolin, cajón."""
+    import random
+    from pytheory import Fretboard
+    random.seed(7)
+    score = Score("4/4", bpm=115)
+
+    fb_g = Fretboard.guitar()
+    guitar = score.part("guitar", instrument="acoustic_guitar", fretboard=fb_g,
+                         reverb=0.3, reverb_type="plate", humanize=0.2, pan=-0.3)
+
+    fb_u = Fretboard.ukulele()
+    uke = score.part("uke", instrument="ukulele", fretboard=fb_u,
+                      reverb=0.25, reverb_type="plate", humanize=0.25, pan=0.3)
+
+    fb_m = Fretboard.mandolin()
+    mando = score.part("mando", instrument="mandolin", fretboard=fb_m,
+                        reverb=0.25, reverb_type="plate", humanize=0.2, pan=0.15)
+
+    for sym in ["C", "G", "Am", "F"] * 3:
+        vd = random.randint(75, 95)
+        vu = random.randint(58, 78)
+        guitar.strum(sym, Duration.QUARTER, direction="down", velocity=vd)
+        guitar.strum(sym, Duration.EIGHTH, direction="up", velocity=vu)
+        guitar.strum(sym, Duration.EIGHTH, direction="down", velocity=vd - 8)
+        guitar.strum(sym, Duration.QUARTER, direction="up", velocity=vu)
+        guitar.strum(sym, Duration.QUARTER, direction="down", velocity=vd)
+
+        vd2 = random.randint(65, 88)
+        vu2 = random.randint(50, 72)
+        uke.rest(Duration.EIGHTH)
+        uke.strum(sym, Duration.EIGHTH, direction="up", velocity=vu2)
+        uke.strum(sym, Duration.QUARTER, direction="down", velocity=vd2)
+        uke.strum(sym, Duration.EIGHTH, direction="up", velocity=vu2)
+        uke.strum(sym, Duration.EIGHTH, direction="down", velocity=vd2 - 5)
+        uke.strum(sym, Duration.QUARTER, direction="up", velocity=vu2)
+
+        mando.strum(sym, Duration.EIGHTH, direction="down",
+                    velocity=random.randint(65, 82))
+        mando.strum(sym, Duration.EIGHTH, direction="up",
+                    velocity=random.randint(55, 72))
+        mando.strum(sym, Duration.EIGHTH, direction="down",
+                    velocity=random.randint(65, 82))
+        mando.rest(Duration.EIGHTH)
+        mando.strum(sym, Duration.EIGHTH, direction="up",
+                    velocity=random.randint(55, 72))
+        mando.strum(sym, Duration.EIGHTH, direction="down",
+                    velocity=random.randint(68, 85))
+        mando.strum(sym, Duration.QUARTER, direction="down",
+                    velocity=random.randint(70, 85))
+
+    score.drums("cajon", repeats=6)
+    score.set_drum_effects(reverb=0.15)
+
+    play_song(score, "Acoustic Ensemble — Guitar, Uke, Mandolin, Cajón")
+
+
 SONGS = {
     "1": ("Bossa Nova in A minor", bossa_nova_girl),
     "2": ("Bebop in Bb major", bebop_in_bb),
@@ -1576,6 +1837,8 @@ SONGS = {
     "22": ("Greensleeves (Renaissance Lute)", greensleeves),
     "23": ("Tabla Solo (Raga Yaman)", tabla_solo_yaman),
     "24": ("Journey (Western → World → Indian)", journey),
+    "25": ("Epic Bhairav (Orchestral + Tabla)", epic_bhairav),
+    "26": ("Acoustic Ensemble (Guitar+Uke+Mando+Cajón)", acoustic_ensemble),
 }
 
 if __name__ == "__main__":
@@ -1589,7 +1852,7 @@ if __name__ == "__main__":
             print(f"    {key:>2}. {name}")
 
         print()
-        choice = input("  Pick a song (1-24, or 'all'): ").strip()
+        choice = input("  Pick a song (1-26, or 'all'): ").strip()
         print()
 
         if choice == "all":

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pytheory"
-version = "0.34.1"
+version = "0.36.1"
 description = "Music Theory for Humans"
 readme = "README.md"
 license = "MIT"
@@ -21,7 +21,6 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
-    "pytuning",
     "numeral",
     "sounddevice",
     "scipy",

pytheory/__init__.py

@@ -1,6 +1,6 @@
 """PyTheory: Music Theory for Humans."""
 
-__version__ = "0.34.1"
+__version__ = "0.36.1"
 
 from .tones import Tone, Interval
 from .systems import System, SYSTEMS, TET

pytheory/_statics.py

@@ -1,4 +1,4 @@
-from pytuning import scales
+import math
 
 REFERENCE_A = 440
 
@@ -6,41 +6,59 @@ REFERENCE_A = 440
 # Scientific pitch notation changes octave at C, not A, so this offset
 # is needed for all octave arithmetic.
 C_INDEX = 3
-def _create_just_intonation_scale(n):
-    """5-limit just intonation ratios for 12-tone systems.
 
-    These are the pure frequency ratios derived from the harmonic series —
-    the way intervals "want" to sound before equal temperament imposed
-    compromise. Each ratio is mathematically exact: a perfect fifth is
-    exactly 3/2, a major third is exactly 5/4.
 
-    For non-12 systems, falls back to equal temperament.
+# ── Temperament scale generators (replaces pytuning dependency) ──────────
+
+def _create_edo_scale(n):
+    """N-tone equal division of the octave. Each step = 2^(1/n)."""
+    return [2 ** (i / n) for i in range(n + 1)]
+
+
+def _create_pythagorean_scale(n):
+    """Pythagorean tuning — spiral of pure fifths (3/2 ratio).
+
+    Each tone is generated by stacking perfect fifths and octave-reducing.
     """
-    from fractions import Fraction
+    ratios = [1.0]
+    for i in range(1, n):
+        # Stack fifths: (3/2)^i, then reduce to within one octave
+        r = (3 / 2) ** i
+        while r >= 2.0:
+            r /= 2.0
+        ratios.append(r)
+    ratios.sort()
+    ratios.append(2.0)
+    return ratios
+
+
+def _create_quarter_comma_meantone_scale(n):
+    """Quarter-comma meantone — pure major thirds (5/4), tempered fifths.
+
+    The fifth is narrowed by 1/4 of a syntonic comma so that four
+    fifths make a pure major third (5/4). The meantone fifth =
+    5^(1/4) ≈ 1.49535.
+    """
+    fifth = 5 ** 0.25  # meantone fifth ≈ 1.49535 (vs 1.5 pure)
+    ratios = [1.0]
+    for i in range(1, n):
+        r = fifth ** i
+        while r >= 2.0:
+            r /= 2.0
+        ratios.append(r)
+    ratios.sort()
+    ratios.append(2.0)
+    return ratios
+def _create_just_intonation_scale(n):
+    """5-limit just intonation ratios for 12-tone systems."""
     if n != 12:
-        return scales.create_edo_scale(n)
-    # Standard 5-limit JI ratios (A-based: A=1/1)
-    ratios = [
-        Fraction(1, 1),       # A  — unison
-        Fraction(16, 15),     # A# — minor second
-        Fraction(9, 8),       # B  — major second
-        Fraction(6, 5),       # C  — minor third
-        Fraction(5, 4),       # C# — major third
-        Fraction(4, 3),       # D  — perfect fourth
-        Fraction(45, 32),     # D# — augmented fourth
-        Fraction(3, 2),       # E  — perfect fifth
-        Fraction(8, 5),       # F  — minor sixth
-        Fraction(5, 3),       # F# — major sixth
-        Fraction(9, 5),       # G  — minor seventh
-        Fraction(15, 8),      # G# — major seventh
-        Fraction(2, 1),       # A  — octave
-    ]
-    return [float(r) for r in ratios]
+        return _create_edo_scale(n)
+    return [1, 16/15, 9/8, 6/5, 5/4, 4/3, 45/32, 3/2, 8/5, 5/3, 9/5, 15/8, 2.0]
 
 TEMPERAMENTS = {
-    "equal": scales.create_edo_scale,
-    "pythagorean": scales.create_pythagorean_scale,
-    "meantone": scales.create_quarter_comma_meantone_scale,
+    "equal": _create_edo_scale,
+    "pythagorean": _create_pythagorean_scale,
+    "meantone": _create_quarter_comma_meantone_scale,
     "just": _create_just_intonation_scale,
 }
 

pytheory/cli.py

@@ -299,6 +299,54 @@ def cmd_demo(args):
          "lead": ("trumpet_synth", "bowed", 0.3, 0.2),
          "pad": ("piano_synth", "none", -0.2),
          "bass_lp": 600, "reverb_type": "plate"},
+        {"name": "Theremin Noir", "key": ("A", "minor"), "drums": "hip hop",
+         "fill": "rock", "bpm": 85,
+         "prog": ("i", "iv", "V", "i"),
+         "lead": ("theremin_synth", "pad", 0.4, 0.0),
+         "pad": ("granular_synth", "pad", 0.0),
+         "bass_lp": 300, "reverb_type": "cave"},
+        {"name": "Caribbean", "key": ("C", "major"), "drums": "reggae",
+         "fill": "reggae", "bpm": 110,
+         "prog": ("I", "IV", "V", "IV"),
+         "lead": ("steel_drum_synth", "none", 0.25, 0.3),
+         "pad": ("acoustic_guitar_synth", "none", -0.3),
+         "bass_lp": 500, "reverb_type": "plate"},
+        {"name": "Accordion Waltz", "key": ("D", "minor"), "drums": "waltz",
+         "fill": "jazz", "bpm": 88,
+         "prog": ("i", "iv", "V", "i"),
+         "lead": ("accordion_synth", "organ", 0.2, 0.1),
+         "pad": ("strings_synth", "pad", -0.2),
+         "bass_lp": 500, "reverb_type": "plate"},
+        {"name": "Kalimba Dreams", "key": ("G", "major"), "drums": "cajon folk",
+         "fill": "bossa nova", "bpm": 95,
+         "prog": ("I", "vi", "IV", "V"),
+         "lead": ("kalimba_synth", "none", 0.35, 0.2),
+         "pad": ("piano_synth", "none", -0.2),
+         "bass_lp": 400, "reverb_type": "taj_mahal"},
+        {"name": "Outback Drone", "key": ("E", "minor"), "drums": "djembe",
+         "fill": "afrobeat", "bpm": 70,
+         "prog": ("i", "iv", "i", "V"),
+         "lead": ("didgeridoo_synth", "pad", 0.3, 0.0),
+         "pad": ("granular_synth", "pad", 0.0),
+         "bass_lp": 200, "reverb_type": "cave"},
+        {"name": "Highland", "key": ("A", "minor"), "drums": "flamenco",
+         "fill": "rock", "bpm": 95,
+         "prog": ("i", "iv", "V", "i"),
+         "lead": ("bagpipe_synth", "organ", 0.15, 0.0),
+         "pad": ("strings_synth", "pad", -0.2),
+         "bass_lp": 400, "reverb_type": "cathedral"},
+        {"name": "Nashville Tears", "key": ("G", "major"), "drums": "country",
+         "fill": "rock", "bpm": 85,
+         "prog": ("I", "IV", "V", "IV"),
+         "lead": ("pedal_steel_synth", "strings", 0.35, 0.2),
+         "pad": ("piano_synth", "none", -0.3),
+         "bass_lp": 500, "reverb_type": "spring"},
+        {"name": "Tabla Fusion", "key": ("E", "minor"), "drums": "teental",
+         "fill": "rock", "bpm": 120,
+         "prog": ("i", "iv", "V", "i"),
+         "lead": ("sitar_synth", "none", 0.3, 0.2),
+         "pad": ("vocal_synth", "pad", 0.0),
+         "bass_lp": 400, "reverb_type": "taj_mahal"},
     ]
 
     mood = random.choice(moods)

pytheory/play.py

@@ -2,11 +2,24 @@ from enum import Enum
 import time
 
 import numpy
-import scipy.signal
 
 from .tones import Tone
 
 
+class _LazyModule:
+    """Lazy import wrapper — module loaded on first attribute access."""
+    def __init__(self, name):
+        self._name = name
+        self._mod = None
+    def __getattr__(self, attr):
+        if self._mod is None:
+            import importlib
+            self._mod = importlib.import_module(self._name)
+        return getattr(self._mod, attr)
+
+scipy = type('scipy', (), {'signal': _LazyModule('scipy.signal')})()
+
+
 def _get_sd():
     """Lazy import sounddevice — only needed for actual audio playback."""
     import sounddevice as sd
@@ -257,7 +270,7 @@ def strings_wave(hz, peak=SAMPLE_PEAK, n_samples=SAMPLE_RATE):
 
     # Delayed vibrato: ramps in over ~200ms, like a real bow
     vib_rate = 5.2 + rng.uniform(-0.3, 0.3)  # slight randomness per note
-    vib_depth = hz * 0.003  # ~5 cents
+    vib_depth = hz * 0.001  # subtle
     vib_onset = numpy.clip(t / 0.2, 0.0, 1.0)  # ramp over 200ms
     vibrato = vib_depth * vib_onset * numpy.sin(2 * numpy.pi * vib_rate * t)
 
@@ -481,7 +494,7 @@ def trumpet_wave(hz, peak=SAMPLE_PEAK, n_samples=SAMPLE_RATE):
 
     # Vibrato
     vib_onset = numpy.clip(t / 0.15, 0.0, 1.0)
-    vib = hz * 0.002 * vib_onset * numpy.sin(2 * numpy.pi * 5.5 * t)
+    vib = hz * 0.001 * vib_onset * numpy.sin(2 * numpy.pi * 5.5 * t)
 
     # Lip buzz — additive with brass spectral shape
     # Trumpet has strong even AND odd harmonics (unlike clarinet)
@@ -523,7 +536,7 @@ def clarinet_wave(hz, peak=SAMPLE_PEAK, n_samples=SAMPLE_RATE):
     rng = numpy.random.default_rng(int(hz * 100) % 2**31)
 
     vib_onset = numpy.clip(t / 0.3, 0.0, 1.0)
-    vib = hz * 0.002 * vib_onset * numpy.sin(2 * numpy.pi * 4.5 * t)
+    vib = hz * 0.001 * vib_onset * numpy.sin(2 * numpy.pi * 4.5 * t)
 
     # Cylindrical bore: odd harmonics dominate
     wave = numpy.zeros(n_samples, dtype=numpy.float64)
@@ -592,7 +605,7 @@ def oboe_wave(hz, peak=SAMPLE_PEAK, n_samples=SAMPLE_RATE):
     rng = numpy.random.default_rng(int(hz * 100) % 2**31)
 
     vib_onset = numpy.clip(t / 0.2, 0.0, 1.0)
-    vib = hz * 0.002 * vib_onset * numpy.sin(2 * numpy.pi * 5.0 * t)
+    vib = hz * 0.001 * vib_onset * numpy.sin(2 * numpy.pi * 5.0 * t)
 
     wave = numpy.zeros(n_samples, dtype=numpy.float64)
     n_harmonics = min(18, int((SAMPLE_RATE / 2) / hz))
@@ -668,7 +681,7 @@ def cello_wave(hz, peak=SAMPLE_PEAK, n_samples=SAMPLE_RATE):
 
     # Delayed vibrato
     vib_rate = 5.0 + rng.uniform(-0.3, 0.3)
-    vib_depth = hz * 0.002
+    vib_depth = hz * 0.001
     vib_onset = numpy.clip(t / 0.25, 0.0, 1.0)
     vibrato = vib_depth * vib_onset * numpy.sin(2 * numpy.pi * vib_rate * t)
 
@@ -787,6 +800,689 @@ def upright_bass_wave(hz, peak=SAMPLE_PEAK, n_samples=SAMPLE_RATE):
     return (peak * out).astype(numpy.int16)
 
 
+def timpani_wave(hz, peak=SAMPLE_PEAK, n_samples=SAMPLE_RATE):
+    """Timpani — large kettle drum with definite pitch.
+
+    The copper kettle creates a tuned resonance with inharmonic
+    overtones. The head modes are at ratios 1.0, 1.5, 1.99, 2.44
+    (not integer multiples like strings). The felt mallet gives a
+    soft attack with a deep, booming body.
+    """
+    t = numpy.arange(n_samples, dtype=numpy.float64) / SAMPLE_RATE
+
+    # Timpani head modes — inharmonic but definite pitch
+    # Mode ratios from vibrating circular membrane physics
+    wave = numpy.sin(2 * numpy.pi * hz * t) * 0.8
+    wave += numpy.sin(2 * numpy.pi * hz * 1.5 * t) * 0.35 * numpy.exp(-6 * t)
+    wave += numpy.sin(2 * numpy.pi * hz * 1.99 * t) * 0.2 * numpy.exp(-10 * t)
+    wave += numpy.sin(2 * numpy.pi * hz * 2.44 * t) * 0.1 * numpy.exp(-15 * t)
+
+    # Two-stage decay: initial thump fades fast, fundamental rings
+    decay = numpy.where(t < 0.15,
+                        numpy.exp(-4 * t),
+                        numpy.exp(-4 * 0.15) * numpy.exp(-1.5 * (t - 0.15)))
+    wave *= decay
+
+    # Felt mallet impact — warm, not sharp
+    mallet_len = min(int(SAMPLE_RATE * 0.02), n_samples)
+    rng = numpy.random.default_rng(int(hz * 100) % 2**31)
+    mallet = rng.uniform(-0.3, 0.3, mallet_len)
+    mallet *= numpy.exp(-numpy.linspace(0, 8, mallet_len))
+    wave[:mallet_len] += mallet
+
+    # Copper kettle resonance — boosts low-mids
+    import scipy.signal as _sig
+    lo, hi = max(20, int(hz * 0.7)), min(SAMPLE_RATE // 2 - 1, int(hz * 2))
+    if lo < hi:
+        bp, ap = _sig.butter(2, [lo, hi], btype='band', fs=SAMPLE_RATE)
+        kettle = _sig.lfilter(bp, ap, wave) * 0.3
+        wave += kettle
+
+    mx = numpy.abs(wave).max()
+    if mx > 0:
+        wave /= mx
+
+    return (peak * wave).astype(numpy.int16)
+
+
+def saxophone_wave(hz, peak=SAMPLE_PEAK, n_samples=SAMPLE_RATE):
+    """Saxophone — single reed through a conical brass bore.
+
+    The conical bore produces all harmonics (like oboe), but the
+    brass body and larger mouthpiece give a warmer, fatter, more
+    vocal quality. The reed adds a slight buzz. Saxophone is
+    between clarinet (odd harmonics) and oboe (nasal even+odd) —
+    it has everything, with a strong fundamental and rich mids.
+    """
+    t = numpy.arange(n_samples, dtype=numpy.float64) / SAMPLE_RATE
+    rng = numpy.random.default_rng(int(hz * 100) % 2**31)
+
+    # Vibrato — develops after ~250ms, wider than flute
+    vib_onset = numpy.clip(t / 0.25, 0.0, 1.0)
+    vib = hz * 0.0012 * vib_onset * numpy.sin(2 * numpy.pi * 5.2 * t)
+
+    wave = numpy.zeros(n_samples, dtype=numpy.float64)
+    n_harmonics = min(20, int((SAMPLE_RATE / 2) / hz))
+
+    for n in range(1, n_harmonics + 1):
+        f_n = hz * n
+        if f_n >= SAMPLE_RATE / 2:
+            break
+        # Sax spectral shape: strong fundamental, broad mid peak (3-6),
+        # slower rolloff than oboe (brass body carries harmonics further)
+        if n == 1:
+            amp = 1.0
+        elif n <= 3:
+            amp = 0.6
+        elif n <= 6:
+            amp = 0.4 * numpy.exp(-0.1 * (n - 4) ** 2)
+        else:
+            amp = 0.2 / n
+        phase = rng.uniform(0, 2 * numpy.pi)
+        wave += amp * numpy.sin(2 * numpy.pi * (f_n + vib * n) * t + phase)
+
+    # Reed buzz — more present than oboe but still warm
+    reed = rng.normal(0, 0.07, n_samples)
+    # Bandpass the reed noise around 1-3kHz (the "honk" range)
+    import scipy.signal as _sig
+    reed_lo = max(20, int(hz * 2))
+    reed_hi = min(SAMPLE_RATE // 2 - 1, int(hz * 6))
+    if reed_lo < reed_hi:
+        br, ar = _sig.butter(2, [reed_lo, reed_hi], btype='band', fs=SAMPLE_RATE)
+        reed = _sig.lfilter(br, ar, reed).astype(numpy.float64) * 2.0
+    wave += reed
+
+    # Brass body warmth — low-mid boost
+    center = min(1500, hz * 4)
+    bw = 500
+    lo = max(20, int(center - bw))
+    hi = min(SAMPLE_RATE // 2 - 1, int(center + bw))
+    if lo < hi:
+        bp, ap = _sig.butter(2, [lo, hi], btype='band', fs=SAMPLE_RATE)
+        body = _sig.lfilter(bp, ap, wave) * 0.2
+        wave += body
+
+    mx = numpy.abs(wave).max()
+    if mx > 0:
+        wave /= mx
+
+    return (peak * wave).astype(numpy.int16)
+
+
+def vocal_wave(hz, peak=SAMPLE_PEAK, n_samples=SAMPLE_RATE, lyric="ah"):
+    """Vocal/formant synthesis — sings vowel sounds at a given pitch.
+
+    Models the human voice with:
+    1. LF glottal model — asymmetric pulse with sharp closure (not just sines)
+    2. 5 parallel resonant formant filters (real voice has 5 formant peaks)
+    3. Jitter + shimmer (natural pitch/amplitude irregularity)
+    4. Aspiration noise mixed with the glottal source
+    5. Consonant onsets (plosives, sibilants, nasals, etc.)
+    """
+    import scipy.signal as _sig
+
+    # 5-formant table: (F1, F2, F3, F4, F5) frequencies and bandwidths
+    # Based on Peterson & Barney (1952) measurements, male voice
+    FORMANTS = {
+        'a': [(800, 130), (1200, 100), (2500, 140), (3300, 250), (3750, 300)],
+        'e': [(530, 80),  (1850, 100), (2500, 130), (3300, 250), (3750, 300)],
+        'i': [(280, 60),  (2250, 100), (2900, 120), (3350, 250), (3750, 300)],
+        'o': [(500, 100), (1000, 80),  (2500, 140), (3300, 250), (3750, 300)],
+        'u': ((325, 70),  (700, 60),   (2530, 140), (3300, 250), (3750, 300)),
+    }
+    # Formant gains (relative amplitude per formant)
+    FGAINS = [1.0, 0.8, 0.5, 0.25, 0.15]
+
+    rng = numpy.random.default_rng(int(hz * 100 + len(lyric) * 7) % 2**31)
+    t = numpy.arange(n_samples, dtype=numpy.float64) / SAMPLE_RATE
+
+    # Parse vowels from lyric
+    vowels_in_lyric = [c.lower() for c in lyric if c.lower() in FORMANTS]
+    if not vowels_in_lyric:
+        vowels_in_lyric = ['a']
+
+    # ── Glottal source: LF model approximation ──
+    # Asymmetric pulse: slow open phase, sharp closure, then closed phase.
+    # Much more "voice-like" than a sine or sawtooth.
+    # Jitter (pitch irregularity) + shimmer (amplitude irregularity)
+    jitter = rng.normal(0, hz * 0.001, n_samples)  # ~0.1% pitch jitter
+    shimmer = 1.0 + rng.normal(0, 0.008, n_samples)  # ~0.8% amp shimmer
+    # Vibrato
+    vib = hz * 0.001 * numpy.sin(2 * numpy.pi * 5.5 * t)
+    inst_freq = hz + vib + jitter
+    phase = numpy.cumsum(2 * numpy.pi * inst_freq / SAMPLE_RATE)
+    # LF glottal shape: sharper falling edge via phase shaping
+    saw = (phase / (2 * numpy.pi)) % 1.0  # 0 to 1 sawtooth
+    # Asymmetric: slow rise (60%), fast fall (40%)
+    glottal = numpy.where(saw < 0.6,
+                          numpy.sin(numpy.pi * saw / 0.6),   # smooth rise
+                          -numpy.sin(numpy.pi * (saw - 0.6) / 0.4) * 0.8)  # sharp fall
+    glottal *= shimmer
+
+    # Aspiration noise (breathiness) — subtle
+    breath = rng.normal(0, 0.04, n_samples)
+    source = glottal * 0.92 + breath * 0.08
+
+    # ── Formant filtering ──
+    n_vowels = len(vowels_in_lyric)
+    out = numpy.zeros(n_samples, dtype=numpy.float64)
+
+    if n_vowels == 1:
+        # Single vowel — filter the whole thing
+        formants = FORMANTS[vowels_in_lyric[0]]
+        for (fc, bw), gain in zip(formants, FGAINS):
+            lo = max(20, fc - bw)
+            hi = min(SAMPLE_RATE // 2 - 1, fc + bw)
+            if lo < hi:
+                bp, ap = _sig.butter(2, [lo, hi], btype='band', fs=SAMPLE_RATE)
+                out += _sig.lfilter(bp, ap, source).astype(numpy.float64) * gain
+    else:
+        # Multiple vowels — crossfade formants
+        samples_per_vowel = n_samples // n_vowels
+        for vi, vowel in enumerate(vowels_in_lyric):
+            formants = FORMANTS[vowel]
+            start = vi * samples_per_vowel
+            end = n_samples if vi == n_vowels - 1 else start + samples_per_vowel
+            seg = source[start:end].copy()
+            seg_out = numpy.zeros_like(seg)
+            for (fc, bw), gain in zip(formants, FGAINS):
+                lo = max(20, fc - bw)
+                hi = min(SAMPLE_RATE // 2 - 1, fc + bw)
+                if lo < hi:
+                    bp, ap = _sig.butter(2, [lo, hi], btype='band', fs=SAMPLE_RATE)
+                    seg_out += _sig.lfilter(bp, ap, seg).astype(numpy.float64) * gain
+            # Crossfade
+            fade = min(int(SAMPLE_RATE * 0.02), len(seg_out) // 4)
+            if vi > 0 and fade > 0:
+                seg_out[:fade] *= numpy.linspace(0, 1, fade)
+            if vi < n_vowels - 1 and fade > 0:
+                seg_out[-fade:] *= numpy.linspace(1, 0, fade)
+            out[start:end] += seg_out[:end - start]
+
+    # ── Consonant onsets ──
+    lyric_lower = lyric.lower()
+    if lyric_lower and lyric_lower[0] not in 'aeiou':
+        c = lyric_lower[0]
+        cl = min(int(SAMPLE_RATE * 0.035), n_samples)
+        if c in 'tdkpb':
+            burst = rng.uniform(-0.5, 0.5, cl) * numpy.exp(-numpy.linspace(0, 18, cl))
+            out[:cl] = burst + out[:cl] * 0.2
+        elif c in 'sz':
+            sib = rng.uniform(-0.4, 0.4, cl)
+            if cl > 20:
+                bl, al = _sig.butter(2, [3000, min(8000, SAMPLE_RATE//2-1)], btype='band', fs=SAMPLE_RATE)
+                sib = _sig.lfilter(bl, al, numpy.pad(sib, (0, max(0, n_samples-cl))))[:cl]
+            sib *= numpy.exp(-numpy.linspace(0, 10, cl))
+            out[:cl] = sib * 0.6 + out[:cl] * 0.4
+        elif c in 'mn':
+            nl = min(int(SAMPLE_RATE * 0.06), n_samples)
+            nasal = numpy.sin(2*numpy.pi*250*t[:nl]) * 0.4 * numpy.exp(-numpy.linspace(0, 4, nl))
+            out[:nl] = nasal + out[:nl] * 0.4
+        elif c in 'fv':
+            fric = rng.uniform(-0.25, 0.25, cl) * numpy.exp(-numpy.linspace(0, 12, cl))
+            out[:cl] = fric * 0.5 + out[:cl] * 0.5
+        elif c in 'lr':
+            gl = min(int(SAMPLE_RATE * 0.05), n_samples)
+            ghz = hz * 0.7 + hz * 0.3 * numpy.linspace(0, 1, gl)
+            glide = numpy.sin(numpy.cumsum(2*numpy.pi*ghz/SAMPLE_RATE)) * 0.35
+            out[:gl] = glide + out[:gl] * 0.65
+        elif c == 'h':
+            hl = min(int(SAMPLE_RATE * 0.05), n_samples)
+            asp = rng.uniform(-0.4, 0.4, hl) * numpy.exp(-numpy.linspace(0, 5, hl))
+            out[:hl] = asp * 0.6 + out[:hl] * 0.4
+        elif c == 'w':
+            wl = min(int(SAMPLE_RATE * 0.06), n_samples)
+            ws = numpy.sin(numpy.cumsum(2*numpy.pi*hz/SAMPLE_RATE*numpy.ones(wl)))
+            if wl > 20:
+                bp, ap = _sig.butter(2, [max(20,300), min(800, SAMPLE_RATE//2-1)], btype='band', fs=SAMPLE_RATE)
+                ws = _sig.lfilter(bp, ap, ws)
+            ws *= numpy.linspace(0.5, 0, wl)
+            out[:wl] = ws * 0.4 + out[:wl] * 0.6
+
+    # Soft edges — prevent clicks at note boundaries
+    fade_samples = min(int(SAMPLE_RATE * 0.01), n_samples // 4)
+    if fade_samples > 0:
+        out[:fade_samples] *= numpy.linspace(0, 1, fade_samples)
+        out[-fade_samples:] *= numpy.linspace(1, 0, fade_samples)
+
+    mx = numpy.abs(out).max()
+    if mx > 0:
+        out /= mx
+
+    return (peak * out).astype(numpy.int16)
+
+
+def granular_wave(hz, peak=SAMPLE_PEAK, n_samples=SAMPLE_RATE,
+                  grain_size=0.04, density=50, scatter=0.5,
+                  pitch_var=12, source="saw"):
+    """Granular synthesis — clouds of tiny sound grains.
+
+    Chops a source waveform into overlapping micro-grains (10-200ms),
+    each independently windowed and optionally pitch/time scattered.
+    Creates textures impossible with other synthesis: frozen tones,
+    shimmering clouds, evolving pads, glitchy stutters.
+
+    Args:
+        hz: Base frequency.
+        grain_size: Duration of each grain in seconds (default 0.05 = 50ms).
+        density: Grains per second (default 20). Higher = denser cloud.
+        scatter: Random position jitter 0-1 (default 0.3). How much each
+            grain's read position varies from sequential order.
+        pitch_var: Random pitch variation per grain in cents (default 5).
+        source: Base waveform — ``"saw"``, ``"sine"``, ``"triangle"``,
+            ``"square"``, ``"noise"`` (default ``"saw"``).
+    """
+    rng = numpy.random.default_rng(int(hz * 100) % 2**31)
+
+    # Generate source material — longer than needed for scatter headroom
+    src_len = n_samples + int(SAMPLE_RATE * scatter * 2)
+    src_fns = {
+        "saw": sawtooth_wave, "sine": sine_wave, "triangle": triangle_wave,
+        "square": square_wave, "noise": noise_wave,
+    }
+    src_fn = src_fns.get(source, sawtooth_wave)
+    src = src_fn(hz, n_samples=src_len).astype(numpy.float64) / SAMPLE_PEAK
+
+    # Grain parameters
+    grain_samples = max(64, int(grain_size * SAMPLE_RATE))
+    n_grains = max(1, int(n_samples / SAMPLE_RATE * density))
+
+    # Hanning window for each grain (smooth fade in/out, no clicks)
+    window = numpy.hanning(grain_samples).astype(numpy.float64)
+
+    out = numpy.zeros(n_samples, dtype=numpy.float64)
+
+    for i in range(n_grains):
+        # Output position — evenly spaced with jitter
+        base_pos = int(i * n_samples / n_grains)
+        jitter = int(rng.uniform(-0.5, 0.5) * n_samples / n_grains * 0.3)
+        out_pos = max(0, min(n_samples - grain_samples, base_pos + jitter))
+
+        # Source read position — sequential with scatter
+        src_pos = int(base_pos * src_len / n_samples)
+        src_jitter = int(rng.uniform(-scatter, scatter) * grain_samples * 4)
+        src_pos = max(0, min(src_len - grain_samples, src_pos + src_jitter))
+
+        # Per-grain pitch variation via resampling
+        if pitch_var > 0:
+            cents = rng.uniform(-pitch_var, pitch_var)
+            rate = 2 ** (cents / 1200)
+            read_len = max(2, min(int(grain_samples * rate), src_len - src_pos))
+            grain_src = src[src_pos:src_pos + read_len]
+            x_old = numpy.linspace(0, 1, len(grain_src))
+            x_new = numpy.linspace(0, 1, grain_samples)
+            grain = numpy.interp(x_new, x_old, grain_src)
+        else:
+            end = min(src_pos + grain_samples, src_len)
+            grain = src[src_pos:end]
+            if len(grain) < grain_samples:
+                grain = numpy.pad(grain, (0, grain_samples - len(grain)))
+
+        # Apply window and mix
+        grain *= window[:len(grain)]
+        end = min(out_pos + len(grain), n_samples)
+        out[out_pos:end] += grain[:end - out_pos]
+
+    mx = numpy.abs(out).max()
+    if mx > 0:
+        out /= mx
+
+    return (peak * out).astype(numpy.int16)
+
+
+def pedal_steel_wave(hz, peak=SAMPLE_PEAK, n_samples=SAMPLE_RATE):
+    """Pedal steel guitar — the Nashville crying sound.
+
+    Sustained steel string with natural portamento character,
+    very smooth, lots of harmonics, and a singing quality from
+    the bar sliding on the strings.
+    """
+    t = numpy.arange(n_samples, dtype=numpy.float64) / SAMPLE_RATE
+    rng = numpy.random.default_rng(int(hz * 100) % 2**31)
+    # Slow, singing vibrato — the bar wobbling on the strings
+    vib = hz * 0.002 * numpy.sin(2 * numpy.pi * 4.0 * t)
+    # Rich harmonics — steel bar gives a clear, singing tone
+    wave = numpy.zeros(n_samples, dtype=numpy.float64)
+    for n in range(1, 12):
+        f_n = hz * n
+        if f_n >= SAMPLE_RATE / 2:
+            break
+        amp = 1.0 / n * numpy.exp(-0.08 * n)
+        phase = rng.uniform(0, 2 * numpy.pi)
+        wave += amp * numpy.sin(2 * numpy.pi * (f_n + vib * n) * t + phase)
+    # Long sustain envelope
+    wave *= numpy.exp(-0.8 * t)
+    mx = numpy.abs(wave).max()
+    if mx > 0:
+        wave /= mx
+    return (peak * wave).astype(numpy.int16)
+
+
+def theremin_wave(hz, peak=SAMPLE_PEAK, n_samples=SAMPLE_RATE):
+    """Theremin — pure sine with natural wobble.
+
+    The theremin's sound is a nearly pure sine wave with slight
+    pitch instability from hand position. The eerie, sci-fi sound
+    comes from this purity combined with continuous pitch.
+    """
+    t = numpy.arange(n_samples, dtype=numpy.float64) / SAMPLE_RATE
+    # Natural hand wobble — slightly irregular vibrato
+    rng = numpy.random.default_rng(int(hz * 100) % 2**31)
+    wobble = hz * 0.004 * numpy.sin(2 * numpy.pi * 5.8 * t)
+    wobble += hz * 0.001 * rng.normal(0, 1, n_samples)
+    wave = numpy.sin(2 * numpy.pi * (hz + wobble) * t)
+    # Slight 2nd harmonic — real theremins aren't perfectly pure
+    wave += 0.08 * numpy.sin(2 * numpy.pi * (hz * 2 + wobble * 2) * t)
+    mx = numpy.abs(wave).max()
+    if mx > 0:
+        wave /= mx
+    return (peak * wave).astype(numpy.int16)
+
+
+def kalimba_wave(hz, peak=SAMPLE_PEAK, n_samples=SAMPLE_RATE):
+    """Kalimba/thumb piano — metal tines on a wooden body.
+
+    Bright, bell-like attack with inharmonic overtones from the
+    metal tines. The wooden resonator gives warmth underneath.
+    """
+    t = numpy.arange(n_samples, dtype=numpy.float64) / SAMPLE_RATE
+    # Metal tine modes — slightly inharmonic like marimba
+    wave = numpy.sin(2 * numpy.pi * hz * t) * 0.8
+    wave += numpy.sin(2 * numpy.pi * hz * 2.92 * t) * 0.25 * numpy.exp(-12 * t)
+    wave += numpy.sin(2 * numpy.pi * hz * 5.4 * t) * 0.1 * numpy.exp(-20 * t)
+    # Two-stage decay: bright attack dies fast, fundamental rings
+    decay = numpy.where(t < 0.1,
+                        numpy.exp(-3 * t),
+                        numpy.exp(-3 * 0.1) * numpy.exp(-1.5 * (t - 0.1)))
+    wave *= decay
+    # Wooden body resonance
+    import scipy.signal as _sig
+    for center, bw, gain in [(300, 100, 0.2), (600, 120, 0.15)]:
+        lo, hi = max(20, center - bw), min(SAMPLE_RATE // 2 - 1, center + bw)
+        if lo < hi:
+            bp, ap = _sig.butter(2, [lo, hi], btype='band', fs=SAMPLE_RATE)
+            wave += _sig.lfilter(bp, ap, wave) * gain
+    mx = numpy.abs(wave).max()
+    if mx > 0:
+        wave /= mx
+    return (peak * wave).astype(numpy.int16)
+
+
+def steel_drum_wave(hz, peak=SAMPLE_PEAK, n_samples=SAMPLE_RATE):
+    """Steel drum/pan — hammered metal with bright, ringing tone.
+
+    The steel pan has specific inharmonic partials from the
+    hand-hammered notes. Bright, tropical, bell-like.
+    """
+    t = numpy.arange(n_samples, dtype=numpy.float64) / SAMPLE_RATE
+    # Steel pan modes — distinctly metallic
+    wave = numpy.sin(2 * numpy.pi * hz * t) * 0.7
+    wave += numpy.sin(2 * numpy.pi * hz * 2.0 * t) * 0.4 * numpy.exp(-5 * t)
+    wave += numpy.sin(2 * numpy.pi * hz * 3.01 * t) * 0.25 * numpy.exp(-8 * t)
+    wave += numpy.sin(2 * numpy.pi * hz * 4.1 * t) * 0.15 * numpy.exp(-12 * t)
+    wave += numpy.sin(2 * numpy.pi * hz * 5.3 * t) * 0.08 * numpy.exp(-18 * t)
+    # Mallet impact
+    rng = numpy.random.default_rng(int(hz * 100) % 2**31)
+    hit_len = min(int(SAMPLE_RATE * 0.008), n_samples)
+    hit = rng.uniform(-0.2, 0.2, hit_len) * numpy.exp(-numpy.linspace(0, 12, hit_len))
+    wave[:hit_len] += hit
+    # Two-stage decay
+    decay = numpy.where(t < 0.15,
+                        numpy.exp(-4 * t),
+                        numpy.exp(-4 * 0.15) * numpy.exp(-1.2 * (t - 0.15)))
+    wave *= decay
+    mx = numpy.abs(wave).max()
+    if mx > 0:
+        wave /= mx
+    return (peak * wave).astype(numpy.int16)
+
+
+def accordion_wave(hz, peak=SAMPLE_PEAK, n_samples=SAMPLE_RATE):
+    """Accordion — bellows-driven free reeds.
+
+    Two reeds per note slightly detuned (musette tuning) create
+    the characteristic beating/tremolo. Rich in harmonics from
+    the reed vibration.
+    """
+    t = numpy.arange(n_samples, dtype=numpy.float64) / SAMPLE_RATE
+    rng = numpy.random.default_rng(int(hz * 100) % 2**31)
+    # Two reeds slightly detuned — musette beating
+    detune_cents = 8
+    hz2 = hz * (2 ** (detune_cents / 1200))
+    # Reed harmonics — rich, like a square-ish wave but warmer
+    wave = numpy.zeros(n_samples, dtype=numpy.float64)
+    for reed_hz in [hz, hz2]:
+        for n in range(1, 10):
+            f_n = reed_hz * n
+            if f_n >= SAMPLE_RATE / 2:
+                break
+            # Odd harmonics stronger (reed character)
+            amp = (1.0 / n) * (1.2 if n % 2 == 1 else 0.6)
+            phase = rng.uniform(0, 2 * numpy.pi)
+            wave += amp * numpy.sin(2 * numpy.pi * f_n * t + phase)
+    wave *= 0.5  # normalize for two reeds
+    # Bellows pressure variation — slow amplitude swell
+    bellows = 0.85 + 0.15 * numpy.sin(2 * numpy.pi * 0.8 * t)
+    wave *= bellows
+    mx = numpy.abs(wave).max()
+    if mx > 0:
+        wave /= mx
+    return (peak * wave).astype(numpy.int16)
+
+
+def didgeridoo_wave(hz, peak=SAMPLE_PEAK, n_samples=SAMPLE_RATE):
+    """Didgeridoo — circular breathing drone through a wooden tube.
+
+    Deep fundamental with strong odd harmonics from the cylindrical
+    bore. The overtone singing technique creates shifting formants.
+    Buzzy, droning, primal.
+    """
+    t = numpy.arange(n_samples, dtype=numpy.float64) / SAMPLE_RATE
+    rng = numpy.random.default_rng(int(hz * 100) % 2**31)
+    # Lip buzz source — rich, raw
+    phase = numpy.cumsum(2 * numpy.pi * hz / SAMPLE_RATE * numpy.ones(n_samples))
+    buzz = numpy.zeros(n_samples, dtype=numpy.float64)
+    for n in range(1, 15):
+        if hz * n >= SAMPLE_RATE / 2:
+            break
+        # Odd harmonics stronger (cylindrical bore, like clarinet)
+        amp = (1.0 / n) * (1.0 if n % 2 == 1 else 0.4)
+        buzz += amp * numpy.sin(phase * n + rng.uniform(0, 2 * numpy.pi))
+    # Shifting formant — the overtone singing effect
+    # Sweeps slowly between 500Hz and 1500Hz
+    formant_center = 800 + 400 * numpy.sin(2 * numpy.pi * 0.3 * t)
+    import scipy.signal as _sig
+    # Block-process the formant sweep
+    block = 2048
+    out = numpy.zeros(n_samples, dtype=numpy.float64)
+    for i in range(0, n_samples, block):
+        end = min(i + block, n_samples)
+        fc = formant_center[(i + end) // 2]
+        lo = max(20, int(fc - 300))
+        hi = min(SAMPLE_RATE // 2 - 1, int(fc + 300))
+        if lo < hi:
+            bp, ap = _sig.butter(2, [lo, hi], btype='band', fs=SAMPLE_RATE)
+            seg = _sig.lfilter(bp, ap, buzz[i:end])
+            out[i:end] = buzz[i:end] * 0.5 + seg * 0.5
+        else:
+            out[i:end] = buzz[i:end]
+    # Breath noise
+    breath = rng.normal(0, 0.04, n_samples)
+    out += breath
+    mx = numpy.abs(out).max()
+    if mx > 0:
+        out /= mx
+    return (peak * out).astype(numpy.int16)
+
+
+def bagpipe_wave(hz, peak=SAMPLE_PEAK, n_samples=SAMPLE_RATE):
+    """Bagpipes — chanter reed with constant drone pressure.
+
+    The chanter (melody pipe) uses a double reed like an oboe
+    but with more buzz and brightness. The constant air pressure
+    from the bag means no dynamics — always ff.
+    """
+    t = numpy.arange(n_samples, dtype=numpy.float64) / SAMPLE_RATE
+    rng = numpy.random.default_rng(int(hz * 100) % 2**31)
+    # Chanter — all harmonics, bright and reedy
+    wave = numpy.zeros(n_samples, dtype=numpy.float64)
+    for n in range(1, 18):
+        f_n = hz * n
+        if f_n >= SAMPLE_RATE / 2:
+            break
+        # Peaked around harmonics 3-7 (the piercing brightness)
+        amp = (1.0 / n) * numpy.exp(-0.03 * (n - 5) ** 2)
+        phase = rng.uniform(0, 2 * numpy.pi)
+        wave += amp * numpy.sin(2 * numpy.pi * f_n * t + phase)
+    # Reed buzz — more than oboe
+    reed = rng.normal(0, 0.08, n_samples)
+    import scipy.signal as _sig
+    lo = max(20, int(hz * 2))
+    hi = min(SAMPLE_RATE // 2 - 1, int(hz * 8))
+    if lo < hi:
+        br, ar = _sig.butter(2, [lo, hi], btype='band', fs=SAMPLE_RATE)
+        reed = _sig.lfilter(br, ar, reed).astype(numpy.float64) * 1.5
+    wave += reed
+    # Bag pressure wobble — very subtle
+    bag = 1.0 + 0.02 * numpy.sin(2 * numpy.pi * 1.5 * t)
+    wave *= bag
+    mx = numpy.abs(wave).max()
+    if mx > 0:
+        wave /= mx
+    return (peak * wave).astype(numpy.int16)
+
+
+def banjo_wave(hz, peak=SAMPLE_PEAK, n_samples=SAMPLE_RATE):
+    """Banjo — steel strings on a drum-head body.
+
+    The banjo's distinctive twang comes from the membrane head
+    (like a drum skin) instead of a wooden soundboard. This gives
+    a sharp attack, bright tone, and fast decay with a nasal,
+    metallic quality. The 5th string drone adds shimmer.
+    """
+    period = int(SAMPLE_RATE / hz)
+    if period < 2:
+        period = 2
+    rng = numpy.random.default_rng(int(hz * 100) % 2**31)
+
+    # Steel string — bright, sharp attack
+    buf = rng.uniform(-0.9, 0.9, period).astype(numpy.float64)
+    # Minimal filtering — banjo keeps the brightness
+    for k in range(period - 1):
+        buf[k] = 0.7 * buf[k] + 0.3 * buf[k + 1]
+
+    out = numpy.zeros(n_samples, dtype=numpy.float64)
+    for i in range(n_samples):
+        out[i] = buf[i % period]
+        next_idx = (i + 1) % period
+        # Moderate decay — drum head rings but shorter than guitar
+        buf[i % period] = 0.5 * (buf[i % period] + buf[next_idx]) * 0.9988
+
+    # Drum-head resonance — nasal, ringy, mid-frequency peaks
+    # The membrane head rings more than wood — that's the twang
+    import scipy.signal as _sig
+    for center, bw, gain in [(600, 200, 0.5), (1500, 300, 0.4), (3000, 500, 0.25)]:
+        lo = max(20, center - bw)
+        hi = min(SAMPLE_RATE // 2 - 1, center + bw)
+        if lo < hi:
+            bp, ap = _sig.butter(2, [lo, hi], btype='band', fs=SAMPLE_RATE)
+            out += _sig.lfilter(bp, ap, out) * gain
+
+    mx = numpy.abs(out).max()
+    if mx > 0:
+        out /= mx
+    return (peak * out).astype(numpy.int16)
+
+
+def mandolin_wave(hz, peak=SAMPLE_PEAK, n_samples=SAMPLE_RATE):
+    """Mandolin — paired steel strings, bright and ringing.
+
+    The mandolin has 4 courses of paired strings, tuned in unison.
+    The doubled strings create natural chorus. Bright attack from
+    the plectrum, small body with high-frequency resonance.
+    """
+    period = int(SAMPLE_RATE / hz)
+    if period < 2:
+        period = 2
+    rng = numpy.random.default_rng(int(hz * 100) % 2**31)
+
+    # Two strings per course — slightly detuned for natural chorus
+    buf1 = rng.uniform(-0.8, 0.8, period).astype(numpy.float64)
+    period2 = max(2, period + rng.integers(-1, 2))
+    buf2 = rng.uniform(-0.8, 0.8, period2).astype(numpy.float64)
+    # Light filtering — steel is brighter than nylon
+    for k in range(period - 1):
+        buf1[k] = 0.65 * buf1[k] + 0.35 * buf1[k + 1]
+    for k in range(period2 - 1):
+        buf2[k] = 0.65 * buf2[k] + 0.35 * buf2[k + 1]
+
+    out = numpy.zeros(n_samples, dtype=numpy.float64)
+    for i in range(n_samples):
+        s1 = buf1[i % period]
+        s2 = buf2[i % period2]
+        out[i] = s1 * 0.55 + s2 * 0.45
+        next1 = (i + 1) % period
+        buf1[i % period] = 0.5 * (s1 + buf1[next1]) * 0.9988
+        next2 = (i + 1) % period2
+        buf2[i % period2] = 0.5 * (s2 + buf2[next2]) * 0.9988
+
+    # Small bright body — higher resonance than guitar
+    import scipy.signal as _sig
+    for center, bw, gain in [(500, 120, 0.3), (1000, 200, 0.25), (2000, 300, 0.15)]:
+        lo = max(20, center - bw)
+        hi = min(SAMPLE_RATE // 2 - 1, center + bw)
+        if lo < hi:
+            bp, ap = _sig.butter(2, [lo, hi], btype='band', fs=SAMPLE_RATE)
+            out += _sig.lfilter(bp, ap, out) * gain
+
+    mx = numpy.abs(out).max()
+    if mx > 0:
+        out /= mx
+    return (peak * out).astype(numpy.int16)
+
+
+def ukulele_wave(hz, peak=SAMPLE_PEAK, n_samples=SAMPLE_RATE):
+    """Ukulele — nylon strings on a small resonant body.
+
+    Brighter and thinner than guitar, shorter sustain. The small
+    body gives a mid-heavy resonance (no deep bass). Nylon strings
+    have a softer, warmer attack than steel.
+    """
+    period = int(SAMPLE_RATE / hz)
+    if period < 2:
+        period = 2
+    rng = numpy.random.default_rng(int(hz * 100) % 2**31)
+
+    # Nylon string — soft noise
+    buf = rng.uniform(-0.5, 0.5, period).astype(numpy.float64)
+    for _ in range(5):
+        for k in range(period - 1):
+            buf[k] = 0.55 * buf[k] + 0.45 * buf[k + 1]
+
+    out = numpy.zeros(n_samples, dtype=numpy.float64)
+    for i in range(n_samples):
+        out[i] = buf[i % period]
+        next_idx = (i + 1) % period
+        buf[i % period] = 0.5 * (buf[i % period] + buf[next_idx]) * 0.998
+
+    # Small body resonance — mid-heavy, no deep bass
+    import scipy.signal as _sig
+    for center, bw, gain in [(350, 100, 0.35), (700, 150, 0.25), (1200, 200, 0.15)]:
+        lo = max(20, center - bw)
+        hi = min(SAMPLE_RATE // 2 - 1, center + bw)
+        if lo < hi:
+            bp, ap = _sig.butter(2, [lo, hi], btype='band', fs=SAMPLE_RATE)
+            out += _sig.lfilter(bp, ap, out) * gain
+
+    bl, al = _sig.butter(2, min(6000, hz * 12), btype='low', fs=SAMPLE_RATE)
+    out = _sig.lfilter(bl, al, out)
+
+    mx = numpy.abs(out).max()
+    if mx > 0:
+        out /= mx
+    return (peak * out).astype(numpy.int16)
+
+
 def acoustic_guitar_wave(hz, peak=SAMPLE_PEAK, n_samples=SAMPLE_RATE):
     """Acoustic guitar — Karplus-Strong with wooden body resonance.
 
@@ -1087,6 +1783,20 @@ class Synth(Enum):
     CELLO = "cello_synth"
     HARP = "harp_synth"
     UPRIGHT_BASS = "upright_bass_synth"
+    TIMPANI = "timpani_synth"
+    SAXOPHONE = "saxophone_synth"
+    GRANULAR = "granular_synth"
+    VOCAL = "vocal_synth"
+    PEDAL_STEEL = "pedal_steel_synth"
+    THEREMIN = "theremin_synth"
+    KALIMBA = "kalimba_synth"
+    STEEL_DRUM = "steel_drum_synth"
+    ACCORDION = "accordion_synth"
+    DIDGERIDOO = "didgeridoo_synth"
+    BAGPIPE = "bagpipe_synth"
+    BANJO = "banjo_synth"
+    MANDOLIN = "mandolin_synth"
+    UKULELE = "ukulele_synth"
     ACOUSTIC_GUITAR = "acoustic_guitar_synth"
     SITAR = "sitar_synth"
     ELECTRIC_GUITAR = "electric_guitar_synth"
@@ -1108,6 +1818,14 @@ _SYNTH_FUNCTIONS = {
     "marimba_synth": marimba_wave, "oboe_synth": oboe_wave,
     "harpsichord_synth": harpsichord_wave, "cello_synth": cello_wave,
     "harp_synth": harp_wave, "upright_bass_synth": upright_bass_wave,
+    "timpani_synth": timpani_wave, "saxophone_synth": saxophone_wave,
+    "granular_synth": granular_wave, "vocal_synth": vocal_wave,
+    "pedal_steel_synth": pedal_steel_wave, "theremin_synth": theremin_wave,
+    "kalimba_synth": kalimba_wave, "steel_drum_synth": steel_drum_wave,
+    "accordion_synth": accordion_wave, "didgeridoo_synth": didgeridoo_wave,
+    "bagpipe_synth": bagpipe_wave,
+    "banjo_synth": banjo_wave, "mandolin_synth": mandolin_wave,
+    "ukulele_synth": ukulele_wave,
     "acoustic_guitar_synth": acoustic_guitar_wave,
     "sitar_synth": sitar_wave, "electric_guitar_synth": electric_guitar_wave,
 }
@@ -1863,6 +2581,68 @@ def _synth_mridangam_tha(n_samples):
     return out
 
 
+def _synth_cajon_bass(n_samples):
+    """Cajón bass — palm strike on center of the face.
+
+    Deep woody thump. The box resonates like a bass drum but with
+    a warmer, more wooden character.
+    """
+    t = numpy.arange(n_samples, dtype=numpy.float32) / SAMPLE_RATE
+    # Wooden box thump
+    thump_len = min(int(SAMPLE_RATE * 0.06), n_samples)
+    thump_raw = _noise(thump_len)
+    import scipy.signal as _sig
+    if thump_len > 20:
+        bl, al = _sig.butter(2, [40, 200], btype='band', fs=SAMPLE_RATE)
+        thump = _sig.lfilter(bl, al, numpy.pad(thump_raw, (0, max(0, n_samples - thump_len))))[:thump_len].astype(numpy.float32)
+    else:
+        thump = thump_raw
+    thump *= _exp_decay(thump_len, 18) * 0.8
+    body = numpy.sin(2 * numpy.pi * 70 * t) * _exp_decay(n_samples, 7) * 0.8
+    sub = _sine_f32(45, n_samples) * _exp_decay(n_samples, 9) * 0.4
+    click_len = min(200, n_samples)
+    click = _noise(click_len) * _exp_decay(click_len, 45) * 0.3
+    result = body + sub
+    result[:thump_len] += thump
+    result[:click_len] += click
+    return numpy.tanh(result * 1.3).astype(numpy.float32)
+
+
+def _synth_cajon_slap(n_samples):
+    """Cajón slap — fingers near the top edge, snare wires buzz.
+
+    Bright crack with a buzzy rattle from the internal snare wires.
+    The signature cajón sound — like a snare but woodier.
+    """
+    t = numpy.arange(n_samples, dtype=numpy.float32) / SAMPLE_RATE
+    # Snare wire buzz
+    wire = _noise(n_samples) * _exp_decay(n_samples, 18) * 0.6
+    import scipy.signal as _sig
+    bl, al = _sig.butter(2, [1500, 6000], btype='band', fs=SAMPLE_RATE)
+    wire = _sig.lfilter(bl, al, wire).astype(numpy.float32) * 1.2
+    # Wood body
+    body = numpy.sin(2 * numpy.pi * 200 * t) * _exp_decay(n_samples, 22) * 0.4
+    # Sharp slap
+    slap_len = min(int(SAMPLE_RATE * 0.008), n_samples)
+    slap = _noise(slap_len) * _exp_decay(slap_len, 200) * 0.8
+    result = body + wire
+    result[:slap_len] += slap
+    return numpy.tanh(result * 1.5).astype(numpy.float32)
+
+
+def _synth_cajon_tap(n_samples):
+    """Cajón tap — light fingertip on the face. Ghost note."""
+    n = min(n_samples, int(SAMPLE_RATE * 0.04))
+    t = numpy.arange(n, dtype=numpy.float32) / SAMPLE_RATE
+    tap = numpy.sin(2 * numpy.pi * 300 * t) * _exp_decay(n, 35) * 0.3
+    pop = _noise(min(50, n)) * _exp_decay(min(50, n), 250) * 0.5
+    result = tap
+    result[:min(50, n)] += pop
+    out = numpy.zeros(n_samples, dtype=numpy.float32)
+    out[:n] = numpy.tanh(result * 1.5)
+    return out
+
+
 def _synth_metal_kick(n_samples):
     """Metal kick — punchy with beater click. Double-bass ready.
 
@@ -2131,6 +2911,10 @@ def _render_drum_hit(sound_value, n_samples):
         DrumSound.DJEMBE_BASS.value: lambda n: _synth_djembe_bass(n),
         DrumSound.DJEMBE_TONE.value: lambda n: _synth_djembe_tone(n),
         DrumSound.DJEMBE_SLAP.value: lambda n: _synth_djembe_slap(n),
+        # Cajon
+        DrumSound.CAJON_BASS.value: lambda n: _synth_cajon_bass(n),
+        DrumSound.CAJON_SLAP.value: lambda n: _synth_cajon_slap(n),
+        DrumSound.CAJON_TAP.value: lambda n: _synth_cajon_tap(n),
         # Metal kit
         DrumSound.METAL_KICK.value: lambda n: _synth_metal_kick(n),
         DrumSound.METAL_SNARE.value: lambda n: _synth_metal_snare(n),
@@ -3323,8 +4107,13 @@ def _render_notes_to_buf(notes, buf, samples_per_beat, total_samples,
                         bent = src_f[idx] * (1 - frac) + src_f[numpy.minimum(idx + 1, src_len - 1)] * frac
                         waves.append((bent * SAMPLE_PEAK).astype(numpy.int16))
                 else:
-                    # Render oscillators (pass synth_kwargs for FM etc.)
-                    waves = [synth_fn(hz, n_samples=n_samples, **_skw)
+                    # Per-note kwargs (e.g. lyric for vocal synth)
+                    note_skw = dict(_skw)
+                    note_lyric = getattr(note, 'lyric', '')
+                    if note_lyric:
+                        note_skw['lyric'] = note_lyric
+                    # Render oscillators
+                    waves = [synth_fn(hz, n_samples=n_samples, **note_skw)
                              for hz in pitches]
                 # Sub-oscillator: octave-below sine
                 if sub_osc > 0:
@@ -3715,6 +4504,10 @@ def render_score(score):
         DrumSound.DJEMBE_BASS.value: 0.0,
         DrumSound.DJEMBE_TONE.value: 0.1,
         DrumSound.DJEMBE_SLAP.value: -0.1,
+        # Cajon — centered (single instrument)
+        DrumSound.CAJON_BASS.value: 0.0,
+        DrumSound.CAJON_SLAP.value: 0.0,
+        DrumSound.CAJON_TAP.value: 0.1,
         # Metal kit
         DrumSound.METAL_KICK.value: 0.0,
         DrumSound.METAL_SNARE.value: 0.0,

pytheory/rhythm.py

@@ -195,6 +195,54 @@ INSTRUMENTS = {
         "detune": 12, "lowpass": 3000, "lowpass_q": 1.5,
         "humanize": 0.2,
     },
+    "pedal_steel": {
+        "synth": "pedal_steel_synth", "envelope": "strings",
+        "reverb": 0.3, "reverb_type": "spring",
+        "humanize": 0.15,
+    },
+    "theremin": {
+        "synth": "theremin_synth", "envelope": "pad",
+        "legato": True, "glide": 0.05,
+        "reverb": 0.3, "reverb_type": "plate",
+    },
+    "kalimba": {
+        "synth": "kalimba_synth", "envelope": "none",
+        "reverb": 0.35, "reverb_type": "plate",
+    },
+    "steel_drum": {
+        "synth": "steel_drum_synth", "envelope": "none",
+        "reverb": 0.3, "reverb_type": "plate",
+    },
+    "accordion": {
+        "synth": "accordion_synth", "envelope": "organ",
+        "humanize": 0.15,
+    },
+    "didgeridoo": {
+        "synth": "didgeridoo_synth", "envelope": "pad",
+        "lowpass": 1500,
+        "reverb": 0.4, "reverb_type": "cave",
+    },
+    "bagpipe": {
+        "synth": "bagpipe_synth", "envelope": "organ",
+        "lowpass": 4000,
+    },
+    "banjo": {
+        "synth": "banjo_synth", "envelope": "none",
+        "humanize": 0.2,
+    },
+    "mandolin": {
+        "synth": "mandolin_synth", "envelope": "none",
+        "humanize": 0.2,
+    },
+    "mandola": {
+        "synth": "mandolin_synth", "envelope": "none",
+        "lowpass": 3000,
+        "humanize": 0.2,
+    },
+    "ukulele": {
+        "synth": "ukulele_synth", "envelope": "none",
+        "humanize": 0.2,
+    },
     "koto": {
         "synth": "pluck_synth", "envelope": "none",
         "lowpass": 4000,
@@ -241,6 +289,26 @@ INSTRUMENTS = {
         "vel_to_filter": 3000,
         "analog": 0.3,
     },
+    "granular_pad": {
+        "synth": "granular_synth", "envelope": "pad",
+        "reverb": 0.4, "reverb_type": "cathedral",
+        "analog": 0.3,
+    },
+    "vocal": {
+        "synth": "vocal_synth", "envelope": "strings",
+        "reverb": 0.3, "reverb_type": "hall",
+        "humanize": 0.15,
+    },
+    "choir": {
+        "synth": "vocal_synth", "envelope": "pad",
+        "detune": 8, "spread": 0.4,
+        "reverb": 0.45, "reverb_type": "cathedral",
+    },
+    "granular_texture": {
+        "synth": "granular_synth", "envelope": "none",
+        "reverb": 0.5, "reverb_type": "taj_mahal",
+        "delay": 0.3, "delay_time": 0.4, "delay_feedback": 0.4,
+    },
     "808_bass": {
         "synth": "sine", "envelope": "pluck",
         "distortion": 0.4, "distortion_drive": 2.5,
@@ -275,6 +343,31 @@ INSTRUMENTS = {
         "fm_ratio": 2.0, "fm_index": 3.0,
         "reverb": 0.4, "reverb_type": "cathedral",
     },
+    "timpani": {
+        "synth": "timpani_synth", "envelope": "none",
+        "reverb": 0.4, "reverb_type": "cathedral",
+    },
+
+    # ── Woodwinds (continued) ──
+    "saxophone": {
+        "synth": "saxophone_synth", "envelope": "bowed",
+        "humanize": 0.15, "vel_to_filter": 1500,
+    },
+    "alto_sax": {
+        "synth": "saxophone_synth", "envelope": "bowed",
+        "humanize": 0.15, "vel_to_filter": 1800,
+    },
+    "tenor_sax": {
+        "synth": "saxophone_synth", "envelope": "bowed",
+        "lowpass": 3000,
+        "humanize": 0.15, "vel_to_filter": 1200,
+    },
+    "bari_sax": {
+        "synth": "saxophone_synth", "envelope": "bowed",
+        "lowpass": 2000,
+        "humanize": 0.15, "vel_to_filter": 800,
+        "sub_osc": 0.15,
+    },
 }
 
 
@@ -332,6 +425,7 @@ class Note:
     velocity: int = 100
     bend: float = 0.0
     bend_type: str = "smooth"  # "smooth" (log), "linear", "late"
+    lyric: str = ""  # syllable for vocal synth
 
     @property
     def beats(self) -> float:
@@ -433,6 +527,10 @@ class DrumSound(Enum):
     DJEMBE_BASS = 102    # open bass (center of head)
     DJEMBE_TONE = 103    # open tone (edge, fingers together)
     DJEMBE_SLAP = 104    # slap (edge, fingers spread, sharp crack)
+    # Cajon sounds
+    CAJON_BASS = 108     # center of face, deep thump
+    CAJON_SLAP = 109     # top edge, snare wires buzz
+    CAJON_TAP = 110      # light finger tap
     # Metal kit — tighter, punchier, more attack
     METAL_KICK = 105     # clicky, punchy, tight
     METAL_SNARE = 106    # crack, bright, cutting
@@ -1464,6 +1562,50 @@ Pattern._PRESETS["tabla solo"] = dict(
     ],
 )
 
+# ── Cajón patterns ────────────────────────────────────────────────────────
+CB = DrumSound.CAJON_BASS
+CSL = DrumSound.CAJON_SLAP
+CT = DrumSound.CAJON_TAP
+
+# Cajón flamenco — the classic acoustic percussion groove
+Pattern._PRESETS["cajon"] = dict(
+    name="cajon",
+    time_signature="4/4",
+    beats=4.0,
+    hits=[
+        _h(CB, 0.0, 85), _h(CT, 0.5, 35), _h(CT, 0.75, 38),
+        _h(CSL, 1.0, 80), _h(CT, 1.5, 32),
+        _h(CB, 2.0, 82), _h(CT, 2.5, 35), _h(CT, 2.75, 40),
+        _h(CSL, 3.0, 82), _h(CT, 3.25, 30), _h(CT, 3.5, 35),
+    ],
+)
+
+# Cajón rumba — Latin-flavored
+Pattern._PRESETS["cajon rumba"] = dict(
+    name="cajon rumba",
+    time_signature="4/4",
+    beats=4.0,
+    hits=[
+        _h(CB, 0.0, 88), _h(CT, 0.5, 38),
+        _h(CSL, 1.0, 78), _h(CT, 1.25, 32), _h(CB, 1.5, 72),
+        _h(CSL, 2.0, 82), _h(CT, 2.5, 35),
+        _h(CB, 3.0, 75), _h(CSL, 3.5, 80), _h(CT, 3.75, 38),
+    ],
+)
+
+# Cajón singer-songwriter — simple, supportive
+Pattern._PRESETS["cajon folk"] = dict(
+    name="cajon folk",
+    time_signature="4/4",
+    beats=4.0,
+    hits=[
+        _h(CB, 0.0, 80),
+        _h(CSL, 1.0, 72), _h(CT, 1.5, 30),
+        _h(CB, 2.0, 78),
+        _h(CSL, 3.0, 75),
+    ],
+)
+
 # ── Metal kit patterns ────────────────────────────────────────────────────
 MK = DrumSound.METAL_KICK
 MS = DrumSound.METAL_SNARE
@@ -2060,7 +2202,7 @@ class Part:
         self._automation: list[tuple[float, dict]] = []  # (beat, {param: value})
 
     def add(self, tone_or_string, duration=Duration.QUARTER, *, velocity: int = 100,
-            bend: float = 0.0, bend_type: str = "smooth") -> "Part":
+            bend: float = 0.0, bend_type: str = "smooth", lyric: str = "") -> "Part":
         """Add a note. Accepts Tone/Chord objects or note strings like ``"E5"``.
 
         Duration can be a ``Duration`` enum or a raw float (beats).
@@ -2078,7 +2220,7 @@ class Part:
             duration = _RawDuration(duration)
         self.notes.append(Note(tone=tone_or_string, duration=duration,
                                velocity=velocity, bend=bend,
-                               bend_type=bend_type))
+                               bend_type=bend_type, lyric=lyric))
         return self
 
     def set(self, **params) -> "Part":
@@ -2363,7 +2505,7 @@ class Part:
 
     def strum(self, chord_name: str, duration=Duration.QUARTER, *,
               direction: str = "down", velocity: int = 100,
-              strum_time: float = 0.08) -> "Part":
+              strum_time: float = 0.05) -> "Part":
         """Strum a chord using the part's fretboard fingering.
 
         Looks up the chord on the fretboard, gets the fingering, and
@@ -2431,10 +2573,68 @@ class Part:
         from .chords import Chord as ChordClass
         chord_obj = ChordClass(tones=strum_tones)
 
-        self.add(chord_obj, total_beats, velocity=velocity)
+        # Strum sweep: quick individual string hits before the chord.
+        # Only the first 2-3 strings get a tiny grace note, the rest
+        # ring together as the full chord. Gives the strum feel without
+        # sounding like separate plucks.
+        n_strings = len(strum_tones)
+        if strum_time > 0.02 and n_strings >= 3:
+            n_grace = min(2, n_strings - 1)
+            per_grace = strum_time / n_grace
+            grace_vel = max(1, int(velocity * 0.25))
+            for i in range(n_grace):
+                self.add(strum_tones[i], per_grace, velocity=grace_vel)
+            ring = max(0.1, total_beats - strum_time)
+            self.add(chord_obj, ring, velocity=velocity)
+        else:
+            self.add(chord_obj, total_beats, velocity=velocity)
 
         return self
 
+    def roll(self, tone_or_string, duration=Duration.WHOLE, *,
+             velocity_start: int = 40, velocity_end: int = 100,
+             speed=Duration.SIXTEENTH) -> "Part":
+        """Play a roll — rapid repeated notes with velocity ramp.
+
+        Perfect for timpani rolls, snare rolls, tremolo on any
+        instrument. The velocity ramps from ``velocity_start`` to
+        ``velocity_end`` over the duration for crescendo/decrescendo.
+
+        Args:
+            tone_or_string: The note to repeat.
+            duration: Total duration of the roll.
+            velocity_start: Velocity of the first hit (default 40).
+            velocity_end: Velocity of the last hit (default 100).
+            speed: How fast to repeat (default SIXTEENTH notes).
+
+        Returns:
+            Self for chaining.
+
+        Example::
+
+            >>> timp = score.part("timp", instrument="timpani")
+            >>> timp.roll("C3", Duration.WHOLE, velocity_start=30, velocity_end=110)
+        """
+        if hasattr(duration, 'value'):
+            total = duration.value
+        else:
+            total = float(duration)
+        if hasattr(speed, 'value'):
+            step = speed.value
+        else:
+            step = float(speed)
+
+        n_hits = max(1, int(total / step))
+        for i in range(n_hits):
+            frac = i / max(1, n_hits - 1)
+            vel = int(velocity_start + (velocity_end - velocity_start) * frac)
+            vel = max(1, min(127, vel))
+            remaining = total - i * step
+            note_dur = min(step, remaining)
+            if note_dur > 0:
+                self.add(tone_or_string, note_dur, velocity=vel)
+        return self
+
     @property
     def is_drums(self) -> bool:
         """True if this part contains drum hits."""

pytheory/tones.py

@@ -816,8 +816,7 @@ class Tone:
             pitch_scale = list(custom_ratios) + [period]
         elif period != 2.0 and temperament == "equal":
             # Non-octave period (e.g. Bohlen-Pierce tritave=3.0)
-            import sympy
-            pitch_scale = [period ** sympy.Rational(i, tones) for i in range(tones + 1)]
+            pitch_scale = [period ** (i / tones) for i in range(tones + 1)]
         else:
             pitch_scale = TEMPERAMENTS[temperament](tones)
         octave = self.octave if self.octave is not None else 4
@@ -834,7 +833,7 @@ class Tone:
         if symbolic:
             return reference_pitch * ratio
         else:
-            result = reference_pitch * ratio
+            result = float(reference_pitch * ratio)
             if precision:
-                return float(result.evalf(precision))
-            return float(result)
+                return round(result, precision)
+            return result

test_pytheory.py

@@ -5320,7 +5320,7 @@ def test_supersaw_wave():
 @needs_portaudio
 def test_all_synths_in_enum():
     from pytheory.play import Synth
-    assert len(Synth) == 27
+    assert len(Synth) == 30
     for s in Synth:
         wave = s(440, n_samples=1000)
         assert len(wave) == 1000
@@ -6827,7 +6827,7 @@ def test_strum_direction():
     p = score.part("g", instrument="acoustic_guitar", fretboard=fb)
     p.strum("G", Duration.QUARTER, direction="down")
     p.strum("G", Duration.QUARTER, direction="up")
-    assert len(p.notes) == 2
+    assert len(p.notes) >= 2  # grace notes + chord per strum
 
 
 # ── World drums ──────────────────────────────────────────────────────────────

uv.lock

@@ -444,15 +444,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
 ]
 
-[[package]]
-name = "mpmath"
-version = "1.3.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106, upload-time = "2023-03-07T16:47:11.061Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" },
-]
-
 [[package]]
 name = "myst-parser"
 version = "4.0.1"
@@ -707,11 +698,10 @@ wheels = [
 
 [[package]]
 name = "pytheory"
-version = "0.34.1"
+version = "0.36.1"
 source = { editable = "." }
 dependencies = [
     { name = "numeral" },
-    { name = "pytuning" },
     { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
     { name = "scipy", version = "1.17.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "sounddevice" },
@@ -732,7 +722,6 @@ docs = [
 [package.metadata]
 requires-dist = [
     { name = "numeral" },
-    { name = "pytuning" },
     { name = "scipy" },
     { name = "sounddevice" },
 ]
@@ -744,19 +733,6 @@ docs = [
     { name = "sphinx" },
 ]
 
-[[package]]
-name = "pytuning"
-version = "0.7.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "numpy", version = "2.4.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
-    { name = "sympy" },
-]
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/26/59/e2c2fc91688f788587fb387ef6120c9a1ad3a8b88771fba9fc6a9c9a969d/PyTuning-0.7.3-py3-none-any.whl", hash = "sha256:db0b1231c012c1cf6a3c73aa7d791b4cff79a72f2ec6535f159c873fe302214b", size = 108174, upload-time = "2023-09-02T21:11:00.657Z" },
-]
-
 [[package]]
 name = "pyyaml"
 version = "6.0.3"
@@ -1151,18 +1127,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072, upload-time = "2024-07-29T01:10:08.203Z" },
 ]
 
-[[package]]
-name = "sympy"
-version = "1.14.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "mpmath" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" },
-]
-
 [[package]]
 name = "tomli"
 version = "2.4.0"