<!-- https://sournd.com/ -->
# sournd

> Hear it, then build with it.

Audio effect engines for JUCE plugins. Each engine is a tested Rust DSP module behind a small C ABI, with a JUCE module that turns its parameters into an APVTS. Drop one into your plugin with three CMake lines. Effects on audio you supply and instruments you play: never generated music.

- 110 engines: 68 effects across 11 categories and 42 synths you play. 32 are free. Free engines download with no account or email.
- Real-time safe: no allocations, locks or system calls on the audio thread.
- Bit-exact: every engine is tested through the C ABI against its Rust module.
- JUCE 8, CMake. Downloads for macOS universal, Linux (x86_64 and aarch64) and Windows x64 (MSVC).

## Start here

- [JUCE quick start](/docs/juce/index.md)
- [Engine catalogue](/engines/index.md)
- [C ABI reference](/docs/abi/index.md)
- [For AI agents](/docs/ai/index.md)
- [Pricing](/pricing/index.md)
- [Licensing](/docs/licensing/index.md)


---

<!-- https://sournd.com/engines/ -->
# Engine catalogue

> 68 effect engines: 25 free and 43 paid. The 42 synths are under [Sounds](https://sournd.com/sounds/index.md). Every engine runs in JUCE through the sOURnd C ABI. Free engines download with no account: https://sournd.com/download/free/macos (macOS), https://sournd.com/download/free/linux (Linux) or https://sournd.com/download/free/windows (Windows).

Machine-readable: [https://sournd.com/catalog.json](https://sournd.com/catalog.json).

## Distortion

Clippers, saturation, fuzz and drive.

- [Brimm](/engines/brimm/index.md) (free, `org.sournd.distortion.brimm`): Clipper: shaves peaks at a ceiling you set, with a hard, soft or knee corner, oversampled for clean highs. Push the drive for loudness and bite, or keep it low to catch stray transients.
- [Calora](/engines/calora/index.md) (free, `org.sournd.distortion.calora`): Warm magnetic-style saturation: highs round off first, lows thicken, loud passages ease back gently.
- [Soft clip](/engines/soft-clip/index.md) (free, `org.sournd.distortion.soft-clip`): Level-compensated tanh saturation.
- [Grittance](/engines/grittance/index.md) (free, `org.sournd.distortion.grittance`): Lo-fi crusher: lower the sample rate and bit depth, fold the wave, and loosen the clock with jitter.
- [Asphalto](/engines/asphalto/index.md) (paid, `org.sournd.distortion.asphalto`): Lower-gain, darker bass fuzz: heavy body and a thick low-mid, with the top end grit mostly rolled away.
- [Kilnglow](/engines/kilnglow/index.md) (paid, `org.sournd.distortion.kilnglow`): Valve-style asymmetric drive rich in even harmonics; the bias sags with playing level for a touch-sensitive bloom.
- [Lithic](/engines/lithic/index.md) (paid, `org.sournd.distortion.lithic`): Plays amp and pedal captures and cabinet impulse responses you load: a neural capture, an IR, or both. Empty slots pass audio through clean.
- [Monstrous Mandarin](/engines/monstrous-mandarin/index.md) (paid, `org.sournd.distortion.monstrous-mandarin`): Thick valve-amp drive that saturates early and sits heavy in the low mids, with a dark-to-cutting tone sweep and a speaker-and-mic voice you can pull back to feed your own cab.
- [Patinor](/engines/patinor/index.md) (paid, `org.sournd.distortion.patinor`): Lo-fi character: makes anything sound played back from a worn record or tape, with drifting pitch, flutter, crackle and dust pops, hiss, a narrow bandwidth, gentle age saturation and optional bit and sample-rate crush. The surface noise rides under the playing and fades out with it.
- [Scary Satsuma](/engines/scary-satsuma/index.md) (paid, `org.sournd.distortion.scary-satsuma`): Tight, biting valve-amp drive that keeps getting heavier all the way up the gain, with a broad upper-mid push and a speaker-and-mic voice you can pull back to feed your own cab.
- [Thornet](/engines/thornet/index.md) (paid, `org.sournd.distortion.thornet`): Thick, saturated fuzz with an octave-up blend, a gate for tight stops and a scoop-to-bright tone stack.

## Dynamics

Compressors, limiters, gates and transient shapers.

- [Clampa](/engines/clampa/index.md) (free, `org.sournd.dynamics.clampa`): Punchy peak compressor: fast peak sensing with a firm knee, a punch control that lets transients through ahead of the gain reduction, and a parallel mix.
- [Attaq](/engines/attaq/index.md) (free, `org.sournd.dynamics.attaq`): Transient shaper: boost or soften the attack of each hit and lift or tuck its sustain, independent of level, with a speed control for tight or loose envelopes and a clip-safe output.
- [Ceilwall](/engines/ceilwall/index.md) (paid, `org.sournd.dynamics.ceilwall`): Transparent lookahead brickwall limiter: the gain ramps down before each peak arrives so the output never passes the ceiling, then recovers with a smooth release.
- [Hushel](/engines/hushel/index.md) (paid, `org.sournd.dynamics.hushel`): Dynamic EQ band: a bell that cuts only while its own band is louder than the threshold. Set it high and narrow-ish for de-essing; the wide control moves the cut from the band to the whole signal.
- [Sluice](/engines/sluice/index.md) (paid, `org.sournd.dynamics.sluice`): Gate and downward expander: opens above the threshold, closes below it minus the hysteresis after the hold time, and expands at the chosen ratio down to the range floor.
- [Unisill](/engines/unisill/index.md) (paid, `org.sournd.dynamics.unisill`): Glue compressor: RMS sensing that blends feed-forward and feedback detection, a soft knee and a release that speeds up on transient material and relaxes on sustained material.

## EQ

Parametric, graphic and character equalisers.

- [Lancetine](/engines/lancetine/index.md) (free, `org.sournd.eq.lancetine`): Surgical parametric EQ: 24 dB/oct low and high cuts (off at their extremes), low and high shelves and three fully parametric bells.
- [Fournel](/engines/fournel/index.md) (paid, `org.sournd.eq.fournel`): Passive-style program EQ: boost and attenuate the lows at the same frequency for a deep, tight bottom with a dip above it, a broad-to-sharp high boost, a separate high attenuation shelf, and a gentle output stage that thickens as it is driven.
- [Glazen](/engines/glazen/index.md) (paid, `org.sournd.eq.glazen`): Linear-phase parametric EQ: 24 dB/oct low and high cuts, low and high shelves and three bells with no phase shift between frequencies, so boosts and cuts keep transients and parallel paths aligned. Adds a fixed latency the host compensates.
- [Glintfoil](/engines/glintfoil/index.md) (paid, `org.sournd.eq.glintfoil`): Harmonic exciter: adds new overtones above a chosen frequency rather than boosting what is there. Harmonics sets the drive, colour leans the new overtones odd (bright, edgy) or even (sweet, open), and amount blends them in.
- [Gridelle](/engines/gridelle/index.md) (paid, `org.sournd.eq.gridelle`): Thirty-one-band third-octave graphic EQ, 20 Hz to 20 kHz, +-12 dB per band, constant-Q, for room and system voicing and precise tonal balance.

## Filter

Multimode, formant and stepped filters.

- [Veer](/engines/veer/index.md) (free, `org.sournd.filter.veer`): Resonant multimode filter that morphs continuously from low-pass through band-pass and high-pass to notch, with input drive and an envelope that sweeps the cutoff with the playing.
- [Kammerl](/engines/kammerl/index.md) (free, `org.sournd.filter.kammerl`): Tuned comb filter: rings any sound at a note or frequency, from a subtle metallic sheen to a singing, pitched resonance. Flip the polarity for a hollow tone an octave down; damping softens the ring.
- [Pivotta](/engines/pivotta/index.md) (free, `org.sournd.filter.pivotta`): One-knob performance filter: turn left and a low-pass sweeps down from the top to the deep bass, turn right and a high-pass sweeps up to thin the sound out; the centre is a clean bypass. Resonance adds a peak at the cutoff; Steep switches 12 to 24 dB/oct.
- [Glottan](/engines/glottan/index.md) (paid, `org.sournd.filter.glottan`): A vowel filter: three resonant peaks shaped like a voice, slid between two vowels by hand, by an LFO or by how hard the input plays, for talking, wah and growl tones.
- [Prowl](/engines/prowl/index.md) (paid, `org.sournd.filter.prowl`): Auto filter: a resonant low-pass, band-pass, high-pass or notch swept by an LFO (free or locked to the song, including sample-and-hold steps) and by how hard you play, with drive in front, grit after and a stereo offset.
- [Rung](/engines/rung/index.md) (paid, `org.sournd.filter.rung`): Warm resonant low-pass: four cascaded poles in a feedback loop with soft saturation, a slope control from 6 to 24 dB/oct and bass compensation for the level lost to resonance.
- [Treadle](/engines/treadle/index.md) (paid, `org.sournd.filter.treadle`): Pedal wah: one vocal, resonant peak rocked from heel to toe by the position control (map it to an expression pedal), or pushed by your playing for auto-wah. Hard notes squash the peak into a throaty honk.

## Modulation

Chorus, phaser, flanger, tremolo and friends.

- [Chorvane](/engines/chorvane/index.md) (free, `org.sournd.modulation.chorvane`): Lush three-voice ensemble chorus with stereo spread and a soft top end.
- [Eddyturn](/engines/eddyturn/index.md) (free, `org.sournd.modulation.eddyturn`): Eight-stage phaser with staggered notches, feedback for vocal sweeps and a stereo offset that turns it into a slow spin.
- [Tremola](/engines/tremola/index.md) (free, `org.sournd.modulation.tremola`): Tremolo that morphs from a smooth throb to a choppy pulse; widen the stereo phase for auto-pan.
- [Bellrung](/engines/bellrung/index.md) (paid, `org.sournd.modulation.bellrung`): Ring modulator: replaces each note with metallic sum and difference tones, from bell-like shimmer to harsh clangour, with an optional wobble on the carrier.
- [Ebb](/engines/ebb/index.md) (paid, `org.sournd.modulation.ebb`): Harmonic tremolo: lows and highs pulse in opposite phase, so the tone rocks between warm and bright with a subtle phasey sway instead of a plain volume throb.
- [Gyrecast](/engines/gyrecast/index.md) (paid, `org.sournd.modulation.gyrecast`): Rotating speaker: a spinning treble horn and bass drum, slow or fast, that speed up and slow down with real weight, heard by two microphones for a wide swirling stereo image.
- [Jetwake](/engines/jetwake/index.md) (paid, `org.sournd.modulation.jetwake`): Jet-sweep flanger with positive or negative feedback and a near through-zero mode that sweeps the echo across the dry signal.
- [Photocel](/engines/photocel/index.md) (paid, `org.sournd.modulation.photocel`): Lopsided, throbbing four-stage phase shifter swept by a lamp and light cell: chorus mode for liquid, pulsing notches, vibrato mode for a seasick pitch wobble.
- [Stairwhorl](/engines/stairwhorl/index.md) (paid, `org.sournd.modulation.stairwhorl`): Endless sweep: phaser or flanger notches that keep rising, or keep falling, forever without ever resetting.

## Delay

Clean, tape, bucket brigade, granular and ping-pong echoes.

- [Lucento](/engines/lucento/index.md) (free, `org.sournd.delay.lucento`): Clean digital echo: every repeat an exact copy, trimmed by low and high cut in the loop. Set the time in milliseconds or lock it to a note of the host tempo (the Tempo control stands in without one). Changing the time crossfades to the new echo instead of bending its pitch. Offset delays the right side for width. Sync: 0 = free, 1 = 1/32, 2 = 1/16T, 3 = 1/16, 4 = 1/16D, 5 = 1/8T, 6 = 1/8, 7 = 1/8D, 8 = 1/4T, 9 = 1/4, 10 = 1/4D, 11 = 1/2, 12 = 1/2D, 13 = 1 bar.
- [Driftel](/engines/driftel/index.md) (free, `org.sournd.delay.driftel`): Warm, wandering echo. Repeats bend in pitch, soften and saturate as they fade.
- [Backwash](/engines/backwash/index.md) (paid, `org.sournd.delay.backwash`): Backwards echo: every chunk of time is played back reversed during the next one, so notes swell in from nothing and cut off. Feedback flips the repeats back and forth. Fade sets how soft each chunk's edges are. Sync: 0 = free, 1..13 = 1/32 to 1 bar (chunks longer than 2 s are held at 2 s).
- [Bucketta](/engines/bucketta/index.md) (paid, `org.sournd.delay.bucketta`): Dark, gritty analogue-style echo. Short times stay bright, long times get murky because the virtual clock slows down; a compander makes hiss and grit swell and fade with the playing; turning the time bends the repeats in pitch, and the glide sets how fast. Sync as the other echoes: 0 = free, 1..13 = 1/32 to 1 bar.
- [Graniel](/engines/graniel/index.md) (paid, `org.sournd.delay.graniel`): Granular echo: the delayed sound is cut into short grains, scattered in time by Spray, pitched and panned, and layered at the chosen density, from a shimmering cloud to a stuttering glitch. Feedback feeds the cloud back into itself; Freeze (on above half) stops recording so the grains keep playing the held sound. Sync: 0 = free, 1..13 = 1/32 to 1 bar.
- [Volleto](/engines/volleto/index.md) (paid, `org.sournd.delay.volleto`): Stereo ping-pong. Repeats bounce left and right, thinning and blurring into a wash as they go.

## Reverb

Rooms, halls, plates and spaces that do not exist.

- [Roomette](/engines/roomette/index.md) (free, `org.sournd.reverb.roomette`): A real-sounding room: distinct early reflections that place a sound at a distance, with a short soft tail.
- [Coilette](/engines/coilette/index.md) (free, `org.sournd.reverb.coilette`): Spring reverb: a boingy, splashy tank whose echoes chirp downward as the lows lag behind the highs. Tension tightens the springs (shorter, brighter, less chirp); Drip is how hard transients shake the tank; Springs sets how many are in it.
- [Aulana](/engines/aulana/index.md) (paid, `org.sournd.reverb.aulana`): Lush, slowly moving hall. Separate low and high decay let the tail stay warm and dark or open and airy.
- [Blossa](/engines/blossa/index.md) (paid, `org.sournd.reverb.blossa`): Reverb that blooms: it swells in behind notes, steps aside while you play, and can be gated shut for a hard stop.
- [Shimmerhall](/engines/shimmerhall/index.md) (paid, `org.sournd.reverb.shimmerhall`): Shimmer reverb: a long, gently moving space whose tail is pitch-shifted and fed back into itself, so held notes bloom into a bright halo an octave or a fifth above. Shimmer sets how much climbs. Interval: 0 = octave up, 1 = fifth up, 2 = octave and fifth, 3 = octave and octave-plus-fifth, 4 = octave down and up.
- [Tesselle](/engines/tesselle/index.md) (paid, `org.sournd.reverb.tesselle`): Bright, dense sheet of reverb that builds almost instantly. Smooth on drums and vocals.

## Pitch

Octaves, shifters and harmonisers.

- [Octunder](/engines/octunder/index.md) (free, `org.sournd.pitch.octunder`): Analogue-style sub octaves: square-wave subs one and two octaves down that answer instantly and follow your dynamics, rounded by a tone control. Single notes only, like the circuits it is modelled on in spirit.
- [Swoopline](/engines/swoopline/index.md) (free, `org.sournd.pitch.swoopline`): Octave up straight from the waveform: glassy and clean on one side, ringing and fuzzy on the other, with drive, a gate that trims the tails and a tone control. No latency.
- [Northnote](/engines/northnote/index.md) (paid, `org.sournd.pitch.northnote`): Pitch correction for voices and single-note lines: pulls every note to the nearest note of your key and scale (chromatic, major, minor, pentatonics or your own 12-note set) at a speed from natural to a hard snap at 0 ms, with humanise to leave held notes and vibrato alone.
- [Octrel](/engines/octrel/index.md) (paid, `org.sournd.pitch.octrel`): Clean polyphonic octaves: a sub, a second sub and an octave up that follow chords, with their own levels, a darkening filter for the subs and a squash that keeps the octave voices even.
- [Tessarine](/engines/tessarine/index.md) (paid, `org.sournd.pitch.tessarine`): The everything pitch engine: four voices from three octaves down to three up with fine tune, level, pan and delay each; chord-friendly or single-note mode, formants kept or moved, detune spread and a feedback path that climbs in cascades.

## Performance

Tape stops, stutters, gates and live tricks.

- [Torpora](/engines/torpora/index.md) (free, `org.sournd.performance.torpora`): Tape stop: the sound slows down and drops in pitch to a halt over the stop time, then spins back up over the start time (0 = cut straight back in). Curve bends the slowdown from a sudden drag (negative) to a long coast (positive). Trigger: 0 = the Stop control (on above half), 1 = the host transport stopping and starting, 2 = either.
- [Carvello](/engines/carvello/index.md) (paid, `org.sournd.performance.carvello`): Beat slicer: each bar is cut into equal slices, and Shuffle is the chance that a slice is replaced by an earlier slice of the same bar (Reverse the chance it plays backwards), so loops are broken up and rebuilt on the fly. Hold keeps one pattern for every bar (above half) instead of a new one each bar. Slices: 0 = 4, 1 = 8, 2 = 16, 3 = 32 per bar. Seed picks the pattern.
- [Glacine](/engines/glacine/index.md) (paid, `org.sournd.performance.glacine`): Sustainer: turn Hold on and the current sound is captured and held indefinitely as a smooth, evolving texture, blended under or over the live signal. While held, the trigger decides when it crossfades to a fresh capture: 0 = manual (only when Hold is switched on), 1 = new note (a stable pitch change larger than Pitch change), 2 = transient, 3 = every N beats, 4 = every N bars (host grid, or the Tempo control without one). Switching Hold off lets the held sound die away over Release.
- [Rippet](/engines/rippet/index.md) (paid, `org.sournd.performance.rippet`): Grid stutter: once per interval, at the offset, it rolls the dice and may grab a short slice and stutter it for the gate length, each repeat optionally dropping in pitch and level. Locks to the host grid; without one it runs on its own Tempo. Interval: 0 = 1 beat, 1 = 2 beats, 2 = 1 bar, 3 = 2 bars, 4 = 4 bars. Offset and Gate count sixteenth notes. Repeat: 0 = 1/32, 1 = 1/16, 2 = 1/8, 3 = 1/4, 4 = 1/2. The same seed and song position always make the same decision.

## Utility

Width, routing, polarity and gain staging.

- [Gain](/engines/gain/index.md) (free, `org.sournd.utility.gain`): Clean level control with a short de-zipper ramp.
- [Keelson](/engines/keelson/index.md) (free, `org.sournd.utility.keelson`): Channel utility: flip polarity per channel, swap channels, fold to mono (sum, left or right), balance or pan with a choice of pan law, delay each channel by samples plus milliseconds for time alignment, remove DC, and trim the level.
- [Breadth](/engines/breadth/index.md) (free, `org.sournd.utility.breadth`): Stereo width from mono to double width, with a low end that folds to mono below a chosen frequency.
- [Meridel](/engines/meridel/index.md) (paid, `org.sournd.utility.meridel`): Mid/side mixer: set the centre and the sides separately, spread or narrow the image, and turn the whole image left or right without losing energy. Decode mode takes a mid/side recording in; encode mode sends mid/side out.
- [Spherel](/engines/spherel/index.md) (paid, `org.sournd.utility.spherel`): Binaural panner for headphones: places the input around the listener's head by azimuth, elevation and distance, with the time and level differences between the ears, the head's shadow, a pinna cue for height and softer highs from behind and far away.

## Analysis

Meters, tuners and detectors. Audio passes untouched.

- [Plumb](/engines/plumb/index.md) (free, `org.sournd.analysis.plumb`): Level meter: per-channel sample peak with a falling needle, RMS and a peak hold. Audio passes untouched.
- [Tunra](/engines/tunra/index.md) (free, `org.sournd.analysis.tunra`): Chromatic tuner: the nearest note, how many cents sharp or flat, the frequency and how sure it is, against an adjustable A4. Audio passes untouched.
- [Heft](/engines/heft/index.md) (paid, `org.sournd.analysis.heft`): Loudness meter: momentary (400 ms), short-term (3 s) and gated integrated loudness in LUFS, loudness range and 4x-oversampled true peak, against a target. Audio passes untouched.
- [Huescope](/engines/huescope/index.md) (paid, `org.sournd.analysis.huescope`): Spectrum meter: 31 third-octave band levels from 20 Hz to 20 kHz with an optional display tilt, plus peak and RMS. Audio passes untouched.


---

<!-- https://sournd.com/what-are-engines/ -->
# What are sOURnd engines?

> The sound of an effect, without the plugin around it. You, your AI or your developer build the plugin you need around it.

## 1. One effect. Nothing else.

A sOURnd engine is a single audio effect: a clipper, a tape delay, a vowel filter. Audio goes in, transformed audio comes out. It has no window, no knobs and no opinion about how it should look.

## 2. Tested DSP behind a tiny door.

Inside is DSP written in Rust, tested against references and bit-exact through one small C interface, the C ABI. It never allocates memory on the audio thread, so it is safe in any host at any buffer size.

## 3. Parameters, not controls.

An engine exposes numbered parameters with ranges, units and defaults. Brimm has six: drive, ceiling, shape, knee, mix and output. That is the whole contract. What a user touches is up to you.

## 4. Any controls you can imagine.

Wrap those parameters in knobs, faders, an XY pad, a foot pedal, MIDI pads, one macro or a typed prompt. Same engine, same sound, any surface. Try it on Play: press Randomise, then New control surface.

## 5. Into your plugin in three lines.

Add the JUCE module, link the library, and every parameter appears in your APVTS, ready for automation and presets. Chain as many engines as you like inside one plugin.

## 6. Use your AI or developer to build the plugins you need.

Every page here has a Markdown twin, the catalogue is one JSON file and llms.txt tells an agent where everything is. Describe the plugin you want: your AI or your developer picks the engines and writes the code, and you design the face.

## 7. Played by you. Never generated.

Every engine is an effect that transforms audio you supply, or an instrument you play. Nothing here generates music: the playing, the writing and the sound are yours. Access, not replacement.

## Our ethic

AI should always enable creators, musicians and producers, never replace them. Every engine is an effect on audio you supply or an instrument you play: nothing here makes the music for you. [How we make things](https://sournd.com/ethics/index.md).

## Next

- [All engines](https://sournd.com/engines/index.md)
- [JUCE quick start](https://sournd.com/docs/juce/index.md)
- [For AI agents](https://sournd.com/docs/ai/index.md)


---

<!-- https://sournd.com/games/ -->
# sOURnd for games

> Every sOURnd engine, inside your game. One C library, real-time safe, with no account, licence check or network call at runtime. No per-game fee and no royalty.

## What you get

- **68 effect engines, and synths too,** behind one small C interface: reverbs, delays, filters, distortion, dynamics, modulation, pitch and more. Some are free.
- **Effects on your game's audio and instruments your game plays.** Put a reverb on a bus, a filter on a voice, a synth under a note. The engines never generate music.
- **Built for the audio thread.** `process` is real-time safe and in place. Parameters can be set from the audio thread. State saves and loads, and newer engine versions keep loading older saves.
- **Nothing to phone home.** The library is linked into your game. Your players need nothing from sOURnd.

## How it fits in a game

The library is the same one plugin makers use: a static archive and one header, [the C ABI](https://sournd.com/docs/abi/). Call it from C or C++ directly, or from any engine that can call C.

```c
sournd_engine *reverb;
sournd_engine_create("org.sournd.reverb.roomette", &reverb);
sournd_engine_prepare(reverb, 48000.0, 1024);
sournd_engine_set_param(reverb, 0, 0.35);
sournd_engine_process(reverb, in, out, 2, frames);
```

- **Today:** link the C library yourself, on macOS, Linux and Windows. Engines take mono or stereo buffers.
- **On the way:** ready-made plugins for FMOD, Wwise, Unity and Unreal, and builds for iOS, Android and consoles. [Tell us what you ship on](mailto:licensing@sournd.com?subject=sOURnd%20for%20games) and we will tell you where it stands.

## What it costs

- **No game fee and no royalty.** A game is licensed the same way as a plugin: buy the engines you use once, or hold a plan when you release. [Pricing](https://sournd.com/pricing/).
- **Releases stay licensed.** A game version released with engines you own, or while your plan is active, is licensed for good.
- **Some engines are free,** with no account or email.

The library is built for macOS, Linux and Windows today. Other platforms open as their builds are ready.

[Full licence terms](https://sournd.com/docs/licensing/#games) · [Browse the engines](https://sournd.com/engines/)

## For your AI assistant

Paste this into your coding assistant:

```text
Read https://sournd.com/llms.txt, pick a sournd reverb for a cave ambience bus and add it to my game's audio code through the C ABI.
```


---

<!-- https://sournd.com/upcoming/ -->
# Upcoming engines

> New blocks every day. 35 engines on the way, one a day; included in the subscription the day each lands. 9 of them will be free, so a free one lands every few days.

- 2026-11-14: **Tapsody** (delay, multi tap; paid). Taps that fan across the field.
- 2026-11-15: **Cellara** (reverb, chamber; paid). Hard walls, then stillness.
- 2026-11-16: **Downstep** (pitch, drop tune, shifter; paid). Down without retuning.
- 2026-11-17: **Gatestep** (performance, gater; free). Sixteen steps of light.
- 2026-11-18: **Loomwise** (utility, spread, width; paid). Bands woven left and right.
- 2026-11-19: **Metrin** (analysis, tempo detect; free). Find the beat in the room.
- 2026-11-20: **Fizzmelt** (distortion, fuzz, distortion; paid). Fizzing on top, nothing underneath.
- 2026-11-21: **Levella** (dynamics, compressor; paid). Slow, smooth, always level.
- 2026-11-22: **Leanwise** (eq, tilt, shelf; free). Weight below, air above.
- 2026-11-23: **Sifta** (filter, spectral gate; paid). Keep only what shines.
- 2026-11-24: **Offsetter** (modulation, frequency shifter; paid). Every partial, moved as one.
- 2026-11-25: **Twindle** (delay, stereo, ping pong; free). Left and right, each their own.
- 2026-11-26: **Shapeverb** (reverb, nonlinear, gated; paid). A space shaped by your hand.
- 2026-11-27: **Followtone** (pitch, track oscillator; paid). A voice that follows yours.
- 2026-11-28: **Marcher** (performance, step sequencer; paid). Three lanes, marching in step.
- 2026-11-29: **Widewing** (utility, haas, width; free). A few milliseconds, a wide sky.
- 2026-11-30: **Pairo** (analysis, correlation; paid). How far apart, how together.
- 2026-12-01: **Hulvar** (distortion, amp, overdrive; paid). Steady below, growl beneath.
- 2026-12-02: **Merlon** (dynamics, limiter; free). Loud as you like, never over.
- 2026-12-03: **Likenry** (eq, match, linear phase; paid). Follow the curve exactly.
- 2026-12-04: **Stepvale** (filter, filterbank, formant; paid). Shapes that morph down the hill.
- 2026-12-05: **Spinhorn** (modulation, scanner vibrato, vibrato; paid). A pickup spinning through time.
- 2026-12-06: **Warblecot** (delay, modulation delay; free). Doubling, drifting, warbling.
- 2026-12-07: **Skyrung** (pitch, expression shift, shifter; paid). Heel to toe, up the sky.
- 2026-12-08: **Rondel** (performance, arp; paid). A frozen slice, played round.
- 2026-12-09: **Screel** (distortion, fuzz, distortion; paid). Rough grit, heavy ground.
- 2026-12-10: **Yieldcourt** (dynamics, ducker, compressor; paid). Yield, then come back.
- 2026-12-11: **Stile** (eq, graphic; free). Ten posts, one at a time.
- 2026-12-12: **Vocodra** (filter, vocoder, formant; paid). Your sound, made to speak.
- 2026-12-13: **Unfurl** (modulation, spreader, chorus; paid). Narrow to wide, gently moving.
- 2026-12-14: **Undercroft** (pitch, sub bass, octaver; paid). A floor beneath the bass.
- 2026-12-15: **Shardglow** (distortion, distortion, saturation; paid). One light, two characters.
- 2026-12-16: **Vibrel** (modulation, vibrato; free). The whole pitch, bending.
- 2026-12-17: **Strikel** (distortion, distortion, fuzz; paid). Strike it. Watch it bite.
- 2026-12-18: **Warpel** (distortion, phase distortion; paid). The shape bends. The flock holds.


---

<!-- https://sournd.com/play/ -->
# Play

> Program a beat of simple test sounds and hear it through any sournd engine, running live in your browser.

Never generated music: the test voices are yours to sequence; the engine transforms them. Open engines play without a limit; previews of paid engines stop after 30 seconds per play.


---

<!-- https://sournd.com/engines/brimm/ -->
# Brimm

> Clipper: shaves peaks at a ceiling you set, with a hard, soft or knee corner, oversampled for clean highs. Push the drive for loudness and bite, or keep it low to catch stray transients.

- Engine id: `org.sournd.distortion.brimm`
- Category: Distortion
- Licence: free (Apache-2.0, in the open framework)
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 15 samples
- Tail: 0.01 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/brimm.mp3 (a bass line, default settings)
- Live preview: https://sournd.com/engines/brimm/ (runs the real engine in the browser; test sounds or the user's own file)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `drive_db` | Drive | 0 | 36 | 0 | dB | linear |
| 1 | `ceiling_db` | Ceiling | -24 | 0 | -1 | dB | linear |
| 2 | `shape` | Shape | 0 | 2 | 2 | - | linear |
| 3 | `knee_db` | Knee | 0 | 12 | 3 | dB | linear |
| 4 | `mix` | Mix | 0 | 100 | 100 | % | linear |
| 5 | `output_db` | Output | -24 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.distortion.brimm" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.distortion.brimm", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 0); /* Drive */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: drive into a ceiling-normalised static clipper with hard, hyperbolic-tangent or quadratic soft-knee transfer curves, run inside 2x windowed-sinc oversampling with the dry blend at the oversampled rate.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.distortion.brimm to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/brimm/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/calora/ -->
# Calora

> Warm magnetic-style saturation: highs round off first, lows thicken, loud passages ease back gently.

- Engine id: `org.sournd.distortion.calora`
- Category: Distortion
- Licence: free (Apache-2.0, in the open framework)
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 15 samples
- Tail: 0.05 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/calora.mp3 (a bass line, default settings)
- Live preview: https://sournd.com/engines/calora/ (runs the real engine in the browser; test sounds or the user's own file)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `drive` | Drive | 0 | 30 | 9 | dB | linear |
| 1 | `warmth` | Warmth | 0 | 100 | 40 | % | linear |
| 2 | `tone` | Tone | 0 | 100 | 60 | % | linear |
| 3 | `mix` | Mix | 0 | 100 | 100 | % | linear |
| 4 | `output_db` | Output | -24 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.distortion.calora" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.distortion.calora", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 9); /* Drive */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: pre-/de-emphasis shelving around a soft tanh saturator, a one-sample output memory for a hysteresis-like loop, envelope-eased drive, envelope-driven auto gain compensation and 2x oversampling.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.distortion.calora to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/calora/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/soft-clip/ -->
# Soft clip

> Level-compensated tanh saturation.

- Engine id: `org.sournd.distortion.soft-clip`
- Category: Distortion
- Licence: free (Apache-2.0, in the open framework)
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/soft-clip.mp3 (a bass line, default settings)
- Live preview: https://sournd.com/engines/soft-clip/ (runs the real engine in the browser; test sounds or the user's own file)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `drive` | Drive | 1 | 20 | 1 | x | log |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.distortion.soft-clip" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.distortion.soft-clip", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 1); /* Drive */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd utility: normalised hyperbolic-tangent waveshaper.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.distortion.soft-clip to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/soft-clip/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/grittance/ -->
# Grittance

> Lo-fi crusher: lower the sample rate and bit depth, fold the wave, and loosen the clock with jitter.

- Engine id: `org.sournd.distortion.grittance`
- Category: Distortion
- Licence: free: a closed library, free to use in your plugins, downloaded with no account or email
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 15 samples
- Tail: 0.01 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/grittance.mp3 (a bass line, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `bits` | Bits | 1 | 16 | 8 | bits | linear |
| 1 | `rate_hz` | Rate | 400 | 48000 | 12000 | Hz | log |
| 2 | `fold` | Fold | 0 | 100 | 0 | % | linear |
| 3 | `jitter` | Jitter | 0 | 100 | 0 | % | linear |
| 4 | `mix` | Mix | 0 | 100 | 100 | % | linear |
| 5 | `output_db` | Output | -24 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.distortion.grittance" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.distortion.grittance", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 8); /* Bits */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: sample-and-hold rate reduction with a jittered clock, mid-tread uniform quantisation, a sine wavefolder and 2x oversampling.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.distortion.grittance to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/grittance/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/asphalto/ -->
# Asphalto

> Lower-gain, darker bass fuzz: heavy body and a thick low-mid, with the top end grit mostly rolled away.

- Engine id: `org.sournd.distortion.asphalto`
- Category: Distortion
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 15 samples
- Tail: 0.5 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/asphalto.mp3 (a bass line, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `amount` | Amount | 0 | 5 | 1.3125 | x | linear |
| 1 | `tightness` | Tightness | 0 | 1 | 1 | x | linear |
| 2 | `bite` | Bite | 0 | 4 | 0 | x | linear |
| 3 | `asym` | Asymmetry | 0.2 | 1 | 0.2 | x | linear |
| 4 | `hardness` | Hardness | 0 | 1 | 0.7 | x | linear |
| 5 | `grit` | Grit | -3 | 4 | 1 | x | linear |
| 6 | `tame` | Tame | 0 | 1 | 0 | x | linear |
| 7 | `low_blend` | Low blend | -3 | 3 | -0.2 | x | linear |
| 8 | `presence` | Presence | 0 | 8 | 0 | dB | linear |
| 9 | `body` | Body | 0 | 4 | 4 | x | linear |
| 10 | `defizz` | De-fizz | 0 | 1.5 | 0.8 | x | linear |
| 11 | `warmth` | Warmth | 0 | 1.5 | 1 | x | linear |
| 12 | `level_db` | Level trim | -24 | 12 | -14 | dB | linear |
| 13 | `mix` | Mix | 0 | 100 | 100 | % | linear |
| 14 | `output_db` | Output | -24 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.distortion.asphalto" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.distortion.asphalto", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 1.3125); /* Amount */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Ported from our own Box Of Rules bass fuzz (Box Of Bass): AGC-normalised asymmetric soft/hard clipper, per-band grit cascade, casc warmth shelf, tame, de-fizz, a Linkwitz-Riley clean-low blend, presence, body, warmth and low high-pass, all inside a 2x oversampler; the cabinet impulse response is not included. Voicing: the second of our three locked fuzz characters.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.distortion.asphalto to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/asphalto/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/kilnglow/ -->
# Kilnglow

> Valve-style asymmetric drive rich in even harmonics; the bias sags with playing level for a touch-sensitive bloom.

- Engine id: `org.sournd.distortion.kilnglow`
- Category: Distortion
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 15 samples
- Tail: 0.1 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/kilnglow.mp3 (a bass line, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `drive` | Drive | 0 | 36 | 14 | dB | linear |
| 1 | `bias` | Bias | 0 | 100 | 40 | % | linear |
| 2 | `sag` | Sag | 0 | 100 | 35 | % | linear |
| 3 | `tone` | Tone | 0 | 100 | 55 | % | linear |
| 4 | `mix` | Mix | 0 | 100 | 100 | % | linear |
| 5 | `output_db` | Output | -24 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.distortion.kilnglow" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.distortion.kilnglow", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 14); /* Drive */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: a biased (asymmetric) tanh stage, an envelope follower that shifts bias and eases gain with level, envelope-driven auto gain compensation, coupling high-pass, DC blocking, post low-pass and 2x oversampling.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.distortion.kilnglow to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/kilnglow/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/lithic/ -->
# Lithic

> Plays amp and pedal captures and cabinet impulse responses you load: a neural capture, an IR, or both. Empty slots pass audio through clean.

- Engine id: `org.sournd.distortion.lithic`
- Category: Distortion
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0.2 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/lithic.mp3 (a bass line, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `input_db` | Input | -24 | 24 | 0 | dB | linear |
| 1 | `output_db` | Output | -24 | 24 | 0 | dB | linear |
| 2 | `normalise` | Normalise | 0 | 1 | 1 | - | linear |
| 3 | `calibrate` | Calibrate input | 0 | 1 | 1 | - | linear |
| 4 | `interface_dbu` | Interface level | -20 | 30 | 12 | dBu | linear |
| 5 | `cabinet` | Cabinet | 0 | 100 | 100 | % | linear |
| 6 | `low_cut` | Low cut | 10 | 1000 | 10 | Hz | log |
| 7 | `high_cut` | High cut | 1000 | 20000 | 20000 | Hz | log |
| 8 | `mix` | Mix | 0 | 100 | 100 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.distortion.lithic" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.distortion.lithic", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 0); /* Input */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd engine. Runs Neural Amp Modeler format captures (.nam: WaveNet, LSTM, Linear) and standard WAV impulse responses with in-crate inference, zero-latency FFT convolution and band-limited resampling. Ships no captures or impulse responses.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.distortion.lithic to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/lithic/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/monstrous-mandarin/ -->
# Monstrous Mandarin

> Thick valve-amp drive that saturates early and sits heavy in the low mids, with a dark-to-cutting tone sweep and a speaker-and-mic voice you can pull back to feed your own cab.

- Engine id: `org.sournd.distortion.monstrous-mandarin`
- Category: Distortion
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 15 samples
- Tail: 0.1 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/monstrous-mandarin.mp3 (a bass line, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `gain` | Gain | 0 | 100 | 50 | % | linear |
| 1 | `tone` | Tone | 0 | 100 | 50 | % | linear |
| 2 | `cabinet` | Cabinet | 0 | 100 | 100 | % | linear |
| 3 | `mic` | Mic | 0 | 2 | 0 | - | linear |
| 4 | `mix` | Mix | 0 | 100 | 100 | % | linear |
| 5 | `output_db` | Output | -24 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.distortion.monstrous-mandarin" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.distortion.monstrous-mandarin", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 50); /* Gain */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design fitted to our own noise profiling of a two-channel valve amp through three capture paths: tone, low-end and cabinet curves are least-squares biquad fits to those measurements; the drive is general biased-tanh preamp and power-stage shaping with auto gain compensation and 2x oversampling. Models no product circuit.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.distortion.monstrous-mandarin to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/monstrous-mandarin/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/patinor/ -->
# Patinor

> Lo-fi character: makes anything sound played back from a worn record or tape, with drifting pitch, flutter, crackle and dust pops, hiss, a narrow bandwidth, gentle age saturation and optional bit and sample-rate crush. The surface noise rides under the playing and fades out with it.

- Engine id: `org.sournd.distortion.patinor`
- Category: Distortion
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 256 samples
- Tail: 2 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/patinor.mp3 (a bass line, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `wow` | Wow | 0 | 100 | 20 | % | linear |
| 1 | `flutter` | Flutter | 0 | 100 | 15 | % | linear |
| 2 | `crackle` | Crackle | 0 | 100 | 20 | % | linear |
| 3 | `dust` | Dust | 0 | 100 | 10 | % | linear |
| 4 | `hiss` | Hiss | 0 | 100 | 10 | % | linear |
| 5 | `low_cut_hz` | Low cut | 20 | 1000 | 60 | Hz | log |
| 6 | `high_cut_hz` | High cut | 1000 | 20000 | 9000 | Hz | log |
| 7 | `bits` | Bits | 4 | 16 | 16 | bits | linear |
| 8 | `rate_hz` | Rate | 2000 | 48000 | 48000 | Hz | log |
| 9 | `age` | Age | 0 | 100 | 30 | % | linear |
| 10 | `mix` | Mix | 0 | 100 | 100 | % | linear |
| 11 | `output_db` | Output | -24 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.distortion.patinor" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.distortion.patinor", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 20); /* Wow */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: a sine-plus-random-drift and two-sine modulated fractional delay for wow and flutter with a fixed centre delay reported as latency, band-limiting biquads, tanh saturation, sample-and-hold rate reduction with mid-tread quantisation, and probabilistic impulse noise through resonant filters gated by an input envelope follower.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.distortion.patinor to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/patinor/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/scary-satsuma/ -->
# Scary Satsuma

> Tight, biting valve-amp drive that keeps getting heavier all the way up the gain, with a broad upper-mid push and a speaker-and-mic voice you can pull back to feed your own cab.

- Engine id: `org.sournd.distortion.scary-satsuma`
- Category: Distortion
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 15 samples
- Tail: 0.1 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/scary-satsuma.mp3 (a bass line, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `gain` | Gain | 0 | 100 | 50 | % | linear |
| 1 | `tone` | Tone | 0 | 100 | 50 | % | linear |
| 2 | `cabinet` | Cabinet | 0 | 100 | 100 | % | linear |
| 3 | `mic` | Mic | 0 | 2 | 0 | - | linear |
| 4 | `mix` | Mix | 0 | 100 | 100 | % | linear |
| 5 | `output_db` | Output | -24 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.distortion.scary-satsuma" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.distortion.scary-satsuma", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 50); /* Gain */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design fitted to our own noise profiling of a two-channel valve amp through three capture paths: tone, low-end and cabinet curves are least-squares biquad fits to those measurements; the drive is general biased-tanh preamp and power-stage shaping with auto gain compensation and 2x oversampling. Models no product circuit.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.distortion.scary-satsuma to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/scary-satsuma/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/thornet/ -->
# Thornet

> Thick, saturated fuzz with an octave-up blend, a gate for tight stops and a scoop-to-bright tone stack.

- Engine id: `org.sournd.distortion.thornet`
- Category: Distortion
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 15 samples
- Tail: 0.1 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/thornet.mp3 (a bass line, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `fuzz` | Fuzz | 0 | 100 | 65 | % | linear |
| 1 | `octave` | Octave | 0 | 100 | 0 | % | linear |
| 2 | `gate` | Gate | 0 | 100 | 15 | % | linear |
| 3 | `tone` | Tone | 0 | 100 | 45 | % | linear |
| 4 | `mids` | Mids | -12 | 6 | -3 | dB | linear |
| 5 | `mix` | Mix | 0 | 100 | 100 | % | linear |
| 6 | `output_db` | Output | -24 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.distortion.thornet" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.distortion.thornet", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 65); /* Fuzz */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: input high-pass, high-gain cubic-knee hard clipping, full-wave rectification for an octave-up blend, crossfaded low/high-pass tone stack with a mid peak, an envelope noise gate and 2x oversampling.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.distortion.thornet to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/thornet/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/clampa/ -->
# Clampa

> Punchy peak compressor: fast peak sensing with a firm knee, a punch control that lets transients through ahead of the gain reduction, and a parallel mix.

- Engine id: `org.sournd.dynamics.clampa`
- Category: Dynamics
- Licence: free (Apache-2.0, in the open framework)
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 0 samples
- Tail: 1 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/clampa.mp3 (a drum loop, default settings)
- Live preview: https://sournd.com/engines/clampa/ (runs the real engine in the browser; test sounds or the user's own file)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `threshold_db` | Threshold | -60 | 0 | -20 | dB | linear |
| 1 | `ratio` | Ratio | 1 | 100 | 5 | x | log |
| 2 | `attack_ms` | Attack | 0.05 | 50 | 3 | ms | log |
| 3 | `release_ms` | Release | 2 | 1000 | 90 | ms | log |
| 4 | `punch_pct` | Punch | 0 | 100 | 40 | % | linear |
| 5 | `makeup_db` | Makeup | 0 | 24 | 0 | dB | linear |
| 6 | `mix` | Mix | 0 | 100 | 100 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.dynamics.clampa" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.dynamics.clampa", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, -20); /* Threshold */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: instant-attack peak detector, log-domain gain computer, dual-envelope transient detection (fast minus slow), parallel wet/dry compression.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.dynamics.clampa to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/clampa/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/attaq/ -->
# Attaq

> Transient shaper: boost or soften the attack of each hit and lift or tuck its sustain, independent of level, with a speed control for tight or loose envelopes and a clip-safe output.

- Engine id: `org.sournd.dynamics.attaq`
- Category: Dynamics
- Licence: free: a closed library, free to use in your plugins, downloaded with no account or email
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0.5 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/attaq.mp3 (a drum loop, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `attack_pct` | Attack | -100 | 100 | 0 | % | linear |
| 1 | `sustain_pct` | Sustain | -100 | 100 | 0 | % | linear |
| 2 | `speed_pct` | Speed | 0 | 100 | 50 | % | linear |
| 3 | `output_db` | Output | -18 | 18 | 0 | dB | linear |
| 4 | `clip` | Clip-safe output | 0 | 1 | 1 | - | linear |
| 5 | `mix` | Mix | 0 | 100 | 100 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.dynamics.attaq" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.dynamics.attaq", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 0); /* Attack */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: stereo-linked peak sensing, three envelope followers whose log-domain differences separate attack from sustain, a smoothed gain in dB, and a soft output ceiling.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.dynamics.attaq to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/attaq/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/ceilwall/ -->
# Ceilwall

> Transparent lookahead brickwall limiter: the gain ramps down before each peak arrives so the output never passes the ceiling, then recovers with a smooth release.

- Engine id: `org.sournd.dynamics.ceilwall`
- Category: Dynamics
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 96 samples
- Tail: 0.05 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/ceilwall.mp3 (a drum loop, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `input_db` | Input | 0 | 24 | 0 | dB | linear |
| 1 | `ceiling_db` | Ceiling | -24 | 0 | -1 | dB | linear |
| 2 | `release_ms` | Release | 1 | 1000 | 60 | ms | log |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.dynamics.ceilwall" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.dynamics.ceilwall", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 0); /* Input */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: stereo-linked peak detection, sliding-window minimum over the lookahead span, box-filter gain ramp, one-pole release.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.dynamics.ceilwall to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/ceilwall/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/hushel/ -->
# Hushel

> Dynamic EQ band: a bell that cuts only while its own band is louder than the threshold. Set it high and narrow-ish for de-essing; the wide control moves the cut from the band to the whole signal.

- Engine id: `org.sournd.dynamics.hushel`
- Category: Dynamics
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 1 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/hushel.mp3 (a drum loop, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `freq_hz` | Frequency | 200 | 16000 | 6500 | Hz | log |
| 1 | `q` | Q | 0.3 | 10 | 2 | x | log |
| 2 | `gain_db` | Static gain | -18 | 18 | 0 | dB | linear |
| 3 | `threshold_db` | Threshold | -60 | 0 | -30 | dB | linear |
| 4 | `ratio` | Ratio | 1 | 20 | 4 | x | log |
| 5 | `range_db` | Range | 0 | 24 | 12 | dB | linear |
| 6 | `attack_ms` | Attack | 0.1 | 50 | 1 | ms | log |
| 7 | `release_ms` | Release | 5 | 1000 | 80 | ms | log |
| 8 | `wide_pct` | Wide | 0 | 100 | 0 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.dynamics.hushel" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.dynamics.hushel", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 6500); /* Frequency */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: constant-peak band-pass sidechain, bell built by adding a scaled band-pass to the dry signal, log-domain threshold/ratio/range gain computer, split-band versus wideband reduction blend.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.dynamics.hushel to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/hushel/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/sluice/ -->
# Sluice

> Gate and downward expander: opens above the threshold, closes below it minus the hysteresis after the hold time, and expands at the chosen ratio down to the range floor.

- Engine id: `org.sournd.dynamics.sluice`
- Category: Dynamics
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0.5 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/sluice.mp3 (a drum loop, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `threshold_db` | Threshold | -80 | 0 | -45 | dB | linear |
| 1 | `hysteresis_db` | Hysteresis | 0 | 20 | 4 | dB | linear |
| 2 | `range_db` | Range | 0 | 90 | 60 | dB | linear |
| 3 | `ratio` | Ratio | 1.5 | 50 | 10 | x | log |
| 4 | `attack_ms` | Attack | 0.05 | 50 | 0.5 | ms | log |
| 5 | `hold_ms` | Hold | 0 | 500 | 30 | ms | linear |
| 6 | `release_ms` | Release | 5 | 2000 | 150 | ms | log |
| 7 | `sidechain_hpf_hz` | Sidechain high-pass | 20 | 2000 | 60 | Hz | log |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.dynamics.sluice" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.dynamics.sluice", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, -45); /* Threshold */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: high-passed linked peak sidechain, two-threshold hysteresis state machine with hold, downward-expansion gain curve with range floor, dB-domain attack/release.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.dynamics.sluice to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/sluice/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/unisill/ -->
# Unisill

> Glue compressor: RMS sensing that blends feed-forward and feedback detection, a soft knee and a release that speeds up on transient material and relaxes on sustained material.

- Engine id: `org.sournd.dynamics.unisill`
- Category: Dynamics
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 2 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/unisill.mp3 (a drum loop, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `threshold_db` | Threshold | -60 | 0 | -18 | dB | linear |
| 1 | `ratio` | Ratio | 1 | 100 | 3 | x | log |
| 2 | `attack_ms` | Attack | 0.1 | 1500 | 10 | ms | log |
| 3 | `release_ms` | Release | 5 | 2000 | 250 | ms | log |
| 4 | `knee_db` | Knee | 0 | 24 | 8 | dB | linear |
| 5 | `feedback_pct` | Feedback blend | 0 | 100 | 35 | % | linear |
| 6 | `auto_release_pct` | Auto release | 0 | 100 | 50 | % | linear |
| 7 | `makeup_db` | Makeup | 0 | 24 | 0 | dB | linear |
| 8 | `mix` | Mix | 0 | 100 | 100 | % | linear |
| 9 | `sidechain_hpf_hz` | Sidechain high-pass | 20 | 500 | 60 | Hz | log |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.dynamics.unisill" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.dynamics.unisill", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, -18); /* Threshold */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: log-domain gain computer with quadratic soft knee, one-pole RMS detection, feed-forward/feedback detector blend, crest-factor program-dependent release.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.dynamics.unisill to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/unisill/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/lancetine/ -->
# Lancetine

> Surgical parametric EQ: 24 dB/oct low and high cuts (off at their extremes), low and high shelves and three fully parametric bells.

- Engine id: `org.sournd.eq.lancetine`
- Category: EQ
- Licence: free (Apache-2.0, in the open framework)
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0.2 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/lancetine.mp3 (a drum loop, default settings)
- Live preview: https://sournd.com/engines/lancetine/ (runs the real engine in the browser; test sounds or the user's own file)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `low_cut_hz` | Low cut | 10 | 2000 | 10 | Hz | log |
| 1 | `low_shelf_hz` | Low shelf freq | 20 | 1000 | 100 | Hz | log |
| 2 | `low_shelf_db` | Low shelf gain | -18 | 24 | 0 | dB | linear |
| 3 | `bell1_hz` | Bell 1 freq | 20 | 20000 | 250 | Hz | log |
| 4 | `bell1_gain_db` | Bell 1 gain | -36 | 24 | 0 | dB | linear |
| 5 | `bell1_q` | Bell 1 Q | 0.1 | 18 | 1 | x | log |
| 6 | `bell2_hz` | Bell 2 freq | 20 | 20000 | 1000 | Hz | log |
| 7 | `bell2_gain_db` | Bell 2 gain | -36 | 24 | 0 | dB | linear |
| 8 | `bell2_q` | Bell 2 Q | 0.1 | 18 | 1 | x | log |
| 9 | `bell3_hz` | Bell 3 freq | 20 | 20000 | 4000 | Hz | log |
| 10 | `bell3_gain_db` | Bell 3 gain | -36 | 24 | 0 | dB | linear |
| 11 | `bell3_q` | Bell 3 Q | 0.1 | 18 | 1 | x | log |
| 12 | `high_shelf_hz` | High shelf freq | 1000 | 20000 | 8000 | Hz | log |
| 13 | `high_shelf_db` | High shelf gain | -18 | 24 | 0 | dB | linear |
| 14 | `high_cut_hz` | High cut | 1000 | 22000 | 22000 | Hz | log |
| 15 | `output_db` | Output | -18 | 18 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.eq.lancetine" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.eq.lancetine", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 10); /* Low cut */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: RBJ cookbook peaking and shelving biquads, cascaded Butterworth high- and low-pass sections, control-rate coefficient updates.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.eq.lancetine to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/lancetine/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/fournel/ -->
# Fournel

> Passive-style program EQ: boost and attenuate the lows at the same frequency for a deep, tight bottom with a dip above it, a broad-to-sharp high boost, a separate high attenuation shelf, and a gentle output stage that thickens as it is driven.

- Engine id: `org.sournd.eq.fournel`
- Category: EQ
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 15 samples
- Tail: 0.3 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/fournel.mp3 (a drum loop, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `low_freq_hz` | Low frequency | 20 | 120 | 60 | Hz | log |
| 1 | `low_boost_db` | Low boost | 0 | 12 | 0 | dB | linear |
| 2 | `low_atten_db` | Low attenuate | 0 | 12 | 0 | dB | linear |
| 3 | `high_freq_hz` | High boost frequency | 3000 | 16000 | 8000 | Hz | log |
| 4 | `high_boost_db` | High boost | 0 | 16 | 0 | dB | linear |
| 5 | `bandwidth_pct` | Bandwidth (sharp to broad) | 0 | 100 | 50 | % | linear |
| 6 | `high_atten_hz` | High attenuate frequency | 5000 | 20000 | 10000 | Hz | log |
| 7 | `high_atten_db` | High attenuate | 0 | 16 | 0 | dB | linear |
| 8 | `drive_pct` | Output drive | 0 | 100 | 0 | % | linear |
| 9 | `output_db` | Output | -12 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.eq.fournel" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.eq.fournel", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 60); /* Low frequency */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design modelling the general behaviour of passive program equalisers mathematically: a steep second-order boost shelf against a shallow first-order attenuation shelf centred higher, an RBJ bell with bandwidth control, a high shelf cut, and a 2x oversampled asymmetric soft saturator blended in by drive.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.eq.fournel to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/fournel/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/glazen/ -->
# Glazen

> Linear-phase parametric EQ: 24 dB/oct low and high cuts, low and high shelves and three bells with no phase shift between frequencies, so boosts and cuts keep transients and parallel paths aligned. Adds a fixed latency the host compensates.

- Engine id: `org.sournd.eq.glazen`
- Category: EQ
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 2303 samples
- Tail: 0.2 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/glazen.mp3 (a drum loop, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `low_cut_hz` | Low cut | 10 | 2000 | 10 | Hz | log |
| 1 | `low_shelf_hz` | Low shelf freq | 20 | 1000 | 100 | Hz | log |
| 2 | `low_shelf_db` | Low shelf gain | -18 | 18 | 0 | dB | linear |
| 3 | `bell1_hz` | Bell 1 freq | 20 | 20000 | 250 | Hz | log |
| 4 | `bell1_gain_db` | Bell 1 gain | -24 | 18 | 0 | dB | linear |
| 5 | `bell1_q` | Bell 1 Q | 0.1 | 12 | 1 | x | log |
| 6 | `bell2_hz` | Bell 2 freq | 20 | 20000 | 1000 | Hz | log |
| 7 | `bell2_gain_db` | Bell 2 gain | -24 | 18 | 0 | dB | linear |
| 8 | `bell2_q` | Bell 2 Q | 0.1 | 12 | 1 | x | log |
| 9 | `bell3_hz` | Bell 3 freq | 20 | 20000 | 4000 | Hz | log |
| 10 | `bell3_gain_db` | Bell 3 gain | -24 | 18 | 0 | dB | linear |
| 11 | `bell3_q` | Bell 3 Q | 0.1 | 12 | 1 | x | log |
| 12 | `high_shelf_hz` | High shelf freq | 1000 | 20000 | 8000 | Hz | log |
| 13 | `high_shelf_db` | High shelf gain | -18 | 18 | 0 | dB | linear |
| 14 | `high_cut_hz` | High cut | 1000 | 22000 | 22000 | Hz | log |
| 15 | `output_db` | Output | -18 | 18 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.eq.glazen" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.eq.glazen", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 10); /* Low cut */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: analog-prototype shelf, bell and Butterworth magnitudes sampled into a zero-phase spectrum, inverse FFT, Blackman windowing, uniformly partitioned overlap-save FFT convolution, and a stepwise background redesign crossfaded in at block boundaries.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.eq.glazen to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/glazen/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/glintfoil/ -->
# Glintfoil

> Harmonic exciter: adds new overtones above a chosen frequency rather than boosting what is there. Harmonics sets the drive, colour leans the new overtones odd (bright, edgy) or even (sweet, open), and amount blends them in.

- Engine id: `org.sournd.eq.glintfoil`
- Category: EQ
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 15 samples
- Tail: 0.05 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/glintfoil.mp3 (a drum loop, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `frequency_hz` | Frequency | 1000 | 12000 | 3000 | Hz | log |
| 1 | `harmonics_pct` | Harmonics | 0 | 100 | 50 | % | linear |
| 2 | `colour_pct` | Colour (odd to even) | -100 | 100 | 0 | % | linear |
| 3 | `amount_pct` | Amount | 0 | 100 | 25 | % | linear |
| 4 | `output_db` | Output | -12 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.eq.glintfoil" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.eq.glintfoil", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 3000); /* Frequency */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: a 24 dB/oct high-pass side band, 2x oversampled odd (hyperbolic tangent) and even (squared tangent) waveshapers, a second high-pass to remove DC and low products, and a latency-matched dry path.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.eq.glintfoil to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/glintfoil/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/gridelle/ -->
# Gridelle

> Thirty-one-band third-octave graphic EQ, 20 Hz to 20 kHz, +-12 dB per band, constant-Q, for room and system voicing and precise tonal balance.

- Engine id: `org.sournd.eq.gridelle`
- Category: EQ
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0.3 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/gridelle.mp3 (a drum loop, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `band_1_db` | 20 Hz | -12 | 12 | 0 | dB | linear |
| 1 | `band_2_db` | 25 Hz | -12 | 12 | 0 | dB | linear |
| 2 | `band_3_db` | 31.5 Hz | -12 | 12 | 0 | dB | linear |
| 3 | `band_4_db` | 40 Hz | -12 | 12 | 0 | dB | linear |
| 4 | `band_5_db` | 50 Hz | -12 | 12 | 0 | dB | linear |
| 5 | `band_6_db` | 63 Hz | -12 | 12 | 0 | dB | linear |
| 6 | `band_7_db` | 80 Hz | -12 | 12 | 0 | dB | linear |
| 7 | `band_8_db` | 100 Hz | -12 | 12 | 0 | dB | linear |
| 8 | `band_9_db` | 125 Hz | -12 | 12 | 0 | dB | linear |
| 9 | `band_10_db` | 160 Hz | -12 | 12 | 0 | dB | linear |
| 10 | `band_11_db` | 200 Hz | -12 | 12 | 0 | dB | linear |
| 11 | `band_12_db` | 250 Hz | -12 | 12 | 0 | dB | linear |
| 12 | `band_13_db` | 315 Hz | -12 | 12 | 0 | dB | linear |
| 13 | `band_14_db` | 400 Hz | -12 | 12 | 0 | dB | linear |
| 14 | `band_15_db` | 500 Hz | -12 | 12 | 0 | dB | linear |
| 15 | `band_16_db` | 630 Hz | -12 | 12 | 0 | dB | linear |
| 16 | `band_17_db` | 800 Hz | -12 | 12 | 0 | dB | linear |
| 17 | `band_18_db` | 1 kHz | -12 | 12 | 0 | dB | linear |
| 18 | `band_19_db` | 1.25 kHz | -12 | 12 | 0 | dB | linear |
| 19 | `band_20_db` | 1.6 kHz | -12 | 12 | 0 | dB | linear |
| 20 | `band_21_db` | 2 kHz | -12 | 12 | 0 | dB | linear |
| 21 | `band_22_db` | 2.5 kHz | -12 | 12 | 0 | dB | linear |
| 22 | `band_23_db` | 3.15 kHz | -12 | 12 | 0 | dB | linear |
| 23 | `band_24_db` | 4 kHz | -12 | 12 | 0 | dB | linear |
| 24 | `band_25_db` | 5 kHz | -12 | 12 | 0 | dB | linear |
| 25 | `band_26_db` | 6.3 kHz | -12 | 12 | 0 | dB | linear |
| 26 | `band_27_db` | 8 kHz | -12 | 12 | 0 | dB | linear |
| 27 | `band_28_db` | 10 kHz | -12 | 12 | 0 | dB | linear |
| 28 | `band_29_db` | 12.5 kHz | -12 | 12 | 0 | dB | linear |
| 29 | `band_30_db` | 16 kHz | -12 | 12 | 0 | dB | linear |
| 30 | `band_31_db` | 20 kHz | -12 | 12 | 0 | dB | linear |
| 31 | `output_db` | Output | -12 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.eq.gridelle" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.eq.gridelle", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 0); /* 20 Hz */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: cascaded constant-Q RBJ peaking biquads on the base-2 third-octave series, bands out of the path at 0 dB.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.eq.gridelle to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/gridelle/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/veer/ -->
# Veer

> Resonant multimode filter that morphs continuously from low-pass through band-pass and high-pass to notch, with input drive and an envelope that sweeps the cutoff with the playing.

- Engine id: `org.sournd.filter.veer`
- Category: Filter
- Licence: free (Apache-2.0, in the open framework)
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0.5 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/veer.mp3 (a bass line, default settings)
- Live preview: https://sournd.com/engines/veer/ (runs the real engine in the browser; test sounds or the user's own file)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `cutoff_hz` | Cutoff | 20 | 20000 | 1200 | Hz | log |
| 1 | `resonance_pct` | Resonance | 0 | 100 | 25 | % | linear |
| 2 | `morph` | Morph | 0 | 3 | 0 | - | linear |
| 3 | `drive_db` | Drive | 0 | 24 | 0 | dB | linear |
| 4 | `env_amount_oct` | Envelope amount | -4 | 4 | 0 | oct | linear |
| 5 | `env_release_ms` | Envelope release | 10 | 2000 | 150 | ms | log |
| 6 | `mix` | Mix | 0 | 100 | 100 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.filter.veer" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.filter.veer", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 1200); /* Cutoff */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: trapezoidal zero-delay-feedback state-variable filter, crossfaded mode outputs, hyperbolic-tangent input drive, envelope-follower cutoff modulation in octaves.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.filter.veer to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/veer/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/kammerl/ -->
# Kammerl

> Tuned comb filter: rings any sound at a note or frequency, from a subtle metallic sheen to a singing, pitched resonance. Flip the polarity for a hollow tone an octave down; damping softens the ring.

- Engine id: `org.sournd.filter.kammerl`
- Category: Filter
- Licence: free: a closed library, free to use in your plugins, downloaded with no account or email
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 0 samples
- Tail: 8 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/kammerl.mp3 (a bass line, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `tuning` | Tuning | 0 | 1 | 0 | - | linear |
| 1 | `note` | Note | 24 | 96 | 57 | note | linear |
| 2 | `fine_cents` | Fine | -100 | 100 | 0 | cents | linear |
| 3 | `freq_hz` | Frequency | 30 | 5000 | 220 | Hz | log |
| 4 | `feedback` | Feedback | 0 | 95 | 70 | % | linear |
| 5 | `feedforward` | Feed-forward | 0 | 100 | 0 | % | linear |
| 6 | `polarity` | Polarity | 0 | 1 | 0 | - | linear |
| 7 | `damping_hz` | Damping | 500 | 20000 | 9000 | Hz | log |
| 8 | `spread_cents` | Spread | 0 | 50 | 0 | cents | linear |
| 9 | `mix` | Mix | 0 | 100 | 100 | % | linear |
| 10 | `output_db` | Output | -24 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.filter.kammerl" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.filter.kammerl", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 0); /* Tuning */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: a fractional-delay feedback comb with a one-pole damper in the loop (its group delay compensated in the tuning), a feed-forward tap, polarity inversion and noise-power normalisation.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.filter.kammerl to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/kammerl/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/pivotta/ -->
# Pivotta

> One-knob performance filter: turn left and a low-pass sweeps down from the top to the deep bass, turn right and a high-pass sweeps up to thin the sound out; the centre is a clean bypass. Resonance adds a peak at the cutoff; Steep switches 12 to 24 dB/oct.

- Engine id: `org.sournd.filter.pivotta`
- Category: Filter
- Licence: free: a closed library, free to use in your plugins, downloaded with no account or email
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0.05 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/pivotta.mp3 (a bass line, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `filter` | Filter | -100 | 100 | 0 | % | linear |
| 1 | `resonance` | Resonance | 0 | 100 | 20 | % | linear |
| 2 | `steep` | Steep | 0 | 1 | 1 | - | linear |
| 3 | `mix` | Mix | 0 | 100 | 100 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.filter.pivotta" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.filter.pivotta", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 0); /* Filter */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design: two cascaded zero-delay-feedback state-variable filters whose mode follows the knob's side, a logarithmic cutoff map per side, a dead zone and a smooth blend around the centre for an exact bypass, and resonance split between the stages.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.filter.pivotta to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/pivotta/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/glottan/ -->
# Glottan

> A vowel filter: three resonant peaks shaped like a voice, slid between two vowels by hand, by an LFO or by how hard the input plays, for talking, wah and growl tones.

- Engine id: `org.sournd.filter.glottan`
- Category: Filter
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0.2 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/glottan.mp3 (a bass line, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `vowel_a` | Vowel A | 0 | 10 | 0 | - | linear |
| 1 | `vowel_b` | Vowel B | 0 | 10 | 3 | - | linear |
| 2 | `morph` | Morph | 0 | 100 | 0 | % | linear |
| 3 | `resonance` | Resonance | 0 | 100 | 60 | % | linear |
| 4 | `shift` | Shift | -24 | 24 | 0 | st | linear |
| 5 | `lfo_rate_hz` | LFO rate | 0.05 | 10 | 0.5 | Hz | log |
| 6 | `lfo_depth` | LFO depth | 0 | 100 | 0 | % | linear |
| 7 | `env_amount` | Envelope amount | -100 | 100 | 0 | % | linear |
| 8 | `env_attack_ms` | Envelope attack | 1 | 200 | 10 | ms | log |
| 9 | `env_release_ms` | Envelope release | 10 | 1000 | 150 | ms | log |
| 10 | `stereo` | Stereo | 0 | 180 | 0 | deg | linear |
| 11 | `mix` | Mix | 0 | 100 | 100 | % | linear |
| 12 | `output_db` | Output | -24 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.filter.glottan" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.filter.glottan", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 0); /* Vowel A */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: three parallel trapezoidal band-pass filters at typical published formant frequencies of eleven vowels, fixed peak gains, geometric interpolation between two vowels, an LFO and input envelope follower on the morph, with makeup gain and a soft shoulder.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.filter.glottan to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/glottan/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/prowl/ -->
# Prowl

> Auto filter: a resonant low-pass, band-pass, high-pass or notch swept by an LFO (free or locked to the song, including sample-and-hold steps) and by how hard you play, with drive in front, grit after and a stereo offset.

- Engine id: `org.sournd.filter.prowl`
- Category: Filter
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0.3 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/prowl.mp3 (a bass line, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `cutoff_hz` | Cutoff | 20 | 20000 | 800 | Hz | log |
| 1 | `resonance_pct` | Resonance | 0 | 100 | 40 | % | linear |
| 2 | `mode` | Mode | 0 | 3 | 0 | - | linear |
| 3 | `drive_db` | Drive | 0 | 36 | 0 | dB | linear |
| 4 | `lfo_amount_oct` | LFO amount | 0 | 6 | 2 | oct | linear |
| 5 | `lfo_shape` | LFO shape | 0 | 5 | 0 | - | linear |
| 6 | `lfo_rate_hz` | LFO rate | 0.02 | 20 | 1 | Hz | log |
| 7 | `sync` | Sync | 0 | 11 | 0 | - | linear |
| 8 | `tempo` | Tempo | 40 | 300 | 120 | bpm | linear |
| 9 | `stereo` | Stereo | 0 | 180 | 0 | deg | linear |
| 10 | `env_amount_oct` | Envelope amount | -6 | 6 | 0 | oct | linear |
| 11 | `env_attack_ms` | Envelope attack | 0.5 | 200 | 5 | ms | log |
| 12 | `env_release_ms` | Envelope release | 10 | 2000 | 200 | ms | log |
| 13 | `distortion` | Distortion | 0 | 100 | 0 | % | linear |
| 14 | `mix` | Mix | 0 | 100 | 100 | % | linear |
| 15 | `output_db` | Output | -24 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.filter.prowl" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.filter.prowl", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 800); /* Cutoff */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: trapezoidal zero-delay-feedback state-variable filter with selectable outputs, octave-scaled cutoff modulation from a tempo-synced LFO and a peak envelope follower, slewed cutoff, hyperbolic-tangent pre-drive and post-distortion.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.filter.prowl to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/prowl/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/rung/ -->
# Rung

> Warm resonant low-pass: four cascaded poles in a feedback loop with soft saturation, a slope control from 6 to 24 dB/oct and bass compensation for the level lost to resonance.

- Engine id: `org.sournd.filter.rung`
- Category: Filter
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0.5 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/rung.mp3 (a bass line, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `cutoff_hz` | Cutoff | 20 | 20000 | 900 | Hz | log |
| 1 | `resonance_pct` | Resonance | 0 | 100 | 30 | % | linear |
| 2 | `drive_db` | Drive | 0 | 24 | 0 | dB | linear |
| 3 | `poles` | Slope | 1 | 4 | 4 | poles | linear |
| 4 | `bass_comp_pct` | Bass compensation | 0 | 100 | 50 | % | linear |
| 5 | `output_db` | Output | -18 | 18 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.filter.rung" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.filter.rung", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 900); /* Cutoff */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: cascaded trapezoidal one-pole sections with global negative feedback solved instantaneously, hyperbolic-tangent loop saturation, tap blending for variable slope, passband gain compensation.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.filter.rung to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/rung/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/treadle/ -->
# Treadle

> Pedal wah: one vocal, resonant peak rocked from heel to toe by the position control (map it to an expression pedal), or pushed by your playing for auto-wah. Hard notes squash the peak into a throaty honk.

- Engine id: `org.sournd.filter.treadle`
- Category: Filter
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0.2 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/treadle.mp3 (a bass line, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `position` | Position | 0 | 100 | 50 | % | linear |
| 1 | `env_amount` | Auto amount | -100 | 100 | 0 | % | linear |
| 2 | `sensitivity_db` | Sensitivity | -24 | 24 | 0 | dB | linear |
| 3 | `env_attack_ms` | Auto attack | 1 | 100 | 8 | ms | log |
| 4 | `env_release_ms` | Auto release | 20 | 1000 | 180 | ms | log |
| 5 | `heel_hz` | Heel | 200 | 800 | 380 | Hz | log |
| 6 | `toe_hz` | Toe | 1000 | 4000 | 2200 | Hz | log |
| 7 | `resonance_pct` | Resonance | 0 | 100 | 60 | % | linear |
| 8 | `voice` | Voice | 0 | 100 | 50 | % | linear |
| 9 | `mix` | Mix | 0 | 100 | 100 | % | linear |
| 10 | `output_db` | Output | -24 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.filter.treadle" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.filter.treadle", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 50); /* Position */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: a trapezoidal state-variable resonator with soft saturation on its band integrator, position-dependent Q, a log-frequency sweep between two corner frequencies, an envelope follower on the sweep and a low-pass blend under the peak.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.filter.treadle to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/treadle/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/chorvane/ -->
# Chorvane

> Lush three-voice ensemble chorus with stereo spread and a soft top end.

- Engine id: `org.sournd.modulation.chorvane`
- Category: Modulation
- Licence: free (Apache-2.0, in the open framework)
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0.1 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/chorvane.mp3 (plucked chords, default settings)
- Live preview: https://sournd.com/engines/chorvane/ (runs the real engine in the browser; test sounds or the user's own file)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `rate_hz` | Rate | 0.05 | 25 | 0.5 | Hz | log |
| 1 | `depth` | Depth | 0 | 100 | 55 | % | linear |
| 2 | `delay_ms` | Delay | 4 | 30 | 11 | ms | linear |
| 3 | `spread` | Spread | 0 | 100 | 75 | % | linear |
| 4 | `tone` | Tone | 0 | 100 | 70 | % | linear |
| 5 | `mix` | Mix | 0 | 100 | 45 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.modulation.chorvane" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.modulation.chorvane", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 0.5); /* Rate */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: three delay voices with 120-degree spaced slow LFOs, a light faster vibrato layer, staggered base delays, stereo LFO offset, Hermite-interpolated reads and a one-pole wet low-pass.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.modulation.chorvane to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/chorvane/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/eddyturn/ -->
# Eddyturn

> Eight-stage phaser with staggered notches, feedback for vocal sweeps and a stereo offset that turns it into a slow spin.

- Engine id: `org.sournd.modulation.eddyturn`
- Category: Modulation
- Licence: free: a closed library, free to use in your plugins, downloaded with no account or email
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 0 samples
- Tail: 2.5 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/eddyturn.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `rate_hz` | Rate | 0.02 | 25 | 0.35 | Hz | log |
| 1 | `depth` | Depth | 0 | 100 | 70 | % | linear |
| 2 | `center_hz` | Center | 150 | 4000 | 800 | Hz | log |
| 3 | `feedback` | Feedback | -85 | 85 | 35 | % | linear |
| 4 | `stereo` | Stereo | 0 | 180 | 90 | deg | linear |
| 5 | `mix` | Mix | 0 | 100 | 50 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.modulation.eddyturn" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.modulation.eddyturn", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 0.35); /* Rate */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: cascaded first-order all-pass stages with staggered break frequencies, exponential LFO sweep, tanh-limited feedback, stereo LFO phase offset and a dry/wet blend.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.modulation.eddyturn to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/eddyturn/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/tremola/ -->
# Tremola

> Tremolo that morphs from a smooth throb to a choppy pulse; widen the stereo phase for auto-pan.

- Engine id: `org.sournd.modulation.tremola`
- Category: Modulation
- Licence: free: a closed library, free to use in your plugins, downloaded with no account or email
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/tremola.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `rate_hz` | Rate | 0.1 | 25 | 4 | Hz | log |
| 1 | `depth` | Depth | 0 | 100 | 50 | % | linear |
| 2 | `shape` | Shape | 0 | 100 | 25 | % | linear |
| 3 | `stereo_phase` | Stereo phase | 0 | 180 | 0 | deg | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.modulation.tremola" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.modulation.tremola", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 4); /* Rate */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: an LFO morphing from sine to a tanh-rounded square, gain modulation between unity and one minus depth, and a per-channel LFO phase offset for panning.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.modulation.tremola to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/tremola/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/bellrung/ -->
# Bellrung

> Ring modulator: replaces each note with metallic sum and difference tones, from bell-like shimmer to harsh clangour, with an optional wobble on the carrier.

- Engine id: `org.sournd.modulation.bellrung`
- Category: Modulation
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/bellrung.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `carrier_hz` | Carrier | 20 | 5000 | 440 | Hz | log |
| 1 | `lfo_rate_hz` | Wobble rate | 0.05 | 10 | 0.5 | Hz | log |
| 2 | `lfo_depth` | Wobble | 0 | 100 | 0 | % | linear |
| 3 | `shape` | Shape | 0 | 100 | 0 | % | linear |
| 4 | `stereo` | Stereo | 0 | 180 | 0 | deg | linear |
| 5 | `mix` | Mix | 0 | 100 | 100 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.modulation.bellrung" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.modulation.bellrung", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 440); /* Carrier */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: four-quadrant multiplication by an internal carrier oscillator that morphs from sine to a tanh-rounded square, exponential LFO modulation of the carrier frequency, and a stereo carrier phase offset.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.modulation.bellrung to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/bellrung/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/ebb/ -->
# Ebb

> Harmonic tremolo: lows and highs pulse in opposite phase, so the tone rocks between warm and bright with a subtle phasey sway instead of a plain volume throb.

- Engine id: `org.sournd.modulation.ebb`
- Category: Modulation
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0.05 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/ebb.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `rate_hz` | Rate | 0.1 | 15 | 4 | Hz | log |
| 1 | `depth` | Depth | 0 | 100 | 70 | % | linear |
| 2 | `crossover_hz` | Crossover | 150 | 3000 | 600 | Hz | log |
| 3 | `shape` | Shape | 0 | 100 | 0 | % | linear |
| 4 | `stereo` | Stereo | 0 | 180 | 0 | deg | linear |
| 5 | `mix` | Mix | 0 | 100 | 100 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.modulation.ebb" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.modulation.ebb", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 4); /* Rate */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: a fourth-order complementary crossover, one LFO morphing from sine to a tanh-rounded square applied in opposite phase to the two bands, and a per-channel LFO phase offset.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.modulation.ebb to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/ebb/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/gyrecast/ -->
# Gyrecast

> Rotating speaker: a spinning treble horn and bass drum, slow or fast, that speed up and slow down with real weight, heard by two microphones for a wide swirling stereo image.

- Engine id: `org.sournd.modulation.gyrecast`
- Category: Modulation
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0.05 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/gyrecast.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `speed` | Speed | 0 | 1 | 0 | - | linear |
| 1 | `horn_slow_hz` | Horn slow | 0.2 | 3 | 0.8 | Hz | log |
| 2 | `horn_fast_hz` | Horn fast | 3 | 10 | 6.8 | Hz | log |
| 3 | `drum_slow_hz` | Drum slow | 0.1 | 3 | 0.7 | Hz | log |
| 4 | `drum_fast_hz` | Drum fast | 2 | 10 | 5.9 | Hz | log |
| 5 | `horn_ramp_s` | Horn ramp | 0.05 | 5 | 0.8 | s | log |
| 6 | `drum_ramp_s` | Drum ramp | 0.1 | 10 | 3.5 | s | log |
| 7 | `crossover_hz` | Crossover | 300 | 2000 | 800 | Hz | log |
| 8 | `depth` | Depth | 0 | 100 | 80 | % | linear |
| 9 | `mic_spread` | Mic spread | 0 | 180 | 120 | deg | linear |
| 10 | `mix` | Mix | 0 | 100 | 100 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.modulation.gyrecast" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.modulation.gyrecast", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 0); /* Speed */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: a fourth-order complementary crossover into two rotor paths, one-pole speed inertia per rotor, Doppler from cosine-swept Hermite delay reads, directional amplitude modulation, and two virtual microphones at a spread angle.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.modulation.gyrecast to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/gyrecast/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/jetwake/ -->
# Jetwake

> Jet-sweep flanger with positive or negative feedback and a near through-zero mode that sweeps the echo across the dry signal.

- Engine id: `org.sournd.modulation.jetwake`
- Category: Modulation
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 64 samples
- Tail: 2 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/jetwake.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `rate_hz` | Rate | 0.02 | 25 | 0.2 | Hz | log |
| 1 | `depth` | Depth | 0 | 100 | 70 | % | linear |
| 2 | `manual_ms` | Manual | 0.1 | 8 | 2 | ms | log |
| 3 | `feedback` | Feedback | -90 | 90 | 50 | % | linear |
| 4 | `through_zero` | Through zero | 0 | 1 | 0 | - | linear |
| 5 | `mix` | Mix | 0 | 100 | 50 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.modulation.jetwake" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.modulation.jetwake", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 0.2); /* Rate */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: a short LFO-swept delay with Hermite reads, tanh-limited feedback of either polarity, a fixed dry pre-delay enabling a through-zero sweep, and a dry/wet blend.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.modulation.jetwake to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/jetwake/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/photocel/ -->
# Photocel

> Lopsided, throbbing four-stage phase shifter swept by a lamp and light cell: chorus mode for liquid, pulsing notches, vibrato mode for a seasick pitch wobble.

- Engine id: `org.sournd.modulation.photocel`
- Category: Modulation
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0.05 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/photocel.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `rate_hz` | Rate | 0.1 | 12 | 1 | Hz | log |
| 1 | `depth` | Depth | 0 | 100 | 70 | % | linear |
| 2 | `center_hz` | Center | 150 | 1500 | 450 | Hz | log |
| 3 | `lag` | Lag | 0 | 100 | 50 | % | linear |
| 4 | `mode` | Mode | 0 | 1 | 0 | - | linear |
| 5 | `stereo` | Stereo | 0 | 180 | 0 | deg | linear |
| 6 | `mix` | Mix | 0 | 100 | 100 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.modulation.photocel" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.modulation.photocel", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 1); /* Rate */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: four first-order all-pass stages at widely staggered break frequencies, an LFO-driven lamp followed by an asymmetric one-pole light-cell model, exponential frequency mapping, and a chorus/vibrato blend of dry and phase-shifted signal.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.modulation.photocel to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/photocel/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/stairwhorl/ -->
# Stairwhorl

> Endless sweep: phaser or flanger notches that keep rising, or keep falling, forever without ever resetting.

- Engine id: `org.sournd.modulation.stairwhorl`
- Category: Modulation
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0.1 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/stairwhorl.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `rate_hz` | Rate | 0.01 | 2 | 0.08 | Hz | log |
| 1 | `direction` | Direction | 0 | 1 | 1 | - | linear |
| 2 | `mode` | Mode | 0 | 1 | 0 | - | linear |
| 3 | `range_oct` | Range | 2 | 8 | 6 | oct | linear |
| 4 | `stereo` | Stereo | 0 | 100 | 25 | % | linear |
| 5 | `mix` | Mix | 0 | 100 | 50 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.modulation.stairwhorl" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.modulation.stairwhorl", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 0.08); /* Rate */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: several exponentially swept phaser and flanger voices with evenly staggered start points, raised-cosine crossfade windows that sum to a constant (a Shepard-style illusion), Hermite-interpolated delay reads and a stereo sweep offset.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.modulation.stairwhorl to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/stairwhorl/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/lucento/ -->
# Lucento

> Clean digital echo: every repeat an exact copy, trimmed by low and high cut in the loop. Set the time in milliseconds or lock it to a note of the host tempo (the Tempo control stands in without one). Changing the time crossfades to the new echo instead of bending its pitch. Offset delays the right side for width. Sync: 0 = free, 1 = 1/32, 2 = 1/16T, 3 = 1/16, 4 = 1/16D, 5 = 1/8T, 6 = 1/8, 7 = 1/8D, 8 = 1/4T, 9 = 1/4, 10 = 1/4D, 11 = 1/2, 12 = 1/2D, 13 = 1 bar.

- Engine id: `org.sournd.delay.lucento`
- Category: Delay
- Licence: free (Apache-2.0, in the open framework)
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 0 samples
- Tail: 60 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/lucento.mp3 (plucked chords, default settings)
- Live preview: https://sournd.com/engines/lucento/ (runs the real engine in the browser; test sounds or the user's own file)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `time_ms` | Time | 1 | 4000 | 375 | ms | log |
| 1 | `sync` | Sync | 0 | 13 | 0 | - | linear |
| 2 | `feedback` | Feedback | 0 | 0.98 | 0.4 | - | linear |
| 3 | `low_cut_hz` | Low cut | 20 | 2000 | 40 | Hz | log |
| 4 | `high_cut_hz` | High cut | 1000 | 20000 | 12000 | Hz | log |
| 5 | `offset_ms` | Offset | 0 | 100 | 0 | ms | linear |
| 6 | `tempo` | Tempo | 40 | 300 | 120 | bpm | linear |
| 7 | `mix` | Mix | 0 | 100 | 30 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.delay.lucento" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.delay.lucento", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 375); /* Time */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design: a linear-interpolated delay line per channel read by a crossfading tap (equal-power switch between old and new read points on any time change), 12 dB/oct high-pass and low-pass inside the feedback loop, tempo-derived note times and a fixed right-channel offset.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.delay.lucento to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/lucento/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/driftel/ -->
# Driftel

> Warm, wandering echo. Repeats bend in pitch, soften and saturate as they fade.

- Engine id: `org.sournd.delay.driftel`
- Category: Delay
- Licence: free: a closed library, free to use in your plugins, downloaded with no account or email
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 0 samples
- Tail: 60 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/driftel.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `time_ms` | Time | 20 | 1000 | 340 | ms | log |
| 1 | `feedback` | Feedback | 0 | 0.98 | 0.45 | - | linear |
| 2 | `wow` | Wow | 0 | 1 | 0.3 | - | linear |
| 3 | `flutter` | Flutter | 0 | 1 | 0.25 | - | linear |
| 4 | `drive` | Drive | 0 | 1 | 0.35 | - | linear |
| 5 | `tone_hz` | Tone | 800 | 12000 | 3800 | Hz | log |
| 6 | `low_cut_hz` | Low cut | 20 | 800 | 110 | Hz | log |
| 7 | `spread` | Spread | 0 | 1 | 0.3 | - | linear |
| 8 | `mix` | Mix | 0 | 100 | 30 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.delay.driftel" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.delay.driftel", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 340); /* Time */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design: modulated fractional delay (sinusoidal wow with band-limited random drift, sinusoidal flutter with jitter), soft tanh saturation on record, two-pole low-pass tone and one-pole low cut on each repeat inside the feedback loop.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.delay.driftel to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/driftel/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/backwash/ -->
# Backwash

> Backwards echo: every chunk of time is played back reversed during the next one, so notes swell in from nothing and cut off. Feedback flips the repeats back and forth. Fade sets how soft each chunk's edges are. Sync: 0 = free, 1..13 = 1/32 to 1 bar (chunks longer than 2 s are held at 2 s).

- Engine id: `org.sournd.delay.backwash`
- Category: Delay
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 60 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/backwash.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `time_ms` | Time | 50 | 2000 | 500 | ms | log |
| 1 | `sync` | Sync | 0 | 13 | 0 | - | linear |
| 2 | `feedback` | Feedback | 0 | 0.9 | 0.3 | - | linear |
| 3 | `fade` | Fade | 1 | 50 | 10 | % | linear |
| 4 | `tone_hz` | Tone | 1000 | 20000 | 12000 | Hz | log |
| 5 | `tempo` | Tempo | 40 | 300 | 120 | bpm | linear |
| 6 | `mix` | Mix | 0 | 100 | 50 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.delay.backwash" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.delay.backwash", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 500); /* Time */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design: a delay line whose read delay grows at twice real time across each chunk (so the previous chunk is read backwards), chunk length latched at each chunk start, a raised-sine edge window, and a one-pole low-pass on the feedback path.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.delay.backwash to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/backwash/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/bucketta/ -->
# Bucketta

> Dark, gritty analogue-style echo. Short times stay bright, long times get murky because the virtual clock slows down; a compander makes hiss and grit swell and fade with the playing; turning the time bends the repeats in pitch, and the glide sets how fast. Sync as the other echoes: 0 = free, 1..13 = 1/32 to 1 bar.

- Engine id: `org.sournd.delay.bucketta`
- Category: Delay
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 60 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/bucketta.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `time_ms` | Time | 20 | 800 | 300 | ms | log |
| 1 | `sync` | Sync | 0 | 13 | 0 | - | linear |
| 2 | `feedback` | Feedback | 0 | 0.95 | 0.4 | - | linear |
| 3 | `glide_ms` | Glide | 10 | 2000 | 250 | ms | log |
| 4 | `mod_depth` | Mod depth | 0 | 1 | 0.15 | - | linear |
| 5 | `mod_rate_hz` | Mod rate | 0.05 | 8 | 0.6 | Hz | log |
| 6 | `grit` | Grit | 0 | 1 | 0.3 | - | linear |
| 7 | `bandwidth` | Bandwidth | 0.5 | 2 | 1 | x | log |
| 8 | `tempo` | Tempo | 40 | 300 | 120 | bpm | linear |
| 9 | `mix` | Mix | 0 | 100 | 35 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.delay.bucketta" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.delay.bucketta", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 300); /* Time */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design: a fractional delay line whose read point glides (one-pole) toward the set time, clock-dependent two-pole pre and post low-pass filters (cutoff proportional to the stage count over the delay time), a 2:1 envelope compander around the line with noise injected inside it, soft saturation on record and a sinusoidal clock wobble.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.delay.bucketta to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/bucketta/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/graniel/ -->
# Graniel

> Granular echo: the delayed sound is cut into short grains, scattered in time by Spray, pitched and panned, and layered at the chosen density, from a shimmering cloud to a stuttering glitch. Feedback feeds the cloud back into itself; Freeze (on above half) stops recording so the grains keep playing the held sound. Sync: 0 = free, 1..13 = 1/32 to 1 bar.

- Engine id: `org.sournd.delay.graniel`
- Category: Delay
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 60 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/graniel.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `time_ms` | Time | 10 | 2000 | 250 | ms | log |
| 1 | `sync` | Sync | 0 | 13 | 0 | - | linear |
| 2 | `grain_ms` | Grain | 10 | 500 | 80 | ms | log |
| 3 | `density` | Density | 1 | 80 | 20 | Hz | log |
| 4 | `pitch` | Pitch | -24 | 24 | 0 | st | linear |
| 5 | `pitch_random` | Pitch random | 0 | 12 | 0 | st | linear |
| 6 | `spray_ms` | Spray | 0 | 1000 | 40 | ms | linear |
| 7 | `feedback` | Feedback | 0 | 0.9 | 0.2 | - | linear |
| 8 | `freeze` | Freeze | 0 | 1 | 0 | - | linear |
| 9 | `width` | Width | 0 | 1 | 0.7 | - | linear |
| 10 | `tempo` | Tempo | 40 | 300 | 120 | bpm | linear |
| 11 | `mix` | Mix | 0 | 100 | 40 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.delay.graniel" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.delay.graniel", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 250); /* Time */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design: a stereo delay line read by up to 24 overlapping raised-cosine grains scheduled at a jittered rate, each with a random extra delay, a resampling slide for pitch (clamped inside the recorded span), random pan within a width, density-normalised output, a low-passed feedback path and a record-enable freeze.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.delay.graniel to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/graniel/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/volleto/ -->
# Volleto

> Stereo ping-pong. Repeats bounce left and right, thinning and blurring into a wash as they go.

- Engine id: `org.sournd.delay.volleto`
- Category: Delay
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 60 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/volleto.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `time_ms` | Time | 20 | 800 | 300 | ms | log |
| 1 | `skew` | Skew | -0.5 | 0.5 | 0 | - | linear |
| 2 | `feedback` | Feedback | 0 | 0.98 | 0.5 | - | linear |
| 3 | `diffusion` | Diffusion | 0 | 1 | 0.25 | - | linear |
| 4 | `low_cut_hz` | Low cut | 20 | 1000 | 150 | Hz | log |
| 5 | `high_cut_hz` | High cut | 1000 | 16000 | 6000 | Hz | log |
| 6 | `width` | Width | 0 | 1 | 1 | - | linear |
| 7 | `mix` | Mix | 0 | 100 | 30 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.delay.volleto" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.delay.volleto", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 300); /* Time */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design: cross-coupled pair of fractional delay lines (left feeds right feeds left) with per-crossing feedback gain, 12 dB/oct high and low cut, and two all-pass diffusers per side whose delay is compensated so echo times stay exact.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.delay.volleto to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/volleto/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/roomette/ -->
# Roomette

> A real-sounding room: distinct early reflections that place a sound at a distance, with a short soft tail.

- Engine id: `org.sournd.reverb.roomette`
- Category: Reverb
- Licence: free (Apache-2.0, in the open framework)
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 0 samples
- Tail: 5 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/roomette.mp3 (plucked chords, default settings)
- Live preview: https://sournd.com/engines/roomette/ (runs the real engine in the browser; test sounds or the user's own file)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `size` | Size | 0 | 1 | 0.35 | - | linear |
| 1 | `distance` | Distance | 0 | 1 | 0.35 | - | linear |
| 2 | `absorption` | Absorption | 0 | 1 | 0.4 | - | linear |
| 3 | `decay_s` | Decay | 0.05 | 3 | 0.6 | s | log |
| 4 | `tail` | Tail | 0 | 1 | 0.5 | - | linear |
| 5 | `width` | Width | 0 | 1 | 1 | - | linear |
| 6 | `mix` | Mix | 0 | 100 | 30 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.reverb.roomette" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.reverb.roomette", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 0.35); /* Size */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design: per-ear image-source model of a box room (24 first and second-order reflections with 1/r spreading and per-bounce absorption), order-dependent air/wall filtering, and a short damped four-line Householder feedback network tail.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.reverb.roomette to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/roomette/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/coilette/ -->
# Coilette

> Spring reverb: a boingy, splashy tank whose echoes chirp downward as the lows lag behind the highs. Tension tightens the springs (shorter, brighter, less chirp); Drip is how hard transients shake the tank; Springs sets how many are in it.

- Engine id: `org.sournd.reverb.coilette`
- Category: Reverb
- Licence: free: a closed library, free to use in your plugins, downloaded with no account or email
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 0 samples
- Tail: 14 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/coilette.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `decay_s` | Decay | 0.5 | 8 | 2.5 | s | log |
| 1 | `tension` | Tension | 0 | 1 | 0.5 | - | linear |
| 2 | `springs` | Springs | 1 | 3 | 3 | - | linear |
| 3 | `drip` | Drip | 0 | 1 | 0.4 | - | linear |
| 4 | `tone_hz` | Tone | 1500 | 10000 | 4500 | Hz | log |
| 5 | `low_cut_hz` | Low cut | 40 | 600 | 120 | Hz | log |
| 6 | `width` | Width | 0 | 1 | 1 | - | linear |
| 7 | `mix` | Mix | 0 | 100 | 30 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.reverb.coilette" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.reverb.coilette", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 2.5); /* Decay */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design: per spring, a delay loop through forty first-order all-pass sections with a shared negative coefficient (frequency-dependent group delay, so dispersion grows with every round trip), one-pole damping and low cut inside the loop, RT60-derived loop gain, band-limited mono input, an onset detector that injects extra high-passed energy and kicks a decaying sinusoidal wobble of the loop delay, and fixed stereo placement per spring.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.reverb.coilette to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/coilette/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/aulana/ -->
# Aulana

> Lush, slowly moving hall. Separate low and high decay let the tail stay warm and dark or open and airy.

- Engine id: `org.sournd.reverb.aulana`
- Category: Reverb
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 46 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/aulana.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `predelay_ms` | Pre-delay | 0 | 400 | 24 | ms | linear |
| 1 | `size` | Size | 0 | 1 | 0.65 | - | linear |
| 2 | `decay_s` | Decay | 0.3 | 10 | 2.8 | s | log |
| 3 | `low_decay` | Low decay | 0.5 | 3 | 1.2 | x | linear |
| 4 | `high_decay` | High decay | 0.02 | 2 | 0.45 | x | linear |
| 5 | `damping_hz` | Damping | 1000 | 12000 | 4500 | Hz | log |
| 6 | `diffusion` | Diffusion | 0 | 1 | 0.7 | - | linear |
| 7 | `mod_depth` | Mod depth | 0 | 1 | 0.4 | - | linear |
| 8 | `mod_rate_hz` | Mod rate | 0.05 | 4 | 0.5 | Hz | log |
| 9 | `width` | Width | 0 | 1 | 1 | - | linear |
| 10 | `mix` | Mix | 0 | 100 | 30 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.reverb.aulana" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.reverb.aulana", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 24); /* Pre-delay */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design: stereo all-pass input diffusion feeding an eight-line feedback delay network with a Hadamard mixing matrix, per-line RT60 gains with first-order low/high shelving for frequency-dependent decay, and independent sinusoidal delay modulation.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.reverb.aulana to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/aulana/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/blossa/ -->
# Blossa

> Reverb that blooms: it swells in behind notes, steps aside while you play, and can be gated shut for a hard stop.

- Engine id: `org.sournd.reverb.blossa`
- Category: Reverb
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 19 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/blossa.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `predelay_ms` | Pre-delay | 0 | 400 | 20 | ms | linear |
| 1 | `decay_s` | Decay | 0.2 | 12 | 3.5 | s | log |
| 2 | `damping_hz` | Damping | 1000 | 16000 | 5500 | Hz | log |
| 3 | `swell_ms` | Swell | 0 | 2000 | 300 | ms | linear |
| 4 | `duck` | Duck | 0 | 1 | 0.25 | - | linear |
| 5 | `gate` | Gate | 0 | 1 | 0 | - | linear |
| 6 | `threshold_db` | Gate threshold | -60 | 0 | -30 | dB | linear |
| 7 | `hold_ms` | Gate hold | 0 | 1000 | 180 | ms | linear |
| 8 | `release_ms` | Gate release | 5 | 1000 | 120 | ms | log |
| 9 | `width` | Width | 0 | 1 | 1 | - | linear |
| 10 | `mix` | Mix | 0 | 100 | 35 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.reverb.blossa" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.reverb.blossa", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 20); /* Pre-delay */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design: fast and slow envelope followers drive a swell ratio on the reverb input and a ducking gain on the wet, a separate fast detector drives a hold/release gate, around a damped parallel comb bank with series all-pass diffusion per channel.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.reverb.blossa to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/blossa/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/shimmerhall/ -->
# Shimmerhall

> Shimmer reverb: a long, gently moving space whose tail is pitch-shifted and fed back into itself, so held notes bloom into a bright halo an octave or a fifth above. Shimmer sets how much climbs. Interval: 0 = octave up, 1 = fifth up, 2 = octave and fifth, 3 = octave and octave-plus-fifth, 4 = octave down and up.

- Engine id: `org.sournd.reverb.shimmerhall`
- Category: Reverb
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 45 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/shimmerhall.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `predelay_ms` | Pre-delay | 0 | 300 | 20 | ms | linear |
| 1 | `decay_s` | Decay | 1 | 20 | 6 | s | log |
| 2 | `size` | Size | 0 | 1 | 0.7 | - | linear |
| 3 | `damping_hz` | Damping | 1500 | 16000 | 7000 | Hz | log |
| 4 | `interval` | Interval | 0 | 4 | 0 | - | linear |
| 5 | `shimmer` | Shimmer | 0 | 100 | 40 | % | linear |
| 6 | `mod_depth` | Mod depth | 0 | 1 | 0.4 | - | linear |
| 7 | `width` | Width | 0 | 1 | 1 | - | linear |
| 8 | `mix` | Mix | 0 | 100 | 35 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.reverb.shimmerhall" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.reverb.shimmerhall", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 20); /* Pre-delay */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design: pre-delay and three all-pass input diffusers per channel into an eight-line Hadamard feedback delay network with in-loop all-passes, low shelf and damping; its output passes through one or two crossfading two-head delay-line pitch shifters and a band-pass, and returns to the network input at the shimmer level.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.reverb.shimmerhall to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/shimmerhall/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/tesselle/ -->
# Tesselle

> Bright, dense sheet of reverb that builds almost instantly. Smooth on drums and vocals.

- Engine id: `org.sournd.reverb.tesselle`
- Category: Reverb
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 14 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/tesselle.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `predelay_ms` | Pre-delay | 0 | 400 | 0 | ms | linear |
| 1 | `decay_s` | Decay | 0.2 | 8 | 1.8 | s | log |
| 2 | `size` | Size | 0 | 1 | 0.5 | - | linear |
| 3 | `damping_hz` | Damping | 1000 | 16000 | 9000 | Hz | log |
| 4 | `bandwidth_hz` | Bandwidth | 1000 | 20000 | 13000 | Hz | log |
| 5 | `density` | Density | 0 | 1 | 0.8 | - | linear |
| 6 | `mod_depth` | Mod depth | 0 | 1 | 0.3 | - | linear |
| 7 | `low_cut_hz` | Low cut | 20 | 500 | 90 | Hz | log |
| 8 | `width` | Width | 0 | 1 | 1 | - | linear |
| 9 | `mix` | Mix | 0 | 100 | 25 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.reverb.tesselle" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.reverb.tesselle", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 0); /* Pre-delay */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design: band-limited input into series all-pass diffusers, then a ring of four branches each built from a modulated all-pass, delay, one-pole damping, a second all-pass and delay, with fourteen signed output taps across the ring.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.reverb.tesselle to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/tesselle/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/octunder/ -->
# Octunder

> Analogue-style sub octaves: square-wave subs one and two octaves down that answer instantly and follow your dynamics, rounded by a tone control. Single notes only, like the circuits it is modelled on in spirit.

- Engine id: `org.sournd.pitch.octunder`
- Category: Pitch
- Licence: free (Apache-2.0, in the open framework)
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 1 samples
- Tail: 0.6 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/octunder.mp3 (plucked chords, default settings)
- Live preview: https://sournd.com/engines/octunder/ (runs the real engine in the browser; test sounds or the user's own file)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `sub_level` | Sub | 0 | 100 | 80 | % | linear |
| 1 | `sub2_level` | Sub 2 | 0 | 100 | 0 | % | linear |
| 2 | `dry_level` | Dry | 0 | 100 | 100 | % | linear |
| 3 | `tone_hz` | Tone | 60 | 12000 | 3000 | Hz | log |
| 4 | `tracking` | Tracking | 0 | 100 | 60 | % | linear |
| 5 | `gate_db` | Gate | -80 | -20 | -60 | dB | linear |
| 6 | `release_ms` | Release | 10 | 500 | 60 | ms | log |
| 7 | `output_db` | Output | -24 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.pitch.octunder" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.pitch.octunder", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 80); /* Sub */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: a pitch-tracking low-pass (YIN tracker) ahead of a Schmitt trigger with envelope-relative hysteresis, two toggle flip-flops as frequency dividers with polyBLEP band-limited edges, envelope scaling with a soft gate and a two-pole tone filter. Voicing informed by our own measurements of analogue-style octave pedals.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.pitch.octunder to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/octunder/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/swoopline/ -->
# Swoopline

> Octave up straight from the waveform: glassy and clean on one side, ringing and fuzzy on the other, with drive, a gate that trims the tails and a tone control. No latency.

- Engine id: `org.sournd.pitch.swoopline`
- Category: Pitch
- Licence: free: a closed library, free to use in your plugins, downloaded with no account or email
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0.1 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/swoopline.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `up_level` | Octave | 0 | 100 | 80 | % | linear |
| 1 | `dry_level` | Dry | 0 | 100 | 100 | % | linear |
| 2 | `character` | Character | 0 | 100 | 40 | % | linear |
| 3 | `focus_hz` | Focus | 100 | 3000 | 800 | Hz | log |
| 4 | `drive_db` | Drive | 0 | 30 | 6 | dB | linear |
| 5 | `tone_hz` | Tone | 500 | 16000 | 5000 | Hz | log |
| 6 | `gate_db` | Gate | -80 | -20 | -50 | dB | linear |
| 7 | `output_db` | Output | -24 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.pitch.swoopline" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.pitch.swoopline", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 80); /* Octave */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: a focus low-pass, an all-pass Hilbert pair for the analytic signal and phase doubling, full-wave rectification with DC blocking, tanh drive, a 2:1 downward expander below a threshold and a two-pole tone filter. Character informed by our own measurements of rectifier-style octave-up circuits (period kept, tails gated, upper harmonics lifted).

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.pitch.swoopline to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/swoopline/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/northnote/ -->
# Northnote

> Pitch correction for voices and single-note lines: pulls every note to the nearest note of your key and scale (chromatic, major, minor, pentatonics or your own 12-note set) at a speed from natural to a hard snap at 0 ms, with humanise to leave held notes and vibrato alone.

- Engine id: `org.sournd.pitch.northnote`
- Category: Pitch
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 1024 samples
- Tail: 0.1 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/northnote.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `key` | Key | 0 | 11 | 0 | - | linear |
| 1 | `scale` | Scale | 0 | 5 | 0 | - | linear |
| 2 | `note_c` | C | 0 | 1 | 1 | - | linear |
| 3 | `note_cs` | C# | 0 | 1 | 1 | - | linear |
| 4 | `note_d` | D | 0 | 1 | 1 | - | linear |
| 5 | `note_ds` | D# | 0 | 1 | 1 | - | linear |
| 6 | `note_e` | E | 0 | 1 | 1 | - | linear |
| 7 | `note_f` | F | 0 | 1 | 1 | - | linear |
| 8 | `note_fs` | F# | 0 | 1 | 1 | - | linear |
| 9 | `note_g` | G | 0 | 1 | 1 | - | linear |
| 10 | `note_gs` | G# | 0 | 1 | 1 | - | linear |
| 11 | `note_a` | A | 0 | 1 | 1 | - | linear |
| 12 | `note_as` | A# | 0 | 1 | 1 | - | linear |
| 13 | `note_b` | B | 0 | 1 | 1 | - | linear |
| 14 | `retune_ms` | Retune | 0 | 400 | 40 | ms | linear |
| 15 | `humanise` | Humanise | 0 | 100 | 0 | % | linear |
| 16 | `reference_hz` | Reference | 415 | 466 | 440 | Hz | linear |
| 17 | `amount` | Amount | 0 | 100 | 100 | % | linear |
| 18 | `formant` | Formant keep | 0 | 1 | 1 | - | linear |
| 19 | `mix` | Mix | 0 | 100 | 100 | % | linear |
| 20 | `output_db` | Output | -24 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.pitch.northnote" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.pitch.northnote", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 0); /* Key */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: a YIN pitch tracker with full-rate refinement, nearest-allowed-note quantisation against a 12-note mask and a reference pitch, one-pole retune smoothing lengthened on held notes (humanise), and pitch-synchronous overlap-add grains that keep the formants.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.pitch.northnote to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/northnote/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/octrel/ -->
# Octrel

> Clean polyphonic octaves: a sub, a second sub and an octave up that follow chords, with their own levels, a darkening filter for the subs and a squash that keeps the octave voices even.

- Engine id: `org.sournd.pitch.octrel`
- Category: Pitch
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 624 samples
- Tail: 0.2 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/octrel.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `sub_level` | Sub | 0 | 100 | 80 | % | linear |
| 1 | `sub2_level` | Sub 2 | 0 | 100 | 0 | % | linear |
| 2 | `up_level` | Up | 0 | 100 | 0 | % | linear |
| 3 | `dry_level` | Dry | 0 | 100 | 100 | % | linear |
| 4 | `sub_tone_hz` | Sub tone | 60 | 8000 | 2500 | Hz | log |
| 5 | `up_tone_hz` | Up tone | 500 | 16000 | 5000 | Hz | log |
| 6 | `squash` | Squash | 0 | 100 | 60 | % | linear |
| 7 | `output_db` | Output | -24 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.pitch.octrel" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.pitch.octrel", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 80); /* Sub */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: a sinusoidal phase vocoder on the analytic signal (low-delay asymmetric window, whole-lobe resynthesis of every partial, transient phase reset) driving three voices from one analysis, two-pole low-passes on the voices and an envelope-driven wet compressor. Voicing informed by our own measurements of polyphonic octave pedals (dark subs, compressed octave voices).

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.pitch.octrel to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/octrel/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/tessarine/ -->
# Tessarine

> The everything pitch engine: four voices from three octaves down to three up with fine tune, level, pan and delay each; chord-friendly or single-note mode, formants kept or moved, detune spread and a feedback path that climbs in cascades.

- Engine id: `org.sournd.pitch.tessarine`
- Category: Pitch
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 624 samples
- Tail: 15 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/tessarine.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `voice1_semitones` | Voice 1 pitch | -36 | 36 | 12 | st | linear |
| 1 | `voice1_cents` | Voice 1 fine | -100 | 100 | 0 | cents | linear |
| 2 | `voice1_level` | Voice 1 level | 0 | 100 | 100 | % | linear |
| 3 | `voice1_pan` | Voice 1 pan | -100 | 100 | -25 | % | linear |
| 4 | `voice1_delay_ms` | Voice 1 delay | 0 | 500 | 0 | ms | linear |
| 5 | `voice2_semitones` | Voice 2 pitch | -36 | 36 | -12 | st | linear |
| 6 | `voice2_cents` | Voice 2 fine | -100 | 100 | 0 | cents | linear |
| 7 | `voice2_level` | Voice 2 level | 0 | 100 | 70 | % | linear |
| 8 | `voice2_pan` | Voice 2 pan | -100 | 100 | 25 | % | linear |
| 9 | `voice2_delay_ms` | Voice 2 delay | 0 | 500 | 0 | ms | linear |
| 10 | `voice3_semitones` | Voice 3 pitch | -36 | 36 | 7 | st | linear |
| 11 | `voice3_cents` | Voice 3 fine | -100 | 100 | 0 | cents | linear |
| 12 | `voice3_level` | Voice 3 level | 0 | 100 | 0 | % | linear |
| 13 | `voice3_pan` | Voice 3 pan | -100 | 100 | 0 | % | linear |
| 14 | `voice3_delay_ms` | Voice 3 delay | 0 | 500 | 0 | ms | linear |
| 15 | `voice4_semitones` | Voice 4 pitch | -36 | 36 | 19 | st | linear |
| 16 | `voice4_cents` | Voice 4 fine | -100 | 100 | 0 | cents | linear |
| 17 | `voice4_level` | Voice 4 level | 0 | 100 | 0 | % | linear |
| 18 | `voice4_pan` | Voice 4 pan | -100 | 100 | 0 | % | linear |
| 19 | `voice4_delay_ms` | Voice 4 delay | 0 | 500 | 0 | ms | linear |
| 20 | `mode` | Mode | 0 | 1 | 0 | - | linear |
| 21 | `formant` | Formant keep | 0 | 100 | 0 | % | linear |
| 22 | `spread_cents` | Spread | 0 | 50 | 0 | cents | linear |
| 23 | `feedback` | Feedback | 0 | 70 | 0 | % | linear |
| 24 | `feedback_ms` | Feedback delay | 10 | 500 | 150 | ms | log |
| 25 | `low_cut_hz` | Low cut | 10 | 400 | 20 | Hz | log |
| 26 | `mix` | Mix | 0 | 100 | 50 | % | linear |
| 27 | `output_db` | Output | -24 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.pitch.tessarine" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.pitch.tessarine", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 12); /* Voice 1 pitch */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general techniques: a sinusoidal phase vocoder on the analytic signal with a low-delay asymmetric window, whole-lobe resynthesis, transient phase reset and cepstral formant keeping (poly mode); pitch-synchronous overlap-add grains driven by a YIN tracker with full-rate refinement (mono mode); equal-power panning, per-voice delay lines and a soft-limited feedback loop through the shifter. Ranges informed by our own measurements of octave and pitch pedals.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.pitch.tessarine to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/tessarine/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/torpora/ -->
# Torpora

> Tape stop: the sound slows down and drops in pitch to a halt over the stop time, then spins back up over the start time (0 = cut straight back in). Curve bends the slowdown from a sudden drag (negative) to a long coast (positive). Trigger: 0 = the Stop control (on above half), 1 = the host transport stopping and starting, 2 = either.

- Engine id: `org.sournd.performance.torpora`
- Category: Performance
- Licence: free (Apache-2.0, in the open framework)
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 0 samples
- Tail: 4.5 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/torpora.mp3 (a drum loop, default settings)
- Live preview: https://sournd.com/engines/torpora/ (runs the real engine in the browser; test sounds or the user's own file)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `stop` | Stop | 0 | 1 | 0 | - | linear |
| 1 | `trigger` | Trigger | 0 | 2 | 0 | - | linear |
| 2 | `stop_ms` | Stop time | 50 | 4000 | 800 | ms | log |
| 3 | `start_ms` | Start time | 0 | 4000 | 300 | ms | linear |
| 4 | `curve` | Curve | -1 | 1 | 0 | - | linear |
| 5 | `mix` | Mix | 0 | 100 | 100 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.performance.torpora" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.performance.torpora", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 0); /* Stop */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design: a stereo ring buffer read behind the write point at a variable speed following a power-curve ramp (the read lag grows by one minus the speed each sample), linear-interpolated reads, a level fade over the last quarter of the speed range, and an equal-power hand-back to the live signal after spin-up; triggered by control or transport edges.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.performance.torpora to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/torpora/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/carvello/ -->
# Carvello

> Beat slicer: each bar is cut into equal slices, and Shuffle is the chance that a slice is replaced by an earlier slice of the same bar (Reverse the chance it plays backwards), so loops are broken up and rebuilt on the fly. Hold keeps one pattern for every bar (above half) instead of a new one each bar. Slices: 0 = 4, 1 = 8, 2 = 16, 3 = 32 per bar. Seed picks the pattern.

- Engine id: `org.sournd.performance.carvello`
- Category: Performance
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 6.5 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/carvello.mp3 (a drum loop, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `slices` | Slices | 0 | 3 | 2 | - | linear |
| 1 | `shuffle` | Shuffle | 0 | 100 | 50 | % | linear |
| 2 | `reverse` | Reverse | 0 | 100 | 0 | % | linear |
| 3 | `hold` | Hold | 0 | 1 | 0 | - | linear |
| 4 | `seed` | Seed | 1 | 64 | 1 | - | linear |
| 5 | `tempo` | Tempo | 40 | 300 | 120 | bpm | linear |
| 6 | `mix` | Mix | 0 | 100 | 100 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.performance.carvello" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.performance.carvello", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 2); /* Slices */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design: bar-locked recording into preallocated memory from the musical clock, per-slice decisions from a seeded hash of the slice and bar indices (source restricted to already-recorded slices, so no latency is needed), forward or reversed reads with raised-sine slice edges crossfaded against the live signal.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.performance.carvello to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/carvello/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/glacine/ -->
# Glacine

> Sustainer: turn Hold on and the current sound is captured and held indefinitely as a smooth, evolving texture, blended under or over the live signal. While held, the trigger decides when it crossfades to a fresh capture: 0 = manual (only when Hold is switched on), 1 = new note (a stable pitch change larger than Pitch change), 2 = transient, 3 = every N beats, 4 = every N bars (host grid, or the Tempo control without one). Switching Hold off lets the held sound die away over Release.

- Engine id: `org.sournd.performance.glacine`
- Category: Performance
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 10.5 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/glacine.mp3 (a drum loop, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `trigger` | Trigger | 0 | 4 | 0 | - | linear |
| 1 | `hold` | Hold | 0 | 1 | 0 | - | linear |
| 2 | `sensitivity` | Sensitivity | 0 | 100 | 50 | % | linear |
| 3 | `pitch_cents` | Pitch change | 10 | 200 | 50 | cents | linear |
| 4 | `every` | Every | 1 | 16 | 1 | - | linear |
| 5 | `fade` | Fade | 5 | 2000 | 150 | ms | log |
| 6 | `release` | Release | 10 | 10000 | 1500 | ms | log |
| 7 | `texture` | Texture | 0 | 100 | 40 | % | linear |
| 8 | `low_cut` | Low cut | 20 | 2000 | 20 | Hz | log |
| 9 | `high_cut` | High cut | 1000 | 20000 | 20000 | Hz | log |
| 10 | `tempo` | Tempo | 40 | 300 | 120 | bpm | linear |
| 11 | `mix` | Mix | 0 | 100 | 50 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.performance.glacine" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.performance.glacine", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 0); /* Trigger */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design: a continuously recorded input history, post-attack captures that are level-evened when they decay, and an overlapped cloud of Hann-windowed grains at randomised positions with power normalisation, so the hold has no loop to hear. Triggers come from a relative-level transient detector, a YIN-style pitch tracker and the transport grid. Inspired by our own earlier hardware sustain block; no third-party code or audio.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.performance.glacine to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/glacine/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/rippet/ -->
# Rippet

> Grid stutter: once per interval, at the offset, it rolls the dice and may grab a short slice and stutter it for the gate length, each repeat optionally dropping in pitch and level. Locks to the host grid; without one it runs on its own Tempo. Interval: 0 = 1 beat, 1 = 2 beats, 2 = 1 bar, 3 = 2 bars, 4 = 4 bars. Offset and Gate count sixteenth notes. Repeat: 0 = 1/32, 1 = 1/16, 2 = 1/8, 3 = 1/4, 4 = 1/2. The same seed and song position always make the same decision.

- Engine id: `org.sournd.performance.rippet`
- Category: Performance
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 25 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/rippet.mp3 (a drum loop, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `interval` | Interval | 0 | 4 | 2 | - | linear |
| 1 | `offset` | Offset | 0 | 15 | 8 | 1/16 | linear |
| 2 | `repeat` | Repeat | 0 | 4 | 1 | - | linear |
| 3 | `gate` | Gate | 1 | 64 | 4 | 1/16 | linear |
| 4 | `chance` | Chance | 0 | 100 | 50 | % | linear |
| 5 | `pitch_decay` | Pitch decay | 0 | 12 | 0 | st | linear |
| 6 | `fade_db` | Fade | 0 | 6 | 0 | dB | linear |
| 7 | `seed` | Seed | 1 | 64 | 1 | - | linear |
| 8 | `tempo` | Tempo | 40 | 300 | 120 | bpm | linear |
| 9 | `mix` | Mix | 0 | 100 | 100 | % | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.performance.rippet" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.performance.rippet", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 2); /* Interval */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design: grid events from the bar-relative musical clock, a seeded hash of the event index against the chance, capture of one slice into preallocated memory while the live signal passes, then looped replay with per-repeat resampling ratio and gain, raised-sine edges and a live-path crossfade.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.performance.rippet to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/rippet/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/gain/ -->
# Gain

> Clean level control with a short de-zipper ramp.

- Engine id: `org.sournd.utility.gain`
- Category: Utility
- Licence: free (Apache-2.0, in the open framework)
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/gain.mp3 (plucked chords, default settings)
- Live preview: https://sournd.com/engines/gain/ (runs the real engine in the browser; test sounds or the user's own file)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `gain` | Gain | 0 | 4 | 1 | x | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.utility.gain" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.utility.gain", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 1); /* Gain */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd utility: linear gain.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.utility.gain to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/gain/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/keelson/ -->
# Keelson

> Channel utility: flip polarity per channel, swap channels, fold to mono (sum, left or right), balance or pan with a choice of pan law, delay each channel by samples plus milliseconds for time alignment, remove DC, and trim the level.

- Engine id: `org.sournd.utility.keelson`
- Category: Utility
- Licence: free (Apache-2.0, in the open framework)
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0.25 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/keelson.mp3 (plucked chords, default settings)
- Live preview: https://sournd.com/engines/keelson/ (runs the real engine in the browser; test sounds or the user's own file)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `invert_left` | Invert left | 0 | 1 | 0 | - | linear |
| 1 | `invert_right` | Invert right | 0 | 1 | 0 | - | linear |
| 2 | `swap` | Swap channels | 0 | 1 | 0 | - | linear |
| 3 | `mono_mode` | Mono (off, sum, left, right) | 0 | 3 | 0 | - | linear |
| 4 | `balance_pct` | Balance / pan | -100 | 100 | 0 | % | linear |
| 5 | `pan_law` | Pan law (0, 3, 4.5, 6 dB) | 0 | 3 | 0 | - | linear |
| 6 | `delay_left_samples` | Left delay | 0 | 4800 | 0 | samples | linear |
| 7 | `delay_right_samples` | Right delay | 0 | 4800 | 0 | samples | linear |
| 8 | `delay_left_ms` | Left delay (ms) | 0 | 100 | 0 | ms | linear |
| 9 | `delay_right_ms` | Right delay (ms) | 0 | 100 | 0 | ms | linear |
| 10 | `dc_filter` | DC filter | 0 | 1 | 0 | - | linear |
| 11 | `gain_db` | Gain | -24 | 24 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.utility.keelson" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.utility.keelson", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 0); /* Invert left */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd utility blending general techniques: polarity inversion, channel matrixing, linear-balance and sine-power pan laws, sample-exact delay lines with a short crossfade on change, and a one-pole DC blocker.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.utility.keelson to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/keelson/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/breadth/ -->
# Breadth

> Stereo width from mono to double width, with a low end that folds to mono below a chosen frequency.

- Engine id: `org.sournd.utility.breadth`
- Category: Utility
- Licence: free: a closed library, free to use in your plugins, downloaded with no account or email
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0.05 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/breadth.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `width_pct` | Width | 0 | 200 | 100 | % | linear |
| 1 | `mono_below_hz` | Mono below | 0 | 500 | 0 | Hz | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.utility.breadth" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.utility.breadth", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 100); /* Width */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd utility blending general techniques: mid/side encoding, a scaled side channel and a two-pole side high-pass for a mono low end.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.utility.breadth to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/breadth/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/meridel/ -->
# Meridel

> Mid/side mixer: set the centre and the sides separately, spread or narrow the image, and turn the whole image left or right without losing energy. Decode mode takes a mid/side recording in; encode mode sends mid/side out.

- Engine id: `org.sournd.utility.meridel`
- Category: Utility
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/meridel.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `mode` | Mode (stereo, decode M/S, encode M/S) | 0 | 2 | 0 | - | linear |
| 1 | `mid_db` | Mid | -24 | 12 | 0 | dB | linear |
| 2 | `side_db` | Side | -24 | 12 | 0 | dB | linear |
| 3 | `width_pct` | Spread | 0 | 200 | 100 | % | linear |
| 4 | `direction_deg` | Direction | -45 | 45 | 0 | deg | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.utility.meridel" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.utility.meridel", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 0); /* Mode (stereo, decode M/S, encode M/S) */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd utility blending general techniques: sum/difference mid/side matrixing, independent mid and side gains, side scaling for width, and an energy-preserving rotation of the left/right vector.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.utility.meridel to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/meridel/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/spherel/ -->
# Spherel

> Binaural panner for headphones: places the input around the listener's head by azimuth, elevation and distance, with the time and level differences between the ears, the head's shadow, a pinna cue for height and softer highs from behind and far away.

- Engine id: `org.sournd.utility.spherel`
- Category: Utility
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0.05 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/spherel.mp3 (plucked chords, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `azimuth_deg` | Azimuth | -180 | 180 | 0 | deg | linear |
| 1 | `elevation_deg` | Elevation | -45 | 90 | 0 | deg | linear |
| 2 | `distance_m` | Distance | 0.3 | 20 | 1 | m | log |
| 3 | `head_radius_cm` | Head radius | 7 | 11 | 8.75 | cm | linear |
| 4 | `output_db` | Output | -12 | 12 | 0 | dB | linear |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.utility.spherel" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.utility.spherel", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 0); /* Azimuth */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd design blending general, published techniques: the spherical-head model (per-ear travel-time difference from the head radius and a first-order head-shadow filter whose high-frequency gain follows the angle to the ear), an elevation-dependent pinna notch, a rear shading shelf, inverse-distance gain and air absorption.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.utility.spherel to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/spherel/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/plumb/ -->
# Plumb

> Level meter: per-channel sample peak with a falling needle, RMS and a peak hold. Audio passes untouched.

- Engine id: `org.sournd.analysis.plumb`
- Category: Analysis
- Licence: free (Apache-2.0, in the open framework)
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/plumb.mp3 (a drum loop, default settings)
- Live preview: https://sournd.com/engines/plumb/ (runs the real engine in the browser; test sounds or the user's own file)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `rms_ms` | RMS window | 10 | 3000 | 300 | ms | log |
| 1 | `fall_db_s` | Peak fall | 1 | 120 | 20 | dB/s | log |
| 2 | `hold_s` | Peak hold | 0 | 10 | 1.5 | s | linear |

## Readouts

Read with `sournd_engine_readout_value` on the audio thread.

| Index | Key | Name | Kind | Min | Max | Unit |
|---|---|---|---|---|---|---|
| 0 | `peak_l` | Peak L | level | -120 | 30 | dBFS |
| 1 | `peak_r` | Peak R | level | -120 | 30 | dBFS |
| 2 | `rms_l` | RMS L | level | -120 | 30 | dBFS |
| 3 | `rms_r` | RMS R | level | -120 | 30 | dBFS |
| 4 | `hold_l` | Hold L | level | -120 | 30 | dBFS |
| 5 | `hold_r` | Hold R | level | -120 | 30 | dBFS |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.analysis.plumb" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.analysis.plumb", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 300); /* RMS window */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd meter blending general techniques: instant-attack peak detection with a constant dB-per-second fall, an exponential RMS average and a timed peak hold.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.analysis.plumb to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/plumb/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/tunra/ -->
# Tunra

> Chromatic tuner: the nearest note, how many cents sharp or flat, the frequency and how sure it is, against an adjustable A4. Audio passes untouched.

- Engine id: `org.sournd.analysis.tunra`
- Category: Analysis
- Licence: free: a closed library, free to use in your plugins, downloaded with no account or email
- Download (no account or email): https://sournd.com/download/free/macos (macOS universal), https://sournd.com/download/free/linux (Linux x86_64 and aarch64) or https://sournd.com/download/free/windows (Windows x64). One archive with every free engine: static library, C headers, README.
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/tunra.mp3 (a drum loop, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `reference_a4_hz` | A4 reference | 400 | 480 | 440 | Hz | linear |
| 1 | `sensitivity` | Sensitivity | 0 | 1 | 0.5 | - | linear |

## Readouts

Read with `sournd_engine_readout_value` on the audio thread.

| Index | Key | Name | Kind | Min | Max | Unit |
|---|---|---|---|---|---|---|
| 0 | `note` | Note | note | 0 | 127 | - |
| 1 | `cents` | Cents | value | -50 | 50 | cents |
| 2 | `frequency_hz` | Frequency | value | 0 | 2000 | Hz |
| 3 | `confidence` | Confidence | meter | 0 | 1 | - |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.analysis.tunra" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.analysis.tunra", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 440); /* A4 reference */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd tuner blending general techniques: a decimated difference-function pitch estimate refined by a full-rate difference minimum with parabolic interpolation, and a periodicity-based confidence.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.analysis.tunra to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/tunra/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/heft/ -->
# Heft

> Loudness meter: momentary (400 ms), short-term (3 s) and gated integrated loudness in LUFS, loudness range and 4x-oversampled true peak, against a target. Audio passes untouched.

- Engine id: `org.sournd.analysis.heft`
- Category: Analysis
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/heft.mp3 (a drum loop, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `target_lufs` | Target | -40 | 0 | -14 | LUFS | linear |

## Readouts

Read with `sournd_engine_readout_value` on the audio thread.

| Index | Key | Name | Kind | Min | Max | Unit |
|---|---|---|---|---|---|---|
| 0 | `momentary_lufs` | Momentary | level | -120 | 30 | LUFS |
| 1 | `short_term_lufs` | Short-term | level | -120 | 30 | LUFS |
| 2 | `integrated_lufs` | Integrated | level | -120 | 30 | LUFS |
| 3 | `range_lu` | Loudness range | value | 0 | 100 | LU |
| 4 | `true_peak_l` | True peak L | level | -120 | 30 | dBTP |
| 5 | `true_peak_r` | True peak R | level | -120 | 30 | dBTP |
| 6 | `to_target_lu` | Integrated minus target | value | -150 | 70 | LU |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.analysis.heft" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.analysis.heft", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, -14); /* Target */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd meter implementing the published broadcast loudness method from its description: frequency weighting, 400 ms blocks with 75% overlap, absolute and relative gating, percentile loudness range and oversampled peak detection; bounded-memory histograms are its own design.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.analysis.heft to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/heft/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/engines/huescope/ -->
# Huescope

> Spectrum meter: 31 third-octave band levels from 20 Hz to 20 kHz with an optional display tilt, plus peak and RMS. Audio passes untouched.

- Engine id: `org.sournd.analysis.huescope`
- Category: Analysis
- Licence: paid: £2.99 an effect or £4.99 a synth, once (owned for good, with updates), or included in the Everything plan (£14.99 a month)
- Version: 1.0.0
- Latency: 0 samples
- Tail: 0 s
- Sidechain input: no
- Channels: mono or stereo
- Audio demo: https://sournd.com/static/preview/demos/huescope.mp3 (a drum loop, default settings)

## Parameters

The id is the C ABI parameter id and the JUCE parameter id (as a decimal string).

| Id | Key | Name | Min | Max | Default | Unit | Taper |
|---|---|---|---|---|---|---|---|
| 0 | `response_ms` | Response | 20 | 3000 | 300 | ms | log |
| 1 | `tilt_db_oct` | Tilt | 0 | 6 | 0 | dB/oct | linear |
| 2 | `fall_db_s` | Peak fall | 1 | 120 | 20 | dB/s | log |

## Readouts

Read with `sournd_engine_readout_value` on the audio thread.

| Index | Key | Name | Kind | Min | Max | Unit |
|---|---|---|---|---|---|---|
| 0 to 30 | `bands[0..30]` | Third-octave bands | spectrum, 31 values | -120 | 60 | dB |
| 31 | `peak_db` | Peak | level | -120 | 30 | dBFS |
| 32 | `rms_db` | RMS | level | -120 | 30 | dBFS |

## Use it in JUCE

CMake ([quick start](/docs/juce/index.md)):

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

C++:

```cpp
#include <sournd_engine/sournd_engine.h>

sournd::SourndEngine engine { "org.sournd.analysis.huescope" };
juce::AudioProcessorValueTreeState parameters { *this, nullptr, "Parameters",
    sournd::SourndEngineParameters::createLayout (engine) };
sournd::SourndEngineParameters bridge { engine, parameters };

// prepareToPlay
engine.prepare ({ sampleRate, (juce::uint32) maximumBlock, 2 });
bridge.prepare (sampleRate);
setLatencySamples ((int) engine.latency());

// processBlock
bridge.apply ((uint32_t) buffer.getNumSamples());
juce::dsp::AudioBlock<float> block { buffer };
engine.process (juce::dsp::ProcessContextReplacing<float> { block });

// get/setStateInformation: hold getCallbackLock() around saveState / loadState,
// so state work never overlaps processBlock (full example: /docs/juce/)
```

Plain C:

```c
sournd_engine *e = NULL;
if (sournd_engine_create("org.sournd.analysis.huescope", &e) == SOURND_OK) {
    sournd_engine_prepare(e, 48000.0, 512);
    sournd_engine_set_param(e, 0, 300); /* Response */
    sournd_engine_process(e, in, out, 2, frames);
    sournd_engine_destroy(e);
}
```

## How it is made

Original sOURnd meter blending general techniques: a bank of constant-Q band-pass filters on base-ten third-octave centres, exponential band averaging, a slope tilt and a falling peak.

## Ask your AI

Paste this into your coding assistant:

```text
Add the sournd engine org.sournd.analysis.huescope to my JUCE plugin. Follow https://sournd.com/docs/juce/index.md
and the engine reference at https://sournd.com/engines/huescope/index.md. Expose every parameter through APVTS.
```


---

<!-- https://sournd.com/sounds/braidel/ -->
# Braidel

> A four-voice paraphonic keyboard voice: braided oscillators through one warm low-pass, with a dark, wobbling echo behind it.

- Instrument id: `org.sournd.instrument.braidel`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 4 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/braidel/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 1800 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.2 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.35 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.1 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 2 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 500 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.4 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 400 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 3 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 600 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.8 | - |
| 12 | `release` | Release | 5 | 10000 | 400 | ms |
| 13 | `detune` | Detune | 0 | 50 | 4 | cents |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0 | - |
| 17 | `noise` | Noise | 0 | 1 | 0 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 20 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 21 | `drift` | Drift | 0 | 25 | 0.5 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.2 | - |
| 24 | `echo` | Echo | 0 | 1 | 0.18 | - |
| 25 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 26 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/brazier/ -->
# Brazier

> A modern six-voice analogue poly: saw and pulse per voice, a resonant low-pass after a clean high-pass, and a wide stereo chorus.

- Instrument id: `org.sournd.instrument.brazier`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 6 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/brazier/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 2500 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.2 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.35 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.05 | - |
| 5 | `filter2_cutoff` | Second filter | 20 | 18000 | 60 | Hz |
| 6 | `filter_attack` | Filter attack | 0.5 | 10000 | 4 | ms |
| 7 | `filter_decay` | Filter decay | 5 | 10000 | 500 | ms |
| 8 | `filter_sustain` | Filter sustain | 0 | 1 | 0.4 | - |
| 9 | `filter_release` | Filter release | 5 | 10000 | 450 | ms |
| 10 | `attack` | Attack | 0.5 | 10000 | 5 | ms |
| 11 | `decay` | Decay | 5 | 10000 | 600 | ms |
| 12 | `sustain` | Sustain | 0 | 1 | 0.8 | - |
| 13 | `release` | Release | 5 | 10000 | 500 | ms |
| 14 | `detune` | Detune | 0 | 50 | 4 | cents |
| 15 | `unison` | Unison | 1 | 7 | 1 | voices |
| 16 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 17 | `sub` | Sub | 0 | 1 | 0 | - |
| 18 | `noise` | Noise | 0 | 1 | 0 | - |
| 19 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 20 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 21 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 22 | `drift` | Drift | 0 | 25 | 1.5 | cents |
| 23 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 24 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.2 | - |
| 25 | `chorus` | Chorus | 0 | 1 | 0.25 | - |
| 26 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 27 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/bristle/ -->
# Bristle

> A bright, buzzy two-voice synth with snappy percussive envelopes and a biting two-pole filter that screams when the resonance goes up.

- Instrument id: `org.sournd.instrument.bristle`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 2 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/bristle/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 2200 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.3 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.5 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.15 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 5 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 200 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.2 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 120 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 5 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 250 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.6 | - |
| 12 | `release` | Release | 5 | 10000 | 120 | ms |
| 13 | `detune` | Detune | 0 | 50 | 5.5 | cents |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0 | - |
| 17 | `noise` | Noise | 0 | 1 | 0 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 20 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 21 | `drift` | Drift | 0 | 25 | 2 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.2 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.2 | - |
| 24 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 25 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/cantilla/ -->
# Cantilla

> Sings vowels by frequency modulation: formants locked in place as the pitch glides, a two-axis vowel pad, throat, breath, vibrato and ensemble. Vowels only: no words, lyrics or likeness of any voice.

- Instrument id: `org.sournd.instrument.cantilla`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 8 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/cantilla/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `vowel_x` | Vowel front to back | 0 | 1 | 0.5 | - |
| 1 | `vowel_y` | Vowel close to open | 0 | 1 | 0.5 | - |
| 2 | `throat` | Throat | 0 | 1 | 0.35 | - |
| 3 | `formant_shift` | Formant shift | -12 | 12 | 0 | st |
| 4 | `formant_spread` | Formant spread | 0.5 | 1.5 | 1 | x |
| 5 | `vibrato_rate` | Vibrato rate | 0.1 | 12 | 5.2 | Hz |
| 6 | `vibrato_depth` | Vibrato depth | 0 | 100 | 12 | ct |
| 7 | `vibrato_delay` | Vibrato delay | 0 | 2000 | 250 | ms |
| 8 | `breath` | Breath | 0 | 1 | 0.1 | - |
| 9 | `pressure_vowel` | Pressure to vowel | 0 | 1 | 0.5 | - |
| 10 | `attack` | Attack | 1 | 10000 | 60 | ms |
| 11 | `decay` | Decay | 1 | 10000 | 400 | ms |
| 12 | `sustain` | Sustain | 0 | 1 | 0.85 | - |
| 13 | `release` | Release | 1 | 10000 | 350 | ms |
| 14 | `ensemble` | Ensemble | 0 | 1 | 0.25 | - |
| 15 | `velocity` | Velocity to level | 0 | 1 | 0.5 | - |
| 16 | `level` | Level | 0 | 1 | 0.7 | - |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/cavitas/ -->
# Cavitas

> A breathy, eerie pad voice: a vowel-like tone with air in it, closed down by a smooth low-pass, like an old sampler playing a choir.

- Instrument id: `org.sournd.instrument.cavitas`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 8 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/cavitas/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 1200 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.15 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.2 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.7 | - |
| 4 | `drive` | Drive | 0 | 1 | 0 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 300 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 1500 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.6 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 1200 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 350 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 1500 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.8 | - |
| 12 | `release` | Release | 5 | 10000 | 1500 | ms |
| 13 | `unison` | Unison | 1 | 7 | 1 | voices |
| 14 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 15 | `sub` | Sub | 0 | 1 | 0 | - |
| 16 | `noise` | Noise | 0 | 1 | 0.15 | - |
| 17 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 18 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 19 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 20 | `drift` | Drift | 0 | 25 | 0 | cents |
| 21 | `velocity_amp` | Velocity to level | 0 | 1 | 0.2 | - |
| 22 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.1 | - |
| 23 | `chorus` | Chorus | 0 | 1 | 0.2 | - |
| 24 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 25 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/chitinel/ -->
# Chitinel

> A powerful virtual analogue voice: saturation between the filter stages keeps the bass under high resonance, with a second band-pass filter in parallel.

- Instrument id: `org.sournd.instrument.chitinel`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 16 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/chitinel/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 1800 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.4 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.45 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.4 | - |
| 5 | `filter2_cutoff` | Second filter | 20 | 18000 | 1200 | Hz |
| 6 | `filter_attack` | Filter attack | 0.5 | 10000 | 1 | ms |
| 7 | `filter_decay` | Filter decay | 5 | 10000 | 350 | ms |
| 8 | `filter_sustain` | Filter sustain | 0 | 1 | 0.35 | - |
| 9 | `filter_release` | Filter release | 5 | 10000 | 300 | ms |
| 10 | `attack` | Attack | 0.5 | 10000 | 1 | ms |
| 11 | `decay` | Decay | 5 | 10000 | 400 | ms |
| 12 | `sustain` | Sustain | 0 | 1 | 0.8 | - |
| 13 | `release` | Release | 5 | 10000 | 300 | ms |
| 14 | `detune` | Detune | 0 | 50 | 7 | cents |
| 15 | `unison` | Unison | 1 | 7 | 1 | voices |
| 16 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 17 | `sub` | Sub | 0 | 1 | 0.2 | - |
| 18 | `noise` | Noise | 0 | 1 | 0 | - |
| 19 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 20 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 21 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 22 | `drift` | Drift | 0 | 25 | 1 | cents |
| 23 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 24 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.25 | - |
| 25 | `chorus` | Chorus | 0 | 1 | 0.2 | - |
| 26 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 27 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/crankshaft/ -->
# Crankshaft

> A punchy virtual analogue lead: a hard-synced oscillator swept by its own envelope, a bright resonant low-pass and a short glide.

- Instrument id: `org.sournd.instrument.crankshaft`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 12 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/crankshaft/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 3500 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.3 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.3 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.1 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 1 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 350 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.4 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 250 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 1 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 300 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.85 | - |
| 12 | `release` | Release | 5 | 10000 | 250 | ms |
| 13 | `detune` | Detune | 0 | 50 | 0 | cents |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0 | - |
| 17 | `noise` | Noise | 0 | 1 | 0 | - |
| 18 | `glide` | Glide | 0 | 2000 | 30 | ms |
| 19 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 20 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 21 | `drift` | Drift | 0 | 25 | 0.5 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.2 | - |
| 24 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 25 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/crystelle/ -->
# Crystelle

> A glassy digital pad voice: a breathy, bell-like partial layer over a resonant digital low-pass, with chorus and a soft echo trail.

- Instrument id: `org.sournd.instrument.crystelle`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 16 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/crystelle/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 3500 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.45 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.3 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 20 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 1500 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.5 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 1200 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 30 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 1200 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.7 | - |
| 12 | `release` | Release | 5 | 10000 | 1500 | ms |
| 13 | `detune` | Detune | 0 | 50 | 2 | cents |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0 | - |
| 17 | `noise` | Noise | 0 | 1 | 0.03 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 20 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 21 | `drift` | Drift | 0 | 25 | 0 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.2 | - |
| 24 | `chorus` | Chorus | 0 | 1 | 0.4 | - |
| 25 | `echo` | Echo | 0 | 1 | 0.15 | - |
| 26 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 27 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/duskfall/ -->
# Duskfall

> A grand, expressive eight-voice poly: two detuned layers per voice, high-pass into low-pass, slow swelling filter and pressure that opens the tone as you lean in.

- Instrument id: `org.sournd.instrument.duskfall`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 8 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/duskfall/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 900 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.25 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.4 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.05 | - |
| 5 | `filter2_cutoff` | Second filter | 20 | 18000 | 150 | Hz |
| 6 | `filter_attack` | Filter attack | 0.5 | 10000 | 600 | ms |
| 7 | `filter_decay` | Filter decay | 5 | 10000 | 1200 | ms |
| 8 | `filter_sustain` | Filter sustain | 0 | 1 | 0.6 | - |
| 9 | `filter_release` | Filter release | 5 | 10000 | 900 | ms |
| 10 | `attack` | Attack | 0.5 | 10000 | 250 | ms |
| 11 | `decay` | Decay | 5 | 10000 | 800 | ms |
| 12 | `sustain` | Sustain | 0 | 1 | 0.85 | - |
| 13 | `release` | Release | 5 | 10000 | 1200 | ms |
| 14 | `detune` | Detune | 0 | 50 | 10 | cents |
| 15 | `unison` | Unison | 1 | 7 | 1 | voices |
| 16 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 17 | `sub` | Sub | 0 | 1 | 0 | - |
| 18 | `noise` | Noise | 0 | 1 | 0 | - |
| 19 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 20 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 21 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 22 | `drift` | Drift | 0 | 25 | 4 | cents |
| 23 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 24 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.4 | - |
| 25 | `chorus` | Chorus | 0 | 1 | 0.35 | - |
| 26 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 27 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/fanfara/ -->
# Fanfara

> A bold eight-voice brass poly: two wide-detuned saws per voice through an open, fizzy two-pole low-pass for stabs and big chords.

- Instrument id: `org.sournd.instrument.fanfara`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 8 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/fanfara/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 4000 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.15 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.3 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.1 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 25 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 400 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.5 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 350 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 30 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 300 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.75 | - |
| 12 | `release` | Release | 5 | 10000 | 350 | ms |
| 13 | `detune` | Detune | 0 | 50 | 8 | cents |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0 | - |
| 17 | `noise` | Noise | 0 | 1 | 0 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 20 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 21 | `drift` | Drift | 0 | 25 | 1.5 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.25 | - |
| 24 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 25 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/fibrel/ -->
# Fibrel

> A clean, modern hybrid poly: pristine digital oscillators into a warm analogue-style low-pass with drive, for bright pads and leads.

- Instrument id: `org.sournd.instrument.fibrel`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 8 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/fibrel/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 2600 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.3 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.3 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.3 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 3 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 600 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.45 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 550 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 3 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 600 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.8 | - |
| 12 | `release` | Release | 5 | 10000 | 600 | ms |
| 13 | `detune` | Detune | 0 | 50 | 5 | cents |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0 | - |
| 17 | `noise` | Noise | 0 | 1 | 0 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 20 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 21 | `drift` | Drift | 0 | 25 | 1 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.2 | - |
| 24 | `chorus` | Chorus | 0 | 1 | 0.25 | - |
| 25 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 26 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/forgewren/ -->
# Forgewren

> A fat three-oscillator mono for bass and lead: punchy exponential envelopes, a warm four-pole low-pass that thins its lows as the resonance climbs, and a little drift.

- Instrument id: `org.sournd.instrument.forgewren`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: mono
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/forgewren/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 900 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.25 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.45 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.66 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.25 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 1 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 350 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.35 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 200 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 1.25 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 600 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.8 | - |
| 12 | `release` | Release | 5 | 10000 | 150 | ms |
| 13 | `detune` | Detune | 0 | 50 | 5 | cents |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0 | - |
| 17 | `noise` | Noise | 0 | 1 | 0 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 20 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 21 | `drift` | Drift | 0 | 25 | 1.5 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.2 | - |
| 24 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 25 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/gridwork/ -->
# Gridwork

> A semi-modular style mono: three oscillators, noise and a resonant four-pole low-pass for leads, basses and odd effects.

- Instrument id: `org.sournd.instrument.gridwork`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: mono
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/gridwork/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 1200 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.3 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.4 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.2 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 2 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 350 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.3 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 250 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 2 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 400 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.7 | - |
| 12 | `release` | Release | 5 | 10000 | 250 | ms |
| 13 | `detune` | Detune | 0 | 50 | 3 | cents |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0 | - |
| 17 | `noise` | Noise | 0 | 1 | 0.05 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 20 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 21 | `drift` | Drift | 0 | 25 | 3 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.25 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.2 | - |
| 24 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 25 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/herald/ -->
# Herald

> A silky eight-voice poly: saw and pulse per voice, smooth envelopes and a warm four-pole low-pass that self-oscillates cleanly.

- Instrument id: `org.sournd.instrument.herald`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 8 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/herald/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 3000 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.2 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.3 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 8 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 600 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.45 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 500 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 10 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 500 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.8 | - |
| 12 | `release` | Release | 5 | 10000 | 500 | ms |
| 13 | `detune` | Detune | 0 | 50 | 4 | cents |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0 | - |
| 17 | `noise` | Noise | 0 | 1 | 0 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 20 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 21 | `drift` | Drift | 0 | 25 | 0.8 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.2 | - |
| 24 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 25 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/hessian/ -->
# Hessian

> A punchy hybrid voice: a short, clicky transient on every note over a grainy digital tone and a warm low-pass, for plucks and stabs.

- Instrument id: `org.sournd.instrument.hessian`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 8 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/hessian/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 2000 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.25 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.45 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.1 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 1 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 300 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.25 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 350 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 1 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 500 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.6 | - |
| 12 | `release` | Release | 5 | 10000 | 400 | ms |
| 13 | `detune` | Detune | 0 | 50 | 0 | cents |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0 | - |
| 17 | `noise` | Noise | 0 | 1 | 0.08 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 20 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 21 | `drift` | Drift | 0 | 25 | 0.01 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.35 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.3 | - |
| 24 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 25 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/hobstone/ -->
# Hobstone

> A warm five-voice analogue poly: two detuned oscillators per voice, a creamy four-pole low-pass and exponential envelopes for pads, brass and keys.

- Instrument id: `org.sournd.instrument.hobstone`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 5 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/hobstone/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 2200 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.2 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.35 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.1 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 5 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 500 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.4 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 400 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 8 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 600 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.75 | - |
| 12 | `release` | Release | 5 | 10000 | 450 | ms |
| 13 | `detune` | Detune | 0 | 50 | 6.5 | cents |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0 | - |
| 17 | `noise` | Noise | 0 | 1 | 0 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 20 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 21 | `drift` | Drift | 0 | 25 | 2 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.2 | - |
| 24 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 25 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/howlmere/ -->
# Howlmere

> A raw, snarling mono: a high-pass into a driven two-pole low-pass whose resonance howls and distorts as you open it.

- Instrument id: `org.sournd.instrument.howlmere`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: mono
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/howlmere/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 1400 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.55 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.45 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.3 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.55 | - |
| 5 | `filter2_cutoff` | Second filter | 20 | 18000 | 120 | Hz |
| 6 | `filter_attack` | Filter attack | 0.5 | 10000 | 2 | ms |
| 7 | `filter_decay` | Filter decay | 5 | 10000 | 300 | ms |
| 8 | `filter_sustain` | Filter sustain | 0 | 1 | 0.3 | - |
| 9 | `filter_release` | Filter release | 5 | 10000 | 200 | ms |
| 10 | `attack` | Attack | 0.5 | 10000 | 2 | ms |
| 11 | `decay` | Decay | 5 | 10000 | 300 | ms |
| 12 | `sustain` | Sustain | 0 | 1 | 0.75 | - |
| 13 | `release` | Release | 5 | 10000 | 200 | ms |
| 14 | `detune` | Detune | 0 | 50 | 5 | cents |
| 15 | `unison` | Unison | 1 | 7 | 1 | voices |
| 16 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 17 | `sub` | Sub | 0 | 1 | 0 | - |
| 18 | `noise` | Noise | 0 | 1 | 0 | - |
| 19 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 20 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 21 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 22 | `drift` | Drift | 0 | 25 | 5 | cents |
| 23 | `velocity_amp` | Velocity to level | 0 | 1 | 0.25 | - |
| 24 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.25 | - |
| 25 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 26 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/ingotry/ -->
# Ingotry

> A solid two-oscillator mono: saw and square into a resonant four-pole low-pass with snappy envelopes, for tight basses and clean leads.

- Instrument id: `org.sournd.instrument.ingotry`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: mono
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/ingotry/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 800 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.3 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.55 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.2 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 1 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 250 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.2 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 150 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 1 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 300 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.6 | - |
| 12 | `release` | Release | 5 | 10000 | 150 | ms |
| 13 | `detune` | Detune | 0 | 50 | 4 | cents |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0 | - |
| 17 | `noise` | Noise | 0 | 1 | 0 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 20 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 21 | `drift` | Drift | 0 | 25 | 1 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.2 | - |
| 24 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 25 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/inlay/ -->
# Inlay

> A rich digital voice built from layered tones and a choice of digital filters, here a resonant low-pass after a notch, for strings, pads and evolving keys.

- Instrument id: `org.sournd.instrument.inlay`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 16 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/inlay/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 8400 | 3500 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.35 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.3 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0 | - |
| 5 | `filter2_cutoff` | Second filter | 20 | 18000 | 1800 | Hz |
| 6 | `filter_attack` | Filter attack | 0.5 | 10000 | 20 | ms |
| 7 | `filter_decay` | Filter decay | 5 | 10000 | 900 | ms |
| 8 | `filter_sustain` | Filter sustain | 0 | 1 | 0.5 | - |
| 9 | `filter_release` | Filter release | 5 | 10000 | 800 | ms |
| 10 | `attack` | Attack | 0.5 | 10000 | 20 | ms |
| 11 | `decay` | Decay | 5 | 10000 | 900 | ms |
| 12 | `sustain` | Sustain | 0 | 1 | 0.8 | - |
| 13 | `release` | Release | 5 | 10000 | 900 | ms |
| 14 | `detune` | Detune | 0 | 50 | 5 | cents |
| 15 | `unison` | Unison | 1 | 7 | 1 | voices |
| 16 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 17 | `sub` | Sub | 0 | 1 | 0 | - |
| 18 | `noise` | Noise | 0 | 1 | 0 | - |
| 19 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 20 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 21 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 22 | `drift` | Drift | 0 | 25 | 0 | cents |
| 23 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 24 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.2 | - |
| 25 | `chorus` | Chorus | 0 | 1 | 0.3 | - |
| 26 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 27 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/knotwork/ -->
# Knotwork

> A wild, unstable mono for drones and effects: wandering oscillators, noise and a squelchy low-pass that breaks into distortion before it sings.

- Instrument id: `org.sournd.instrument.knotwork`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: mono
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/knotwork/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 900 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.6 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.5 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.3 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.5 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 2 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 800 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.3 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 800 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 2 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 800 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.6 | - |
| 12 | `release` | Release | 5 | 10000 | 800 | ms |
| 13 | `detune` | Detune | 0 | 50 | 10 | cents |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0 | - |
| 17 | `noise` | Noise | 0 | 1 | 0.1 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `lfo_rate` | Motion rate | 0.02 | 40 | 0.3 | Hz |
| 20 | `lfo_amount` | Motion | 0 | 1 | 0.3 | - |
| 21 | `drift` | Drift | 0 | 25 | 10 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.2 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.2 | - |
| 24 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 25 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/lullwick/ -->
# Lullwick

> A soft-edged six-voice poly: a pulse-led oscillator, a smooth low-pass that tracks the keyboard and a slightly faster stereo chorus for keys and leads.

- Instrument id: `org.sournd.instrument.lullwick`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 6 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/lullwick/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 1800 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.3 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.4 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.7 | - |
| 4 | `drive` | Drive | 0 | 1 | 0 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 1.5 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 400 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.3 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 350 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 1.5 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 500 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.7 | - |
| 12 | `release` | Release | 5 | 10000 | 350 | ms |
| 13 | `detune` | Detune | 0 | 50 | 0 | cents |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0.25 | - |
| 17 | `noise` | Noise | 0 | 1 | 0 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 20 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 21 | `drift` | Drift | 0 | 25 | 0.05 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.2 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.1 | - |
| 24 | `chorus` | Chorus | 0 | 1 | 0.45 | - |
| 25 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 26 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/nimbel/ -->
# Nimbel

> A clean one-oscillator poly wrapped in a wide, shimmering stereo chorus: the chorus is the sound, for pads, chords and gentle keys.

- Instrument id: `org.sournd.instrument.nimbel`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 6 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/nimbel/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 2500 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.15 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.3 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0 | - |
| 5 | `filter2_cutoff` | Second filter | 20 | 18000 | 80 | Hz |
| 6 | `filter_attack` | Filter attack | 0.5 | 10000 | 1.5 | ms |
| 7 | `filter_decay` | Filter decay | 5 | 10000 | 450 | ms |
| 8 | `filter_sustain` | Filter sustain | 0 | 1 | 0.4 | - |
| 9 | `filter_release` | Filter release | 5 | 10000 | 400 | ms |
| 10 | `attack` | Attack | 0.5 | 10000 | 1.5 | ms |
| 11 | `decay` | Decay | 5 | 10000 | 400 | ms |
| 12 | `sustain` | Sustain | 0 | 1 | 0.8 | - |
| 13 | `release` | Release | 5 | 10000 | 400 | ms |
| 14 | `detune` | Detune | 0 | 50 | 0 | cents |
| 15 | `unison` | Unison | 1 | 7 | 1 | voices |
| 16 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 17 | `sub` | Sub | 0 | 1 | 0.3 | - |
| 18 | `noise` | Noise | 0 | 1 | 0 | - |
| 19 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 20 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 21 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 22 | `drift` | Drift | 0 | 25 | 0.05 | cents |
| 23 | `velocity_amp` | Velocity to level | 0 | 1 | 0.2 | - |
| 24 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.1 | - |
| 25 | `chorus` | Chorus | 0 | 1 | 0.5 | - |
| 26 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 27 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/parada/ -->
# Parada

> A lavish eight-voice poly: two detuned oscillators per voice, a liquid switchable low-pass and envelopes with a huge range, from plucks to slow swells.

- Instrument id: `org.sournd.instrument.parada`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 8 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/parada/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 3000 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.2 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.4 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.05 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 15 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 900 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.45 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 700 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 20 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 800 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.8 | - |
| 12 | `release` | Release | 5 | 10000 | 800 | ms |
| 13 | `detune` | Detune | 0 | 50 | 8 | cents |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0 | - |
| 17 | `noise` | Noise | 0 | 1 | 0 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 20 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 21 | `drift` | Drift | 0 | 25 | 1.2 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.2 | - |
| 24 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 25 | `width` | Width | 0 | 2 | 1.2 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/polisk/ -->
# Polisk

> A polished, modern three-oscillator mono with two low-pass filters side by side for a wide, glossy lead that still growls when pushed.

- Instrument id: `org.sournd.instrument.polisk`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: mono
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/polisk/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 1500 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.2 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.4 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.15 | - |
| 5 | `filter2_cutoff` | Second filter | 20 | 18000 | 2200 | Hz |
| 6 | `filter_attack` | Filter attack | 0.5 | 10000 | 2 | ms |
| 7 | `filter_decay` | Filter decay | 5 | 10000 | 450 | ms |
| 8 | `filter_sustain` | Filter sustain | 0 | 1 | 0.4 | - |
| 9 | `filter_release` | Filter release | 5 | 10000 | 300 | ms |
| 10 | `attack` | Attack | 0.5 | 10000 | 2 | ms |
| 11 | `decay` | Decay | 5 | 10000 | 400 | ms |
| 12 | `sustain` | Sustain | 0 | 1 | 0.85 | - |
| 13 | `release` | Release | 5 | 10000 | 300 | ms |
| 14 | `detune` | Detune | 0 | 50 | 3 | cents |
| 15 | `unison` | Unison | 1 | 7 | 1 | voices |
| 16 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 17 | `sub` | Sub | 0 | 1 | 0 | - |
| 18 | `noise` | Noise | 0 | 1 | 0 | - |
| 19 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 20 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 21 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 22 | `drift` | Drift | 0 | 25 | 0.5 | cents |
| 23 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 24 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.2 | - |
| 25 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 26 | `width` | Width | 0 | 2 | 1.2 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/psalmery/ -->
# Psalmery

> A fully polyphonic, organ-like voice: every key sounds, with a buzzy resonant band in parallel with a smooth master low-pass, for strings and choirs.

- Instrument id: `org.sournd.instrument.psalmery`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 16 voices
- Tier: Free
- Version: 0.1.0
- Price: free: a closed library, free to use in your plugins, downloaded with no account or email

## Get it

Download it with no account or email: https://sournd.com/download/free/macos (macOS universal) or https://sournd.com/download/free/linux (Linux x86_64 and aarch64). One archive with every free engine and synth: static library, C headers, README. An AI agent can fetch the links with the MCP tool `get_free_download` at https://sournd.com/mcp.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 2500 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.1 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.2 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0 | - |
| 5 | `filter2_cutoff` | Second filter | 20 | 18000 | 900 | Hz |
| 6 | `filter_attack` | Filter attack | 0.5 | 10000 | 10 | ms |
| 7 | `filter_decay` | Filter decay | 5 | 10000 | 600 | ms |
| 8 | `filter_sustain` | Filter sustain | 0 | 1 | 0.6 | - |
| 9 | `filter_release` | Filter release | 5 | 10000 | 600 | ms |
| 10 | `attack` | Attack | 0.5 | 10000 | 15 | ms |
| 11 | `decay` | Decay | 5 | 10000 | 600 | ms |
| 12 | `sustain` | Sustain | 0 | 1 | 0.85 | - |
| 13 | `release` | Release | 5 | 10000 | 700 | ms |
| 14 | `detune` | Detune | 0 | 50 | 3 | cents |
| 15 | `unison` | Unison | 1 | 7 | 1 | voices |
| 16 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 17 | `sub` | Sub | 0 | 1 | 0 | - |
| 18 | `noise` | Noise | 0 | 1 | 0 | - |
| 19 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 20 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 21 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 22 | `drift` | Drift | 0 | 25 | 0.5 | cents |
| 23 | `velocity_amp` | Velocity to level | 0 | 1 | 0.2 | - |
| 24 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.1 | - |
| 25 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 26 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/quillwren/ -->
# Quillwren

> A clean workstation-style keys voice: an additive tone with a non-resonant low-pass that only darkens, never whistles, so the motion comes from the tone itself.

- Instrument id: `org.sournd.instrument.quillwren`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 16 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/quillwren/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 4500 | Hz |
| 1 | `env_amount` | Filter envelope | -1 | 1 | 0.25 | - |
| 2 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 3 | `drive` | Drive | 0 | 1 | 0 | - |
| 4 | `filter_attack` | Filter attack | 0.5 | 10000 | 2 | ms |
| 5 | `filter_decay` | Filter decay | 5 | 10000 | 1200 | ms |
| 6 | `filter_sustain` | Filter sustain | 0 | 1 | 0.3 | - |
| 7 | `filter_release` | Filter release | 5 | 10000 | 600 | ms |
| 8 | `attack` | Attack | 0.5 | 10000 | 2 | ms |
| 9 | `decay` | Decay | 5 | 10000 | 1500 | ms |
| 10 | `sustain` | Sustain | 0 | 1 | 0.5 | - |
| 11 | `release` | Release | 5 | 10000 | 700 | ms |
| 12 | `detune` | Detune | 0 | 50 | 0 | cents |
| 13 | `unison` | Unison | 1 | 7 | 1 | voices |
| 14 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 15 | `sub` | Sub | 0 | 1 | 0 | - |
| 16 | `noise` | Noise | 0 | 1 | 0 | - |
| 17 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 18 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 19 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 20 | `drift` | Drift | 0 | 25 | 0 | cents |
| 21 | `velocity_amp` | Velocity to level | 0 | 1 | 0.4 | - |
| 22 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.3 | - |
| 23 | `chorus` | Chorus | 0 | 1 | 0.25 | - |
| 24 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 25 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/rillstorm/ -->
# Rillstorm

> A heavy two-oscillator mono with a sub, saturation that keeps the bottom end under high resonance, and a second voice for two-note lines.

- Instrument id: `org.sournd.instrument.rillstorm`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 2 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/rillstorm/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 700 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.35 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.5 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.45 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 1 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 280 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.25 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 200 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 1 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 500 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.7 | - |
| 12 | `release` | Release | 5 | 10000 | 200 | ms |
| 13 | `detune` | Detune | 0 | 50 | 4 | cents |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0.5 | - |
| 17 | `noise` | Noise | 0 | 1 | 0 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 20 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 21 | `drift` | Drift | 0 | 25 | 0.1 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.25 | - |
| 24 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 25 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/russetine/ -->
# Russetine

> A warm, friendly six-voice poly: one oscillator and a sub per voice, a musical four-pole low-pass and a lush ensemble chorus.

- Instrument id: `org.sournd.instrument.russetine`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 6 voices
- Tier: Free
- Version: 0.1.0
- Price: free: a closed library, free to use in your plugins, downloaded with no account or email

## Get it

Download it with no account or email: https://sournd.com/download/free/macos (macOS universal) or https://sournd.com/download/free/linux (Linux x86_64 and aarch64). One archive with every free engine and synth: static library, C headers, README. An AI agent can fetch the links with the MCP tool `get_free_download` at https://sournd.com/mcp.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 2400 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.2 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.3 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.05 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 8 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 500 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.4 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 400 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 10 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 500 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.8 | - |
| 12 | `release` | Release | 5 | 10000 | 400 | ms |
| 13 | `unison` | Unison | 1 | 7 | 1 | voices |
| 14 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 15 | `sub` | Sub | 0 | 1 | 0.3 | - |
| 16 | `noise` | Noise | 0 | 1 | 0 | - |
| 17 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 18 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 19 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 20 | `drift` | Drift | 0 | 25 | 0.5 | cents |
| 21 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 22 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.15 | - |
| 23 | `chorus` | Chorus | 0 | 1 | 0.4 | - |
| 24 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 25 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/sackcloth/ -->
# Sackcloth

> A gritty hybrid voice: rough, aliased-sounding digital tones smoothed by a warm analogue-style low-pass, for characterful keys and basses.

- Instrument id: `org.sournd.instrument.sackcloth`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 8 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/sackcloth/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 1600 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.3 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.4 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.1 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 2 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 600 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.35 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 450 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 2 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 700 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.7 | - |
| 12 | `release` | Release | 5 | 10000 | 500 | ms |
| 13 | `detune` | Detune | 0 | 50 | 4 | cents |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0 | - |
| 17 | `noise` | Noise | 0 | 1 | 0 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 20 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 21 | `drift` | Drift | 0 | 25 | 0.01 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.25 | - |
| 24 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 25 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/sawtide/ -->
# Sawtide

> A huge stacked-saw voice: seven detuned saws spread around a centre saw, a resonant low-pass and stereo chorus, for anthemic leads and pads.

- Instrument id: `org.sournd.instrument.sawtide`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 8 voices
- Tier: Free
- Version: 0.1.0
- Price: free: a closed library, free to use in your plugins, downloaded with no account or email

## Get it

Download it with no account or email: https://sournd.com/download/free/macos (macOS universal) or https://sournd.com/download/free/linux (Linux x86_64 and aarch64). One archive with every free engine and synth: static library, C headers, README. An AI agent can fetch the links with the MCP tool `get_free_download` at https://sournd.com/mcp.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 5000 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.15 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.2 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 5 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 600 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.6 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 500 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 5 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 500 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.9 | - |
| 12 | `release` | Release | 5 | 10000 | 600 | ms |
| 13 | `detune` | Detune | 0 | 50 | 0 | cents |
| 14 | `unison` | Unison | 1 | 7 | 7 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 12 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0 | - |
| 17 | `noise` | Noise | 0 | 1 | 0 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 20 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 21 | `drift` | Drift | 0 | 25 | 1.5 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.2 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.1 | - |
| 24 | `chorus` | Chorus | 0 | 1 | 0.3 | - |
| 25 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 26 | `width` | Width | 0 | 2 | 1.4 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/scurrow/ -->
# Scurrow

> A restless hybrid voice: a phase-modulated digital tone into a chirpy, unstable two-pole filter that gets vocal and aggressive but never quite sings on its own.

- Instrument id: `org.sournd.instrument.scurrow`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 4 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/scurrow/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 1500 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.7 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.5 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.2 | - |
| 5 | `fm_index` | FM depth | 0 | 12 | 2 | - |
| 6 | `feedback` | Feedback | 0 | 1 | 0 | - |
| 7 | `filter_attack` | Tone attack | 0.5 | 10000 | 1 | ms |
| 8 | `filter_decay` | Tone decay | 5 | 10000 | 300 | ms |
| 9 | `filter_sustain` | Tone sustain | 0 | 1 | 0.25 | - |
| 10 | `filter_release` | Tone release | 5 | 10000 | 300 | ms |
| 11 | `attack` | Attack | 0.5 | 10000 | 1 | ms |
| 12 | `decay` | Decay | 5 | 10000 | 350 | ms |
| 13 | `sustain` | Sustain | 0 | 1 | 0.5 | - |
| 14 | `release` | Release | 5 | 10000 | 300 | ms |
| 15 | `noise` | Noise | 0 | 1 | 0 | - |
| 16 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 17 | `lfo_rate` | Motion rate | 0.02 | 40 | 6 | Hz |
| 18 | `lfo_amount` | Motion | 0 | 1 | 0 | - |
| 19 | `drift` | Drift | 0 | 25 | 0 | cents |
| 20 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 21 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.3 | - |
| 22 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 23 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/sequina/ -->
# Sequina

> A bright three-operator FM voice: a sharp, glassy attack that decays fast, for electric pianos, bells and slap basses.

- Instrument id: `org.sournd.instrument.sequina`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 16 voices
- Tier: Free
- Version: 0.1.0
- Price: free: a closed library, free to use in your plugins, downloaded with no account or email

## Get it

Download it with no account or email: https://sournd.com/download/free/macos (macOS universal) or https://sournd.com/download/free/linux (Linux x86_64 and aarch64). One archive with every free engine and synth: static library, C headers, README. An AI agent can fetch the links with the MCP tool `get_free_download` at https://sournd.com/mcp.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `fm_index` | FM depth | 0 | 12 | 2.5 | - |
| 1 | `feedback` | Feedback | 0 | 1 | 0 | - |
| 2 | `filter_attack` | Tone attack | 0.5 | 10000 | 1 | ms |
| 3 | `filter_decay` | Tone decay | 5 | 10000 | 450 | ms |
| 4 | `filter_sustain` | Tone sustain | 0 | 1 | 0.15 | - |
| 5 | `filter_release` | Tone release | 5 | 10000 | 400 | ms |
| 6 | `attack` | Attack | 0.5 | 10000 | 1 | ms |
| 7 | `decay` | Decay | 5 | 10000 | 1600 | ms |
| 8 | `sustain` | Sustain | 0 | 1 | 0.25 | - |
| 9 | `release` | Release | 5 | 10000 | 500 | ms |
| 10 | `noise` | Noise | 0 | 1 | 0 | - |
| 11 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 12 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 13 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 14 | `drift` | Drift | 0 | 25 | 0 | cents |
| 15 | `velocity_amp` | Velocity to level | 0 | 1 | 0.5 | - |
| 16 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 17 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/sinuate/ -->
# Sinuate

> A crisp digital voice with no filter at all: the tone itself is bent from a pure sine towards a buzzing edge by its own envelope, for bright basses, keys and brass.

- Instrument id: `org.sournd.instrument.sinuate`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 8 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/sinuate/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `fm_index` | FM depth | 0 | 12 | 2.5 | - |
| 1 | `feedback` | Feedback | 0 | 1 | 0 | - |
| 2 | `filter_attack` | Tone attack | 0.5 | 10000 | 1 | ms |
| 3 | `filter_decay` | Tone decay | 5 | 10000 | 500 | ms |
| 4 | `filter_sustain` | Tone sustain | 0 | 1 | 0.2 | - |
| 5 | `filter_release` | Tone release | 5 | 10000 | 300 | ms |
| 6 | `attack` | Attack | 0.5 | 10000 | 1 | ms |
| 7 | `decay` | Decay | 5 | 10000 | 900 | ms |
| 8 | `sustain` | Sustain | 0 | 1 | 0.6 | - |
| 9 | `release` | Release | 5 | 10000 | 400 | ms |
| 10 | `noise` | Noise | 0 | 1 | 0 | - |
| 11 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 12 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 13 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 14 | `drift` | Drift | 0 | 25 | 0 | cents |
| 15 | `velocity_amp` | Velocity to level | 0 | 1 | 0.4 | - |
| 16 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 17 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/sproutkin/ -->
# Sproutkin

> A simple, bouncy one-oscillator mono with a sub: saw and pulse into a smooth four-pole low-pass, made for basslines and chirpy leads.

- Instrument id: `org.sournd.instrument.sproutkin`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: mono
- Tier: Free
- Version: 0.1.0
- Price: free: a closed library, free to use in your plugins, downloaded with no account or email

## Get it

Download it with no account or email: https://sournd.com/download/free/macos (macOS universal) or https://sournd.com/download/free/linux (Linux x86_64 and aarch64). One archive with every free engine and synth: static library, C headers, README. An AI agent can fetch the links with the MCP tool `get_free_download` at https://sournd.com/mcp.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 1100 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.3 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.5 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.1 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 1.5 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 220 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.15 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 120 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 1.5 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 250 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.6 | - |
| 12 | `release` | Release | 5 | 10000 | 120 | ms |
| 13 | `detune` | Detune | 0 | 50 | 0 | cents |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0.4 | - |
| 17 | `noise` | Noise | 0 | 1 | 0 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 20 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 21 | `drift` | Drift | 0 | 25 | 0.5 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.4 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.2 | - |
| 24 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 25 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/squallo/ -->
# Squallo

> A punchy six-voice poly with a moving pulse width, a sub and a compressed stereo chorus, for big rave stabs, organs and basses.

- Instrument id: `org.sournd.instrument.squallo`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 6 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/squallo/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 2200 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.25 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.35 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.05 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 2 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 450 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.35 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 400 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 2 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 500 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.7 | - |
| 12 | `release` | Release | 5 | 10000 | 400 | ms |
| 13 | `detune` | Detune | 0 | 50 | 0 | cents |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0.3 | - |
| 17 | `noise` | Noise | 0 | 1 | 0 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 20 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 21 | `drift` | Drift | 0 | 25 | 0.05 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.2 | - |
| 24 | `chorus` | Chorus | 0 | 1 | 0.45 | - |
| 25 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 26 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/squidgeon/ -->
# Squidgeon

> A squelchy one-oscillator bass voice: an envelope-swept four-pole low-pass with gritty resonance, slides between notes and an accent that bites on hard hits.

- Instrument id: `org.sournd.instrument.squidgeon`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: mono
- Tier: Free
- Version: 0.1.0
- Price: free: a closed library, free to use in your plugins, downloaded with no account or email

## Get it

Download it with no account or email: https://sournd.com/download/free/macos (macOS universal) or https://sournd.com/download/free/linux (Linux x86_64 and aarch64). One archive with every free engine and synth: static library, C headers, README. An AI agent can fetch the links with the MCP tool `get_free_download` at https://sournd.com/mcp.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 450 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.75 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.7 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.3 | - |
| 4 | `drive` | Drive | 0 | 1 | 0.45 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 1.5 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 400 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 50 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 1.5 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 1800 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.2 | - |
| 12 | `release` | Release | 5 | 10000 | 15 | ms |
| 13 | `unison` | Unison | 1 | 7 | 1 | voices |
| 14 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 15 | `sub` | Sub | 0 | 1 | 0 | - |
| 16 | `noise` | Noise | 0 | 1 | 0 | - |
| 17 | `glide` | Glide | 0 | 2000 | 60 | ms |
| 18 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 19 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 20 | `drift` | Drift | 0 | 25 | 2 | cents |
| 21 | `velocity_amp` | Velocity to level | 0 | 1 | 0.5 | - |
| 22 | `velocity_cutoff` | Accent | 0 | 1 | 0.5 | - |
| 23 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 24 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/swarmora/ -->
# Swarmora

> Coupled oscillators that pull into tune: a detuned swarm of sines per note that pull draws into one pitched tone and chaos breaks into rough motion.

- Instrument id: `org.sournd.instrument.swarmora`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 8 voices
- Tier: Free
- Version: 0.1.0
- Price: free: a closed library, free to use in your plugins, downloaded with no account or email

## Get it

Download it with no account or email: https://sournd.com/download/free/macos (macOS universal) or https://sournd.com/download/free/linux (Linux x86_64 and aarch64). One archive with every free engine and synth: static library, C headers, README. An AI agent can fetch the links with the MCP tool `get_free_download` at https://sournd.com/mcp.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `pull` | Pull | 0 | 100 | 70 | % |
| 1 | `scatter` | Scatter | 0 | 100 | 30 | cents |
| 2 | `chaos` | Chaos | 0 | 100 | 0 | % |
| 3 | `size` | Swarm size | 4 | 12 | 8 | oscillators |
| 4 | `ratio_set` | Ratio set | 0 | 3 | 0 | - |
| 5 | `kick` | Kick | 0 | 100 | 40 | % |
| 6 | `brightness` | Operator brightness | 0 | 100 | 0 | % |
| 7 | `gather` | Gather | 1 | 8000 | 400 | ms |
| 8 | `tone` | Tone | 200 | 18000 | 6000 | Hz |
| 9 | `glow` | Lock to tone | 0 | 100 | 30 | % |
| 10 | `attack` | Attack | 1 | 10000 | 30 | ms |
| 11 | `decay` | Decay | 5 | 20000 | 800 | ms |
| 12 | `sustain` | Sustain | 0 | 100 | 80 | % |
| 13 | `release` | Release | 5 | 10000 | 900 | ms |
| 14 | `width` | Width | 0 | 100 | 60 | % |
| 15 | `pressure_pull` | Pressure to pull | 0 | 100 | 0 | % |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/tangelle/ -->
# Tangelle

> Six sine operators in a fully patchable feedback network that weaves between two topologies, held at the edge of chaos by a loop governor.

- Instrument id: `org.sournd.instrument.tangelle`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 16 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/tangelle/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `weave` | Weave | 0 | 1 | 0 | - |
| 1 | `tension` | Tension | 0 | 2 | 1 | x |
| 2 | `fray` | Fray | 0.02 | 0.6 | 0.25 | - |
| 3 | `ratio_set` | Ratio set | 0 | 3 | 3 | - |
| 4 | `brightness` | Brightness | 0 | 2 | 1 | x |
| 5 | `env_time` | Operator envelope time | 0.1 | 10 | 1 | x |
| 6 | `velocity_index` | Velocity to index | 0 | 1 | 0.5 | - |
| 7 | `pressure_tension` | Pressure to tension | 0 | 1 | 0 | - |
| 8 | `attack` | Attack | 0.5 | 10000 | 3 | ms |
| 9 | `decay` | Decay | 5 | 20000 | 1500 | ms |
| 10 | `sustain` | Sustain | 0 | 1 | 0.7 | - |
| 11 | `release` | Release | 5 | 20000 | 600 | ms |
| 12 | `detune` | Detune spread | 0 | 50 | 0 | cents |
| 13 | `width` | Width | 0 | 1 | 0.5 | - |
| 14 | `level` | Level | 0 | 1 | 0.5 | - |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/vapora/ -->
# Vapora

> A lively six-voice poly for stabs and plucks: saw and sub through a resonant low-pass, a free-running wobble and a warm stereo chorus.

- Instrument id: `org.sournd.instrument.vapora`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 6 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/vapora/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 1500 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.4 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.45 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0 | - |
| 5 | `filter2_cutoff` | Second filter | 20 | 18000 | 90 | Hz |
| 6 | `filter_attack` | Filter attack | 0.5 | 10000 | 1.5 | ms |
| 7 | `filter_decay` | Filter decay | 5 | 10000 | 280 | ms |
| 8 | `filter_sustain` | Filter sustain | 0 | 1 | 0.2 | - |
| 9 | `filter_release` | Filter release | 5 | 10000 | 300 | ms |
| 10 | `attack` | Attack | 0.5 | 10000 | 1.5 | ms |
| 11 | `decay` | Decay | 5 | 10000 | 300 | ms |
| 12 | `sustain` | Sustain | 0 | 1 | 0.5 | - |
| 13 | `release` | Release | 5 | 10000 | 300 | ms |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0.5 | - |
| 17 | `noise` | Noise | 0 | 1 | 0 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `lfo_rate` | Motion rate | 0.02 | 40 | 4.5 | Hz |
| 20 | `lfo_amount` | Motion | 0 | 1 | 0.05 | - |
| 21 | `drift` | Drift | 0 | 25 | 0.05 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.2 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.15 | - |
| 24 | `chorus` | Chorus | 0 | 1 | 0.45 | - |
| 25 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 26 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/varnisha/ -->
# Varnisha

> A bright, polished digital voice: stacked oscillators an octave apart into a clean resonant low-pass, for sparkling pads and keys.

- Instrument id: `org.sournd.instrument.varnisha`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 16 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/varnisha/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 6000 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.35 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.25 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 5 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 900 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.5 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 800 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 5 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 900 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.8 | - |
| 12 | `release` | Release | 5 | 10000 | 900 | ms |
| 13 | `detune` | Detune | 0 | 50 | 7 | cents |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0 | - |
| 17 | `noise` | Noise | 0 | 1 | 0 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 20 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 21 | `drift` | Drift | 0 | 25 | 0 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.2 | - |
| 24 | `chorus` | Chorus | 0 | 1 | 0.3 | - |
| 25 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 26 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/velluto/ -->
# Velluto

> A velvety six-voice poly with a two-pole state-variable filter that keeps its bass at any resonance, shape-blending oscillators and stereo chorus.

- Instrument id: `org.sournd.instrument.velluto`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 6 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/velluto/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 2800 | Hz |
| 1 | `resonance` | Resonance | 0 | 0.98 | 0.45 | - |
| 2 | `env_amount` | Filter envelope | -1 | 1 | 0.3 | - |
| 3 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 4 | `drive` | Drive | 0 | 1 | 0 | - |
| 5 | `filter_attack` | Filter attack | 0.5 | 10000 | 4 | ms |
| 6 | `filter_decay` | Filter decay | 5 | 10000 | 550 | ms |
| 7 | `filter_sustain` | Filter sustain | 0 | 1 | 0.4 | - |
| 8 | `filter_release` | Filter release | 5 | 10000 | 500 | ms |
| 9 | `attack` | Attack | 0.5 | 10000 | 5 | ms |
| 10 | `decay` | Decay | 5 | 10000 | 600 | ms |
| 11 | `sustain` | Sustain | 0 | 1 | 0.8 | - |
| 12 | `release` | Release | 5 | 10000 | 600 | ms |
| 13 | `detune` | Detune | 0 | 50 | 5 | cents |
| 14 | `unison` | Unison | 1 | 7 | 1 | voices |
| 15 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 16 | `sub` | Sub | 0 | 1 | 0 | - |
| 17 | `noise` | Noise | 0 | 1 | 0 | - |
| 18 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 19 | `vibrato_rate` | Vibrato rate | 0.02 | 40 | 5.5 | Hz |
| 20 | `vibrato` | Vibrato | 0 | 100 | 0 | cents |
| 21 | `drift` | Drift | 0 | 25 | 1.5 | cents |
| 22 | `velocity_amp` | Velocity to level | 0 | 1 | 0.3 | - |
| 23 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.2 | - |
| 24 | `chorus` | Chorus | 0 | 1 | 0.3 | - |
| 25 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 26 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/wanderwave/ -->
# Wanderwave

> An evolving digital pad: tones that morph slowly under a tempo-locked stepping filter, with chorus and a dotted echo, for moving textures.

- Instrument id: `org.sournd.instrument.wanderwave`
- Kind: instrument (a synth you play with notes, keys or MIDI)
- Voices: 16 voices
- Tier: Paid
- Version: 0.1.0
- Price: £4.99 once (yours for good, with updates), or in the Synths and Everything plans

## Get it

Buy it once for £4.99 (https://sournd.com/sounds/wanderwave/, PayPal, no account), or get every synth with the Everything plan (https://sournd.com/pricing/index.md). An AI agent can quote it with the MCP tool `get_price` and start a checkout with `create_checkout`.

## Parameters

| Id | Key | Name | Min | Max | Default | Unit |
|---|---|---|---|---|---|---|
| 0 | `cutoff` | Cutoff | 30 | 18000 | 3000 | Hz |
| 1 | `env_amount` | Filter envelope | -1 | 1 | 0.2 | - |
| 2 | `key_track` | Key tracking | 0 | 1 | 0.5 | - |
| 3 | `drive` | Drive | 0 | 1 | 0 | - |
| 4 | `filter_attack` | Filter attack | 0.5 | 10000 | 300 | ms |
| 5 | `filter_decay` | Filter decay | 5 | 10000 | 2000 | ms |
| 6 | `filter_sustain` | Filter sustain | 0 | 1 | 0.6 | - |
| 7 | `filter_release` | Filter release | 5 | 10000 | 1500 | ms |
| 8 | `attack` | Attack | 0.5 | 10000 | 400 | ms |
| 9 | `decay` | Decay | 5 | 10000 | 2000 | ms |
| 10 | `sustain` | Sustain | 0 | 1 | 0.8 | - |
| 11 | `release` | Release | 5 | 10000 | 2000 | ms |
| 12 | `detune` | Detune | 0 | 50 | 4 | cents |
| 13 | `unison` | Unison | 1 | 7 | 1 | voices |
| 14 | `unison_spread` | Unison spread | 0 | 50 | 10 | cents |
| 15 | `sub` | Sub | 0 | 1 | 0 | - |
| 16 | `noise` | Noise | 0 | 1 | 0 | - |
| 17 | `glide` | Glide | 0 | 2000 | 0 | ms |
| 18 | `lfo_rate` | Motion rate | 0.02 | 40 | 0.25 | Hz |
| 19 | `lfo_amount` | Motion | 0 | 1 | 0.6 | - |
| 20 | `drift` | Drift | 0 | 25 | 0 | cents |
| 21 | `velocity_amp` | Velocity to level | 0 | 1 | 0.2 | - |
| 22 | `velocity_cutoff` | Velocity to cutoff | 0 | 1 | 0.1 | - |
| 23 | `chorus` | Chorus | 0 | 1 | 0.4 | - |
| 24 | `echo` | Echo | 0 | 1 | 0.2 | - |
| 25 | `bend_range` | Bend range | 0 | 24 | 2 | st |
| 26 | `width` | Width | 0 | 2 | 1 | x |

## Play it from code

Instruments use the same C ABI as effects, plus note input: `sournd_engine_note_on(e, note, velocity, sample_offset)`, `sournd_engine_note_off(e, note, sample_offset)` and `sournd_engine_all_notes_off(e)`. In JUCE, the bridge feeds your `MidiBuffer` straight in. See the [C ABI reference](https://sournd.com/docs/abi/index.md).


---

<!-- https://sournd.com/sounds/ -->
# Sounds

> 42 instrument engines (synths you play), 7 free (downloaded with no account or email), the rest £4.99 each or in the Everything plan.

Free synths: https://sournd.com/download/free/macos (macOS) or https://sournd.com/download/free/linux (Linux), one archive with every free engine and synth; an AI agent can use the MCP tool `get_free_download`. Every instrument is also in https://sournd.com/catalog.json (category `instrument`).

- [Braidel](https://sournd.com/sounds/braidel/index.md): A four-voice paraphonic keyboard voice: braided oscillators through one warm low-pass, with a dark, wobbling echo behind it.
- [Brazier](https://sournd.com/sounds/brazier/index.md): A modern six-voice analogue poly: saw and pulse per voice, a resonant low-pass after a clean high-pass, and a wide stereo chorus.
- [Bristle](https://sournd.com/sounds/bristle/index.md): A bright, buzzy two-voice synth with snappy percussive envelopes and a biting two-pole filter that screams when the resonance goes up.
- [Cantilla](https://sournd.com/sounds/cantilla/index.md): Sings vowels by frequency modulation: formants locked in place as the pitch glides, a two-axis vowel pad, throat, breath, vibrato and ensemble. Vowels only: no words, lyrics or likeness of any voice.
- [Cavitas](https://sournd.com/sounds/cavitas/index.md): A breathy, eerie pad voice: a vowel-like tone with air in it, closed down by a smooth low-pass, like an old sampler playing a choir.
- [Chitinel](https://sournd.com/sounds/chitinel/index.md): A powerful virtual analogue voice: saturation between the filter stages keeps the bass under high resonance, with a second band-pass filter in parallel.
- [Crankshaft](https://sournd.com/sounds/crankshaft/index.md): A punchy virtual analogue lead: a hard-synced oscillator swept by its own envelope, a bright resonant low-pass and a short glide.
- [Crystelle](https://sournd.com/sounds/crystelle/index.md): A glassy digital pad voice: a breathy, bell-like partial layer over a resonant digital low-pass, with chorus and a soft echo trail.
- [Duskfall](https://sournd.com/sounds/duskfall/index.md): A grand, expressive eight-voice poly: two detuned layers per voice, high-pass into low-pass, slow swelling filter and pressure that opens the tone as you lean in.
- [Fanfara](https://sournd.com/sounds/fanfara/index.md): A bold eight-voice brass poly: two wide-detuned saws per voice through an open, fizzy two-pole low-pass for stabs and big chords.
- [Fibrel](https://sournd.com/sounds/fibrel/index.md): A clean, modern hybrid poly: pristine digital oscillators into a warm analogue-style low-pass with drive, for bright pads and leads.
- [Forgewren](https://sournd.com/sounds/forgewren/index.md): A fat three-oscillator mono for bass and lead: punchy exponential envelopes, a warm four-pole low-pass that thins its lows as the resonance climbs, and a little drift.
- [Gridwork](https://sournd.com/sounds/gridwork/index.md): A semi-modular style mono: three oscillators, noise and a resonant four-pole low-pass for leads, basses and odd effects.
- [Herald](https://sournd.com/sounds/herald/index.md): A silky eight-voice poly: saw and pulse per voice, smooth envelopes and a warm four-pole low-pass that self-oscillates cleanly.
- [Hessian](https://sournd.com/sounds/hessian/index.md): A punchy hybrid voice: a short, clicky transient on every note over a grainy digital tone and a warm low-pass, for plucks and stabs.
- [Hobstone](https://sournd.com/sounds/hobstone/index.md): A warm five-voice analogue poly: two detuned oscillators per voice, a creamy four-pole low-pass and exponential envelopes for pads, brass and keys.
- [Howlmere](https://sournd.com/sounds/howlmere/index.md): A raw, snarling mono: a high-pass into a driven two-pole low-pass whose resonance howls and distorts as you open it.
- [Ingotry](https://sournd.com/sounds/ingotry/index.md): A solid two-oscillator mono: saw and square into a resonant four-pole low-pass with snappy envelopes, for tight basses and clean leads.
- [Inlay](https://sournd.com/sounds/inlay/index.md): A rich digital voice built from layered tones and a choice of digital filters, here a resonant low-pass after a notch, for strings, pads and evolving keys.
- [Knotwork](https://sournd.com/sounds/knotwork/index.md): A wild, unstable mono for drones and effects: wandering oscillators, noise and a squelchy low-pass that breaks into distortion before it sings.
- [Lullwick](https://sournd.com/sounds/lullwick/index.md): A soft-edged six-voice poly: a pulse-led oscillator, a smooth low-pass that tracks the keyboard and a slightly faster stereo chorus for keys and leads.
- [Nimbel](https://sournd.com/sounds/nimbel/index.md): A clean one-oscillator poly wrapped in a wide, shimmering stereo chorus: the chorus is the sound, for pads, chords and gentle keys.
- [Parada](https://sournd.com/sounds/parada/index.md): A lavish eight-voice poly: two detuned oscillators per voice, a liquid switchable low-pass and envelopes with a huge range, from plucks to slow swells.
- [Polisk](https://sournd.com/sounds/polisk/index.md): A polished, modern three-oscillator mono with two low-pass filters side by side for a wide, glossy lead that still growls when pushed.
- [Psalmery](https://sournd.com/sounds/psalmery/index.md): A fully polyphonic, organ-like voice: every key sounds, with a buzzy resonant band in parallel with a smooth master low-pass, for strings and choirs.
- [Quillwren](https://sournd.com/sounds/quillwren/index.md): A clean workstation-style keys voice: an additive tone with a non-resonant low-pass that only darkens, never whistles, so the motion comes from the tone itself.
- [Rillstorm](https://sournd.com/sounds/rillstorm/index.md): A heavy two-oscillator mono with a sub, saturation that keeps the bottom end under high resonance, and a second voice for two-note lines.
- [Russetine](https://sournd.com/sounds/russetine/index.md): A warm, friendly six-voice poly: one oscillator and a sub per voice, a musical four-pole low-pass and a lush ensemble chorus.
- [Sackcloth](https://sournd.com/sounds/sackcloth/index.md): A gritty hybrid voice: rough, aliased-sounding digital tones smoothed by a warm analogue-style low-pass, for characterful keys and basses.
- [Sawtide](https://sournd.com/sounds/sawtide/index.md): A huge stacked-saw voice: seven detuned saws spread around a centre saw, a resonant low-pass and stereo chorus, for anthemic leads and pads.
- [Scurrow](https://sournd.com/sounds/scurrow/index.md): A restless hybrid voice: a phase-modulated digital tone into a chirpy, unstable two-pole filter that gets vocal and aggressive but never quite sings on its own.
- [Sequina](https://sournd.com/sounds/sequina/index.md): A bright three-operator FM voice: a sharp, glassy attack that decays fast, for electric pianos, bells and slap basses.
- [Sinuate](https://sournd.com/sounds/sinuate/index.md): A crisp digital voice with no filter at all: the tone itself is bent from a pure sine towards a buzzing edge by its own envelope, for bright basses, keys and brass.
- [Sproutkin](https://sournd.com/sounds/sproutkin/index.md): A simple, bouncy one-oscillator mono with a sub: saw and pulse into a smooth four-pole low-pass, made for basslines and chirpy leads.
- [Squallo](https://sournd.com/sounds/squallo/index.md): A punchy six-voice poly with a moving pulse width, a sub and a compressed stereo chorus, for big rave stabs, organs and basses.
- [Squidgeon](https://sournd.com/sounds/squidgeon/index.md): A squelchy one-oscillator bass voice: an envelope-swept four-pole low-pass with gritty resonance, slides between notes and an accent that bites on hard hits.
- [Swarmora](https://sournd.com/sounds/swarmora/index.md): Coupled oscillators that pull into tune: a detuned swarm of sines per note that pull draws into one pitched tone and chaos breaks into rough motion.
- [Tangelle](https://sournd.com/sounds/tangelle/index.md): Six sine operators in a fully patchable feedback network that weaves between two topologies, held at the edge of chaos by a loop governor.
- [Vapora](https://sournd.com/sounds/vapora/index.md): A lively six-voice poly for stabs and plucks: saw and sub through a resonant low-pass, a free-running wobble and a warm stereo chorus.
- [Varnisha](https://sournd.com/sounds/varnisha/index.md): A bright, polished digital voice: stacked oscillators an octave apart into a clean resonant low-pass, for sparkling pads and keys.
- [Velluto](https://sournd.com/sounds/velluto/index.md): A velvety six-voice poly with a two-pole state-variable filter that keeps its bass at any resonance, shape-blending oscillators and stereo chorus.
- [Wanderwave](https://sournd.com/sounds/wanderwave/index.md): An evolving digital pad: tones that morph slowly under a tempo-locked stepping filter, with chorus and a dotted echo, for moving textures.


---

<!-- https://sournd.com/docs/juce/ -->
# JUCE quick start

> Add a sournd engine to a JUCE 8 plugin. Three CMake lines, three C++ objects, no Rust toolchain on your machine.

```flow
Download | the JUCE module and your engine library -> CMake | three lines -> Three C++ objects | engine, parameters, bridge -> Your plugin | built by JUCE as usual
```

## What you get

- `sournd_engine`, a standard JUCE module that depends only on `juce_audio_processors` and `juce_dsp` (Apache-2.0). Download it: [sournd-engine-juce-module.zip](https://sournd.com/downloads/sournd-engine-juce-module.zip).
- A static library for your platform (`libsournd_cabi.a`, or `sournd_cabi.lib` on Windows) and the header `sournd_engine.h`: the free engines from any free engine's page (https://sournd.com/download/free/macos, https://sournd.com/download/free/linux, https://sournd.com/download/free/windows), paid ones from Your engines.
- `SourndEngine`, which implements `juce::dsp::ProcessorBase`, and `SourndEngineParameters`, which builds an APVTS layout from the engine and keeps them in step.

## 1. Add the module and the library

Unzip the module so you have a `sournd_engine` folder, and unzip your engine download next to it.

```cmake
juce_add_module(path/to/sournd_engine)
target_include_directories(MyPlugin PRIVATE path/to/include)            # sournd_engine.h
target_link_libraries(MyPlugin PRIVATE sournd_engine path/to/libsournd_cabi.a)
```

For a universal macOS plugin, build with `-DCMAKE_OSX_ARCHITECTURES='arm64;x86_64'` and link the universal archive.

On Linux the download has one archive per architecture. Pick the one for the machine you build for and add the system libraries it needs:

```cmake
if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64")
  set(SOURND_ARCH linux-aarch64)
else()
  set(SOURND_ARCH linux-x86_64)
endif()
target_link_libraries(MyPlugin PRIVATE sournd_engine
    path/to/lib/${SOURND_ARCH}/libsournd_cabi.a pthread dl m)
```

## 2. Create the engine, its parameters and the bridge

Construct them in this order, on the message thread:

```cpp
#include <sournd_engine/sournd_engine.h>

class MyPlugin final : public juce::AudioProcessor
{
public:
    MyPlugin()
        : AudioProcessor (BusesProperties().withInput ("Input", juce::AudioChannelSet::stereo())
                                           .withOutput ("Output", juce::AudioChannelSet::stereo())),
          engine ("org.sournd.reverb.roomette"),
          parameters (*this, nullptr, "Parameters", sournd::SourndEngineParameters::createLayout (engine)),
          bridge (engine, parameters)
    { jassert (engine.isValid()); }

    void prepareToPlay (double rate, int maximumBlock) override
    {
        engine.prepare ({ rate, (juce::uint32) maximumBlock, (juce::uint32) getTotalNumOutputChannels() });
        bridge.prepare (rate);
        setLatencySamples ((int) engine.latency());
    }

    void processBlock (juce::AudioBuffer<float>& buffer, juce::MidiBuffer&) override
    {
        bridge.apply ((uint32_t) buffer.getNumSamples());
        juce::dsp::AudioBlock<float> block { buffer };
        engine.process (juce::dsp::ProcessContextReplacing<float> { block });
    }

    void getStateInformation (juce::MemoryBlock& destination) override
    {
        // Hosts can ask for state during playback: JUCE's callback lock keeps processBlock out
        // while the engine is read (the C ABI allows one call at a time per engine).
        const juce::ScopedLock lock (getCallbackLock());
        bridge.syncToEngine();
        destination = engine.saveState();
    }

    void setStateInformation (const void* data, int bytes) override
    {
        if (bytes < 0) return;
        const juce::ScopedLock lock (getCallbackLock());
        if (engine.loadState (data, (size_t) bytes)) bridge.syncFromEngine();
    }

    double getTailLengthSeconds() const override { return engine.tailSeconds(); }

private:
    sournd::SourndEngine engine;
    juce::AudioProcessorValueTreeState parameters;
    sournd::SourndEngineParameters bridge;
};
```

What happens at run time:

```flow
Every block :: Host | knobs and automation -> APVTS | your plugin's parameters -> `bridge.apply` | changed values, once a block -> `engine.process` | smooths sample by sample -> Audio out
Saving :: Host asks for state -> `getCallbackLock()` | keeps `processBlock` out -> `bridge.syncToEngine()` -> `engine.saveState()` | an opaque blob
Loading :: Host hands state back -> `getCallbackLock()` -> `engine.loadState()` | matched by parameter id -> `bridge.syncFromEngine()`
```

## 3. Choose an engine

Pick any id from the [catalogue](/engines/index.md) or [catalog.json](https://sournd.com/catalog.json). An unknown id produces an invalid engine that outputs silence, so check `isValid()` and `lastError()`.

## Rules worth knowing

- Parameter ids are stable decimal strings: the position of the parameter in the engine's manifest, shown on every engine page. Parameters are only ever added, never renumbered.
- Host ranges follow each parameter's taper. A log parameter (cutoff, time, ratio) maps the host's 0 to 1 as `min * (max / min)^p`, so automation lanes and generic editors move in equal ratios, as the engine's own knobs do. If you already shipped a plugin with linear ranges, pass `createLayout (engine, false)` to keep them, because hosts store automation as 0 to 1 values.
- `bridge.apply` hands each changed value to the engine at the start of the block. The engine smooths continuous controls itself, sample by sample, so the sound does not depend on the host's block size (tested bit for bit at 1, 32, 64 and 512 frames). Stepped and boolean controls snap.
- Frames per call must fit the maximum passed to `prepare`. The wrapper does not split host blocks.
- State is opaque and tied to the engine id. It stores settings, not delay or filter history. It migrates across engine versions: values are matched by parameter id, parameters added since the session was saved take their defaults, and values from a newer engine that this one lacks are ignored (`lastStateReport()` counts both). A state is refused, with nothing changed, only when it belongs to another engine or is damaged.
- The audio thread never allocates, locks or calls the message manager. Use one engine instance per processing thread.
- Calls into one engine must not overlap. Anything outside `processBlock` that touches the engine (saving or loading state, `prepare`, `reset`) holds `getCallbackLock()`, as above, so it never runs while audio is processed.

## Limits

These are the edges of the bridge today.

- **Audio is 32-bit float.** The bridge processes `float` buffers only. Leave `supportsDoublePrecisionProcessing()` at its default (`false`), so hosts hand your plugin float audio.
- **Mono or stereo, the same on input and output.** One or two main channels; mono to stereo, stereo to mono and surround layouts are not supported. Some engines run in stereo only, so ask the engine in `isBusesLayoutSupported` rather than assuming (below). `supportsChannels` prepares a scratch instance, so cache the answer rather than calling it on the audio thread.
- **Sidechain** engines accept a disconnected, mono or stereo auxiliary input.
- **MIDI.** Effects ignore the MIDI buffer, and the bridge never produces MIDI. Instrument engines read note on, note off and all notes off (CC 120 and 123) at their sample positions, on every channel; pitch bend, aftertouch, other controllers and MPE are not passed on.
- **Sample rates** from 8 kHz to 768 kHz, and up to 1,048,576 frames per block.
- **Hidden** engine parameters stay inside the engine's state and are not host controls.

```cpp
bool isBusesLayoutSupported (const BusesLayout& layout) const override
{
    const auto& in = layout.getMainInputChannelSet();
    return in == layout.getMainOutputChannelSet()
        && ((in == juce::AudioChannelSet::mono() && mono) || (in == juce::AudioChannelSet::stereo() && stereo));
}
// members, after engine:
const bool mono = engine.supportsChannels (1), stereo = engine.supportsChannels (2);
```

## Platforms

Downloads are built for macOS universal (arm64 and x86_64), Linux (x86_64 and aarch64, glibc 2.36 or newer) and Windows x64 (MSVC). Pick the platform when you download from your engines page; an agent asks for it with `platform=linux` or `platform=windows-x64`.

On Windows the zip holds two copies of `sournd_cabi.lib`: `lib/windows-x64/` for projects on the dynamic C runtime (`/MD`, the MSVC default) and `lib/windows-x64-static-crt/` for the static one (`/MT`). Link the one that matches your plugin, followed by `kernel32 ntdll userenv ws2_32 dbghelp`. The README in the zip has the CMake lines.

## Licensing

The JUCE module and C header are Apache-2.0, so they link into GPL or commercial JUCE projects. JUCE itself has its own licence and plans, which a sournd licence does not cover: follow the [JUCE 8 licence](https://juce.com/legal/juce-8-licence/) and choose the [JUCE plan](https://juce.com/get-juce/) that fits what you ship. Paid engines ship as closed static libraries. See [licensing](/docs/licensing/index.md).


---

<!-- https://sournd.com/docs/abi/ -->
# C ABI reference

> Version 1. A small, versioned C interface to every sournd engine. The JUCE module is a thin wrapper over it; you can call it from any language with a C FFI.

## Life of an engine

```flow
Control thread, audio stopped :: `abi_version` | check it first -> `create` -> `prepare` -> `load_state` | if there is one -> `save_state` -> `destroy`
Audio thread, real-time safe :: `set_param` -> `process` | no more frames than prepared -> `latency`, `tail_seconds` and the readouts
```

## Rules

- Check `sournd_engine_abi_version()` equals `SOURND_ENGINE_ABI_VERSION` before creating an engine.
- Serialise every call for one instance. Use one instance per processing thread.
- Control thread, audio stopped: `create`, `destroy`, `prepare`, `prepare_layout`, `save_state`, `load_state`, `value_to_text` and the metadata calls.
- Audio thread, real-time safe: `process`, `process_sidechain`, `reset`, `set_param`, `get_param`, `latency`, `tail_seconds` and the readouts.
- Parameter ids are the position of the parameter in the engine's manifest.
- Strings are UTF-8 and NUL terminated. Catalogue strings live for the library lifetime; parameter strings live until `destroy`.
- `process` takes one or two channels, `frames` no more than the prepared maximum. In-place is allowed; output channels must not overlap. Zero frames is a no-op.
- Query state size with `save_state(e, NULL, 0, &size)`, allocate, then save.
- `load_state` migrates across engine versions: saved values are matched by parameter id, parameters the state lacks take their defaults, and ids the engine no longer has are ignored. `state_report` counts both for the last load. Only another engine's state or damaged data is refused, and then nothing changes.
- `SOURND_PARAM_LOG` marks a log taper: a host proportion `p` in 0 to 1 is `min * (max / min)^p`. Without it the range is linear.
- On `SOURND_PANIC` the instance is poisoned: only `destroy` is permitted.

## Status codes

| Code | Name | Meaning |
|---|---|---|
| 0 | `SOURND_OK` | Success |
| -1 | `SOURND_INVALID` | Null pointer, out-of-range value or bad argument |
| -2 | `SOURND_NOT_FOUND` | Unknown engine id, parameter id or index |
| -3 | `SOURND_BUFFER_TOO_SMALL` | Output buffer too small; query the size first |
| -4 | `SOURND_NOT_PREPARED` | Call `prepare` before processing |
| -5 | `SOURND_PANIC` | The engine failed; destroy the instance |
| -6 | `SOURND_UNSUPPORTED` | Layout or feature not supported by this engine |

## Header

```c
// SPDX-License-Identifier: Apache-2.0
#ifndef SOURND_ENGINE_H
#define SOURND_ENGINE_H
#include <stdint.h>
#include <stddef.h>
#define SOURND_ENGINE_ABI_VERSION 1u
#ifdef __cplusplus
extern "C" {
#endif
typedef struct sournd_engine sournd_engine;
enum { SOURND_OK=0, SOURND_INVALID=-1, SOURND_NOT_FOUND=-2, SOURND_BUFFER_TOO_SMALL=-3,
       SOURND_NOT_PREPARED=-4, SOURND_PANIC=-5, SOURND_UNSUPPORTED=-6,
       SOURND_QUEUE_FULL=-7 };
/* Descriptor flags. INSTRUMENT: an engine the musician plays with notes (catalogue kind
   "instrument"); see the note input section below. */
enum { SOURND_ENGINE_SIDECHAIN=1, SOURND_ENGINE_INSTRUMENT=2 };
/* Note events one instance holds for its next process call. */
#define SOURND_NOTE_QUEUE_CAPACITY 256u
/* LOG (added to ABI version 1 append-only): the parameter has a logarithmic taper, so equal
   travel is an equal ratio: value = min * pow(max / min, p) for a proportion p in 0..1. Only
   set when 0 < min < max. Without it the taper is linear. Hosts and UIs that ignore the flag
   still work; they show a linear range. */
enum { SOURND_PARAM_STEPPED=1, SOURND_PARAM_BOOL=2, SOURND_PARAM_HIDDEN=4, SOURND_PARAM_LOG=8 };
/* UTF-8, NUL terminated. Metadata remains valid until destroy (catalogue info: forever). */
typedef struct { const char *id, *name, *version; uint32_t flags; } sournd_engine_descriptor;
typedef struct { uint32_t id; const char *name; double min, max, default_value;
                 const char *unit; uint32_t flags; } sournd_param_descriptor;
uint32_t sournd_engine_abi_version(void);
uint32_t sournd_engine_count(void);
int32_t sournd_engine_info(uint32_t index, sournd_engine_descriptor *out);
int32_t sournd_engine_create(const char *id, sournd_engine **out);
int32_t sournd_engine_destroy(sournd_engine *engine);
int32_t sournd_engine_param_count(sournd_engine *engine, uint32_t *out);
int32_t sournd_engine_param_info(sournd_engine *engine, uint32_t index, sournd_param_descriptor *out);
int32_t sournd_engine_value_to_text(sournd_engine *engine, uint32_t id, double value, char *out, size_t capacity);
int32_t sournd_engine_prepare(sournd_engine *engine, double sample_rate, uint32_t max_block);
/* Explicit layout for Processor implementations whose prepare depends on bus width.
   prepare() selects stereo and, when declared, stereo sidechain. */
int32_t sournd_engine_prepare_layout(sournd_engine *engine, double sample_rate, uint32_t max_block, uint32_t channels, uint32_t side_channels);
int32_t sournd_engine_reset(sournd_engine *engine);
int32_t sournd_engine_set_param(sournd_engine *engine, uint32_t id, double value);
int32_t sournd_engine_get_param(sournd_engine *engine, uint32_t id, double *out);
/* One or two channels, frames <= prepared max_block. In-place is allowed. Output channels
   must not overlap each other. Sidechain can be absent (0 channels), mono or stereo.
   Buffers and pointer arrays must be valid for the call. Zero frames is a no-op.
   An instrument may be given in=NULL (it hears silence); effects require input. */
int32_t sournd_engine_process(sournd_engine *engine, const float *const *in, float *const *out, uint32_t channels, uint32_t frames);
int32_t sournd_engine_process_sidechain(sournd_engine *engine, const float *const *in, float *const *out, uint32_t channels, const float *const *side, uint32_t side_channels, uint32_t frames);
int32_t sournd_engine_latency(sournd_engine *engine, uint32_t *out);
int32_t sournd_engine_tail_seconds(sournd_engine *engine, double *out);
int32_t sournd_engine_readout_count(sournd_engine *engine, uint32_t *out);
int32_t sournd_engine_readout_value(sournd_engine *engine, uint32_t index, double *out);
/* Note input (instruments). Added to ABI version 1 append-only: effects and existing calls
   are unchanged, and a v1 host that never calls these sees no difference.
   is_instrument returns 1 for an instrument, 0 for an effect, or a negative status.
   note_on/note_off/all_notes_off follow the threading rules of set_param: audio thread (or
   any thread that owns the instance), serialised with process, called before the process
   call they belong to. They never allocate, lock or block.
   Timing: sample_offset is a frame position inside the NEXT process call; 0 is its first
   frame. Each event takes effect before the frame at its offset (the engine splits the
   block there). Events at the same offset apply in call order; events need not be sent in
   offset order. An offset at or past the frame count of the next process call is carried,
   not dropped: it takes effect at frame 0 of the call after that. A zero-frame process call
   applies and carries nothing.
   Arguments: note is a MIDI note number 0..127; velocity is 0..1 (a note_on at velocity 0 is a
   note_off, as in MIDI); sample_offset must be below the prepared max_block. Status codes:
   SOURND_INVALID for a NULL engine or a bad note, velocity (NaN, infinite, outside 0..1) or
   offset; SOURND_UNSUPPORTED on an effect; SOURND_NOT_PREPARED before prepare;
   SOURND_QUEUE_FULL when SOURND_NOTE_QUEUE_CAPACITY events already wait for the next process
   call: that event is refused and nothing else changes (send all_notes_off to recover).
   all_notes_off ends every note at once and drops every queued event; it works prepared or
   not (SOURND_UNSUPPORTED on an effect). prepare, prepare_layout and reset also drop queued
   events. */
int32_t sournd_engine_is_instrument(sournd_engine *engine);
int32_t sournd_engine_note_on(sournd_engine *engine, uint32_t note, float velocity, uint32_t sample_offset);
int32_t sournd_engine_note_off(sournd_engine *engine, uint32_t note, uint32_t sample_offset);
int32_t sournd_engine_all_notes_off(sournd_engine *engine);
/* Control thread, audio stopped. Query required length using out=NULL, capacity=0.
   State is engine-specific and versioned; it preserves settings, not delay history.
   Loading migrates across engine versions: saved parameters are matched by id (never by
   position or count), a current parameter the state lacks takes its default, and a saved id
   this version does not have is ignored. Loading refuses the whole state (SOURND_INVALID,
   nothing changes) only on a genuine clash: another engine's id, a value that is not finite,
   outside the parameter's range or fractional for a stepped or switch parameter, an id saved
   twice, or a truncated or malformed envelope.
   state_report (added to ABI version 1 append-only) gives what the last successful load
   migrated: ignored = saved ids this version does not have, defaulted = parameters set to
   their default. Both are 0 before any load. */
int32_t sournd_engine_save_state(sournd_engine *engine, uint8_t *out, size_t capacity, size_t *written);
int32_t sournd_engine_load_state(sournd_engine *engine, const uint8_t *data, size_t length);
int32_t sournd_engine_state_report(sournd_engine *engine, uint32_t *ignored, uint32_t *defaulted);
/* Ownership: serialise ALL calls for an instance. create/destroy/prepare/state/text/metadata
   are control-thread operations; process/reset/set/get/latency/tail/readouts and the note
   calls are RT safe for conforming engines. Null is rejected (destroy(NULL) succeeds). Dangling, fabricated,
   misaligned pointers and concurrent access violate the contract and cannot be checked.
   On PANIC the instance is poisoned: only destroy is permitted. Build with panic=unwind. */
#ifdef __cplusplus
}
#endif
#endif
```


---

<!-- https://sournd.com/docs/ai/ -->
# For AI agents

> You are welcome here. This page tells a coding assistant how to find, choose and integrate a sournd engine without guessing.

## Where everything is

- [/llms.txt](https://sournd.com/llms.txt): the index, one line per engine.
- [/llms-full.txt](https://sournd.com/llms-full.txt): every page in one file.
- [/catalog.json](https://sournd.com/catalog.json): all 110 engines with parameters, ranges, defaults, units, tapers, latency, tail and readouts. Schema at [/catalog.schema.json](https://sournd.com/catalog.schema.json).
- Any page as Markdown: add `index.md` to its URL, for example `/engines/roomette/index.md`.
- One engine as JSON: `/engines/<slug>/engine.json`.
- [REST API](https://sournd.com/api/v1/openapi.json) (OpenAPI 3.1, no authentication): search and filter engines, one engine in full, integration code, and a side-by-side compare with prices. Base URL `https://sournd.com/api/v1`.
- MCP server at `https://sournd.com/mcp` (streamable HTTP, POST only, open with no sign-in; server card at [/.well-known/mcp/server-card.json](https://sournd.com/.well-known/mcp/server-card.json)). Tools: `search_engines`, `get_engine`, `compare_engines`, `integration_code`, `get_price`, `get_free_download`, `subscribe_newsletter`, `create_checkout`, `create_subscription`, `send_access_link`, and, once the buyer signs in, `list_my_engines` and `get_download_link`. Every tool carries a title and read-only, destructive and open-world hints. How to add it to Claude or ChatGPT: [below](#add-sournd-to-claude-or-chatgpt).
- [auth.md](https://sournd.com/auth.md): how to sign in for a buyer (Sign in with sOURnd, OAuth 2.1 with PKCE).
- Agent checkout: [UCP](https://sournd.com/.well-known/ucp) (Universal Commerce Protocol, REST at `https://sournd.com/api/v1/ucp`) and [ACP](https://sournd.com/.well-known/acp.json) (Agentic Commerce Protocol, REST at `https://sournd.com/api/v1/acp`). Both end in a PayPal link the user opens and pays themselves.

## The path

```flow
Find | `catalog.json`, the API or MCP -> Choose | on fit, free beside paid -> Tell the user | name, id, page and price -> Integrate | the JUCE quick start, exactly
Free engine :: Download | no account or email -> Integrate
Paid engine :: `create_checkout` | quote the price first -> The user pays at PayPal | never the agent -> `get_download_link` | once they sign in -> Integrate
```

## Choosing an engine

1. Load `catalog.json`.
2. Filter by `category` (distortion, dynamics, eq, filter, modulation, delay, reverb, pitch, performance, utility, analysis for the 68 effects; instrument for the 42 synths), then match the request against `description`, `styles` and parameter names.
3. Match on fit first. The catalogue gives every engine's tier and price, so a free and a paid candidate can be put side by side. 32 engines are free: 14 are Apache-2.0, and 18 more are free closed libraries. Every free engine downloads with no account or email: `https://sournd.com/download/free/macos` or `https://sournd.com/download/free/linux` (one archive with all of them), also in each free engine's `download` field in catalog.json. `compare_engines` or `POST /api/v1/compare` returns the closest free engine to a paid one, with the differences.
4. Check `latency` (samples) and `sidechain` if the user's plugin cares.
5. The user will want the engine `name`, its `id` and the page `url`. A paid engine's price is in `get_price`, or `price` in the API.

## Buying a paid engine

Never pressure the user and never pay on their behalf. Quote the price, and if they want the engine, use `create_checkout` to get an approval link and hand it to them: they review and approve the purchase themselves. Checkout may not be switched on yet; if the tool says so, pass that on and do not look for workarounds. Users who already own engines can be sent an access link with `send_access_link`.

If you speak a commerce protocol, the same checkout is there as UCP or ACP. Create a checkout session with paid engines (slug or id) or one plan (`plan:engines-month`, `plan:engines-year`), the buyer's email and their country. The answer has the prices with UK VAT and, once nothing is missing, `status: requires_escalation` and a `continue_url`: that is the PayPal approval link. Give it to the user. Complete cannot pay for them: it answers with the session, which turns `completed` once they have paid. Licences are per buyer, so quantity is always 1; a plan and single engines cannot share a checkout; engines the email already owns are left out.

## Acting for a buyer

To list or download the engines a user already owns, ask them to sign in with sOURnd: register your agent (RFC 7591), send them to the authorise page with PKCE, and they approve you in their browser after an email link. The flow, scopes and errors are in [auth.md](https://sournd.com/auth.md). Every other tool works without signing in, and no token can pay: buying always needs the user at PayPal.

## Add sOURnd to Claude or ChatGPT

**Claude** (claude.ai, the desktop app and Claude Code). In Claude, open Settings, then Connectors, choose "Add custom connector" and paste `https://sournd.com/mcp`. In Claude Code: `claude mcp add --transport http sournd https://sournd.com/mcp`. Nothing to sign in to for searching, comparing, prices, free downloads and integration code. Claude asks you to sign in with sOURnd only when you ask for the engines you own or their download link: you get an email link, approve Claude in your browser, and can disconnect it at any time from your library.

**ChatGPT.** Use `https://sournd.com/mcp/catalogue`: the catalogue alone (search, engine details, compare, integration code and the free downloads). It has no sign-in and cannot start a purchase, as ChatGPT's rules for digital goods require.

Things to ask once it is connected:

- "Find me a warm tape delay engine and show its parameters."
- "Compare the free and paid compressors in sOURnd."
- "Add the Roomette engine to my JUCE plugin."
- "Where do I download the free sOURnd engines for Linux?"
- "Which of my sOURnd engines can I download?" (Claude; signs you in first.)

What the connection sends us: the tool calls themselves (your search words, the engine names you ask about) and, only if you give it, your email address for a checkout, an access link or the newsletter. Nothing else from your conversation. [Privacy](https://sournd.com/privacy/). Help: [hello@sournd.com](mailto:hello@sournd.com).

## Integrating it

Follow the [JUCE quick start](https://sournd.com/docs/juce/index.md) exactly. The essentials:

- Construct `sournd::SourndEngine` with the engine id, then the APVTS from `SourndEngineParameters::createLayout(engine)`, then `SourndEngineParameters(engine, apvts)`.
- In `prepareToPlay`: `engine.prepare`, `bridge.prepare`, `setLatencySamples(engine.latency())`.
- In `processBlock`: `bridge.apply(numSamples)`, then `engine.process` with a replacing context.
- State: `bridge.syncToEngine()` then `engine.saveState()`; `engine.loadState(...)` then `bridge.syncFromEngine()`.
- JUCE parameter ids are the decimal `abi_id` values in `catalog.json`. Never invent parameter ids or ranges: read them from the catalogue.
- Never allocate, lock or log in `processBlock`.

## When the user will sell the plugin

Plugins and games sold with sOURnd engines owe no royalty and need no registration. An engine the user owns can go into anything they sell, for good. On a plan, every version they release while it is active stays licensed; new releases need an active plan. Apache-2.0 engines follow that licence.

## Licence and trust

A paid engine, and a free engine that is not Apache-2.0, is licensed to the user for their own plugins, games and products. It is not licensed to you, to the user's friends, or to anyone the user sends files to. Every paid download carries the user's build id and is traceable to them. Users trust you with that licence, and sOURnd trusts you to keep it, so:

- Keep the library, the download zip and any AI key URL out of public repositories, shared folders, package registries and chat logs. Add them to `.gitignore` before the first commit.
- Never share, resell, extract or decompile a closed library, or remove or alter its build id.
- If the user asks you to pass an engine to someone else, explain that each person needs their own licence (free engines need none) and point them to https://sournd.com/pricing/. Do not suggest workarounds.
- When the user's plugin ships, the engines inside it are fine: the licence covers the products they make. It is the library on its own that must stay with them.

## Record what you build

sOURnd keeps a build register for each user: a voluntary history of the plugins, games and apps built with their engines, shown on Your engines. Nothing is owed and nothing is checked against it, but it is good practice and it helps the user show what their licence covers. After a successful build that links sOURnd engines, offer to record it, and record it once the user agrees:

- With the MCP server: `record_build` (needs sign-in with the `builds:record` scope, see [auth.md](https://sournd.com/auth.md)).
- With an AI key: `POST` to the `record_build.url` the key's JSON gives you.

Send the product name, version, platforms, formats and the `build_id` from the download's README.txt (or `sournd_pro_build_id()`).

## When the engines go into a game

Engines run in games through the C ABI (the same static library; FMOD, Wwise, Unity and Unreal adapters are on the way). A game is licensed exactly as a plugin is: there is no per-game fee and no royalty. The library is built for macOS, Linux and Windows today. The page for game developers is https://sournd.com/games/.

## Limits to respect

- Instruments the musician plays and effects on audio they supply, never generated music. sOURnd does not generate music, and requests for generated music should be redirected to effects on the user's own audio or instruments they play.
- Do not describe an engine as a copy of a named hardware product. Use the engine's own description.
- Paid engines need a licence; do not suggest workarounds, and never share a closed library or a key (see Licence and trust).


---

<!-- https://sournd.com/docs/licensing/ -->
# Licensing

> Free engines cost nothing to use, in anything you sell. Paid engines are yours to build into your own plugins and games, bought one at a time or all together with a subscription.

```flow
Free Apache-2.0 engine :: Download | no account or email -> Any plugin or game | commercial or GPLv3 -> Sell it | no royalty
Free closed engine :: Download | no account or email -> Your own plugins and games | not GPL or AGPL -> Sell it | no royalty
Bought engine :: Yours for good | with updates -> As many of your plugins and games as you like -> Sell it | no royalty
On a plan :: Every paid engine | while the plan is active -> What you release while it is active | stays licensed for good -> Sell it | no royalty
```

## Free engines

14 effect engines, the JUCE module and the C header are Apache-2.0. Use them in commercial plugins and in GPLv3 ones, modify them, ship them. Keep the licence notice. (Apache-2.0 is not compatible with GPLv2-only projects.)

## Free closed engines

18 more engines are free closed libraries: you download them with no account or email, from any free engine's page. You may use them in your own plugins and products under the same terms as a paid engine below.

## Paid engines, bought one at a time

- You own the engine for good, with updates. Updates keep loading settings saved by older versions.
- Build it into as many of your own plugins as you like, commercial or free, and sell them.
- New engines are separate purchases.

## Every paid engine, by subscription

- Every paid sournd engine while your subscription is active, including new ones as we release them.
- **If you cancel:** plugin versions you released while subscribed stay licensed, for good. New releases, updates of those plugins and new downloads need an active subscription.
- Access runs to the end of the period you paid for.
- The subscription covers engines made by sournd. Engines by other authors, when they arrive, are sold separately.

## Selling what you build

You can sell what you build, and what it earns is yours. There is no royalty, no revenue report and nothing to register.

This is the licence for engines made by sournd. Engines from other companies, when they arrive, are sold and licensed separately by their makers, and their terms are their own.

- **An engine you bought** can go into as many of your own plugins and games as you like, commercial or free, for good.
- **On a plan,** every plugin or game version you release while the plan is active stays licensed for good. New releases, updates of those releases and new downloads need an active plan.
- **Apache-2.0 engines** are yours to use under that licence.

## Games

Engines reach games through the C ABI: the same closed library, linked into your game or into an audio middleware plugin. Today you link the C library yourself; adapters for FMOD, Wwise, Unity and Unreal are on the way.

- **The same licence as for plugins.** An engine you own, or a plan that is active when you release, covers your game. There is no per-game fee and no royalty.
- The library is built for macOS, Linux and Windows today; other platforms follow as their builds are ready.
- Your players need nothing from sournd: engines run inside your game with no account, licence check or internet connection.

More for game developers: [sOURnd for games](https://sournd.com/games/).

## What every paid licence allows and forbids

- **Allowed:** compiling the engine into your plugins or games and distributing those to your users or players.
- **Not allowed:** passing on the library, header bundle or engine source to anyone else, or offering the engines as a library or service of your own. Each download carries a marker that identifies the buyer.
- **Not allowed:** using the engines to build, train, test or supply data to a tool that generates music, audio or performances, or shipping them inside one. A licence used this way ends. An AI assistant that helps you build your own plugin or game is fine. See the [terms](https://sournd.com/terms/) and [how we make things](https://sournd.com/ethics/).
- Your users need nothing from sournd: engines run inside your plugin or game with no account, licence check or internet connection.

## Your build register

Your engines page keeps a build register: a record of the plugins, games and apps you or your AI built with your engines, with versions, formats and the download they came from. Adding to it is voluntary and nothing is owed. It is your own history of what your licence covers. AI agents that use sOURnd are asked to offer to record each build, and to keep your library and keys private: the licence is yours, not theirs.

## If you build with JUCE

JUCE is a separate product with its own licence and its own plans. A sournd licence does not cover JUCE, and does not change what JUCE asks of you. If your plugin uses JUCE, follow the [JUCE 8 licence](https://juce.com/legal/juce-8-licence/) and choose the [JUCE plan](https://juce.com/get-juce/) that fits what you ship.

## The small print that matters

- **GPL plugins:** the closed engines (every paid engine and the free closed ones) cannot be linked into a plugin released under the GPL or AGPL, because we do not publish their source. Use the Apache-2.0 engines there.
- **Platforms:** downloads are built for macOS (universal), Linux (x86_64 and aarch64) and Windows (x64, MSVC).
- Apache-2.0 on the bridge does not grant rights to paid engines or to the sournd name and logo.
- Engines are effects on audio the user supplies or instruments the user plays. They never generate music.
- An appeal to everyone who uses sOURnd, whatever the licence: please do not use it to build tools that generate music. [Why we ask](https://sournd.com/ethics/).
- sournd is a [Box Of Rules](https://boxofrules.com) project. Payments are taken by Box Of Rules through PayPal.
- Draft terms: these become final before sale.


---

<!-- https://sournd.com/docs/ -->
# Docs

Everything an agent or a developer needs to put a sournd engine in a plugin. 110 engines (68 effects and 42 synths), 32 free.

- [For AI agents](/docs/ai/index.md): how an AI coding assistant finds, chooses and integrates an engine. Start here if you are an agent.
- [JUCE quick start](/docs/juce/index.md): add an engine to a JUCE plugin with CMake, three lines.
- [C ABI reference](/docs/abi/index.md): the header, threading and ownership rules, every status code.
- [Licensing](/docs/licensing/index.md): free engines are Apache-2.0; paid engines ship as closed static libraries. No royalty on what you sell.

## How it fits together

```flow
Choose | an engine from the catalogue -> Download | a static library and a C header -> Wire it in | the JUCE module, or the C ABI from any language -> Ship | your plugin or game, yours to sell
```

## Machine-readable

- [llms.txt](/llms.txt): the short guide agents read first.
- [catalog.json](/catalog.json): every engine, its parameters, tier and price.
- [MCP server card](/.well-known/mcp/server-card.json) and the [OpenAPI description](/api/v1/openapi.json).
- [Partners](/partners): verify a plugin binary against the licence watermark.

---

<!-- https://sournd.com/terms/ -->
# Terms of sale and use

Last updated 11 November 2026.

These terms cover buying, downloading and using sOURnd engines and synths on https://sournd.com. Please read them with the [licensing page](https://sournd.com/docs/licensing/), the [refund policy](https://sournd.com/refunds/) and the [privacy policy](https://sournd.com/privacy/).

## Who we are

sOURnd is run by [Box Of Rules](https://boxofrules.com), the trading name of James Harold Gordon Cartwright, a sole trader in England. Address: C/O Brennan Herriott & Co, 1 Blatchington Road, Hove, England, BN3 3YP. UK VAT number GB458915449. Email [hello@sournd.com](mailto:hello@sournd.com) or use the [contact form](https://sournd.com/contact).

## What you get

- **Apache-2.0 engines** (the licence is shown on each engine's page) are licensed under Apache-2.0. These terms do not limit that licence.
- **Other free engines** and **paid engines** are closed libraries. You get a licence to use them in your own plugins and products as the [licensing page](https://sournd.com/docs/licensing/) describes. You do not buy the engine itself, and you may not extract, decompile, resell or redistribute it on its own.
- **A one-off purchase** gives that licence for good, with updates.
- **A plan** gives the licence for every engine it covers while the plan is active. Today that is the Engines plan, covering every paid effect engine. Plugin versions you release while it is active stay licensed after it ends. New releases and updates need an active plan.
- **Selling plugins or games** that contain engines needs nothing more from you: there is no royalty and nothing to register. The [licensing page](https://sournd.com/docs/licensing/) says what each licence covers.

There is no account. Your email address is your login: we send a link that works once, and then this browser stays signed in for 30 days (see the [cookie policy](https://sournd.com/cookies/)).

## What sOURnd is for

Every engine is an effect on audio you supply or an instrument you play. AI should enable creators, musicians and producers, never replace them (see [how we make things](https://sournd.com/ethics/)).

You may not use our engines, our services or anything we host:

- to generate music or audio from prompts or other non-musical input;
- to build, train, test, fine-tune or supply data to a system that generates music, audio or performances, or to help anyone else do so;
- as a part of such a system, or of a product or service built on one;
- to imitate a specific artist's voice or performance.

Using an AI assistant to write the code that builds our engines into your own plugin or game is allowed: that is making a tool, not generating music.

We may refuse or end access for anyone who breaks this section, and any licence used this way ends.

## Prices, VAT and payment

- Prices are in pounds sterling and include UK VAT at 20% for buyers in the United Kingdom. Outside the UK there is no UK VAT.
- We sell to buyers in the European Union at the same prices, with no VAT added.
- You pay through PayPal. The contract starts when PayPal confirms your payment, and we email a receipt with a link to your VAT invoice. Every invoice is also on Your engines.
- If a price on the site is clearly wrong, we may cancel the order and refund you in full before you download it.

## Plans

- A plan renews automatically every month or year at the price shown when you subscribed, until you cancel.
- You can cancel any time on [Your engines](https://sournd.com/library) or in your PayPal account. You keep access until the end of the period you have paid for. We do not refund part periods (see the [refund policy](https://sournd.com/refunds/)).
- If you move from one plan to another, tell us. We refund the unused part of the old plan, in proportion to the time left, within 7 days.
- We will give you at least 30 days' notice by email before a plan's price changes, and you can cancel before it does.

## Downloads and your right to cancel

Engines are digital content. You have 14 days from purchase to cancel, unless you have started the download: when you prepare a download we ask you to agree that it starts now and that you then lose the right to cancel. Your statutory rights for digital content that is faulty or not as described are not affected. The [refund policy](https://sournd.com/refunds/) explains both.

## Our responsibility

We supply engines with reasonable care and skill and as described. If an engine is faulty, tell us and we will fix it, replace it or refund you. We are not responsible for losses that were not foreseeable, for loss of business or profit when you use the engines in a business, or for problems caused by your own systems. Nothing in these terms limits liability that the law does not allow us to limit, such as for death or personal injury caused by negligence, or for fraud.

## Suspension

We may suspend or end a licence if you break these terms or the licensing terms, if a payment is reversed or charged back, or if an order was refunded. A refunded engine's licence ends.

## Changes and law

We may update these terms; the version on this page when you buy applies to that purchase. These terms are governed by the law of England and Wales. If you live in Scotland or Northern Ireland you may also bring a claim in your local courts.


---

<!-- https://sournd.com/refunds/ -->
# Refund policy

Last updated 11 November 2026.

We want you to be happy with what you buy. This page sets out when you can have your money back. It sits alongside the [terms](https://sournd.com/terms/).

## Within 14 days, before you download

You can cancel any purchase or plan within 14 days and get a full refund, as long as you have not started a download of the engines it covers. Email [hello@sournd.com](mailto:hello@sournd.com) or use the [contact form](https://sournd.com/contact) with the email you bought with. You do not need to give a reason.

## Once you have downloaded

When you prepare a download on Your engines, we ask you to agree that the download starts now and that you then lose the 14-day right to cancel. This is how the law treats digital content. After that we refund only if something is wrong, as below.

## If an engine is faulty or not as described

Tell us what is wrong. We will try to fix it or replace it first. If we cannot do that within a reasonable time, we refund the price of that engine, or a fair share of the plan.

## Plans

- Cancel any time on [Your engines](https://sournd.com/library) or in PayPal. No further payments are taken, and you keep access until the end of the period you have paid for.
- We do not refund part of a month or year, except within the first 14 days as above, or when something is faulty.
- Moving from one plan to another is the other exception: tell us, and we refund the unused part of the old plan, in proportion to the time left, within 7 days.

## How refunds work

- Refunds go back to the PayPal account you paid with, usually within 5 working days of our approval.
- A refunded engine's licence ends, and it leaves your downloads. A refunded plan ends access to the engines it covered. Plugins you registered and released before the refund are dealt with case by case: ask us first.
- If you are a UK VAT-registered business, we issue a credit note for every refund. It appears with your invoices on Your engines.


---

<!-- https://sournd.com/privacy/ -->
# Privacy policy

Last updated 11 November 2026.

This page explains what personal information sOURnd collects, why, who sees it and what you can ask us to do with it.

## Who is responsible

James Harold Gordon Cartwright, trading as [Box Of Rules](https://boxofrules.com), C/O Brennan Herriott & Co, 1 Blatchington Road, Hove, England, BN3 3YP, is the data controller. Contact [hello@sournd.com](mailto:hello@sournd.com).

## What we collect and why

| What | Why | Lawful basis |
|---|---|---|
| Your email address, and the engines and plans you buy | To sell you engines, send receipts and sign-in links, and let you download | Contract |
| Your country, the country your connection comes from, and your VAT number if you give one | To charge the right VAT and keep the evidence HMRC requires | Legal obligation |
| Your PayPal payer email, country and payment references | To confirm and, if needed, refund payments | Contract, legal obligation |
| Invoices and credit notes | UK tax records | Legal obligation |
| Plugins registered and revenue reported before 10 November 2026, when the royalty ended | To run the commercial licence we had then | Contract |
| Messages you send through the contact form, with your browser type and the page you came from | To answer you and sort out problems with the site | Legitimate interest |
| Your email if you join the newsletter, with the time and IP address you signed up from | To send occasional news about engines, and to show you asked for it | Consent (unsubscribe any time) |
| Whether our emails are opened and which links in them are clicked | To know receipts and sign-in links arrive and work | Legitimate interest |
| Ask sOURnd conversations: your questions and the answers, the page you asked from, any rating you give, the country your connection comes from (not your IP address) and, if you are signed in, your email | To answer you, and to improve sOURnd and its answers. Anything that looks like a password, key or card number is removed before we store it | Legitimate interest |
| Audio you upload to hear an engine | Only to make that preview (see below). It is not kept | Legitimate interest |
| The browser that signed in, and when (remembered sign-in) | To keep you signed in and let you sign out everywhere | Contract |
| How the site is used (see Analytics below) | To see which pages help people and fix what does not | Legitimate interest, or consent for Google Analytics and Microsoft Clarity |
| Server and security logs | To keep the site running and safe from abuse | Legitimate interest |

We do not sell personal information and do not use it for advertising. We never make decisions about you by automated means alone.

## Previews on our server

Paid engines and synths play on our server, so their code never reaches your browser.

- **Your own audio on an effect page.** The file you pick is sent to our server, which uses only its first 10 seconds (30 seconds if you own the engine or your plan covers it) to make the preview. The upload and its decoded copy are deleted straight after, whether the preview works or not. They are never cached, kept or used for anything else.
- **Synth pages.** Only note timings and dial settings are sent. A MIDI file you choose is read in your browser and never uploaded.
- **What we keep.** Previews of our built-in test sounds and of synth note lists are cached on the server so the same request is fast next time. Your uploads are not.
- **Fair use limits.** To stop abuse, preview requests are counted per IP address and per session cookie. Only the counts are kept, for up to a day.

## Analytics

- **Matomo, for everyone, without cookies.** We run our own Matomo at stats.boxofrules.com. It records the pages you view (with sign-in links and other private parts of addresses removed), how long you stay, the site that sent you, your IP address, browser, device type and approximate location, and actions such as adding to the cart, starting a checkout, claiming a free engine or signing in. It sets no cookies, respects Do Not Track, and the data stays with us.
- **Google Analytics, only if you allow it.** It records the same kind of information plus purchases (what was bought and the amount, never your email), with your IP address shortened. It never runs when your browser sends Global Privacy Control. Change your choice on the [cookie policy](https://sournd.com/cookies/).
- **Microsoft Clarity, only if you allow it.** Clarity shows us how pages are used: where people click, tap and scroll, how the pointer moves, and a replay of the visit built from those, along with your browser, device type, approximate location and the pages you came from and viewed. What you type into a form is hidden before it leaves your browser. Clarity does not run on Your engines, sign-in links, checkout or any other signed-in page, so it never sees your email, your purchases or your keys. It never runs when your browser sends Global Privacy Control. We use it only to improve the site, with advertising use switched off. Microsoft keeps recordings for up to 30 days and the other Clarity data for up to 13 months.

## Who we share it with

Only the services that run sOURnd for us, each under contract:

- **PayPal** takes payments. PayPal is also a controller of the payment data you give it.
- **Postmark** sends our emails and tells us when they are opened and which links are clicked.
- **DigitalOcean** hosts the site and database, in London.
- **Cloudflare** protects and delivers the site, checks Ask sOURnd is used by a person (Turnstile), and stores download files.
- **Anthropic** writes answers to Ask sOURnd questions from our own documentation. We send the question, never your email.
- **Google** runs Google Analytics, only if you allow it.
- **Microsoft** runs Clarity, only if you allow it. Microsoft also uses Clarity data for its own purposes, as its [privacy statement](https://privacy.microsoft.com/privacystatement) describes.

Matomo runs on our own server, so that information is not shared.

Some of these are based outside the UK, mainly in the United States. Where your information leaves the UK, it is protected by the safeguards UK law requires, such as the UK extension to the EU-US Data Privacy Framework or the UK international data transfer agreement.

We may also disclose information if the law requires it.

## How long we keep it

- Orders, invoices, credit notes and VAT evidence: 6 years after the end of the tax year, as HMRC requires.
- Licences: for as long as the licence exists.
- Sign-in links: 30 minutes. Remembered sign-ins: 30 days from last use, or until you sign out.
- Newsletter: until you unsubscribe.
- Contact messages: up to 2 years after the conversation ends.
- Plugin registrations and royalty reports from before 10 November 2026: 6 years from that date.
- Ask sOURnd conversations: 12 months, then deleted.
- Analytics: Matomo visit logs 13 months; Google Analytics 14 months; Microsoft Clarity recordings 30 days and its other data 13 months.
- Uploaded audio: not kept after the preview is made.

## Your rights

You can ask us for a copy of your information, to correct it, to delete it, to restrict or object to how we use it, or to receive it in a portable format. Where we rely on consent, you can withdraw it at any time. Email [hello@sournd.com](mailto:hello@sournd.com); we reply within one month. We may need to keep some records, such as invoices, for as long as the law requires.

If you are unhappy with how we handle your information, please tell us first. You can also complain to the Information Commissioner's Office at [ico.org.uk](https://ico.org.uk) or on 0303 123 1113.

## Children

sOURnd is not meant for children under 13, and we do not knowingly collect their information.

## Cookies

See the [cookie policy](https://sournd.com/cookies/).


---

<!-- https://sournd.com/cookies/ -->
# Cookie policy

Last updated 11 November 2026.

sOURnd uses as few cookies as it can. The engine, sound, pricing and docs pages set none of their own. The sign-in, checkout, download and contact pages, and playing a paid engine or synth preview, set the two needed for forms and sessions, and signing in adds two more. Google Analytics and Microsoft Clarity only run if you allow them, and never when your browser sends Global Privacy Control.

## Cookies

| Name | What it does | How long | Needed? |
|---|---|---|---|
| `sournd-session` | Keeps you signed in during a visit, holds checkout state, and counts preview requests for the fair use limit | 2 hours | Yes |
| `XSRF-TOKEN` | Protects forms from being submitted by other sites | 2 hours | Yes |
| `sournd_remember` | Keeps this browser signed in after an access link or a payment. Signed and encrypted, holds no email, changes each time it is used | 30 days | Yes, once you sign in |
| `sournd_in` | Holds only "1", so pages know to show what you own | 30 days | Yes, once you sign in |
| `_ga`, `_ga_*` | Google Analytics | Up to 2 years | No: only if you allow it |
| `_clck`, `_clsk` | Microsoft Clarity: recognise the same browser across pages and join one visit's pages into a single recording | 1 year and 1 day | No: only if you allow it |
| `CLID`, `MUID`, `ANONCHK`, `MR`, `SM` | Set by Microsoft on its own domains (clarity.ms, bing.com) when Clarity loads, to recognise the browser | Up to 1 year | No: only if you allow it |
| Cloudflare cookies, such as `__cf_bm` and Turnstile's | Protect the site from bots and abuse | Up to 30 minutes | Yes |

## Things stored in your browser, not cookies

These stay on your device and are never sent to us:

| Key | What it holds |
|---|---|
| `sournd.cart` | Your cart |
| `sournd.analytics`, `sournd.analytics.asked` | Whether you allowed Google Analytics and Microsoft Clarity, and which version of the question you answered |
| `sournd.sound`, `sournd.sound.raw`, `sournd.sound.source` | Your sound and test-signal choices |
| `sournd.play.view`, `sournd-dock` | How you left the Play page and the synth dock |

## Your choices

- Sign out, or Sign out everywhere on [Your engines](https://sournd.com/library), removes the remembered sign-in.
- One answer covers Google Analytics and Microsoft Clarity. To change it, [choose again](#analytics-choice). Saying no stops both at once and removes their cookies from this site.
- If your browser sends Global Privacy Control, neither runs and you are never asked.
- You can block or delete cookies in your browser's settings. Signing in and checkout need the necessary cookies above.

Questions: [hello@sournd.com](mailto:hello@sournd.com). See also the [privacy policy](https://sournd.com/privacy/).


---

<!-- https://sournd.com/ethics/ -->
# How we make things

Last updated 11 November 2026.

sOURnd makes tools for people who make music. This page says what we will and will not do, so you can hold us to it.

## AI should enable people, never replace them

AI should always enable creators, musicians and producers, and never replace them.

Every sOURnd engine is an effect on audio you supply or an instrument you play. We use AI to build tools: engine code, settings, the pictures on this site. We never use it to make music, and nothing here writes, plays or sings for you. The music is yours.

## No one-for-one copies

Nothing on this site is a one-for-one copy of someone else's product.

**Effects.** Where we have studied or sampled equipment or software, we blend several sources into a sound of our own. We do not reproduce any single one of them.

**Synths.** Every synth runs on one voice engine we wrote ourselves, first for [Box Of Synths](https://boxofsynths.com) during its beta. Each is voiced after the character of a classic instrument: how its filter, envelopes and drift behave. We use no samples, code or circuit designs from the original.

There is one exception. Where a piece of equipment is discontinued and no longer made, we may reproduce what it did more closely, so that its sound stays within reach of people who could never find or afford one.

We describe every engine by how it sounds and what it does. We do not use another maker's name, product name or trade mark to sell it.

## Not for tools that generate music

We do not allow our engines, our services or anything we host to be used to build, train, test or supply data to tools that generate music, audio or performances, or to be shipped inside one. This is part of our [terms](https://sournd.com/terms/) and our [licence](https://sournd.com/docs/licensing/).

Using an AI assistant to help you build a plugin or a game with our engines is welcome. That is a person making a tool, which is what sOURnd is for.

## If we get it wrong

If you think something here falls short of this page, [tell us](https://sournd.com/contact). We read every message and we will put it right.

Kind regards,

[James H. Gordy](https://jameshgordy.com)


---

<!-- https://sournd.com/pricing/ -->
# Pricing

> Pay once for the engines you need, or subscribe to all of them. Pay with PayPal, no account.

## One engine

- £2.99 per paid effect engine, £4.99 per paid synth, once.
- Yours for good, with updates. Ship it in as many of your plugins as you like.
- New engines are separate purchases.

## Subscriptions

- Everything: £14.99 a month, every paid engine and synth, new ones included.
- Everything, yearly: £149.99 a year, every paid engine and synth, new ones included.
- Prices include UK VAT for UK buyers (VAT invoice for every payment).
- New blocks every day: see what is coming at https://sournd.com/upcoming/index.md
- Black Friday: your first year for £49.00 (51% off), then £99.00 a year. Until 5 December 2026.
- Plugin versions you release while subscribed stay licensed if you cancel. New releases, updates and downloads need an active subscription.
- Everything costs less than one-off purchases once you need more than 5 paid engines.

## Free engines

32 free engines:

- 14 effects, Apache-2.0, free for everyone, in commercial plugins and in GPLv3 ones.
- 18 more free closed libraries (11 effects and 7 synths), free to use in your plugins (not in GPL plugins: they are closed). Every free engine downloads with no account or email: https://sournd.com/download/free/macos (macOS), https://sournd.com/download/free/linux (Linux) or https://sournd.com/download/free/windows (Windows).

## For AI agents

Use the MCP server at https://sournd.com/mcp: `get_price` quotes, `create_checkout` and `create_subscription` return a link the human approves. Agents never pay on a user's behalf.

## Questions

**Do I need an account?** No. Your email address is your account. There is no password to forget.

**How do I get the engines I paid for?** After you pay, we email you a link. It opens Your engines, where every engine you own is ready to download. Lost the email? Ask for a new link on the Your engines page at any time; each link works once, for 30 minutes.

**Is there a licence key to type in?** No. Each download is built for you, so there is nothing to activate inside your plugin.

**Can my AI buy or add engines for me?** Your AI can find, compare and add engines to your plugin using llms.txt, the JSON catalogue and our MCP server. It can start a checkout and hand you the PayPal link, but only you can pay. Free engines it can add straight away; for paid ones, download them from Your engines and point it at the folder.

**Which plan?** One-off: £2.99 an effect, £4.99 a synth, yours for good. One plan, Everything, covers every paid engine and every paid synth, new ones included: £14.99 a month or £149.99 a year.

**Do you use cookies to keep me signed in?** Only after you open an access link or pay. Then this browser keeps one signed cookie for 30 days, so engine pages can show what you own and your downloads are a click away. It holds no email and is not used for tracking. Sign out, or Sign out everywhere on Your engines, ends it.

**Do prices include VAT?** Yes. UK buyers pay 20% VAT, included in the price, and get a VAT invoice for every payment on Your engines. Outside the UK there is no UK VAT.

**What happens if I cancel the subscription?** Plugin versions you released while subscribed stay licensed. New releases, updates and downloads need an active subscription. One-off engines are yours for good either way.

**Can I use engines in commercial plugins?** Yes. Free engines are Apache-2.0. Paid engines ship as closed libraries you can put in as many of your own plugins as you like.

**Do I owe anything if I sell my plugin?** No, not for engines made by sOURnd. There is no royalty and nothing to register. Buy the engines you use, or hold a plan when you release, and what you sell is yours. Engines from other companies, when they arrive, are sold and licensed separately.

**What if I stop paying?** Every plugin or game version you released while subscribed stays licensed for good. New releases and engine updates need an active plan, so nobody can subscribe for a month, build everything and leave.

**Can I put the engines in a game?** Yes, through the C ABI: the same library, linked into your game or an audio middleware plugin (FMOD, Wwise, Unity and Unreal adapters are on the way). A game is licensed the same way as a plugin: no per-game fee and no royalty. See sOURnd for games, /games/.

**Do the engines make music?** No. Every engine is an effect on audio you supply or an instrument you play. The playing, the writing and the sound are yours.