diff --git a/README.md b/README.md
index 4f5fd46..d5b963b 100644
--- a/README.md
+++ b/README.md
@@ -21,6 +21,7 @@ same either way.
 | `include/taptools/ladder.h` | `tap.ladder~` | ZDF Moog-style ladder (`tap::tools::ladder`) |
 | `include/taptools/svf.h` | `tap.svf~` | Simper/Cytomic morphing SVF (`tap::tools::svf`) |
 | `include/taptools/vco.h` | `tap.vco~` | Virtual-analog oscillator (`tap::tools::vco`) |
+| `include/taptools/overdrive.h` | `tap.overdrive~` | LGW-voiced feedback overdrive (`tap::tools::od`) |
 | `include/taptools/grm_comb.h` | `tap.5comb~` | GRM comb-bank recreation (`tap::tools::fivecomb`) |
 | `include/taptools/grm_pitchaccum.h` | `tap.pitchaccum~` | GRM PitchAccum recreation (`tap::tools::pitchaccum`) |
 | `include/taptools/conv_engine.h` | `tap.convolve~` | Partitioned (UPOLS) true-stereo convolution (`tap::tools::conv_engine`) |
@@ -33,18 +34,20 @@ Plus, all Max-free:
 - **`tools/render/`** — offline WAV renderers (`diode_render`, `tb303_render`, `ladder_render`, `vco_render`,
   `grm_comb_render`, `grm_pitchaccum_render`, `autowah_render`) for listening checks outside Max.
 - **`tools/capi/`** — a small C ABI (`taptools_capi`) over the kernels for non-C++ consumers:
-  `conv_engine`, `svf`, `ladder`, `diode`, `tb303`, `vco`, and `autowah`.
+  `conv_engine`, `svf`, `ladder`, `diode`, `tb303`, `vco`, `autowah`, and `overdrive`.
 - **`notebooks/`** — Jupyter verification notebooks driving the *actual shipping DSP* through the
   C ABI via ctypes (`taptools_py.py`): `convolution_reverb.ipynb`, `svf.ipynb`, `ladder.ipynb`,
-  `vco.ipynb`, `tb303.ipynb` (the tap.303/tap.diode verification + the phase-2 WDF go/no-go evidence), and `autowah_validation.ipynb` (the hardware-calibration harness for the Snow
+  `vco.ipynb`, `tb303.ipynb` (the tap.303/tap.diode verification + the phase-2 WDF go/no-go evidence), `overdrive.ipynb` (the feedback-loop tilt, asymmetry harmonics, alias floor, and
+  body voicing, measured), and `autowah_validation.ipynb` (the hardware-calibration harness for the Snow
   White model — its last section ingests reamped recordings of the real pedal).
 - **`bench/`** — CPU benchmarks and the per-machine regression ratchet (see `bench/README.md`).
 - **`book/`** — *Tools on Tap*, the mdBook field guide (the AmbiTap/SampleRateTap/MuTap book
   pattern): one chapter per object family, every claim measured by the notebooks/tests. Built
-  and published to Pages by `.github/workflows/docs.yml`. Ten user-facing chapters across four
+  and published to Pages by `.github/workflows/docs.yml`. Fourteen user-facing chapters across seven
   parts — sources (`vco`), filters (`svf`, `ladder`, `autowah`), strings/rooms/spirals
-  (`convolve`, `5comb`, `pitchaccum`), the spectral set (`vocoder`, `nr`, `spectra`) — plus
-  **Part V, "The machine, file by file"**: one deep-dive appendix per kernel header
+  (`convolve`, `5comb`, `pitchaccum`), the spectral set (`vocoder`, `nr`, `spectra`), the rhythm
+  section (`acid`, `drums`), staying in tune (`tune`), the pedalboard (`overdrive`) — plus
+  **"The machine, file by file"**: one deep-dive appendix per kernel header
   (SampleRateTap-style) deriving the math, reviewing the code, and recording why each
   algorithm is built the way it is.
 
diff --git a/book/src/SUMMARY.md b/book/src/SUMMARY.md
index 46d7d66..846cff5 100644
--- a/book/src/SUMMARY.md
+++ b/book/src/SUMMARY.md
@@ -33,7 +33,11 @@
 
 - [The note you meant](tune.md)
 
-# Part VII — The machine, file by file
+# Part VII — The pedalboard
+
+- [Distortion with a memory](overdrive.md)
+
+# Part VIII — The machine, file by file
 
 - [Solving the filter on paper: svf.h](machine/svf.md)
 - [The nonlinear loop: ladder.h](machine/ladder.md)
@@ -50,3 +54,4 @@
 - [Time as a function of phase: step_seq.h](machine/seq.md)
 - [Three ways to move a pitch: yin.h, psola.h, pvoc.h](machine/pitch.md)
 - [The nearest allowed note: tune.h](machine/tune.md)
+- [The clipper in the loop: overdrive.h](machine/overdrive.md)
diff --git a/book/src/introduction.md b/book/src/introduction.md
index 5f5b13c..1fca59a 100644
--- a/book/src/introduction.md
+++ b/book/src/introduction.md
@@ -35,10 +35,15 @@ The book is organized the way a patch is:
   its diode-ladder filter, and its sequencer (`tap.303~`, `tap.diode~`,
   `tap.303.seq~`), and the eight TR-808 voice channels with their row
   sequencer (`tap.808.*`, `tap.808.seq~`).
-- **Part VI — The machine, file by file**: the SampleRateTap-style deep dives —
+- **Part VI — Staying in tune**: the pitch corrector (`tap.tune~`) and the
+  detection/resynthesis machinery it stands on.
+- **Part VII — The pedalboard**: the stompbox recreations — the voiced feedback
+  overdrive (`tap.overdrive~`), chasing the TS-lineage feedback pedals rather
+  than a waveshaping curve.
+- **Part VIII — The machine, file by file**: the SampleRateTap-style deep dives —
   one chapter per kernel header, deriving the math, reviewing the code, and
   recording *why* each algorithm is written the way it is, alternatives and
-  all. Parts I–IV are for driving the objects; Part V is for trusting them —
+  all. Parts I–VII are for driving the objects; Part VIII is for trusting them —
   or changing them.
 
 More chapters land as objects mature; the utility and Jitter objects live in
diff --git a/book/src/machine/overdrive.md b/book/src/machine/overdrive.md
new file mode 100644
index 0000000..4e97340
--- /dev/null
+++ b/book/src/machine/overdrive.md
@@ -0,0 +1,170 @@
+# The clipper in the loop: `overdrive.h`
+
+The user-facing chapter claimed that `tap.overdrive~`'s gain tilts with
+frequency and that the tilt grows with drive — behavior a memoryless
+waveshaper cannot produce. This appendix derives the loop that produces it,
+shows why the obvious implementation of that loop is a stability bomb and how
+the file defuses it, and records the design decisions — shaper choice,
+asymmetry mechanics, oversampling versus ADAA — with the alternatives they
+beat.
+
+The design brief was not a schematic (none is published for the Little Green
+Wonder, the listening reference): it was the *class* of TS-lineage feedback
+overdrives. The honest statement of the goal, from the project's handoff
+notes: the interesting part is not the transfer curve — it's the
+frequency-dependent gain and the softer, never-fully-flat knee that a
+feedback clipper gives you.
+
+## The topology, and what it must do
+
+In a TS-lineage pedal the diodes sit in the feedback path of a non-inverting
+op-amp stage whose feedback network is frequency-dependent. Two consequences:
+
+1. The loop gain — and with it the effective clip threshold — varies with
+   frequency: bass sees little gain and stays clean, mids see all of it.
+2. The output is `input + limited feedback term`: even at maximum drive the
+   transfer's slope never reaches zero, because the clean input always passes.
+
+`overdrive.h` models this with the minimal structure that keeps both traits:
+
+```text
+w = shape( G·x − g_fb·LP(w) )      the clipper inside a lowpass feedback loop
+y = x + w                          the unity clean path (non-inverting topology)
+```
+
+`G` is the drive gain (a dB sweep, +6 to +46). The lowpass `LP` (one-pole,
+corner 660 Hz) makes the fed-back signal predominantly low-frequency, so the
+negative feedback suppresses gain exactly where the pedal does. In the linear
+region (`shape ≈ identity`) the loop's small-signal gain is
+
+```text
+w/x = G / (1 + g_fb·|LP(ω)|)
+```
+
+— at DC, `G / (1 + g_fb)`; far above the corner, `G`. The file picks `g_fb`
+from a single voicing constant: `g_fb = G/k_lf_gain − 1` with
+`k_lf_gain = 2`, which **pins the low-frequency gain at +6 dB regardless of
+drive** while the mids ride `G` all the way up. That one line is the measured
+headline — a bass-to-mid tilt of +5/+16.3/+17.2 dB at drive 0/0.5/0.9 —
+and it is the real-pedal behavior: turning up a TS makes the mids filthier
+while the low E barely moves.
+
+## Why the loop must be solved zero-delay
+
+The naive discretization feeds back *yesterday's* lowpass state:
+
+```text
+s    = G·x − g_fb·lp_state        // uses the previous sample's state
+w    = shape(s)
+lp_state += a·(w − lp_state)
+```
+
+That inserts a unit delay into a feedback loop — the same mistake as the
+Chamberlin SVF, with the same fuse. Linearize it: the state-to-state map has
+Jacobian `J = (1 − a) − a·g_fb·shape′`. At 48 kHz × 4 oversampling, a 660 Hz
+one-pole has `a ≈ 0.021`; at `drive 0.9`, `g_fb ≈ 62`. With `shape′ = 1`
+(small signal — the *quiet* case!) `J ≈ 0.979 − 1.34 = −0.36`: stable, fine.
+But push `g_fb` higher — drive 1.0 gives `G = 200`, `g_fb = 99` — and
+`J ≈ 0.979 − 2.12 = −1.14`. `|J| > 1`: the loop limit-cycles near Nyquist,
+audible as a parasitic whine that comes and goes with the signal level.
+A feedback clipper that oscillates when you turn it up is not a pedal, it's a
+bug report.
+
+The fix is the house zero-delay move (`svf.h`'s driven circuit, `ladder.h`'s
+`solver_fast`): integrate the one-pole trapezoidally (TPT), solve the loop's
+linear part implicitly, *then* apply the nonlinearity and commit its output
+to the state. With the TPT one-pole `v = (g·w + s)/(1 + g)`, substitute into
+the loop and solve for the node as if `shape` were identity:
+
+```text
+w_lin = ( G·x − g_fb·s/(1+g) ) / ( 1 + g_fb·g/(1+g) )
+w     = shape(w_lin + bias) − shape(bias)
+v     = (g·w + s)/(1+g);   s ← 2v − s
+```
+
+No delay in the linear loop, so no delay-induced instability at any `g_fb`;
+and because `shape′ ≤ 1` everywhere, the committed value only ever *reduces*
+the effective loop gain below the linear prediction — the approximation errs
+toward stability. At DC the solve gives `w = G·x/(1 + g_fb)` exactly, which
+is what makes the pinned-bass-gain arithmetic above exact rather than
+approximate. The kernel suite pins the consequence: after a full-drive,
+full-asymmetry signal stops, the output decays below 10⁻⁶ — no limit cycles.
+
+## The shaper: `u/√(1+u²)`, and why not tanh
+
+Three candidates from the brief, in the order they were rejected:
+
+- **`std::tanh`** — the reference softclip, and the expensive outlier: a
+  transcendental call per (oversampled) sample that vectorizes badly.
+- **Padé-style tanh approximations** — cheap, but the usual forms are exact
+  only on a bounded interval and go *flat* (or worse, retreat) beyond it —
+  reintroducing the hard plateau this design exists to avoid, with a
+  curvature discontinuity at the seam that aliases.
+- **`shape(u) = u/√(1+u²)`** — chosen: C∞ (no curvature seam to alias),
+  strictly monotonic, asymptotic to ±1 but never flat, one multiply-add and
+  one square root — which vectorizes as a reciprocal-sqrt instruction on
+  every SIMD ISA this kernel targets, and reduces to a small LUT for a
+  future fixed-point port.
+
+Asymmetry — the even-harmonic control the odd-only Jamoma curves structurally
+lacked — is a bias *inside* the shaper, output-corrected so silence stays
+silence: `w = shape(u + b) − shape(b)` with `b = 0.5·asymmetry`. At
+`asymmetry 0` the whole path is an odd function and the measured H2 sits at
+the numerical floor (−151 dB); at 0.6 it is −26 dB and musically present.
+The correction term keeps the first-order DC out, but a biased clipper still
+rectifies: under signal it *makes* DC, and the feedback one-pole would
+happily integrate it. Hence the DC blocker after the clipper —
+`y[n] = x[n] − x[n−1] + 0.9997·y[n−1]`, the Jamoma `TTDCBlock` constant kept
+for provenance — permanently in the path, not an option. (The original
+TTOverdrive instantiated that same blocker and then overwrote its output
+buffer without using it; the vestigial call was one of the tells, noted in
+the handoff brief, that the old code path was never going to be the base.)
+
+## Oversampling, not ADAA (for now)
+
+Clipping generates harmonics without limit; everything past Nyquist folds
+back inharmonically. Two published remedies: oversample the nonlinearity, or
+antiderivative anti-aliasing (Parker et al., DAFx-16). ADAA is cheaper per
+dB of alias suppression, but its `x[n] ≈ x[n−1]` fallback branch is hostile
+to the branchless-SIMD constraint this kernel inherits from its embedded
+targets, and its difference quotient loses precision in single-precision
+float — a real concern for the fixed-point/f32 ports. So v1 oversamples:
+zero-stuff + 4th-order Butterworth anti-image up, matching anti-alias down —
+the `ladder.h`/`svf.h` resampler verbatim, self-contained per house rule.
+Factors 1/2/4/8, default 4×. Measured on a hard-driven 5 kHz tone: the
+folded seventh harmonic improves from −22 dB (1×) to −36 dB (4×) while the
+in-band harmonics stay within measurement error. ADAA remains the flagged
+experiment for after the voicing locks, so the comparison is apples to
+apples.
+
+## The voicing layer, honestly labeled
+
+Everything above is structure; the *sound* of the body control is a handful
+of constants (`k_voice_*` at the top of the file): the pre-clipper highpass
+corner sliding 40→320 Hz across the knob, the upper-mid bell at 1150 Hz
+(above the classic TS hump — the LGW's push sits higher), the +2.5 dB
+counterclockwise treble shelf, the fixed +1.5 dB mid seasoning. They produce
+the measured control shape (±10 dB at 100 Hz between extremes, +4 dB at the
+bell) and they are **by-ear placeholders**: the header says so, this book
+says so, and the numbers will move when the in-Max voicing pass against LGW
+demos happens. What will not move is where they live — all linear EQ outside
+the nonlinearity, because in the reference pedal that is what the Body knob
+is.
+
+## The parameter block is normalized on purpose
+
+`drive` and `asymmetry` are 0..1, `body` is −1..+1; only `preamp`/`output`
+carry units (dB). The perceptual mapping (dB sweep of `G`, level
+compensation) lives inside the kernel, not in the knob range — so the
+parameters map directly to controllers, to `live.dial`, and to Q15/Q31
+fixed-point registers on the Cortex-M targets this library's headers are
+written to reach. Parameters ride the standard per-sample linear ramps
+(default 20 ms); the derived coefficients — `G`, `g_fb`, the solve constants,
+the voicing biquads — refresh only on samples where a ramp actually moved,
+the same two-tier scheme as `svf.h`.
+
+Everything in this chapter is executable: the loop math and stability claims
+are pinned by `tests/overdrive_test.cpp` (silence decay, tilt-grows-with-
+drive, even-harmonic emergence, DC blocking, alias improvement, determinism),
+and every number is a cell in
+[the verification notebook](https://github.com/tap/TapTools/blob/main/notebooks/overdrive.ipynb).
diff --git a/book/src/overdrive.md b/book/src/overdrive.md
new file mode 100644
index 0000000..e3a1fa4
--- /dev/null
+++ b/book/src/overdrive.md
@@ -0,0 +1,103 @@
+# Distortion with a memory
+
+Every distortion plugin can bend a transfer curve. `tap.overdrive~` is built
+on the observation that the pedals people actually love — the Tube Screamer
+lineage, and specifically the Mad Professor Little Green Wonder that served as
+this object's listening reference — don't apply one curve to the whole
+spectrum. Their clipper lives inside an op-amp's feedback loop with
+frequency-dependent parts around it, and that loop is most of the sound: bass
+sees less gain and stays tight, mids break up first, and the knee never quite
+flattens because the clean signal always rides through. A memoryless
+waveshaper — including both modes of the Jamoma-era `tap.overdrive~` this
+object succeeds — structurally cannot do any of that. This one can, because
+the shaper sits inside a lowpass feedback loop: distortion with a memory.
+
+Companion material: the reference page and help patcher in the TapTools-Max
+package, and the [verification notebook](https://github.com/tap/TapTools/blob/main/notebooks/overdrive.ipynb),
+where every number below is an executed, plotted measurement of the shipping
+kernel.
+
+## What the loop buys
+
+The claim worth leading with, because no static curve can make it: the
+object's small-signal gain **tilts with frequency, and the tilt grows with
+drive**. Measured between 80 Hz and 4 kHz, the tilt is +5 dB at `drive 0`
+(just the voicing EQ), +16.3 dB at `drive 0.5`, +17.2 dB at `drive 0.9`. Low
+frequencies are pinned near-clean by the feedback while mids and highs take
+the full drive gain — so a low E stays articulate under the same setting that
+saturates the pick attack. That is the Tube Screamer "tightness" in one plot.
+
+The second structural trait: the transfer **never flattens**. A unity clean
+path is summed around the clipper — the non-inverting op-amp topology — so
+however hard the shaped part saturates, output keeps rising with input
+(measured strictly monotonic at every drive setting). The old sine-shaper
+mode's hard ±1 plateau, a large part of what read as "digital," is gone by
+construction.
+
+## The knobs, one by one
+
+### `drive` — 0 to 1, edge-of-breakup to saturated
+
+Normalized, like every musical parameter on this object, with the perceptual
+mapping done inside (the knob sweeps the clipper's gain from +6 to +46 dB,
+with a level compensation tracking it). `drive 0` is a pedal's gain knob at
+full counterclockwise — still warm, not bit-clean; `bypass` is the clean
+switch. The normalized range maps directly onto MIDI/OSC controllers, and
+onto Q15/Q31 fixed-point for the embedded ports this kernel is written to
+survive.
+
+### `body` — the signature voicing control
+
+The LGW's defining knob, reproduced as linear pre/post EQ around the clipper
+(that's what it is in the pedal — voicing, not nonlinearity). Toward −1,
+fuller lows reach the clipper and the top gets a slight shelf lift; toward
++1, the lows thin and tighten and an upper-mid bell pushes forward — centered
+at 1150 Hz, deliberately above the classic TS hump. Measured at the extremes:
+100 Hz moves by 10 dB, the 1150 Hz push adds 4 dB, the counterclockwise
+treble lift is +2.5 dB at 8 kHz. The exact centers and gains are by-ear
+placeholders pending the in-Max voicing pass against LGW demos — the shape of
+the control is final, the seasoning isn't.
+
+### `asymmetry` — the even harmonics the old object couldn't make
+
+Both Jamoma modes were odd functions: odd harmonics only, the entire "warmth"
+vocabulary absent. `asymmetry` biases the clipper: at 0 the path is exactly
+symmetric (measured H2 at −151 dB — the numerical floor), and raising it
+brings the even series up smoothly (H2 at −26 dB by `asymmetry 0.6`). The
+default sits at 0.15, a small nonzero warmth chosen by ear. Asymmetric
+clipping generates DC, so a DC blocker sits permanently after the clipper —
+measured output mean under full drive, full asymmetry: 10⁻¹⁰. (The original
+TTOverdrive contained a DC blocker whose output was computed and then
+discarded; this one is load-bearing.)
+
+### `oversample` — 1, 2, 4, or 8; default 4
+
+Clipping makes harmonics; harmonics past Nyquist fold back as inharmonic
+junk. At 1× a hard-driven 5 kHz tone puts its folded seventh harmonic at
+−22 dB relative to the fundamental — clearly audible garbage at 12993 Hz. At
+the default 4× the same component measures −36 dB, with the true harmonics
+unchanged. Turn it down to 1× only when CPU matters more than the top octave,
+or when you *want* the fizz.
+
+### `preamp`, `output`, `smooth`, `bypass`, `mute`
+
+Input and makeup gain in dB (±24) — the only unit-bearing parameters, because
+gains are the one place real units belong. Everything ramps click-free over
+`smooth` milliseconds (default 20).
+
+## Where it sits in a patch
+
+Mono by design; wrap it in `mc.` for multichannel like the rest of the
+package. It takes line-level signals as happily as guitar DI — the drive
+mapping is normalized to full-scale digital, not to pickup output. For the
+LGW move, start at `drive 0.4, body -0.3, asymmetry 0.15` and ride `body`
+against the source's low end. For a clean boost that just thickens, `drive 0`
+with `asymmetry 0.3`. For fuzz territory this is the wrong object on
+purpose — the loop keeps pulling it back toward articulation.
+
+Every claim above is pinned twice: as an executed measurement in the
+notebook, and as a hard assertion in the kernel's Catch2 suite
+(`tests/overdrive_test.cpp`), which CI runs on every push. The math behind
+the loop — including why it had to be solved zero-delay, and what happens if
+you don't — is in the machine chapter:
+[The clipper in the loop](machine/overdrive.md).
diff --git a/include/taptools/overdrive.h b/include/taptools/overdrive.h
new file mode 100644
index 0000000..518299d
--- /dev/null
+++ b/include/taptools/overdrive.h
@@ -0,0 +1,501 @@
+/// @file
+/// @brief      Portable overdrive/saturation kernel for tap.overdrive~ — no Max/Min dependency.
+/// @details    A voiced feedback soft-clipper chasing the *class* of TS-lineage feedback
+///             overdrives (the Mad Professor Little Green Wonder was the listening reference),
+///             rather than a memoryless waveshaper. The old Jamoma TTOverdrive that tap.overdrive~
+///             wrapped was a static odd-function curve applied to the full spectrum; this is its
+///             spiritual successor, not a port — the design goals and their rationale live in the
+///             project's overdrive handoff notes. Design points:
+///
+///             - The clipping stage is a nonlinearity inside a *feedback loop with a lowpass*,
+///               emulating the frequency-dependent loop gain of an op-amp/diode-feedback stage:
+///               low frequencies see a pinned small gain (bass stays tight and nearly clean at
+///               any drive), mids/highs see the full drive gain and break up first. A static
+///               curve cannot do this; it is most of the perceptual distance to the reference.
+///             - The loop is solved with the house fast one-pass scheme (tap.svf~ driven circuit,
+///               tap.ladder~ solver_fast): a linear zero-delay (trapezoidal/TPT) prediction of
+///               the loop node, then the saturated value is committed to the one-pole state.
+///               No one-sample delay in the loop, so no limit-cycling at high loop gain —
+///               w = shape(G*x - g_fb*LP(w)) with the LP integrated implicitly.
+///             - shape() is u/sqrt(1+u^2): smooth (C-inf, so no curvature discontinuity to
+///               alias), monotonic, asymptotic to +-1, one sqrt — vectorizes as rsqrt and is
+///               LUT-able for a later fixed-point port. Asymmetry (even harmonics — the "warmth"
+///               the odd-only Jamoma curves structurally lacked) comes from a bias added inside
+///               the shaper, output-referred-corrected so silence stays at zero.
+///             - A unity clean path is summed around the clipper (y = x + w), the non-inverting
+///               op-amp topology's "never fully flattens" trait: the transfer keeps rising with
+///               reduced slope instead of plateauing at a rail.
+///             - The clipper runs oversampled (1/2/4/8x, default 4x): zero-stuff + 4th-order
+///               Butterworth anti-image up, matching anti-alias before decimation (the
+///               tap.ladder~ / tap.svf~ pattern, self-contained here per house rule).
+///             - "body" is the LGW-signature voicing control, all linear pre/post EQ (not part of
+///               the nonlinearity): it slides the pre-clipper highpass corner (CW = thinner,
+///               tighter lows into the clipper), adds an upper-mid push CW (a higher mid center
+///               than the classic TS hump) and a slight treble lift CCW.
+///             - A DC blocker (R = 0.9997, the Jamoma TTDCBlock constant, via tap.dcblock~) sits
+///               after the clipper: with asymmetry > 0 the shaper generates DC that the feedback
+///               one-pole would otherwise integrate, so it is always on, not a user option.
+///             - All musical parameters are normalized (drive/asymmetry 0..1, body -1..+1) with
+///               the perceptual mapping done internally (drive sweeps the shaper gain in dB) —
+///               deliberate, both for mappability and so the parameter block translates directly
+///               to Q15/Q31 on a future fixed-point embedded target. Gains (preamp/output) are
+///               the only unit-bearing parameters, in dB.
+///             - The voicing constants below (k_voice_*) are placeholders tuned against LGW
+///               demos by ear during the in-Max voicing pass — they are the "sound" of the
+///               object and are expected to be retouched there, not derived analytically.
+///             - The kernel itself is multichannel (tick() once per frame, process(channel, x)
+///               per channel — the tap.svf~ frame protocol); the Max wrapper runs it
+///               single-channel and leaves multichannel to mc. wrapping.
+///
+///             As in the other TapTools kernels: parameters ride per-sample linear ramps (no
+///             zipper), and everything is allocation-free after prepare(); setters are safe while
+///             audio runs.
+/// @author     Timothy Place
+// SPDX-License-Identifier: BSD-3-Clause
+// Copyright 2026 Timothy Place.
+
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <vector>
+
+namespace tap::tools {
+    namespace od {
+
+        constexpr double k_pi                = 3.14159265358979323846;
+        constexpr double k_gain_range_db     = 24.0; // preamp/output range
+        constexpr double k_default_smooth_ms = 20.0;
+
+        // Drive mapping: drive 0..1 sweeps the shaper (mid-band) gain linearly in dB.
+        // 0 is edge-of-breakup (a pedal's gain knob at CCW, still warm), 1 is saturated.
+        constexpr double k_drive_min_db = 6.0;
+        constexpr double k_drive_max_db = 46.0;
+
+        // Feedback voicing: the low-frequency loop gain is pinned at k_lf_gain regardless of
+        // drive (g_fb = G/k_lf_gain - 1), the TS trait of bass staying nearly clean while mids
+        // get the full G; the loop lowpass corner sets where the transition sits.
+        constexpr double k_lf_gain     = 2.0;
+        constexpr double k_loop_lp_hz  = 660.0;
+        constexpr double k_clean_level = 1.0; // unity clean path summed around the clipper
+
+        // Asymmetry: bias inside the shaper at full asymmetry, in units of the clip knee.
+        constexpr double k_bias_max = 0.5;
+
+        // Output: fixed trim for the summed clean+clipped path, plus a drive-tracking makeup cut
+        // so the perceived level stays roughly constant across the drive sweep.
+        constexpr double k_out_trim_db   = -6.0;
+        constexpr double k_drive_comp_db = 10.0;
+
+        // Voicing constants — placeholders pending the by-ear voicing pass against LGW demos.
+        constexpr double k_voice_hp_min_hz  = 40.0;   // pre-clipper highpass corner, body full CCW
+        constexpr double k_voice_hp_max_hz  = 320.0;  // ... body full CW (thin, tight lows)
+        constexpr double k_voice_mid_hz     = 1150.0; // upper-mid push center (higher than a TS hump)
+        constexpr double k_voice_mid_q      = 0.8;
+        constexpr double k_voice_mid_db     = 4.5; // mid push at body full CW
+        constexpr double k_voice_mid_fix_db = 1.5; // fixed mid voicing, body-independent
+        constexpr double k_voice_shelf_hz   = 3500.0;
+        constexpr double k_voice_shelf_db   = 2.5;    // treble lift at body full CCW
+        constexpr double k_dc_r             = 0.9997; // DC blocker (Jamoma TTDCBlock, via tap.dcblock~)
+
+        enum param_index : int {
+            p_drive = 0, // 0..1, normalized; internally a dB sweep of the shaper gain
+            p_body,      // -1..+1 voicing tilt: CCW full lows + slight treble lift, CW thin/tight lows + mid push
+            p_asymmetry, // 0..1 even-harmonic amount (0 = odd-only)
+            p_preamp,    // input gain, dB
+            p_output,    // makeup gain, dB
+            k_num_params
+        };
+
+        /// Clamp a value to the legal range of a parameter.
+        inline double clamp_param(int index, double value) {
+            switch (index) {
+            case p_drive:
+                return std::clamp(value, 0.0, 1.0);
+            case p_body:
+                return std::clamp(value, -1.0, 1.0);
+            case p_asymmetry:
+                return std::clamp(value, 0.0, 1.0);
+            case p_preamp:
+                return std::clamp(value, -k_gain_range_db, k_gain_range_db);
+            case p_output:
+                return std::clamp(value, -k_gain_range_db, k_gain_range_db);
+            default:
+                return value;
+            }
+        }
+
+        class overdrive {
+          public:
+            overdrive() {
+                static constexpr double k_defaults[k_num_params] = {0.35, 0.0, 0.15, 0.0, 0.0};
+                for (int i = 0; i < k_num_params; ++i) {
+                    m_ramp[i].current = m_ramp[i].target = k_defaults[i];
+                }
+                m_state.resize(1);
+            }
+
+            // -- lifecycle -------------------------------------------------------------------------------
+
+            /// Set the sample rate and channel count, (re)configure oversampling, clear state, snap ramps.
+            /// Allocates (the per-channel state vector) — call from the main thread, not the perform loop.
+            void prepare(double sr, int channels = 1) {
+                m_sr       = (sr > 0.0) ? sr : 48000.0;
+                m_channels = std::max(1, channels);
+                m_state.assign(static_cast<size_t>(m_channels), channel_state{});
+                configure_resampler();
+                snap();
+            }
+
+            /// Zero all filter, loop, and resampler state in every channel; parameters untouched.
+            void clear() {
+                for (auto& c : m_state) {
+                    c.clear();
+                }
+            }
+
+            /// Jump all parameter ramps to their targets.
+            void snap() {
+                for (auto& r : m_ramp) {
+                    r.current   = r.target;
+                    r.inc       = 0.0;
+                    r.remaining = 0;
+                }
+                m_ramps_active = 0;
+                m_dirty        = true;
+            }
+
+            int    channels() const { return m_channels; }
+            double samplerate() const { return m_sr; }
+
+            // -- structural settings (not ramped) --------------------------------------------------------
+
+            /// Oversampling factor 1, 2, 4, or 8 for the clipping stage (default 4). Takes effect
+            /// immediately; resampler state is cleared.
+            void set_oversample(int os) {
+                const int v = (os >= 8) ? 8 : (os >= 4) ? 4 : (os >= 2) ? 2 : 1;
+                if (v != m_os) {
+                    m_os = v;
+                    configure_resampler();
+                    for (auto& c : m_state) {
+                        c.up.reset();
+                        c.down.reset();
+                    }
+                    m_dirty = true;
+                }
+            }
+            int oversample() const { return m_os; }
+
+            void   set_smooth_ms(double ms) { m_smooth_ms = std::max(0.0, ms); }
+            double smooth_ms() const { return m_smooth_ms; }
+
+            // -- parameter targets (click-free; safe while audio runs) ------------------------------------
+
+            void set_param(int index, double value) {
+                if (index < 0 || index >= k_num_params) {
+                    return;
+                }
+                ramp_to(index, clamp_param(index, value), static_cast<long>(m_smooth_ms * 0.001 * m_sr));
+            }
+
+            void set_drive(double v) { set_param(p_drive, v); }
+            void set_body(double v) { set_param(p_body, v); }
+            void set_asymmetry(double v) { set_param(p_asymmetry, v); }
+            void set_preamp(double db) { set_param(p_preamp, db); }
+            void set_output(double db) { set_param(p_output, db); }
+
+            double param(int index) const { return (index >= 0 && index < k_num_params) ? m_ramp[index].target : 0.0; }
+
+            // -- audio -----------------------------------------------------------------------------------
+            //
+            // Frame protocol for multichannel use (the tap.svf~ pattern): call tick() once per sample
+            // frame (it advances the parameter ramps and refreshes the derived coefficients), then
+            // process(ch, x) once per channel. The mono conveniences below fold the two together.
+
+            /// Advance ramps and refresh the derived coefficients if any parameter moved.
+            void tick() {
+                tick_ramps();
+                if (m_dirty) {
+                    update_derived();
+                }
+            }
+
+            /// Process one sample of one channel using the coefficients computed by the last tick().
+            /// Precondition: 0 <= channel < channels().
+            double process(int channel, double x) {
+                channel_state& c = m_state[static_cast<size_t>(channel)];
+
+                // input gain, then the body pre-voicing highpass (what stays out of this stays clean)
+                x *= m_pre_gain;
+                c.hp_lp += m_a_hp * (x - c.hp_lp);
+                const double xn = x - c.hp_lp;
+
+                // the feedback clipper, inside the oversampled region
+                double y;
+                if (m_os == 1) {
+                    y = core(c, xn);
+                }
+                else {
+                    // zero-stuff + anti-image filter up, core at the high rate, anti-alias + decimate down
+                    y = 0.0;
+                    for (int j = 0; j < m_os; ++j) {
+                        const double up = c.up.tick(j == 0 ? xn * m_os : 0.0);
+                        y               = c.down.tick(core(c, up));
+                    }
+                }
+
+                // DC block (asymmetry generates DC), then the post voicing EQ and makeup gain
+                const double d = y - c.dc_x1 + k_dc_r * c.dc_y1;
+                c.dc_x1        = y;
+                c.dc_y1        = anti_denormal(d);
+                return c.shelf.tick(c.mid.tick(d)) * m_post_gain;
+            }
+
+            /// Mono conveniences.
+            double process(double x) {
+                tick();
+                return process(0, x);
+            }
+
+            void process(const double* in, double* out, size_t n) {
+                for (size_t i = 0; i < n; ++i) {
+                    out[i] = process(in[i]);
+                }
+            }
+
+            /// Multichannel block processing: nch channel pointers in and out.
+            void process(const double* const* in, double* const* out, int nch, size_t n) {
+                const int chans = std::min(nch, m_channels);
+                for (size_t i = 0; i < n; ++i) {
+                    tick();
+                    for (int ch = 0; ch < chans; ++ch) {
+                        out[ch][i] = process(ch, in[ch][i]);
+                    }
+                }
+            }
+
+            /// The static transfer curve of the shaper alone (for tests/plots): smooth, monotonic,
+            /// asymptotic to +-1.
+            static double shape(double u) { return u / std::sqrt(1.0 + u * u); }
+
+          private:
+            struct ramp {
+                double current{0.0};
+                double target{0.0};
+                double inc{0.0};
+                long   remaining{0};
+            };
+
+            // RBJ biquad (Transposed Direct Form II) — lowpass pairs make the 4th-order Butterworth
+            // anti-image/anti-alias filters for the oversampling chain (tap.ladder~ / tap.svf~
+            // pattern); peaking and high-shelf voice the body control.
+            struct biquad {
+                double b0{1.0}, b1{0.0}, b2{0.0}, a1{0.0}, a2{0.0};
+                double z1{0.0}, z2{0.0};
+
+                void design_lowpass(double fc_norm, double q) { // fc_norm = fc / fs
+                    const double w     = 2.0 * k_pi * fc_norm;
+                    const double alpha = std::sin(w) / (2.0 * q);
+                    const double cw    = std::cos(w);
+                    const double a0    = 1.0 + alpha;
+                    b0                 = ((1.0 - cw) * 0.5) / a0;
+                    b1                 = (1.0 - cw) / a0;
+                    b2                 = b0;
+                    a1                 = (-2.0 * cw) / a0;
+                    a2                 = (1.0 - alpha) / a0;
+                }
+                void design_peaking(double fc_norm, double q, double gain_db) {
+                    const double A     = std::pow(10.0, gain_db / 40.0);
+                    const double w     = 2.0 * k_pi * fc_norm;
+                    const double alpha = std::sin(w) / (2.0 * q);
+                    const double cw    = std::cos(w);
+                    const double a0    = 1.0 + alpha / A;
+                    b0                 = (1.0 + alpha * A) / a0;
+                    b1                 = (-2.0 * cw) / a0;
+                    b2                 = (1.0 - alpha * A) / a0;
+                    a1                 = b1;
+                    a2                 = (1.0 - alpha / A) / a0;
+                }
+                void design_highshelf(double fc_norm, double gain_db) { // shelf slope S = 1
+                    const double A    = std::pow(10.0, gain_db / 40.0);
+                    const double w    = 2.0 * k_pi * fc_norm;
+                    const double cw   = std::cos(w);
+                    const double sa   = std::sin(w) * 0.5 * std::sqrt(2.0); // RBJ alpha at S = 1
+                    const double ap1  = A + 1.0;
+                    const double am1  = A - 1.0;
+                    const double sqA2 = 2.0 * std::sqrt(A) * sa;
+                    const double a0   = ap1 - am1 * cw + sqA2;
+                    b0                = A * (ap1 + am1 * cw + sqA2) / a0;
+                    b1                = -2.0 * A * (am1 + ap1 * cw) / a0;
+                    b2                = A * (ap1 + am1 * cw - sqA2) / a0;
+                    a1                = 2.0 * (am1 - ap1 * cw) / a0;
+                    a2                = (ap1 - am1 * cw - sqA2) / a0;
+                }
+                double tick(double x) {
+                    const double y = b0 * x + z1;
+                    z1             = b1 * x - a1 * y + z2;
+                    z2             = b2 * x - a2 * y;
+                    return y;
+                }
+                void reset() { z1 = z2 = 0.0; }
+            };
+
+            struct butterworth4 {
+                biquad s1, s2;
+                void   design(double fc_norm) {
+                    s1.design_lowpass(fc_norm, 0.54119610);
+                    s2.design_lowpass(fc_norm, 1.30656296);
+                }
+                double tick(double x) { return s2.tick(s1.tick(x)); }
+                void   reset() {
+                    s1.reset();
+                    s2.reset();
+                }
+            };
+
+            struct channel_state {
+                double       hp_lp{0.0}; // body pre-voicing highpass (one-pole lowpass state)
+                double       lp_s{0.0};  // loop lowpass TPT state
+                double       dc_x1{0.0}, dc_y1{0.0};
+                biquad       mid, shelf; // post voicing EQ
+                butterworth4 up, down;   // oversampling chain
+                void         clear() {
+                    hp_lp = lp_s = dc_x1 = dc_y1 = 0.0;
+                    mid.reset();
+                    shelf.reset();
+                    up.reset();
+                    down.reset();
+                }
+            };
+
+            static double anti_denormal(double x) {
+                return (std::abs(x) < 1e-15) ? 0.0 : x; // house idiom (tap.comb~)
+            }
+
+            void ramp_to(int index, double tgt, long nsamples) {
+                ramp&      r   = m_ramp[index];
+                const bool was = r.remaining > 0;
+                if (nsamples < 1 || tgt == r.current) {
+                    r.current   = tgt;
+                    r.target    = tgt;
+                    r.inc       = 0.0;
+                    r.remaining = 0;
+                    m_dirty     = true;
+                }
+                else {
+                    r.target    = tgt;
+                    r.inc       = (tgt - r.current) / static_cast<double>(nsamples);
+                    r.remaining = nsamples;
+                }
+                m_ramps_active += static_cast<int>(r.remaining > 0) - static_cast<int>(was);
+            }
+
+            void tick_ramps() {
+                if (m_ramps_active <= 0) {
+                    return;
+                }
+                for (auto& r : m_ramp) {
+                    if (r.remaining > 0) {
+                        r.current += r.inc;
+                        if (--r.remaining == 0) {
+                            r.current = r.target;
+                            --m_ramps_active;
+                        }
+                        m_dirty = true;
+                    }
+                }
+            }
+
+            void configure_resampler() {
+                if (m_os > 1) {
+                    // cut just below the original Nyquist, normalized to the oversampled rate
+                    const double fc_norm = 0.45 / m_os;
+                    for (auto& c : m_state) {
+                        c.up.design(fc_norm);
+                        c.down.design(fc_norm);
+                    }
+                }
+            }
+
+            // Refresh everything derived from the (ramped) parameters. Runs only when a parameter
+            // actually moved — per sample during a ramp, then never again until the next change.
+            void update_derived() {
+                const double drive = m_ramp[p_drive].current;
+                const double body  = m_ramp[p_body].current;
+                const double asym  = m_ramp[p_asymmetry].current;
+
+                // drive: dB sweep of the shaper gain; feedback pins the LF loop gain at k_lf_gain
+                const double gain_db = k_drive_min_db + drive * (k_drive_max_db - k_drive_min_db);
+                m_shaper_gain        = std::pow(10.0, gain_db / 20.0);
+                const double g_fb    = std::max(0.0, m_shaper_gain / k_lf_gain - 1.0);
+
+                // loop lowpass (TPT, at the oversampled rate) and the zero-delay solve constants
+                const double g_lp = std::tan(k_pi * k_loop_lp_hz / (m_sr * m_os));
+                m_lp_norm         = 1.0 / (1.0 + g_lp);
+                m_g_lp            = g_lp;
+                m_gfb_lp          = g_fb * m_lp_norm;                      // g_fb / (1+g)
+                m_loop_norm       = 1.0 / (1.0 + g_fb * g_lp * m_lp_norm); // 1 / (1+beta)
+
+                m_bias     = k_bias_max * asym;
+                m_bias_out = shape(m_bias);
+
+                m_pre_gain = std::pow(10.0, m_ramp[p_preamp].current / 20.0);
+                m_post_gain =
+                    std::pow(10.0, (m_ramp[p_output].current + k_out_trim_db - drive * k_drive_comp_db) / 20.0);
+
+                // body voicing: pre-clipper highpass corner slides CCW->CW across a log range;
+                // post EQ adds the CW upper-mid push and the CCW treble lift
+                const double hp_hz =
+                    k_voice_hp_min_hz * std::pow(k_voice_hp_max_hz / k_voice_hp_min_hz, 0.5 * (body + 1.0));
+                m_a_hp = 1.0 - std::exp(-2.0 * k_pi * hp_hz / m_sr);
+
+                const double mid_db   = k_voice_mid_fix_db + k_voice_mid_db * std::max(0.0, body);
+                const double shelf_db = k_voice_shelf_db * std::max(0.0, -body);
+                for (auto& c : m_state) {
+                    c.mid.design_peaking(k_voice_mid_hz / m_sr, k_voice_mid_q, mid_db);
+                    c.shelf.design_highshelf(k_voice_shelf_hz / m_sr, shelf_db);
+                }
+
+                m_dirty = false;
+            }
+
+            // The feedback clipper for one channel at the (possibly oversampled) processing rate.
+            // Linear zero-delay solve of w = shape(G*x - g_fb*v), v = TPT-one-pole(w): predict the
+            // loop node with shape() as identity, saturate, commit the saturated value to the
+            // one-pole state (the tap.svf~ / tap.ladder~ fast one-pass scheme — shape'() <= 1 only
+            // ever reduces the loop gain below the prediction, so the step is stable). The unity
+            // clean path summed at the end is the non-inverting topology's never-flat trait.
+            double core(channel_state& c, double x) {
+                const double w_lin = (m_shaper_gain * x - m_gfb_lp * c.lp_s) * m_loop_norm;
+                const double w     = shape(w_lin + m_bias) - m_bias_out;
+                const double v     = (m_g_lp * w + c.lp_s) * m_lp_norm;
+                c.lp_s             = anti_denormal(2.0 * v - c.lp_s);
+                return w + k_clean_level * x;
+            }
+
+            // configuration
+            double m_sr{48000.0};
+            double m_smooth_ms{k_default_smooth_ms};
+            int    m_channels{1};
+            int    m_os{4};
+
+            // parameters
+            std::array<ramp, k_num_params> m_ramp;
+            int                            m_ramps_active{0};
+            bool                           m_dirty{true};
+
+            // derived
+            double m_shaper_gain{1.0};
+            double m_g_lp{0.0}, m_lp_norm{1.0}, m_gfb_lp{0.0}, m_loop_norm{1.0};
+            double m_bias{0.0}, m_bias_out{0.0};
+            double m_pre_gain{1.0}, m_post_gain{1.0};
+            double m_a_hp{0.0};
+
+            // per-channel state
+            std::vector<channel_state> m_state;
+        };
+
+    } // namespace od
+} // namespace tap::tools
diff --git a/include/taptools/taptools.h b/include/taptools/taptools.h
index 5086fea..941471b 100644
--- a/include/taptools/taptools.h
+++ b/include/taptools/taptools.h
@@ -16,6 +16,7 @@
 #include "ladder.h"
 #include "metal_bank.h"
 #include "nr.h"
+#include "overdrive.h"
 #include "spectra.h"
 #include "stft.h"
 #include "svf.h"
diff --git a/notebooks/overdrive.ipynb b/notebooks/overdrive.ipynb
new file mode 100644
index 0000000..c17e701
--- /dev/null
+++ b/notebooks/overdrive.ipynb
@@ -0,0 +1,541 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "c5ca7eb3",
+   "metadata": {},
+   "source": [
+    "# tap.overdrive~ — voiced feedback overdrive verification\n",
+    "\n",
+    "`tap.overdrive~` is the spiritual successor to the Jamoma-era object of the same name —\n",
+    "deliberately *not* a port. TTOverdrive's memoryless odd-function curves are replaced by a\n",
+    "soft clipper inside a **lowpass feedback loop** (solved zero-delay, the `svf.h` /\n",
+    "`ladder.h` one-pass scheme), chasing the class of TS-lineage feedback pedals (the Mad\n",
+    "Professor Little Green Wonder was the listening reference). This notebook drives the\n",
+    "*shipping* kernel (`overdrive.h`, via the C ABI) and verifies the design goals from the\n",
+    "overdrive handoff brief:\n",
+    "\n",
+    "1. **Frequency-dependent gain** — bass pinned near-clean, mids take the full drive, and\n",
+    "   the tilt grows with the drive setting (a static shaper cannot do this);\n",
+    "2. **A transfer that never flattens** — the unity clean-through path keeps output rising;\n",
+    "3. **Even harmonics from `asymmetry`** — absent at 0, dialable warmth above it;\n",
+    "4. **Oversampling** — the alias floor drops while the harmonics stay put;\n",
+    "5. **`body` voicing** — the pre/post EQ tilt that carries the pedal's signature;\n",
+    "6. **DC safety** — asymmetric clipping generates DC and the built-in blocker removes it.\n",
+    "\n",
+    "Each claim here is also pinned by the kernel's Catch2 suite (`tests/overdrive_test.cpp`);\n",
+    "the notebook is the *measured picture* of the same behavior.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "e8ae4866",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-22T20:35:04.864429Z",
+     "iopub.status.busy": "2026-07-22T20:35:04.864113Z",
+     "iopub.status.idle": "2026-07-22T20:35:05.680617Z",
+     "shell.execute_reply": "2026-07-22T20:35:05.678714Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import taptools_py as tap\n",
+    "\n",
+    "plt.rcParams.update({\n",
+    "    \"figure.dpi\": 96, \"figure.figsize\": (9, 3.2),\n",
+    "    \"axes.grid\": True, \"grid.alpha\": 0.25, \"grid.linewidth\": 0.5,\n",
+    "    \"axes.spines.top\": False, \"axes.spines.right\": False,\n",
+    "    \"axes.titlesize\": 10, \"axes.labelsize\": 9,\n",
+    "    \"xtick.labelsize\": 8, \"ytick.labelsize\": 8, \"legend.fontsize\": 8,\n",
+    "})\n",
+    "PAL = tap.PALETTE\n",
+    "fs = 48000\n",
+    "\n",
+    "\n",
+    "def tone(f, amp, seconds):\n",
+    "    t = np.arange(int(seconds * fs)) / fs\n",
+    "    return amp * np.sin(2 * np.pi * f * t)\n",
+    "\n",
+    "\n",
+    "def level(y, f):\n",
+    "    \"\"\"Hann-windowed single-frequency amplitude (numpy Goertzel).\"\"\"\n",
+    "    n = len(y)\n",
+    "    t = np.arange(n) / fs\n",
+    "    win = np.hanning(n)\n",
+    "    return 2.0 * np.abs(np.dot(y * win, np.exp(-2j * np.pi * f * t))) / win.sum()\n",
+    "\n",
+    "\n",
+    "def gain_db(f, amp=5e-4, settle=0.25, meas=0.5, **params):\n",
+    "    \"\"\"Small-signal gain (dB) at probe frequency f for a fresh kernel with `params`.\"\"\"\n",
+    "    o = tap.Overdrive(fs, **params)\n",
+    "    x = tone(f, amp, settle + meas)\n",
+    "    y = o.process(x)\n",
+    "    n0 = int(settle * fs)\n",
+    "    return 20 * np.log10(level(y[n0:], f) / level(x[n0:], f))\n",
+    "\n",
+    "\n",
+    "def spectrum_db(y, ref=None):\n",
+    "    win = np.hanning(len(y))\n",
+    "    mag = np.abs(np.fft.rfft(y * win)) / (win.sum() / 2)\n",
+    "    freqs = np.fft.rfftfreq(len(y), 1 / fs)\n",
+    "    ref = ref if ref is not None else mag.max()\n",
+    "    return freqs, 20 * np.log10(np.maximum(mag / ref, 1e-9))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4195410b",
+   "metadata": {},
+   "source": [
+    "## 1. The headline: gain tilts with frequency, and the tilt grows with drive\n",
+    "\n",
+    "Small-signal gain across the band at three drive settings. The feedback loop pins the\n",
+    "low-frequency loop gain (`k_lf_gain`) regardless of drive while mids and highs see the\n",
+    "full shaper gain, so the response tilts — and the tilt *grows* as drive rises. This is\n",
+    "the TS-lineage trait (bass stays tight and clean, mids break up first) that a memoryless\n",
+    "waveshaper applied to the full spectrum structurally cannot produce: its small-signal\n",
+    "gain is one number, flat.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "f173be85",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-22T20:35:05.683946Z",
+     "iopub.status.busy": "2026-07-22T20:35:05.683585Z",
+     "iopub.status.idle": "2026-07-22T20:35:07.021021Z",
+     "shell.execute_reply": "2026-07-22T20:35:07.019844Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 864x307.2 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "drive 0.0: gain(4 kHz) - gain(80 Hz) = +5.0 dB\n",
+      "drive 0.5: gain(4 kHz) - gain(80 Hz) = +16.3 dB\n",
+      "drive 0.9: gain(4 kHz) - gain(80 Hz) = +17.2 dB\n"
+     ]
+    }
+   ],
+   "source": [
+    "freqs = np.geomspace(30, 12000, 22)\n",
+    "fig, ax = plt.subplots()\n",
+    "tilts = {}\n",
+    "for i, drive in enumerate((0.0, 0.5, 0.9)):\n",
+    "    g = np.array([gain_db(f, drive=drive) for f in freqs])\n",
+    "    ax.semilogx(freqs, g, color=PAL[i], label=f\"drive {drive}\")\n",
+    "    tilts[drive] = gain_db(4000, drive=drive) - gain_db(80, drive=drive)\n",
+    "ax.set(xlabel=\"frequency (Hz)\", ylabel=\"small-signal gain (dB)\",\n",
+    "       title=\"gain vs frequency: the feedback loop's tilt grows with drive\")\n",
+    "ax.legend()\n",
+    "plt.show()\n",
+    "for d, t in tilts.items():\n",
+    "    print(f\"drive {d}: gain(4 kHz) - gain(80 Hz) = {t:+.1f} dB\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae861855",
+   "metadata": {},
+   "source": [
+    "## 2. The transfer never flattens\n",
+    "\n",
+    "Peak output versus peak input at rising drive. The `shape()` curve is asymptotic to ±1,\n",
+    "but the unity clean path summed around the clipper (the non-inverting op-amp topology)\n",
+    "keeps the total transfer rising with reduced slope — no hard plateau, which is a large\n",
+    "part of why the old sine-shaper mode read as \"digital\".\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "e81544c3",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-22T20:35:07.023801Z",
+     "iopub.status.busy": "2026-07-22T20:35:07.023542Z",
+     "iopub.status.idle": "2026-07-22T20:35:07.554564Z",
+     "shell.execute_reply": "2026-07-22T20:35:07.553392Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 864x307.2 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "output peak strictly increases with input at every drive setting\n"
+     ]
+    }
+   ],
+   "source": [
+    "amps = np.geomspace(0.05, 1.0, 12)\n",
+    "fig, ax = plt.subplots()\n",
+    "for i, drive in enumerate((0.0, 0.5, 1.0)):\n",
+    "    peaks = []\n",
+    "    for amp in amps:\n",
+    "        o = tap.Overdrive(fs, drive=drive)\n",
+    "        y = o.process(tone(500, amp, 0.75))\n",
+    "        peaks.append(np.abs(y[int(0.25 * fs):]).max())\n",
+    "    ax.plot(amps, peaks, \"o-\", ms=3, color=PAL[i], label=f\"drive {drive}\")\n",
+    "    assert np.all(np.diff(peaks) > 0), \"transfer flattened\"\n",
+    "ax.set(xlabel=\"input peak\", ylabel=\"output peak\",\n",
+    "       title=\"peak transfer at 500 Hz: monotonic at every drive (never flat)\")\n",
+    "ax.legend()\n",
+    "plt.show()\n",
+    "print(\"output peak strictly increases with input at every drive setting\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "710f4e2d",
+   "metadata": {},
+   "source": [
+    "## 3. Even harmonics appear with asymmetry — and are absent without it\n",
+    "\n",
+    "At `asymmetry 0` the whole path is odd-symmetric: odd harmonics only, like both Jamoma\n",
+    "modes. Raising `asymmetry` biases the clipper and the even series appears — the\n",
+    "\"warmth\" vocabulary the old object structurally lacked. The DC that the bias generates\n",
+    "is removed by the built-in blocker (section 6).\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "64639c41",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-22T20:35:07.558664Z",
+     "iopub.status.busy": "2026-07-22T20:35:07.558405Z",
+     "iopub.status.idle": "2026-07-22T20:35:07.801617Z",
+     "shell.execute_reply": "2026-07-22T20:35:07.800354Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 864x307.2 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "H2 relative to H1:  asymmetry 0.0 -> -151 dB   asymmetry 0.6 -> -26 dB\n"
+     ]
+    }
+   ],
+   "source": [
+    "f0 = 220.5\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(9, 3.2), sharey=True)\n",
+    "h2 = {}\n",
+    "for ax, asym, ci in ((axes[0], 0.0, 0), (axes[1], 0.6, 2)):\n",
+    "    o = tap.Overdrive(fs, drive=0.6, asymmetry=asym)\n",
+    "    y = o.process(tone(f0, 0.5, 1.5))[int(0.5 * fs):]\n",
+    "    fr, db = spectrum_db(y, ref=level(y, f0))\n",
+    "    ax.plot(fr, db, color=PAL[ci], lw=0.8)\n",
+    "    ax.set(xlim=(0, 3000), ylim=(-100, 5), xlabel=\"frequency (Hz)\",\n",
+    "           title=f\"asymmetry {asym}\")\n",
+    "    h2[asym] = 20 * np.log10(level(y, 2 * f0) / level(y, f0))\n",
+    "axes[0].set_ylabel(\"level re fundamental (dB)\")\n",
+    "plt.show()\n",
+    "print(f\"H2 relative to H1:  asymmetry 0.0 -> {h2[0.0]:.0f} dB   asymmetry 0.6 -> {h2[0.6]:.0f} dB\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3492d141",
+   "metadata": {},
+   "source": [
+    "The second harmonic is dialable — near the measurement floor at 0, rising smoothly with\n",
+    "the control:\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "1ca73a5f",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-22T20:35:07.804402Z",
+     "iopub.status.busy": "2026-07-22T20:35:07.804079Z",
+     "iopub.status.idle": "2026-07-22T20:35:08.133393Z",
+     "shell.execute_reply": "2026-07-22T20:35:08.132038Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 528x268.8 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "asyms = np.linspace(0, 1, 11)\n",
+    "h2_curve = []\n",
+    "for a in asyms:\n",
+    "    o = tap.Overdrive(fs, drive=0.6, asymmetry=a)\n",
+    "    y = o.process(tone(f0, 0.5, 1.0))[int(0.25 * fs):]\n",
+    "    h2_curve.append(20 * np.log10(level(y, 2 * f0) / level(y, f0)))\n",
+    "fig, ax = plt.subplots(figsize=(5.5, 2.8))\n",
+    "ax.plot(asyms, h2_curve, \"o-\", ms=3, color=PAL[2])\n",
+    "ax.set(xlabel=\"asymmetry\", ylabel=\"H2 re H1 (dB)\", title=\"even-harmonic amount vs asymmetry\")\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4c8e6721",
+   "metadata": {},
+   "source": [
+    "## 4. Oversampling drops the alias floor and leaves the harmonics alone\n",
+    "\n",
+    "A 5001 Hz tone at drive 0.9. At 1× the clipper's upper harmonics fold straight back into\n",
+    "the audio band (H7 lands at 12993 Hz); at the default 4× they are generated at 192 kHz\n",
+    "and filtered before decimation. The true harmonics (10002, 15003, 20004 Hz) stay put.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "fd7957cc",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-22T20:35:08.136566Z",
+     "iopub.status.busy": "2026-07-22T20:35:08.136224Z",
+     "iopub.status.idle": "2026-07-22T20:35:08.470756Z",
+     "shell.execute_reply": "2026-07-22T20:35:08.469441Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 864x307.2 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "folded H7: -22 dB at 1x -> -36 dB at 4x (15 dB improvement)\n"
+     ]
+    }
+   ],
+   "source": [
+    "f0a = 5001.0\n",
+    "alias_f = fs - 7 * f0a  # H7 folded at 1x\n",
+    "fig, ax = plt.subplots()\n",
+    "alias_rel = {}\n",
+    "for i, os_ in enumerate((1, 4)):\n",
+    "    o = tap.Overdrive(fs, drive=0.9, asymmetry=0.2, oversample=os_)\n",
+    "    y = o.process(tone(f0a, 0.6, 1.5))[int(0.5 * fs):]\n",
+    "    fr, db = spectrum_db(y, ref=level(y, f0a))\n",
+    "    ax.plot(fr, db, lw=0.7, color=PAL[i], label=f\"oversample {os_}x\")\n",
+    "    alias_rel[os_] = 20 * np.log10(level(y, alias_f) / level(y, f0a))\n",
+    "ax.axvline(alias_f, color=PAL[3], lw=0.8, ls=\"--\", label=\"folded H7 (12993 Hz)\")\n",
+    "ax.set(xlim=(0, fs / 2), ylim=(-110, 5), xlabel=\"frequency (Hz)\",\n",
+    "       ylabel=\"level re fundamental (dB)\",\n",
+    "       title=\"5001 Hz, drive 0.9: alias floor at 1x vs the default 4x\")\n",
+    "ax.legend()\n",
+    "plt.show()\n",
+    "print(f\"folded H7: {alias_rel[1]:.0f} dB at 1x -> {alias_rel[4]:.0f} dB at 4x \"\n",
+    "      f\"({alias_rel[1] - alias_rel[4]:.0f} dB improvement)\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "873de052",
+   "metadata": {},
+   "source": [
+    "## 5. body — the voicing control\n",
+    "\n",
+    "`body` is linear pre/post EQ around the clipper, not part of the nonlinearity. Toward\n",
+    "−1 the pre-clipper highpass corner drops (fuller lows reach the clipper) and a slight\n",
+    "treble shelf lifts the top; toward +1 the lows thin and tighten and an upper-mid bell\n",
+    "(centered at 1150 Hz — deliberately above the classic TS hump) pushes forward. The\n",
+    "voicing constants are by-ear placeholders pending the in-Max pass against LGW demos —\n",
+    "this plot is the shape of the control, not its final tuning.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "2509a973",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-22T20:35:08.473442Z",
+     "iopub.status.busy": "2026-07-22T20:35:08.473143Z",
+     "iopub.status.idle": "2026-07-22T20:35:09.785748Z",
+     "shell.execute_reply": "2026-07-22T20:35:09.785032Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 864x307.2 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100 Hz:   body -1 vs +1 -> +10.0 dB\n",
+      "1150 Hz:  body +1 vs -1 -> +4.0 dB\n",
+      "8 kHz:    body -1 vs 0  -> +2.5 dB\n"
+     ]
+    }
+   ],
+   "source": [
+    "freqs_b = np.geomspace(25, 16000, 24)\n",
+    "fig, ax = plt.subplots()\n",
+    "for i, body in enumerate((-1.0, 0.0, 1.0)):\n",
+    "    g = np.array([gain_db(f, drive=0.3, body=body) for f in freqs_b])\n",
+    "    ax.semilogx(freqs_b, g, color=PAL[i], label=f\"body {body:+.0f}\")\n",
+    "ax.set(xlabel=\"frequency (Hz)\", ylabel=\"small-signal gain (dB)\",\n",
+    "       title=\"body voicing at drive 0.3: lows CCW, upper-mid push CW\")\n",
+    "ax.legend()\n",
+    "plt.show()\n",
+    "print(f\"100 Hz:   body -1 vs +1 -> {gain_db(100, drive=0.3, body=-1.0) - gain_db(100, drive=0.3, body=1.0):+.1f} dB\")\n",
+    "print(f\"1150 Hz:  body +1 vs -1 -> {gain_db(1150, drive=0.3, body=1.0) - gain_db(1150, drive=0.3, body=-1.0):+.1f} dB\")\n",
+    "print(f\"8 kHz:    body -1 vs 0  -> {gain_db(8000, drive=0.3, body=-1.0) - gain_db(8000, drive=0.3, body=0.0):+.1f} dB\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b61ac669",
+   "metadata": {},
+   "source": [
+    "## 6. Asymmetric clipping makes DC; the blocker removes it\n",
+    "\n",
+    "With the blocker in the path (always on — `R = 0.9997`, the Jamoma TTDCBlock constant)\n",
+    "the output mean stays at zero even at full drive and full asymmetry. The old\n",
+    "TTOverdrive had a DC blocker object but wired it so its output was discarded; here it\n",
+    "is load-bearing, since the feedback one-pole would otherwise integrate the offset.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "eadb9fb9",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-22T20:35:09.790504Z",
+     "iopub.status.busy": "2026-07-22T20:35:09.790192Z",
+     "iopub.status.idle": "2026-07-22T20:35:09.881823Z",
+     "shell.execute_reply": "2026-07-22T20:35:09.880157Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "asymmetry 0.0: output mean = +1.66e-12\n",
+      "asymmetry 0.5: output mean = -3.22e-10\n",
+      "asymmetry 1.0: output mean = -7.02e-10\n"
+     ]
+    }
+   ],
+   "source": [
+    "means = []\n",
+    "for a in (0.0, 0.5, 1.0):\n",
+    "    o = tap.Overdrive(fs, drive=1.0, asymmetry=a)\n",
+    "    y = o.process(tone(100, 0.8, 2.0))[fs:]  # exactly 100 periods\n",
+    "    means.append(np.mean(y))\n",
+    "    print(f\"asymmetry {a}: output mean = {np.mean(y):+.2e}\")\n",
+    "assert all(abs(m) < 5e-3 for m in means)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d53c52b4",
+   "metadata": {},
+   "source": [
+    "## Summary\n",
+    "\n",
+    "- The feedback loop delivers the frequency-dependent gain the brief asked for: flat at\n",
+    "  minimum drive, tens of dB of bass-vs-mid tilt at high drive, growing monotonically.\n",
+    "- The transfer is monotonic at every drive — the clean-through path keeps it from ever\n",
+    "  flattening into the plateau that made the old sine shaper read as digital.\n",
+    "- Even harmonics are absent at `asymmetry 0` and dialable above it.\n",
+    "- The default 4× oversampling buys a measurably lower alias floor with the true\n",
+    "  harmonics unchanged.\n",
+    "- `body` reshapes lows/upper-mids/top as designed (final tuning belongs to the by-ear\n",
+    "  voicing pass).\n",
+    "- The always-on DC blocker holds the mean at zero under the heaviest asymmetric\n",
+    "  clipping.\n",
+    "\n",
+    "The same claims are pinned as hard assertions in the kernel suite\n",
+    "(`tests/overdrive_test.cpp`), so CI guards them from regressing.\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.15"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/notebooks/taptools_py.py b/notebooks/taptools_py.py
index d976094..007f58c 100644
--- a/notebooks/taptools_py.py
+++ b/notebooks/taptools_py.py
@@ -11,12 +11,12 @@
 externals compile — so the notebooks exercise the real shipping code, not a
 Python re-implementation. Exposed kernels: tap.convolve~'s conv_engine
 (`Convolver`), tap.svf~ (`Svf`), tap.ladder~ (`Ladder`), tap.diode~
-(`Diode`), tap.303~ (`TB303`), tap.vco~ (`Vco`), tap.autowah~ (`Wah`), the
-step-sequencer rows behind tap.808.seq~ / tap.303.seq~ (`TriggerRow`,
-`NoteRow`), tap.808.kick~ (`Kick`), and tap.tune~'s pitch corrector
-(`Tune`, with the shared DspTap detector passed through as `Yin` for the
-notebooks' pitch tracking). Parameter names on the kernel classes mirror
-each kernel header's param_index enum.
+(`Diode`), tap.303~ (`TB303`), tap.vco~ (`Vco`), tap.autowah~ (`Wah`),
+tap.overdrive~ (`Overdrive`), the step-sequencer rows behind tap.808.seq~ /
+tap.303.seq~ (`TriggerRow`, `NoteRow`), tap.808.kick~ (`Kick`), and
+tap.tune~'s pitch corrector (`Tune`, with the shared DspTap detector passed
+through as `Yin` for the notebooks' pitch tracking). Parameter names on the
+kernel classes mirror each kernel header's param_index enum.
 
 Copyright 2003-2026 Timothy Place. New BSD License.
 """
@@ -173,6 +173,14 @@ def load() -> ctypes.CDLL:
         "taptools_seqnote_recall":        ([vp, ctypes.c_int], ctypes.c_int),
         "taptools_seqnote_reset":         ([vp], ctypes.c_int),
         "taptools_seqnote_process":       ([vp, f64p, f64p, f64p, ctypes.c_int], ctypes.c_int),
+        "taptools_od_create":         ([], vp),
+        "taptools_od_destroy":        ([vp], None),
+        "taptools_od_prepare":        ([vp, ctypes.c_double], ctypes.c_int),
+        "taptools_od_set":            ([vp, ctypes.c_int, ctypes.c_double], ctypes.c_int),
+        "taptools_od_set_oversample": ([vp, ctypes.c_int], ctypes.c_int),
+        "taptools_od_set_smooth_ms":  ([vp, ctypes.c_double], ctypes.c_int),
+        "taptools_od_clear":          ([vp], ctypes.c_int),
+        "taptools_od_process":        ([vp, f64p, f64p, ctypes.c_int], ctypes.c_int),
         "taptools_kick_create":     ([], vp),
         "taptools_kick_destroy":    ([vp], None),
         "taptools_kick_prepare":    ([vp, ctypes.c_double], ctypes.c_int),
@@ -552,6 +560,25 @@ def recall(self, slot: int, seconds: float = 0.0) -> "Wah":
         return self
 
 
+class Overdrive(_Kernel):
+    """tap.overdrive~'s voiced feedback soft clipper (taptools::od::overdrive, mono).
+
+    >>> o = Overdrive(48000, drive=0.7, asymmetry=0.3, body=-0.5)
+    >>> y = o.process(x)
+    >>> o.set(oversample=1)   # structural: 1/2/4/8 (default 4)
+    """
+
+    PREFIX = "taptools_od"
+    PARAMS = {"drive": 0, "body": 1, "asymmetry": 2, "preamp": 3, "output": 4}
+
+    def process(self, x) -> np.ndarray:
+        x = _f64(x)
+        n = len(x)
+        out = np.empty(n)
+        _check(_LIB.taptools_od_process(self._h, _p64(x), _p64(out), n), "process")
+        return out
+
+
 class _SeqRow:
     """Base for the step-sequencer rows (the step_seq.h engine behind tap.808.seq~ /
     tap.303.seq~): a live C-ABI handle plus the shared clock surface. `phase(cycles)` builds
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 4b25c4f..b0720e2 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -16,6 +16,7 @@ add_executable(taptools_kernel_tests
     diode_ladder_test.cpp
     grm_comb_test.cpp
     nr_test.cpp
+    overdrive_test.cpp
     spectra_test.cpp
     step_seq_test.cpp
     tune_test.cpp
diff --git a/tests/overdrive_test.cpp b/tests/overdrive_test.cpp
new file mode 100644
index 0000000..f4ba070
--- /dev/null
+++ b/tests/overdrive_test.cpp
@@ -0,0 +1,298 @@
+/// @file
+/// @brief      Unit tests for the overdrive kernel (tap::tools::od::overdrive).
+/// @details    Pins the design goals from the overdrive handoff brief: the feedback loop's
+///             frequency-dependent gain (bass pinned near-clean while mids take the full drive —
+///             the claim a static shaper cannot satisfy), even harmonics appearing with asymmetry
+///             and absent without it, the DC blocker holding the mean at zero under heavy
+///             asymmetric clipping, the never-flat clean-through slope, the oversampling alias
+///             improvement, body-voicing tilt, decay to silence (loop stability), determinism,
+///             and parameter clamping.
+// SPDX-License-Identifier: BSD-3-Clause
+// Copyright 2026 Timothy Place.
+
+#include <cmath>
+#include <vector>
+
+#include <catch2/catch_test_macros.hpp>
+#include <taptools/overdrive.h>
+
+namespace {
+
+    constexpr double k_pi = 3.14159265358979323846;
+    constexpr double k_sr = 48000.0;
+
+    namespace od = tap::tools::od;
+
+    od::overdrive make(double sr = k_sr) {
+        od::overdrive o;
+        o.prepare(sr);
+        o.set_smooth_ms(0.0);
+        return o;
+    }
+
+    // Goertzel magnitude at one frequency (Hann-windowed).
+    double level_at(const std::vector<double>& x, double f, double sr) {
+        const double w  = 2.0 * k_pi * f / sr;
+        const double c  = 2.0 * std::cos(w);
+        double       s1 = 0.0, s2 = 0.0;
+        for (size_t i = 0; i < x.size(); ++i) {
+            const double win = 0.5 - 0.5 * std::cos(2.0 * k_pi * i / (x.size() - 1));
+            const double s0  = x[i] * win + c * s1 - s2;
+            s2               = s1;
+            s1               = s0;
+        }
+        const double re = s1 - s2 * std::cos(w);
+        const double im = s2 * std::sin(w);
+        return std::sqrt(re * re + im * im);
+    }
+
+    // Drive a sine through the object; discard a settle window, return the following second.
+    std::vector<double> run_sine(od::overdrive& o, double hz, double amp, double sr = k_sr) {
+        const size_t        settle = static_cast<size_t>(0.5 * sr);
+        const size_t        n      = static_cast<size_t>(1.0 * sr);
+        std::vector<double> y(n);
+        double              ph = 0.0;
+        for (size_t i = 0; i < settle + n; ++i) {
+            const double x = amp * std::sin(ph);
+            ph += 2.0 * k_pi * hz / sr;
+            const double v = o.process(x);
+            if (i >= settle) {
+                y[i - settle] = v;
+            }
+        }
+        return y;
+    }
+
+    // Small-signal gain (dB) at a probe frequency: settle, then compare the Goertzel level of the
+    // output window against the same window of the raw input.
+    double gain_db_at(od::overdrive& o, double probe_hz, double sr = k_sr) {
+        const size_t        settle = static_cast<size_t>(0.5 * sr);
+        const size_t        n      = static_cast<size_t>(1.0 * sr);
+        std::vector<double> in(n), out(n);
+        double              ph = 0.0;
+        for (size_t i = 0; i < settle + n; ++i) {
+            const double x = 0.0005 * std::sin(ph);
+            ph += 2.0 * k_pi * probe_hz / sr;
+            const double y = o.process(x);
+            if (i >= settle) {
+                in[i - settle]  = x;
+                out[i - settle] = y;
+            }
+        }
+        return 20.0 * std::log10(level_at(out, probe_hz, sr) / level_at(in, probe_hz, sr));
+    }
+
+    double db(double ratio) {
+        return 20.0 * std::log10(ratio);
+    }
+
+} // namespace
+
+TEST_CASE("overdrive: silence in, silence out; bounded output across the parameter grid") {
+    for (double drive : {0.0, 0.5, 1.0}) {
+        for (double asym : {0.0, 1.0}) {
+            auto o = make();
+            o.set_drive(drive);
+            o.set_asymmetry(asym);
+            for (int i = 0; i < 4800; ++i) {
+                REQUIRE(o.process(0.0) == 0.0);
+            }
+            const auto y = run_sine(o, 220.0, 1.0);
+            for (double v : y) {
+                REQUIRE(std::isfinite(v));
+                REQUIRE(std::abs(v) < 4.0);
+            }
+        }
+    }
+}
+
+TEST_CASE("overdrive: even harmonics appear with asymmetry and are absent without it") {
+    const double f0 = 220.5;
+
+    auto odd = make();
+    odd.set_drive(0.6);
+    odd.set_asymmetry(0.0);
+    const auto   y_odd  = run_sine(odd, f0, 0.5);
+    const double h1_odd = level_at(y_odd, f0, k_sr);
+    const double h2_odd = level_at(y_odd, 2.0 * f0, k_sr);
+    const double h3_odd = level_at(y_odd, 3.0 * f0, k_sr);
+
+    // the signal path is odd-symmetric at asymmetry 0: strong odd harmonics, no even ones
+    REQUIRE(db(h2_odd / h1_odd) < -50.0);
+    REQUIRE(db(h3_odd / h1_odd) > -40.0);
+
+    auto asym = make();
+    asym.set_drive(0.6);
+    asym.set_asymmetry(0.6);
+    const auto   y_asym = run_sine(asym, f0, 0.5);
+    const double h1     = level_at(y_asym, f0, k_sr);
+    const double h2     = level_at(y_asym, 2.0 * f0, k_sr);
+
+    REQUIRE(db(h2 / h1) > -35.0);
+    REQUIRE(db(h2 / h1) > db(h2_odd / h1_odd) + 20.0);
+}
+
+TEST_CASE("overdrive: the feedback loop tilts gain with frequency — bass pinned, mids take the drive") {
+    auto tilt_db = [](double drive) {
+        auto lo = make();
+        lo.set_drive(drive);
+        auto hi = make();
+        hi.set_drive(drive);
+        return gain_db_at(hi, 4000.0) - gain_db_at(lo, 80.0);
+    };
+
+    const double t_low  = tilt_db(0.0);
+    const double t_mid  = tilt_db(0.5);
+    const double t_high = tilt_db(0.9);
+
+    // at minimum drive the loop is barely tilted (just the voicing HP and mid bell)
+    REQUIRE(t_low < 8.0);
+    // the tilt grows with drive — the behavior a memoryless shaper cannot produce
+    REQUIRE(t_high > 12.0);
+    REQUIRE(t_high > t_mid);
+    REQUIRE(t_mid > t_low);
+}
+
+TEST_CASE("overdrive: DC stays blocked under heavy asymmetric clipping") {
+    auto o = make();
+    o.set_drive(1.0);
+    o.set_asymmetry(1.0);
+    const auto y = run_sine(o, 100.0, 0.8); // exactly 100 periods in the 1 s window
+
+    double mean = 0.0;
+    for (double v : y) {
+        mean += v;
+    }
+    mean /= static_cast<double>(y.size());
+    REQUIRE(std::abs(mean) < 0.005);
+}
+
+TEST_CASE("overdrive: the clean-through path never lets the transfer flatten") {
+    auto peak_for = [](double amp) {
+        auto o = make();
+        o.set_drive(1.0);
+        const auto y = run_sine(o, 500.0, amp);
+        double     p = 0.0;
+        for (double v : y) {
+            p = std::max(p, std::abs(v));
+        }
+        return p;
+    };
+
+    const double p25  = peak_for(0.25);
+    const double p50  = peak_for(0.5);
+    const double p100 = peak_for(1.0);
+
+    REQUIRE(p50 > p25 + 0.01);
+    REQUIRE(p100 > p50 + 0.02);
+}
+
+TEST_CASE("overdrive: oversampling lowers the alias floor without moving the fundamental") {
+    const double f0    = 5001.0;
+    const double alias = k_sr - 7.0 * f0; // H7 folded at 1x: 12993 Hz, clear of the harmonics
+
+    auto rel_alias_db = [&](int os) {
+        auto o = make();
+        o.set_drive(0.9);
+        o.set_asymmetry(0.2);
+        o.set_oversample(os);
+        const auto y = run_sine(o, f0, 0.6);
+        return std::make_pair(db(level_at(y, alias, k_sr) / level_at(y, f0, k_sr)), db(level_at(y, f0, k_sr)));
+    };
+
+    const auto [alias_1x, fund_1x] = rel_alias_db(1);
+    const auto [alias_4x, fund_4x] = rel_alias_db(4);
+
+    REQUIRE(alias_1x - alias_4x > 10.0);
+    REQUIRE(std::abs(fund_1x - fund_4x) < 1.5);
+}
+
+TEST_CASE("overdrive: body voices the spectrum — CCW keeps lows, CW thins them and pushes upper mids") {
+    auto gain_at = [](double body, double probe_hz) {
+        auto o = make();
+        o.set_drive(0.3);
+        o.set_body(body);
+        return gain_db_at(o, probe_hz);
+    };
+
+    // CCW (fuller lows) passes far more 100 Hz than CW (thin, tight lows)
+    REQUIRE(gain_at(-1.0, 100.0) - gain_at(1.0, 100.0) > 6.0);
+    // CW pushes the upper mids
+    REQUIRE(gain_at(1.0, od::k_voice_mid_hz) - gain_at(-1.0, od::k_voice_mid_hz) > 2.0);
+    // CCW lifts the treble slightly
+    REQUIRE(gain_at(-1.0, 8000.0) - gain_at(0.0, 8000.0) > 1.0);
+}
+
+TEST_CASE("overdrive: output decays to silence after the input stops (no limit cycles)") {
+    auto o = make();
+    o.set_drive(1.0);
+    o.set_asymmetry(1.0);
+    run_sine(o, 220.0, 1.0);
+
+    double tail_max = 0.0;
+    for (int i = 0; i < static_cast<int>(k_sr); ++i) {
+        const double v = o.process(0.0);
+        if (i >= static_cast<int>(0.8 * k_sr)) {
+            tail_max = std::max(tail_max, std::abs(v));
+        }
+    }
+    REQUIRE(tail_max < 1e-6);
+}
+
+TEST_CASE("overdrive: parameter ramps keep the output click-free") {
+    auto o = make();
+    o.set_smooth_ms(20.0);
+    o.set_drive(0.0);
+    o.snap();
+
+    double ph = 0.0, prev = 0.0, max_step = 0.0;
+    for (int i = 0; i < static_cast<int>(k_sr); ++i) {
+        if (i == static_cast<int>(0.25 * k_sr)) {
+            o.set_drive(1.0); // hard parameter jump mid-signal, ramped internally
+            o.set_body(1.0);
+        }
+        const double x = 0.5 * std::sin(ph);
+        ph += 2.0 * k_pi * 500.0 / k_sr;
+        const double v = o.process(x);
+        if (i > 0) {
+            max_step = std::max(max_step, std::abs(v - prev));
+        }
+        prev = v;
+    }
+    // a 500 Hz sine at these levels moves ~0.05/sample; a click would be an order larger
+    REQUIRE(max_step < 0.25);
+}
+
+TEST_CASE("overdrive: deterministic across identical instances") {
+    auto a = make();
+    auto b = make();
+    a.set_drive(0.7);
+    b.set_drive(0.7);
+    a.set_asymmetry(0.4);
+    b.set_asymmetry(0.4);
+    a.set_body(-0.5);
+    b.set_body(-0.5);
+
+    double ph = 0.0;
+    for (int i = 0; i < 48000; ++i) {
+        const double x = 0.6 * std::sin(ph) + 0.2 * std::sin(2.7 * ph);
+        ph += 2.0 * k_pi * 173.0 / k_sr;
+        REQUIRE(a.process(x) == b.process(x));
+    }
+}
+
+TEST_CASE("overdrive: parameter clamping") {
+    REQUIRE(od::clamp_param(od::p_drive, 2.0) == 1.0);
+    REQUIRE(od::clamp_param(od::p_drive, -1.0) == 0.0);
+    REQUIRE(od::clamp_param(od::p_body, 2.0) == 1.0);
+    REQUIRE(od::clamp_param(od::p_body, -2.0) == -1.0);
+    REQUIRE(od::clamp_param(od::p_asymmetry, 1.5) == 1.0);
+    REQUIRE(od::clamp_param(od::p_preamp, 100.0) == od::k_gain_range_db);
+    REQUIRE(od::clamp_param(od::p_output, -100.0) == -od::k_gain_range_db);
+
+    auto o = make();
+    o.set_oversample(3); // snaps down to 2
+    REQUIRE(o.oversample() == 2);
+    o.set_oversample(100); // snaps to 8
+    REQUIRE(o.oversample() == 8);
+}
diff --git a/tools/capi/taptools_capi.cpp b/tools/capi/taptools_capi.cpp
index 325d3ac..f7047d8 100644
--- a/tools/capi/taptools_capi.cpp
+++ b/tools/capi/taptools_capi.cpp
@@ -10,6 +10,7 @@
 #include <taptools/conv_engine.h>
 #include <taptools/diode_ladder.h>
 #include <taptools/ladder.h>
+#include <taptools/overdrive.h>
 #include <taptools/step_seq.h>
 #include <taptools/svf.h>
 #include <taptools/tb303_voice.h>
@@ -787,4 +788,43 @@ int taptools_yin_track(taptools_yin h, const double* x, int n, int hop, double*
     return count;
 }
 
+// ---- tap.overdrive~ ------------------------------------------------------------------------------
+
+using tap::tools::od::overdrive;
+
+taptools_od taptools_od_create(void) {
+    return static_cast<taptools_od>(new overdrive());
+}
+
+void taptools_od_destroy(taptools_od h) {
+    delete static_cast<overdrive*>(h);
+}
+
+int taptools_od_prepare(taptools_od h, double sr) {
+    return with<overdrive>(h, [&](overdrive& o) { o.prepare(sr, 1); });
+}
+
+int taptools_od_set(taptools_od h, int param, double value) {
+    return with<overdrive>(h, [&](overdrive& o) { o.set_param(param, value); });
+}
+
+int taptools_od_set_oversample(taptools_od h, int os) {
+    return with<overdrive>(h, [&](overdrive& o) { o.set_oversample(os); });
+}
+
+int taptools_od_set_smooth_ms(taptools_od h, double ms) {
+    return with<overdrive>(h, [&](overdrive& o) { o.set_smooth_ms(ms); });
+}
+
+int taptools_od_clear(taptools_od h) {
+    return with<overdrive>(h, [&](overdrive& o) { o.clear(); });
+}
+
+int taptools_od_process(taptools_od h, const double* in, double* out, int n) {
+    if (!in || !out || n < 0) {
+        return -1;
+    }
+    return with<overdrive>(h, [&](overdrive& o) { o.process(in, out, static_cast<size_t>(n)); });
+}
+
 } // extern "C"
diff --git a/tools/capi/taptools_capi.h b/tools/capi/taptools_capi.h
index af2eeb6..026613f 100644
--- a/tools/capi/taptools_capi.h
+++ b/tools/capi/taptools_capi.h
@@ -6,8 +6,8 @@
 ///        functions return 0 on success and -1 on any error (bad argument, unconfigured engine).
 ///        No global state. Exposes tap.convolve~'s conv_engine (uniformly-partitioned overlap-save
 ///        convolution) plus the parameter-indexed kernels behind tap.svf~, tap.ladder~, tap.vco~,
-///        and tap.autowah~ (param indices and mode/solver/waveform constants match the enums in
-///        each kernel header; ..._set() takes the kernel's param_index).
+///        tap.autowah~, and tap.overdrive~ (param indices and mode/solver/waveform constants match
+///        the enums in each kernel header; ..._set() takes the kernel's param_index).
 // SPDX-License-Identifier: BSD-3-Clause
 // Copyright 2003-2026 Timothy Place.
 
@@ -263,6 +263,19 @@ TAPTOOLS_API int          taptools_yin_frame_size(taptools_yin h);
 /// (0 where unvoiced). Returns the number written, or -1 on error.
 TAPTOOLS_API int taptools_yin_track(taptools_yin h, const double* x, int n, int hop, double* periods, int max_out);
 
+// ---- tap.overdrive~ (tap::tools::od::overdrive, mono) --------------------------------------------
+
+typedef void* taptools_od;
+
+TAPTOOLS_API taptools_od taptools_od_create(void);
+TAPTOOLS_API void        taptools_od_destroy(taptools_od h);
+TAPTOOLS_API int         taptools_od_prepare(taptools_od h, double sr);
+TAPTOOLS_API int         taptools_od_set(taptools_od h, int param, double value); // od::param_index
+TAPTOOLS_API int         taptools_od_set_oversample(taptools_od h, int os);       // 1, 2, 4, or 8
+TAPTOOLS_API int         taptools_od_set_smooth_ms(taptools_od h, double ms);
+TAPTOOLS_API int         taptools_od_clear(taptools_od h);
+TAPTOOLS_API int         taptools_od_process(taptools_od h, const double* in, double* out, int n);
+
 #ifdef __cplusplus
 }
 #endif