A free, open-source guitar amp simulator plugin for Linux, Windows, and macOS — with several vocal effects built in too.
AmpForge is a single plugin — not a chain of separate plugins bolted together in a DAW — that hosts a full, reorderable pedalboard-and-amp chain internally, in the spirit of Guitar Rig / BIAS FX. It ships as VST3, LV2, CLAP, and a standalone app (JACK/PipeWire on Linux, CoreAudio on macOS), all built from one codebase. A Windows installer (VST3/CLAP/LV2, cross-compiled from the same codebase) and a macOS build (VST3/CLAP/LV2/standalone, built natively) are also available - see Download below.
Linux has never really had a good, free, actively-developed answer to Guitar Rig or BIAS FX. AmpForge is an attempt at exactly that, now available on Windows and macOS too.
Video demo: youtube.com/watch?v=gz9fyAHsE6M
Grab the latest tarball from the Releases
page, extract it,
and run ./install.sh - installs VST3/CLAP/LV2 and the standalone
binary into your home directory (~/.vst3, ~/.clap, ~/.lv2,
~/.local/bin), no root/sudo needed. ./install.sh --uninstall
removes them again. Prefer to build it yourself, or install each
format individually? See Building from source
below.
(Windows users: an installer - AmpForge-Setup.exe - is on the
Releases page too.)
(macOS users: grab AmpForge-<version>-macos.zip from the same
Releases page, extract
it, and run ./install.sh the same way - installs VST3/CLAP/LV2 into
~/Library/Audio/Plug-Ins/... and the standalone binary into
~/.local/bin. This build isn't code-signed or notarized (no paid
Apple Developer account behind this project), so install.sh clears
the quarantine flag itself; installing by hand instead, run xattr -dr com.apple.quarantine on whatever you copied to get past Gatekeeper's
"is damaged and can't be opened" dialog.)
- 19 internal modules, freely reorderable at runtime: Noise Gate,
Compressor, Wah, Screamer (overdrive), Distortion (a harder,
asymmetric-clipping second gain stage), Amp (always present),
Cabinet (convolves with a loaded speaker-cab impulse response), NAM
(loads a Neural Amp Modeler
.namcapture of a real amp/pedal/cab), Chorus, Phaser, Tremolo, Delay, Reverb, EQ (a 3-band parametric with adjustable centers), Autotune, De-esser, Doubler (automatic double-tracking), Harmonizer (a fixed-interval second voice), Exciter (harmonic top-end brightener). See The pedals below for what every knob on every one of them actually does. - Vocal effects — Autotune and De-esser sit in the same reorderable chain as everything else, so a "vocal preset" is just Amp/Cabinet/NAM turned off and these (plus Delay/Reverb, already generic enough to double as vocal effects) turned on. Autotune is a classic "hard-tune" pitch corrector — snaps your voice to the nearest note in a chosen Key/Scale, with a Retune Speed knob going from a gentle glide to the instant, robotic T-Pain-style snap. De-esser tames harsh "s"/"sh" sibilance without dulling the rest of the voice, using a split-band technique that only reduces the sibilant frequency band, not the whole signal.
- Neural Amp Modeler (NAM) support — load a
.namcapture file (both the original and newer A2 architectures) into its own block, independent from the modeled Amp/Cabinet chain — mix, input trim, and output trim knobs let you blend it in, and the status sidebar shows the loaded capture's filename and architecture (WaveNet, LSTM, ...). NAM inference is CPU-heavier than the rest of the chain combined, especially with larger WaveNet captures — expect a real jump in CPU usage once a model is loaded. - 4 Amp Type voicings (Modern, Vintage, Crunch, Hi-Gain) — distinct EQ centers, headroom, and clip character per type; "Modern" is the default and matches the Amp block's original fixed behavior exactly.
- Tempo-syncable Delay, Tremolo, and Chorus — lock their time/rate to the host's BPM (whole down to sixteenth notes, plus a couple of dotted/triplet divisions) instead of only a free-running ms/Hz knob.
- Built-in tuner — a standalone autocorrelation-based pitch detector with a note-name-and-cents overlay, reading the signal straight off the input so it's unaffected by whatever the pedalboard is doing further down the chain.
- CPU load meter in the top bar, especially handy once the Cabinet block's convolution is in the chain.
- A/B compare — snapshot the current chain into slot A or B and flip between them instantly while dialing in a tone.
- Drag-and-drop pedalboard UI — add pedals from a palette, drag them into the rack, reorder by dragging cards (other cards live-reflow around wherever you're about to drop it), real footswitch-style bypass separate from add/remove (bypassed pedals stay fully legible, just desaturated to a dead-metal look with their LED dark, instead of fading into a washed-out ghost of the card).
- Noise Gate with an adjustable Range — instead of slamming quiet passages to total silence, it attenuates by a Range you dial in (0–80dB), with hysteresis and a hold time so it doesn't choke a note's natural decay or chatter on signal hovering near the threshold.
- 3 factory presets (Pristine Clean, Rock Crunch, Heavy Distortion) — deliberately spread across the clean-to-heavy range rather than several close variations, plus custom presets you can save, update, delete, and export/import as files (to share a tone with someone else, or between machines) from within the plugin.
- Every parameter is host-automatable, with correct automation gesture handling (touch/undo work properly in your DAW) and proper boolean/integer/unit metadata for automation lanes.
- Works as a VST3, LV2, or CLAP plugin in any compatible host on Linux, Windows, or macOS (Reaper, Carla, Bitwig, etc.), or as a standalone app (JACK/PipeWire on Linux, CoreAudio on macOS).
Prefer building it yourself over the prebuilt tarball - e.g. to install just one plugin format, or to track the latest commit? It's a standard CMake + Ninja project and only takes a few minutes.
Planning to load it into a flatpak/snap-sandboxed host (Bitwig's
flatpak build is the most common case)? The native steps below link
against your own system's glibc - on a rolling-release distro (Arch,
CachyOS, Manjaro) in particular, that's often newer than what an older
sandboxed host ships internally, so the plugin then fails to load
there with an error like version 'GLIBC_2.43' not found, even though
it built and runs fine outside the sandbox. Skip straight to the
Docker build below
instead - it sidesteps this by pinning to a fixed, older glibc
baseline. Using a natively-installed host instead (not flatpak/snap),
or a non-rolling distro? The native steps below are simpler and just
as correct - no need for Docker at all.
Debian / Ubuntu:
sudo apt install build-essential cmake ninja-build git pkg-config \
libx11-dev libxext-dev libxcursor-dev libxrandr-dev libgl1-mesa-devNeeds CMake 3.17+ (for FetchContent's GIT_SUBMODULES_RECURSE) -
Ubuntu 22.04/Debian 12 and newer already have this in apt. Older releases
(Ubuntu 20.04's cmake is 3.16.3, too old) need a newer CMake from
elsewhere (e.g. Kitware's apt repo) - or just
use the Docker build below,
which sidesteps this and every other toolchain-version question at once.
Arch / CachyOS / Manjaro:
sudo pacman -S --needed base-devel cmake ninja git \
libx11 libxext libxcursor libxrandr mesaFor the standalone app you'll also want a running JACK server or
PipeWire with its JACK-compatibility layer (pipewire-jack) — most
modern distros already have this. VST3/LV2 use inside a DAW or Carla
don't need it.
macOS:
xcode-select --install # Xcode Command Line Tools, if not already present
brew install cmake ninjaNeeds CMake 3.17+ the same as Linux above - Homebrew's cmake is
comfortably ahead of that. No JACK/PipeWire equivalent is needed for
the standalone app - it talks to CoreAudio directly.
git clone https://github.com/Loursy/AmpForge.git
cd AmpForge
mkdir build && cd build
cmake .. -G Ninja
ninjaCMake fetches the DPF framework
automatically on first configure — no submodules, no extra flags, a
plain git clone is all you need.
This builds four plugin folders (01-gain, 02-amp, 03-screamer
are early scaffolding kept for reference; 04-chain is AmpForge
itself, the actual product). All the output ends up under
build/bin/.
Just want the plugin? You don't need this section - the prebuilt tarball is already built this exact way, so it works out of the box, flatpak/snap-sandboxed hosts included, with zero build steps on your end. This section is for building from source with that same portability guarantee - useful if you're testing an unreleased commit in a sandboxed host, don't want to fight your own system's toolchain versions (see step 1 above), or are the one cutting a release (though even that's automated now - see Project status).
A native build like the one above links against whatever glibc your own distro ships. On a rolling-release distro that can be too new: a plugin built against glibc 2.43, for example, fails to load in an older sandboxed host - such as Bitwig's flatpak build on a just-released Fedora - with an error like:
Failed to load CLAP plug-in ... version `GLIBC_2.43' not found
To avoid that, build inside installer/linux/Dockerfile's Ubuntu
22.04 (glibc 2.35) environment instead, which covers essentially every
mainstream Linux distro and flatpak/snap runtime from the last several
years. That specific baseline isn't arbitrary - pushing it back further to
Debian 11 (glibc 2.31, still a meaningfully common target) was tried and
hits a real wall: DPF's own (unused - AmpForge's UI is OpenGL/DGL, not a
WebView) WebViewImpl.cpp always compiles in, and its shm_open/
shm_unlink/pthread_create/pthread_join calls link cleanly on glibc
2.34+ (those merged into libc itself around then) but fail with
undefined reference on anything older without patching DPF's own build
to add -lrt - out of scope here. Ubuntu 22.04 is the oldest base that
builds clean without touching DPF at all.
installer/linux/docker-build.shThis mounts the repo into a container and runs the same CMake/Ninja
build as above, landing the result in build-docker/bin/ instead of
build/bin/ (so it never collides with a native build you already
have). installer/linux/package.sh and installer/linux/install.sh
(step 3 below) both work against it the same way, just point them at
it with BUILD_DIR:
BUILD_DIR=build-docker installer/linux/package.sh # -> a release tarball
BUILD_DIR=build-docker installer/linux/install.sh # -> install it straight away, no tarballThis is also exactly what CI (.github/workflows/linux-build.yml)
runs on every push - and on a v* tag, automatically publishes the
result as the official GitHub Release, so this is what actually
produces the prebuilt tarball mentioned above. Requires
only Docker itself - no
other prerequisites from step 1.
Which systems the Docker build actually loads on: a Docker-built
.clap/.vst3/.lv2 needs at most GLIBC_2.34 and GLIBCXX_3.4.29.
Check your own system against that with:
ldd --version # glibc version, first line
strings /usr/lib/x86_64-linux-gnu/libstdc++.so.6 | grep GLIBCXX | sort -V | tail -1(that second path varies by distro - e.g. /usr/lib64/libstdc++.so.6 on
Fedora). Verified for real below, not just compared version numbers -
actually resolved the built .clap's dynamic symbols with ld.so --list
inside each distro's own container image:
| System | Status |
|---|---|
| Ubuntu 22.04 LTS and newer (24.04, ...) | ✅ Works |
| Debian 12 (bookworm) and newer | ✅ Works |
| Fedora (recent releases, native or flatpak-sandboxed hosts like Bitwig on a current runtime) | ✅ Works - this is the exact bug report that started this section |
| Arch / CachyOS / Manjaro (rolling) | ✅ Works (glibc is always current there) |
| Ubuntu 20.04 (focal) | ❌ Too old - GLIBC_2.32/2.33/2.34 not found |
| Debian 11 (bullseye) and older | ❌ Too old - same GLIBC/GLIBCXX errors, and can't even be used as the build environment either (see the DPF -lrt wall above) |
A native build (the non-Docker path above) inherits whatever's newer or older about your own system's glibc instead of this table - it can be strictly more restrictive (a rolling-release host, the original problem this section exists for) or, in principle, less (building directly on an even-older-than-Ubuntu-22.04 system that nonetheless has a new enough compiler for everything else) than what the Docker build produces.
Built it yourself and just want it installed, without copying each
format by hand below? installer/linux/install.sh does exactly the
same copies in one step - run it straight from the repo root
(installer/linux/install.sh) once build/bin/ exists (used the
Docker build above
instead? BUILD_DIR=build-docker installer/linux/install.sh), or
installer/linux/install.sh --uninstall to remove it again.
The manual per-format copies below all assume a native build
(build/bin/...) - swap in build-docker/bin/... if that's what you
built.
LV2 (for Carla, Ardour, Qtractor, and most Linux LV2 hosts):
mkdir -p ~/.lv2
cp -r build/bin/ampforge_main.lv2 ~/.lv2/VST3 (for Reaper and other VST3 hosts):
mkdir -p ~/.vst3
cp -r build/bin/ampforge_main.vst3 ~/.vst3/Rescan plugins in your host afterward (in Reaper: Options → Preferences → Plug-ins → VST → Re-scan).
CLAP (for Reaper, Bitwig, and other CLAP hosts):
mkdir -p ~/.clap
cp -r build/bin/ampforge_main.clap ~/.clap/Standalone (JACK/PipeWire, no host needed):
./build/bin/ampforge_mainmacOS: installer/macos/install.sh does the same one-step install
(run from the repo root once build-macos/bin/ exists), or
installer/macos/install.sh --uninstall to remove it again. The
manual per-format copies are the same idea, just macOS's own plugin
directories instead of Linux's dotfolders:
mkdir -p ~/Library/Audio/Plug-Ins/VST3
cp -r build-macos/bin/ampforge_main.vst3 ~/Library/Audio/Plug-Ins/VST3/
mkdir -p ~/Library/Audio/Plug-Ins/CLAP
cp -r build-macos/bin/ampforge_main.clap ~/Library/Audio/Plug-Ins/CLAP/
mkdir -p ~/Library/Audio/Plug-Ins/LV2
cp -r build-macos/bin/ampforge_main.lv2 ~/Library/Audio/Plug-Ins/LV2/A self-built copy runs into the same unsigned-build Gatekeeper prompt
mentioned in Download above - clear it the same way:
xattr -dr com.apple.quarantine <path>.
The DSP in core/ has a small, dependency-free test suite - plain CTest,
no GoogleTest or Catch2 to fetch:
cd build
ctest --output-on-failureTests are built by default; configure with -DAMPFORGE_BUILD_TESTS=OFF
to skip them. They cover the EQ/filter coefficient math against a
measured frequency response, the effect chain's ordering and
reset-on-re-enable behaviour, delay timing, gate and compressor
behaviour, the pitch detector, and a sweep that runs every block - then
all of them chained together - through real audio to catch NaN/Inf and
runaway gain. CI runs them on all three platforms (on Windows under
Wine, since those binaries are cross-compiled).
- In Reaper: add it from the FX browser like any other VST3 or CLAP plugin — it shows up as "AmpForge". Automate any knob, switch, or the pedal Position parameters directly from Reaper's automation lanes; the 7 factory presets are also available from Reaper's own plugin preset dropdown.
- In Carla / other LV2 hosts: add it as an LV2 plugin named "AmpForge".
- Standalone: run
ampforge_mainwith JACK or PipeWire running, and patch its input/output ports (e.g. withqpwgraphorcatia/carla-patchbay) to your interface.
Custom presets you save from inside the plugin are stored at
~/.config/ampforge/user_presets.txt and are shared across every
instance and format (VST3/LV2/CLAP/standalone) on your machine. Note
that, by design, custom presets are a global, machine-local list rather
than DAW state — they don't travel inside a saved project file, though
every parameter value you've dialed in does (that's standard host
automation state, saved and restored with your project like any other
plugin).
What each pedal does and what its knobs actually change, in plain terms (the same order they sit in on the default board):
- Noise Gate — quiets the signal between notes so hiss/hum doesn't ride along with high-gain distortion. Thresh: how quiet the signal has to get before the gate starts closing. Attack: how fast it re-opens once you play again. Release: how fast it closes after you stop. Range: how far down it pulls the signal instead of slamming it to total silence.
- Compressor — evens out volume, taming loud peaks and lifting quiet parts closer together. Thresh: the level above which it starts reducing gain. Ratio: how hard it squashes anything over that (4:1 means 4dB over becomes 1dB over). Attack/Release: how fast it reacts to a peak, and how fast it lets go afterward. Makeup: turns the overall (now quieter) output back up.
- Wah — a swept filter that mimics a real wah pedal's rocking treadle. Pedal: heel-down (0) to toe-down (1) — automate this from your DAW to actually "play" the wah. Q: how narrow/sharp the sweeping peak sounds.
- Screamer — a Tube-Screamer-style overdrive: smooth, warm grit. Drive: how hard it pushes into clipping. Tone: rolls off highs as you turn it down. Level: final output volume.
- Distortion — a harder, buzzier gain stage than Screamer (asymmetric clipping, like a Boss DS-1/ProCo Rat style circuit). Same three knobs as Screamer (Drive/Tone/Level), just on a much hotter Drive range meant to get considerably dirtier.
- Amp — the core amp simulation; always present (though it can be turned off/bypassed like anything else). Type: picks a voicing (Modern/Vintage/Crunch/Hi-Gain — different EQ character and headroom). Drive: pushes into the amp's soft-clip saturation. Bass/Mid/ Treble: the tone stack. Volume: final output level.
- Cabinet — convolves the signal with a loaded speaker cabinet impulse response (a WAV recording of how a real cab+mic responds), which is what makes a driven amp sound like it's coming out of a real speaker instead of sounding thin/synthetic. Needs its own IR file loaded first — see Loading a cabinet impulse response below. Mix: dry/wet blend. Level: output trim.
- NAM — runs the signal through a loaded Neural Amp
Modeler
.namcapture of one specific real amp/pedal/cab, as an independent tone source alongside (not instead of) the Amp/Cabinet above. Needs its own model file loaded first — see Loading a NAM capture below. In: input trim before the model (it expects a clean, unprocessed signal). Mix: dry/wet blend. Out: output trim. - Chorus — thickens the sound with a constantly-wobbling delayed copy mixed in, for a "multiple instruments at once" effect. Rate: how fast the wobble moves. Depth: how far it wobbles. Mix: dry/wet blend. Sync: lock Rate to the host's tempo instead of a free-running Hz value.
- Phaser — a sweeping "whoosh" from moving notches in the frequency response, different in character from Chorus. Rate: sweep speed. Depth: how far the sweep travels. Mix: dry/wet blend.
- Tremolo — rhythmically pulses the volume up and down (the classic surf/indie "pulsing" sound). Rate: pulse speed. Depth: how strong the pulse is. Sync: lock Rate to the host's tempo.
- Delay — a classic echo. Time: gap between repeats. Feedback: how many repeats you hear before they die out. Mix: dry/wet blend. Sync: lock Time to a note division of the host's tempo instead of a free-running ms value.
- Reverb — simulates the sound of a space (room, hall, plate). Room: how big/long the simulated space feels. Damping: how quickly the high frequencies die out in the tail (more damping = darker, more "absorbed" sound). Mix: dry/wet blend.
- Autotune — vocal pitch correction; see Vocal effects above for the concept. Key/Scale: which notes count as "in tune" to snap to (Scale = Chromatic/Major/Minor). Speed: how fast it snaps to the corrected pitch — low is a gentle glide, high is the instant, robotic T-Pain-style snap.
- De-esser — tames harsh "s"/"sh" sibilance in a voice without dulling the rest of it. Freq: where the sibilant band starts (typically 4–9kHz depending on the voice — sweep it until it lands on the harsh part of an "s"). Thresh: how loud that band has to get before it kicks in. Reduction: the maximum amount it's allowed to turn that band down by.
Every pedal also has an On/off toggle (adds/removes it from the board) and a Bypass footswitch (keeps it on the board, visible, but temporarily out of the signal path) — the same distinction a real pedalboard has between unplugging a pedal and just stepping on it.
The preset dropdown's Export button writes the currently-loaded
preset to its own file under ~/.config/ampforge/exports/, named after
the preset (the toast that pops up after exporting shows the exact
path) — hand that file to someone else, or copy it to another machine,
and their Import button's native file picker can load it straight
back in as a custom preset. A whole copied-over user_presets.txt can
be imported the same way. Imported presets are added to (or, if the
name matches one already in your list, update) your custom presets;
importing a file whose preset happens to be named after one of the 7
factory presets is skipped rather than silently shadowing it, since the
dropdown has no way to show two same-named entries as distinct.
The Cabinet block convolves your tone with a real speaker cabinet's impulse response (a short WAV recording of how that cab + mic responds to an impulse) — this is what gives a driven amp its "coming out of a real speaker" character, rather than sounding thin or synthetic.
AmpForge doesn't bundle any IRs (most are copyrighted captures of real gear, so shipping them isn't something a free/open plugin can do) — bring your own. Plenty of free, permissively-licensed cabinet IRs exist online; look for mono WAV files.
Add the Cabinet pedal to your board, click its Load IR File... button, and pick a WAV file (8/16/24/32-bit PCM or 32-bit float, mono or stereo — stereo files are downmixed). Unlike custom presets, the loaded IR's file path is saved with your DAW session/project (it's DPF plugin state, not a parameter, but it's still real host-persisted state), so it survives a project reload as long as the file stays at the same path on disk.
The NAM block runs a Neural Amp Modeler
.nam file — a neural network trained to reproduce one specific real
amp, pedal, or cabinet, rather than a hand-tuned emulation like the
Amp block. It's a separate, optional tone source you can mix in
alongside (or instead of) the modeled Amp/Cabinet chain, not something
you have to choose between.
AmpForge doesn't bundle any captures (most are shared under their own terms by whoever trained them) — bring your own from ToneHunt or Tone3000, or train your own with the official NAM trainer.
Add the NAM pedal to your board, click its Load NAM Model...
button, and pick a .nam file. Like the Cabinet IR path above, the
loaded model's file path is saved with your DAW session/project and
survives a reload as long as the file stays at the same path on disk.
The status sidebar confirms what's loaded — filename and architecture
(WaveNet, LSTM, the A2 "SlimmableContainer" wrapper, ...).
The DSP engine (all 19 modules, the reorderable chain, factory presets) and the pedalboard UI are both functional and usable today. Known gaps, tracked for future work:
- The NAM block runs inference one audio sample at a time rather than
batched per-block (see
core/NamBlock.hpp's comment on why), which gives up some of NAM's own internal batching efficiency - fine for a single real-time instance, but a future optimization target if CPU cost ever becomes a problem. - The Cabinet block's convolution is a straightforward direct time-domain implementation, not an FFT-partitioned one — plenty fast enough for a single instance at the IR lengths a speaker cab actually needs (capped at 4096 samples), but a future optimization opportunity if that ever changes.
- The Windows installer only covers VST3/CLAP/LV2 - the standalone app
pulls in SDL2/RtAudio for its audio backend, and cross-compiling
those for Windows isn't set up yet, so there's no Windows standalone
.exefor now (VST3/CLAP/LV2 inside a DAW cover the overwhelming majority of Windows use anyway). - CI (GitHub Actions) builds and
packages the Linux tarball on every push/PR/tag using the same
portable Docker build described above, and on a
v*tag push publishes it as a GitHub Release automatically - pushing a tag is the whole Linux release process now, no local Docker run or manual upload needed. A separate workflow (windows-build.yml) cross-compiles the Windows installer the same way (installer/windows/build.sh) and attachesAmpForge-<version>-Setup.exeto that same release. A third workflow (macos-build.yml) builds natively on a macOS runner (installer/macos/build.sh- no cross-compile needed there, unlike Windows) and attachesAmpForge-<version>-macos.zipthe same way, so pushing a tag now publishes all three platforms with no manual packaging step on any of them. - The macOS build isn't code-signed or notarized (that needs a paid Apple Developer account this project doesn't have) - see Download above for the Gatekeeper workaround this makes necessary on first launch.
Issues and pull requests are welcome. The codebase is organized as:
core/— header-only DSP blocks, one per effect, all implementing a small sharedAudioBlockinterface.plugins/04-chain/— the actual plugin: DSP (ChainPlugin.cpp), UI (ChainUI.cpp), and the shared parameter/preset definitions used by both.
GPL-3.0-or-later — see LICENSE.
Built on DPF and what it bundles (pugl, NanoVG, a fallback font, and the CLAP/LV2 interface headers) - all permissively licensed, see THIRD-PARTY-NOTICES.md for the full text of each.
