damp

A high-quality true-peak limiter and automated mastering engine.

Six mastering algorithms, 38 factory presets, and a transparent look-ahead limiter — as a command-line tool, a desktop GUI, and a C++ library.

Quick Start · Mastering Modes · Presets · Recipes · FAQ

---

damp began as an attempt to end a long standing frustation at limited free audio software. It doesn't require tokens, its not a service, its not behind a paywall. Free software, all the time.

Features

• Phase-aware look-ahead limiting. The default phase limiter solves for the gain envelope that hits your ceiling with the least audible damage, rather than clamping peaks.
• True-peak accurate. ITU-R BS.1770 true-peak detection with 4× oversampling. When you ask for a −1 dBTP ceiling, you get −1.00 dBTP.
• Six mastering engines, from a transparent 9-band loudness match to an 8-stage analog-modeled chain with tube/tape/transformer saturation.
• 38 factory presets — engineer styles, streaming targets, and genre starting points.
• Real metering. Integrated loudness (LUFS), loudness range, true peak, spectrum, and a sound-quality model, all exposed as JSON.
• Fast. Intel TBB parallelism and AVX/AVX2/FMA3 SIMD throughout.
• Portable, self-contained releases. Download, extract, run. No installer, no runtime to chase down, nothing phones home.
• Scriptable. Every knob is a flag. The GUI is a front end to the same binary you can drive from a shell script or a CI job.

---

Quick Start

Grab the archive for your platform from the latest release. Everything below assumes you are standing in the extracted damp/ directory.

Important

Auto-mastering is off by default — damp is a limiter first. Pass --mastering=true to turn on a mastering engine. Without it, --mastering_mode is ignored.

Windows

Download damp-windows-x64.zip and extract it. The archive is fully self-contained: the Visual C++ runtime ships alongside the binaries, so there is nothing to install.

GUI — double-click bin\damp_gui.exe, pick an input file, choose a preset, hit PROCESS.

CLI:

bin\damp.exe --input="song.wav" --output="master.wav" ^
  --mastering=true --mastering_mode=mastering6 ^
  --mastering_reference_file=resource\mastering_reference.json ^
  --reference=-14 --ceiling=-1

macOS

The archive targets Intel Macs. On Apple Silicon it runs under Rosetta 2, which means it needs the x86_64 Homebrew prefix (/usr/local), not /opt/homebrew.

brew install libsndfile tbb boost libpng fftw ffmpeg

tar xzf damp-macos-x64.tar.gz && cd damp
xattr -dr com.apple.quarantine .        # if you downloaded via a browser

./bin/damp --input=song.wav --output=master.wav \
  --mastering=true --mastering_mode=mastering6 \
  --mastering_reference_file=resource/mastering_reference.json \
  --reference=-14 --ceiling=-1

Linux

Requires glibc ≥ 2.38 (Ubuntu 24.04+, Debian 13+). Everything else — libsndfile and its codecs, TBB, FFTW, libstdc++ — ships in lib/. Keep bin/ and lib/ siblings; the binaries find their libraries through DT_RPATH=$ORIGIN/../lib.

sudo apt install ffmpeg                 # the only external runtime dependency

tar xf damp-linux-x64.tar.xz && cd damp

./bin/damp --input=song.wav --output=master.wav \
  --mastering=true --mastering_mode=mastering6 \
  --mastering_reference_file=resource/mastering_reference.json \
  --reference=-14 --ceiling=-1

Check your work

damp_analyzer prints measurements as JSON. It reads WAV only — it is a measurement tool, not a decoder.

$ ./bin/damp_analyzer --input=master.wav | jq '{loudness, true_peak, loudness_range}'
{
  "loudness": -15.66,
  "true_peak": -1.00,
  "loudness_range": 3.44
}

---

The GUI

damp_gui ships prebuilt in the Windows archive. On macOS and Linux you can build it yourself with -DBUILD_MASTERING_GUI=ON. It shells out to the same damp binary described above, so anything you do in the GUI is reproducible from a script.

38 factory presets, each a starting point rather than a destination.

Before/after loudness, true peak, waveform, and spectrum in one view.

Six tabs: File (I/O, format, bit depth), Mastering (mode and mode-specific controls), Limiter & Dynamics, Presets, Advanced (performance, oversampling, paths), and Analysis (metering, A/B table, waveform, spectrum overlay).

---

Which mastering mode should I use?

Mode	Character	Speed	Reach for it when
classic	Transparent 9-band loudness match	Fast	You want level and balance, not color
mastering6	Modern multiband + saturation + width	Fast	Start here. A good default for most material
mastering_a	8-stage analog chain, 28 knobs	Medium	You want to shape it the way an engineer would
mastering2	STFT per-mel-band compression	Medium	Matching a reference spectrum closely
mastering3	Simulated annealing over band compression	Slow	Quality over turnaround; tune --mastering3_iteration
mastering5	Differential evolution guided by an ML sound-quality model	Slow	You want the machine to decide

Some modes need a resource file. The release archive ships all of them under resource/:

Mode	Also pass
classic	--mastering_reference_file=resource/mastering_reference.json (required)
mastering6	--mastering_reference_file=... (optional, but it changes the result — pass it)
mastering2	--mastering2_config_file=resource/mastering2_config.json (required)
mastering5	--sound_quality2_cache=resource/sound_quality2_cache (also ships at the archive root)
mastering3, mastering_a	nothing

What each mode actually does

classic — Splits the signal into 9 bands and matches each band's loudness to the targets in mastering_reference.json. Nothing is added; levels are moved.

mastering2 — STFT analysis, then per-mel-band compression driven by a reference JSON. Requires an FFTW-enabled build.

mastering3 — Runs simulated annealing over per-band compression parameters, minimizing an acoustic-entropy cost function. --mastering3_iteration (default 1000) trades time for quality. Requires an FFTW-enabled build.

mastering5 — Differential-evolution search over mastering parameters, scored by a pre-trained sound-quality model. --mastering5_mastering_level (default 0.5) sets how aggressive the search is allowed to be.

mastering6 — Configurable 2–8 band processor: ERB-spaced crossovers, soft-knee per-band compression with envelope following, frequency-dependent tanh saturation, per-band M/S width with auto-narrowed bass, spectral tilt, and TPDF dither.

mastering_a — An eight-stage chain: corrective EQ → dynamic EQ (de-mud, de-harsh, de-ess) → 4-band compression with a parallel mix → transient shaping → harmonic saturation (tube 12AX7 / tape Studer A800 / transformer Neve 1073) → 3-band stereo imaging with bass mono-ification → look-ahead limiter → final polish (air band, sub-bass tightening, DC removal, dither).

There is no mastering4 — the engine numbering skips it.

---

Factory presets

38 presets live in resource/presets/ as plain JSON. Load them in the GUI, or read one to see which flags it sets and copy those to your command line. They are starting points — the right master is the one that sounds right, not the one that matched a preset.

Mastering engineers Abbey Road - British Classic · Bernie Grundman - Warm Analog · Bob Ludwig - Transparent · Emily Lazar - Radio Ready · Greg Calbi - Smooth & Polished · Howie Weinberg - Maximum Impact · Ted Jensen - Punchy Modern · Vlado Meller - Bright & Detailed

Delivery targets Spotify / YouTube (-14 LUFS) · Apple Music (-16 LUFS) · Broadcast (EBU R128 / -24 LUFS) · CD Mastering (-9 LUFS) · Vinyl Mastering · Podcast / Voice

Genres Modern Pop · Modern Hip-Hop / Trap · Lo-Fi Hip-Hop · R&B / Soul Smooth · EDM / Festival · Indie Rock / Alt · Metal / Aggressive · Jazz / Natural · Classical / Orchestral · Acoustic / Singer-Songwriter · Bogware (2Pac SM7B)

Engine showcases M2 - Mel Polish · M2 - Spectral Smoother · M6 - Punchy & Loud · M6 - Streaming Optimized · M6 - Transparent Master · M6 - Warm Analog Character · M6 - Wide & Immersive · MA - Loudness Warrior · MA - Surgical Precision · MA - Tape Glue & Cohesion · MA - Transformer Color & Punch · MA - Tube Warmth & Presence · MA - Vinyl & Audiophile

---

Recipes & tips

Set a true-peak ceiling. Always.

The default ceiling is 0 dBFS, which leaves no headroom for the lossy encoder every streaming platform will run over your master. Intersample peaks become clipping.

--ceiling=-1 --ceiling_mode=true_peak     # -1.00 dBTP, measured and guaranteed

--ceiling is a hard limit and is hit exactly. --reference is a different animal.

--reference is a target, not a normalizer

--reference=-14 tells the limiter what loudness to work toward. What you actually get depends on the material and the mastering mode; in practice it lands roughly 1–2 LU under the target rather than exactly on it.

$ ./bin/damp --input=song.wav --output=master.wav --mastering=true \
    --mastering_mode=mastering6 --reference=-14 --ceiling=-1 \
    --mastering_reference_file=resource/mastering_reference.json

$ ./bin/damp_analyzer --input=song.wav    | jq -c '{loudness, true_peak}'
{"loudness":-20.44,"true_peak":-7.64}
$ ./bin/damp_analyzer --input=master.wav  | jq -c '{loudness, true_peak}'
{"loudness":-15.66,"true_peak":-1.00}

The ceiling landed on −1.00 dBTP exactly. The loudness landed near −14, not on it. If you need an exact integrated LUFS, measure with damp_analyzer and nudge --reference.

Don't chase loudness anyway. Streaming platforms turn everything down to their own target; a −8 LUFS master just arrives quieter and more squashed than a −14 one.

The output container follows the file extension

--output=master.wav    # WAV
--output=master.mp3    # MP3
--output=master.m4a    # AAC

Override with --output_format=wav|mp3|aac when the extension lies.

Stay at 24-bit if anything happens downstream

--bit_depth=24         # default is 16

Only dither on the final 16-bit render — dithering twice adds noise for nothing.

Trade time for quality on mastering3

--mastering_mode=mastering3 --mastering3_iteration=5000   # default 1000

Batch a folder

# bash
for f in in/*.wav; do
  ./bin/damp --input="$f" --output="out/$(basename "$f")" \
    --mastering=true --mastering_mode=mastering6 \
    --mastering_reference_file=resource/mastering_reference.json \
    --reference=-14 --ceiling=-1
done

# PowerShell
Get-ChildItem in\*.wav | ForEach-Object {
  .\bin\damp.exe --input="$($_.FullName)" --output="out\$($_.Name)" `
    --mastering=true --mastering_mode=mastering6 `
    --mastering_reference_file=resource\mastering_reference.json `
    --reference=-14 --ceiling=-1
}

Other things worth knowing

• --worker_count=0 (the default) auto-detects cores. Pin it lower to keep a machine usable.
• --limiting_mode=simple swaps the phase-aware limiter for a plain one. Faster, more audible.
• --low_cut_freq / --high_cut_freq default to 20 / 20000 Hz.
• --mastering_reverb=true adds a mastering reverb stage. Subtle by design; easy to overdo.
• Presets are just JSON. Reading resource/presets/*.json is a legitimate way to shop for a starting set of flags.

---

Good to know

ffmpeg is required for every input, including WAV → WAV. All decoding goes through it. damp looks for ffmpeg next to its own binaries, then in the usual install locations, then on PATH. On Windows, if it finds none, it downloads a version-pinned build and verifies its SHA-256 before extracting or running anything. Opt out with --ffmpeg_auto_download=false. --ffmpeg=<path> always wins. On macOS and Linux, install it with brew or apt — damp will never download anything on those platforms.

Nothing else touches the network. No telemetry, no license check, no upload. Your audio never leaves the machine.

Resource paths resolve against the working directory, not the executable. That is why the commands above pass resource/mastering_reference.json explicitly. Running from inside resource/ also works, and is what CI does.

damp_analyzer reads WAV only. Feed it an MP3 and it exits with status 2. Convert first, or point it at damp's output.

The sound_quality2_cache is a Boost.Serialization archive and is deserialized without validation. It ships in the release and is regenerated by CI from in-repo data. Treat a cache file from an untrusted source the way you would treat a shared library from an untrusted source. See SECURITY.md.

---

FAQ

I passed --mastering_mode=mastering6 and nothing changed.

Auto-mastering is off unless you also pass --mastering=true. On its own, damp is a limiter.

auto mastering error: syntax error at line 1

classic (the default mode) could not read mastering_reference.json. It is looked up relative to your working directory, and the release archive keeps it in resource/. Pass --mastering_reference_file=resource/mastering_reference.json, or cd resource first.

I asked for −14 LUFS and got −15.7.

Working as designed. --reference is a target the limiter works toward, not a normalization pass. --ceiling is exact. Measure the result with damp_analyzer and adjust --reference if you need to land on a specific number.

Why does a WAV → WAV run need ffmpeg?

Every input is decoded through ffmpeg so that one code path handles every format. See Good to know for how it is located and how to point at your own build.

Is there a GUI for macOS or Linux?

Not in the release archives — damp_gui is prebuilt for Windows only. It builds and runs on macOS and Linux from source with -DBUILD_MASTERING_GUI=ON.

Linux: error while loading shared libraries

bin/ and lib/ must stay siblings — the binaries locate their libraries via DT_RPATH=$ORIGIN/../lib. Copying bin/damp somewhere on its own will not work. Also confirm that ldd --version reports 2.38 or newer.

macOS: "cannot be opened because the developer cannot be verified"

The binaries are not notarized. Clear the quarantine attribute after extracting:

xattr -dr com.apple.quarantine damp/

Where is mastering4?

It does not exist. The engine numbering skips it. (In the GUI's mode dropdown, index 4 is mastering6.)

Can I use damp in a closed-source product?

damp is AGPL-3.0, which extends copyleft to network use. The vendored DSP core in deps/bakuage/ is MIT and can be used on its own terms. Other vendored dependencies keep their own licenses; see licenses/ in the release archive.

---

Building from source

Prerequisites

Platform
Linux	build-essential cmake ninja-build ffmpeg libsndfile1-dev libtbb-dev libboost-all-dev libpng-dev zlib1g-dev libfftw3-dev libarmadillo-dev
macOS	brew install cmake ninja libsndfile tbb boost libpng fftw ffmpeg armadillo
Windows	Visual Studio 2022 (Desktop C++ workload) and CMake. Dependencies come from NuGet + conda — see .github/workflows/ci.yml

Setting up a self-hosted CI runner instead? See docs/RUNNERS.md.

Build

git clone --recursive https://github.com/bogware/damp.git
cd damp

cmake -GNinja -DCMAKE_BUILD_TYPE=Release -DSANDYBRIDGE_SUPPORT=ON -DDISABLE_IPP=ON .
ninja -j"$(nproc)"

Binaries land in bin/. To use mastering5, generate its model cache once:

bin/damp_analyzer --mode=sound_quality2_preparation \
  --analysis_data_dir=resource/analysis_data \
  --sound_quality2_cache=resource/sound_quality2_cache

Options that matter

Option	Default
SANDYBRIDGE_SUPPORT	OFF	ON builds AVX-only for older CPUs. OFF uses AVX2 + FMA3
DISABLE_IPP	OFF	Build without Intel IPP. Required unless you have IPP installed
ENABLE_FFTW	ON	FFT backend. mastering2 and mastering3 need it
BUILD_MASTERING_GUI	OFF	Builds damp_gui (fetches ImGui + GLFW)
ENABLE_WERROR	ON	Warnings are errors

Docker

docker build -t damp .
docker run --rm -v "$PWD:/audio" damp --input=/audio/song.wav --output=/audio/master.wav

Tests

bin/damp_test          # C++ unit tests (Google Test)
bundle exec rspec      # Ruby integration tests

All executables

damp	Limiter and mastering engine
damp_gui	Desktop GUI (prebuilt for Windows; buildable elsewhere)
damp_analyzer	Loudness, true peak, spectrum, sound quality → JSON
damp_visualizer	Audio visualization renderer
damp_mixer	Clear mixer
damp_spectrogram	Spectrogram image generator
damp_fileinfo	Audio file metadata
damp_effecttest	Effect testing utility
damp_test · damp_bench	Unit tests · benchmarks

Common flags

Flag	Default
--input / --output	—	Input and output file paths
--mastering	false	Enable auto-mastering
--mastering_mode	classic	classic · mastering2 · mastering3 · mastering5 · mastering6 · mastering_a
--reference	-6.0	Loudness target, dB
--reference_mode	loudness	loudness · youtube_loudness · rms · peak · zero
--ceiling	0	Ceiling, dB
--ceiling_mode	true_peak	peak · true_peak · lowpass_true_peak
--true_peak_oversample	4	True-peak oversampling factor
--limiting_mode	phase	phase · simple
--output_format	inferred	wav · mp3 · aac
--bit_depth	16	16 or 24
--sample_rate	44100	Output sample rate
--low_cut_freq / --high_cut_freq	20 / 20000	Band limits, Hz
--worker_count	0	Threads (0 = auto)
--ffmpeg	ffmpeg	Path to ffmpeg
--ffmpeg_auto_download	true	Windows only

damp --help lists every flag, including the 7 mastering6_* and 28 mastering_a_* knobs.

mastering6 knobs

Flag	Default	Range
--mastering6_intensity	0.7	0–1	Overall processing intensity
--mastering6_warmth	0.3	0–1	Harmonic saturation
--mastering6_width	1.0	0–2	Stereo width (1 = unchanged)
--mastering6_dynamics	0.5	0–1	Dynamic range preserved (0 = heavy compression)
--mastering6_brightness	0.0	−1–1	Spectral tilt
--mastering6_band_count	6	2–8	Processing bands
--mastering6_dither	true		TPDF dither

---

Contributing

Issues and pull requests are welcome — see CONTRIBUTING.md and the Code of Conduct. Security reports go through the process described in SECURITY.md, not the issue tracker.

License

damp is licensed under the GNU Affero General Public License v3.0. See LICENSE.

The vendored DSP core under deps/bakuage/ is MIT-licensed. Other vendored dependencies retain their own licenses, reproduced in ci/licenses/ (and in licenses/ inside each release archive).