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.
- Phase-aware look-ahead limiting. The default
phaselimiter 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.
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.
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=-1The 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=-1Requires 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=-1damp_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}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).
| 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.
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 engineersAbbey 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 targetsSpotify / YouTube (-14 LUFS) · Apple Music (-16 LUFS) · Broadcast (EBU R128 / -24 LUFS) ·
CD Mastering (-9 LUFS) · Vinyl Mastering · Podcast / Voice
GenresModern 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 showcasesM2 - 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
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=-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.
--output=master.wav # WAV
--output=master.mp3 # MP3
--output=master.m4a # AACOverride with --output_format=wav|mp3|aac when the extension lies.
--bit_depth=24 # default is 16Only dither on the final 16-bit render — dithering twice adds noise for nothing.
--mastering_mode=mastering3 --mastering3_iteration=5000 # default 1000# bashforfin 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# PowerShellGet-ChildItemin\*.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
}--worker_count=0(the default) auto-detects cores. Pin it lower to keep a machine usable.--limiting_mode=simpleswaps the phase-aware limiter for a plain one. Faster, more audible.--low_cut_freq/--high_cut_freqdefault to20/20000Hz.--mastering_reverb=trueadds a mastering reverb stage. Subtle by design; easy to overdo.- Presets are just JSON. Reading
resource/presets/*.jsonis a legitimate way to shop for a starting set of flags.
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.
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. --ceilingis 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.
| 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.
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| 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 build -t damp .
docker run --rm -v "$PWD:/audio" damp --input=/audio/song.wav --output=/audio/master.wavbin/damp_test # C++ unit tests (Google Test)
bundle exec rspec # Ruby integration testsAll 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 |
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.
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).