Open firmware for the Valeton GP-5 guitar pedal, written from scratch, and a framework for writing your own.
Documentation · Get started · Flash from your browser · Your first effect · Report a problem
OpenGP5 replaces the GP-5's software on both of its processors with code written from scratch, and gives you a small framework for writing your own: your sound, your screen, your controls, flashed over USB. Nothing in it comes from Valeton or the chip vendor, and you can always go back to Valeton's firmware.
Note
Alpha. OpenGP5 has run on several GP-5s, with no problem reported. Expect rough edges, and expect interfaces to change before 1.0. Read Before you flash first.
Pick a firmware built with OpenGP5 and put it on your pedal. Each turns the pedal into something new, and none needs compilers:
| Firmware | What it is |
|---|---|
| NAM Loader | Neural Amp Modeler captures: 30 of them, 12 cab IRs, a noise gate and EQ each |
| Dreamcatcher | Ambient textures: a micro-looper, a glitch delay that smears into reverb, grains |
| Tremolo | The example firmware: small enough to read in one sitting |
Flash them with OpenGP5 Launchpad, the desktop app (it also loads captures, edits presets and backs up the pedal), or with the web flasher in Chrome, Edge or Opera. Step by step: Get started.
The sound of a firmware is plain C. This is the whole sound of the tremolo:
static void fw_process(const int32_t *in, int32_t *out_left, int32_t *out_right)
{
for (uint32_t i = 0; i < GP5_BLOCK; i++) { /* 64 samples at a time */
float wave = 0.5f + 0.5f * sinf(2.0f * GP5_PI * phase);
float gain = 1.0f - depth * wave;
phase += step; if (phase >= 1.0f) phase -= 1.0f;
out_left[i] = out_right[i] = (int32_t)((float)in[i] * gain);
}
}Build it, try it on your computer, and flash it:
release/setup-toolchain.sh # once: both compilers, pinned and checksum-checked (~190 MB)
platform/build_firmware.sh tremolo # -> build/GP-5_tremolo.bin
python3 tools/simulate.py tremolo # the whole firmware on your computer: sound and screen
python3 tools/gp5tool.py flash build/GP-5_tremolo.bin --sections allWhat each system needs: Set up your computer. To start a firmware in its own repository, built and tested by GitHub on every push, use the firmware template.
flowchart LR
pc["Computer: Launchpad or gp5tool.py"] -- "USB-MIDI" --> ctl
subgraph pedal["Valeton GP-5"]
ctl["Control processor (BP1048)<br/>your fw_draw, fw_foot_down, fw_para_turn<br/>platform: drivers, USB-MIDI, screen, storage"]
dsp["DSP (Cortex-M4F)<br/>your fw_process, fw_param<br/>platform: audio in and out, maths"]
ctl -- "parameters (params.h)" --> dsp
dsp <-- "audio link: words each way per block" --> ctl
end
guitar(["Guitar in"]) --> dsp
dsp --> out(["Out L / R"])
You write a manifest (firmware.json), your settings (params.h), the sound (dsp/firmware.h) and the controls
and screen (nds32/firmware.c). The platform does everything else: it carries your settings to the DSP, saves
them, keeps presets, and gives Launchpad an editor for them. Walkthrough:
Your first effect.
Platform (platform/) |
Runs both processors. Control processor: start-up, drivers, USB-MIDI, the colour screen, foot switch, knobs, LEDs, storage (settings and files), the link to the DSP. DSP: start-up, audio in and out, floating-point maths, the link back |
Firmwares (firmwares/) |
tremolo, the example (settings, presets, the screen and controls), and passthrough, the smallest possible firmware |
Flasher (tools/gp5tool.py) |
Flashes your build, or Valeton's own firmware, over USB-MIDI on macOS, Linux and Windows |
| Tools for the computer | simulate.py runs a whole firmware (both processors, the screen, scripted controls); run_effect.py runs your sound on a WAV file; dsp_emu_check.py boots the built DSP firmware in an emulator; make_font.py turns a font into smooth screen text |
Web flasher (docs/flasher/) |
Flashing from the browser, served at opengp5.github.io/flasher |
Catalog (catalog/) |
The firmwares Launchpad and the web flasher offer. List yours |
Documentation (site/, docs/platform/) |
The website. The pages for firmware authors are in docs/platform/, readable here too |
None of it comes from the chip vendor or from Valeton: no vendor SDK code, headers or libraries, and no Valeton code or data. It was written from what the hardware does. The same source builds byte-identical firmware on every supported system.
Everything is on opengp5.github.io:
| Read | For |
|---|---|
| Get started | Flash a firmware, recover from a failed flash, go back to Valeton's firmware |
| Launchpad | The desktop app, page by page |
| Firmwares | NAM Loader, Dreamcatcher and the tremolo: what they do, their controls |
| Build a firmware | Setting up, how a firmware works, your first effect, every guide and reference |
| Help | Problems, beta testing, contributing, the changelog |
Warning
Flashing your own firmware is at your own risk. The pedal's factory loader can't be overwritten over USB, so a bad flash can almost always be undone: unplug the pedal, hold the foot switch and press PARA in while you plug it back in, and flash again (Recovery).
In rare cases, recovery needs an FT232H USB adapter wired to the pedal's internal debug pads, which takes some soldering experience. Valeton's own updater (Valeton Suite) is not a reliable way back. Don't flash unless you're comfortable with that small risk.
MIT (LICENSE). Contributions are welcome: see CONTRIBUTING.md.
Not affiliated with or endorsed by Valeton. "Valeton" and "GP-5" are Valeton's trademarks, used only to say which pedal this runs on.

