Skip to content
LoursyPublic

About

Open-source guitar amp simulator plugin for Linux & Windows — VST3/LV2/CLAP, with a reorderable pedalboard chain (amp, cab IR, drive, mod, delay/reverb)

Topics

Resources

Stars

32 stars

Watchers

1 watching

Forks

Latest commit

 

History

51 Commits

Folders and files

Repository files navigation

AmpForge

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.

AmpForge screenshot

Video demo: youtube.com/watch?v=gz9fyAHsE6M

Download

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.)

Features

  • 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 .nam capture 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 .nam capture 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).

Building from source

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.

1. Install prerequisites

Debian / Ubuntu:

sudo apt install build-essential cmake ninja-build git pkg-config \
    libx11-dev libxext-dev libxcursor-dev libxrandr-dev libgl1-mesa-dev

Needs 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 mesa

For 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 ninja

Needs 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.

2. Clone and build

git clone https://github.com/Loursy/AmpForge.git
cd AmpForge
mkdir build && cd build
cmake .. -G Ninja
ninja

CMake 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/.

Building a portable release build (Docker)

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.sh

This 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 tarball

This 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.

3. Install

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_main

macOS: 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>.

4. Run the tests

The DSP in core/ has a small, dependency-free test suite - plain CTest, no GoogleTest or Catch2 to fetch:

cd build
ctest --output-on-failure

Tests 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).

Using it

  • 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_main with JACK or PipeWire running, and patch its input/output ports (e.g. with qpwgraph or catia/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).

The pedals

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 .nam capture 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.

Exporting and importing presets

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.

Loading a cabinet impulse response

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.

Loading a NAM capture

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, ...).

Project status

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 .exe for 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 attaches AmpForge-<version>-Setup.exe to 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 attaches AmpForge-<version>-macos.zip the 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.

Contributing

Issues and pull requests are welcome. The codebase is organized as:

  • core/ — header-only DSP blocks, one per effect, all implementing a small shared AudioBlock interface.
  • plugins/04-chain/ — the actual plugin: DSP (ChainPlugin.cpp), UI (ChainUI.cpp), and the shared parameter/preset definitions used by both.

License

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.

About

Open-source guitar amp simulator plugin for Linux & Windows — VST3/LV2/CLAP, with a reorderable pedalboard chain (amp, cab IR, drive, mod, delay/reverb)

Topics

Resources

Stars

32 stars

Watchers

1 watching

Forks

Releases

Sponsor this project

Packages

Contributors

Languages