Zoom MultiStomp ZDL

Custom .ZDL effects for Zoom MultiStomp pedals, plus the reverse-engineered toolchain used to build them — no Zoom SDK required.

This was a good amount of work and tokens, please consider to: buymeacoffee.com/sz0kfixkct

New here? This is a pack of 22 extra effects plus a free browser-based Patch Editor for adjusting knobs and arranging effects in your patches. On the original MS-70CDR, you install the ready-made files from dist/ over USB using Zoom Effect Manager—no custom firmware reflash, coding, or compiling needed. Back up your patches and effect list first. The Patch Editor edits patches; Zoom Effect Manager installs the effects. See the installation guide.

Pedal compatibility:

• Tested: original MS-70CDR (firmware 2.10)—custom effects and Patch Editor.
• Compatible family, awaiting confirmation: MS-50G, MS-60B, G1on, G1Xon, B1on and B1Xon. Custom effects and Patch Editor compatibility on these models is awaiting confirmation from users.
• Not supported: MS-100BT and Plus models, including MS-50G+, MS-60B+ and MS-70CDR+. See Compatibility below.

▶ Open the Patch Editor

Plug the MS-70CDR in over USB, click Connect, and edit patches live — no install, no clone, nothing sent anywhere (it is one self-contained HTML file and your patch library lives in your own browser).

• Opera or Edge. Safari and Firefox do not implement Web MIDI; the editor will tell you if you are on one of them. Chrome 152 is currently broken — a Web MIDI input regression means output works, no dump ever arrives, and no error is raised. tools/midi_check.html confirms it in isolation.
• Close Zoom Effect Manager first — it holds the MIDI port. "The pedal did not respond" is usually this.
• Slots 1–3 respond to knob moves instantly. Slots 4–6 cannot be edited live by this hardware, so the editor applies those for you — see docs/MIDI-PARAM-EDIT.md. Effects built before 2026-09-10 also load with their knobs inert until nudged; rebuild or reinstall from dist/ and that goes away.

▶ Open the Cover Editor — draw the 128×64 image an effect shows on the pedal's screen. Drawing, PNG/JSON export and the device preview all work from the link above; the one-click Update ZDL button additionally needs the local build server:

git clone https://github.com/themanro/ZoomMultistompZDL.git
cd ZoomMultistompZDL
python3 tools/serve_editor.py        # opens the editor, wires up "Update ZDL"

Loading new effects onto the pedal still goes through Zoom Effect Manager — the browser can edit patches, but it cannot install effects.

September 14 display update: all 22 effects now have individual laboratory-inspired graphics, corrected LCD proportions, and shorter pedal labels. Mode controls show names in PE and supported custom effects show short names on the pedal. Reinstall the updated files from dist/ to get the pedal artwork and labels; refresh the Patch Editor for its UI changes. Existing patch values and effect IDs are preserved. See the display update notes for details.

This fork ships a curated library of 22 effects — all grouped under the Delay category, each with a custom on-device cover. Eighteen originals, three Airwindows-derived ports (Galactic reverb, Oxide tape, Spool tape echo), and one contributed effect (Dustbox). Full knob layouts, caveats and sound demos are in CUSTOM_EFFECTS.md.

Knob lists are read from the shipped dist/ binaries, so they match what the pedal actually shows.

Every effect ends with a Mix knob (dry/wet, default 50), so levels and controls are consistent across the pack — an effect is audible as soon as it is selected. Dustbox is the exception; its fourth knob is Power.

The pedal can't hold or run all 22 at once (storage + DSP limits) — install a subset, back up first, and flash one at a time. Run heavy effects (Microlm, Galactic, Spool) one per patch.

The ready-to-load effects are in dist/. Point Zoom Effect Manager at that folder, or download individual .ZDL files from it. You do not need the build toolchain unless you want to modify or rebuild effects.

Use Zoom Effect Manager 2.3.3 or newer.

1. Open Zoom Effect Manager, connect your pedal, then open Settings.
2. Choose Read Effects from folder and select this repo's dist/ folder.

3. In the effect browser, enable Effects from devices and From Folder.
4. Add the desired effects to the device and write them with Zoom Effect Manager.

Back up your current effect list before writing. Experimental builds can freeze a pedal until power-cycled.

Effects must be installed with Zoom Effect Manager first. The patch editor only references effects by id — it cannot install them. Its dropdown is the full catalogue from every MS/G1/B1 model, not the subset on your pedal, so selecting something Effect Manager has never written leaves that slot blank. The editor warns when you pick an effect it has not seen in any of your patches, and tells you if the pedal drops one after a write.

If the effect browser says "No data to display, check filters": step 3 is not optional -- choosing the folder only tells Effect Manager where to look, and the browser's From Folder source has to be ticked separately. Connect the pedal before launching, and check no category filter is set (everything here is in Delay). If it still shows nothing, verify the files really are ZDLs and not saved HTML pages -- see docs/INSTALLING-ZDLS.md.

Gotchas learned the hard way:

• Effect Manager does not replace an installed effect with the same fxid — remove the old one from the device, re-read the folder, then add the new one.
• Effect Manager's browser thumbnails come from the app's internal stock database; custom effects always show its generic pedal icon. The covers in this repo control the pedal's screen, which is what matters live.
• FS.bin size mismatch when writing = too many effects installed (storage overflow). DSP full = the per-patch processing budget is blown — run heavy effects (Microloom, Galactic, Spool) one per patch.
• If the pedal freezes on the boot screen (a patch references a bad effect): power off, hold the Parameter 1 (leftmost) knob pressed in, power on → All INITIALIZE → press the footswitch. Patches reset to factory, but effect binaries stay installed — then remove the bad one.

More detailed install notes live in docs/INSTALLING-ZDLS.md.

The "+" models (MS-50G+, MS-60B+, MS-70CDR+) use ZD2, not ZDL, so nothing here loads on them. Whether they could ever be targeted turns on one question: is the payload analysable, or is it signed/encrypted? The evidence so far is encouraging — docs/STATE-ABI-PROGRESS.md records a hand-decoded ZD2 Fx_SFX_LineSel, which means somebody read ZD2 machine code and understood it.

Step-by-step guide: docs/PROBING-A-NEW-PEDAL.md. Two things anyone with a "+" pedal can check, neither of which risks the hardware:

• python3 build/inspect_zd2.py Effect.ZD2 — reports entropy and structure. Uneven per-block entropy means plain code; flat and high everywhere means encrypted or compressed. Validated against a known-plain ZDL, random bytes and a gzip stream.
• Open the patch editor and click Connect. It reads the identity reply, adopts the device id so dumps are addressed correctly, and switches to READ-ONLY on any model but the MS-70CDR — every byte offset here was mapped against that one pedal, so writing elsewhere would scramble patches. If a "+" pedal answers Reload bank with a patch dump, that alone is worth reporting.

Worth being clear about why the MS-70CDR is hackable at all: Zoom themselves ship a tool that writes effect binaries to it. None of this is an exploit. The question for the "+" models is whether an official write path still exists, not whether the format can be understood.

Hard-won findings from getting these effects stable on real hardware. The deep versions live in docs/ and build/ABI.md.

1. Code→data relocations. Any static array referenced from the audio function (even static const float[]) forces a relocation and freezes the pedal at load. Bake tables as #define scalar literals or unrolled macro sums instead — they compile to immediates. A clean build prints .fardata: 0 bytes and Applied 0 .obj relocations; anything else is a red flag. (This froze Spool until its 64-tap FIR was unrolled.)
2. Unresolved runtime helpers. Any float division, integer / or %, or math-lib call (sinf, powf, …) emits a __c6xabi_* helper the loader can't resolve — the branch goes to address 0. Use polynomial sin/cos, Newton-iteration reciprocals, and bit-mask tricks instead of modulo. See docs/SAFE-DSP-RULES.md.

• The host gives each effect instance a large state arena via ctx[3], hardware-probed to ≥705,536 bytes — Lush-class (512 KB) and Spool-class (545 KB) states load fine. Always bounds-check the descriptor and clear big buffers lazily in chunks.
• The linker currently advertises a hardcoded CPU cost (20.0) while stock effects declare 11.6–128, so the firmware can green-light patches the DSP can't actually run. Symptoms range from DSP full to a hang at patch load. Treat very heavy reverbs with respect until per-effect honest costs land.

• The proven knob path delivers normalized 0..1 floats (an earlier ×7.14 scaling assumption made every knob saturate at ~14% travel).
• Saved parameters now initialize at patch load. The former freeze came from absolute handler call targets that lacked relocation records; the linker now emits PC-relative calls. All 22 release effects enable the corrected init. MatProb and Rooms are hardware-confirmed in all six slots, across patch changes and power cycles with the editor disconnected. The remaining effects are built and statically checked, with hardware listening still pending. See docs/PARAM-INIT-INVESTIGATION.md.
• The editor retains live-parameter replay for slots 1–3 for compatibility with older installed binaries. It cannot identify the installed build from its effect ID alone. Slots 4–6 still lack live 0x31 edits; initialization and editor-side update behavior are separate concerns.
• Refocusing an effect in the chain UI clobbers its param block with garbage until wiggled. The fix (piloted in Howl v3) is an edit-driven knob latch: a real knob turn changes one slot at a time, so bulk rewrites are detected and ignored, and the effect keeps sounding as dialed.
• Up to 9 params work (3 pages × 3), image shows the first three knobs; the multi-knob synthesized-handler path is hardware-proven.

• Never feed a resonant filter back into itself — loop gain crosses unity almost everywhere. Use a pole-radius-controlled resonator (radius < 1 is unconditionally stable); that's how Howl works.
• A cubic soft-clip has 1.5× gain at small signal — inside a feedback loop that multiplies loop gain and self-oscillates. Use a unity-slope clipper (x − x³/6.75) in loops. (Caught twice: Scorch's output, then Dissolve's smear loop.)

• The on-device cover is the full 128×64, 1-bpp, column-major in eight 8-row blocks, run-length encoded. The firmware paints live 20×15 knob-value boxes on top at coordinates the ZDL declares — so draw labeled dials under them, stock-style (build/decode_picture.py decodes any ZDL's cover; ~130 stock covers were decoded to learn this).
• The LCD pixels are ~1.3× taller than wide: pre-compress artwork vertically or circles render as tall ellipses.
• Hand-drawn covers: tools/cover_editor.html is a self-contained pixel editor with a device-aspect preview; exported JSON in src/airwindows/common/covers/ overrides the generated cover at build time.

• ZDL basenames must be ≤ 8 characters and unique after truncation, or effect identities collide and the pedal freezes.
• There is no sort field in the header — on-device browse order tracks fxid. This pack uses 450+ to avoid stock collisions.
• gid ↔ category must match the exported symbol prefix (1=DYN, 2=FLT, 3=DRV, 6=CHO/MOD, 8=DLY, 9=REV); everything here is gid 8 (Fx_DLY_*) so the pack lives together in the least crowded menu.

Start from a small effect in src/custom/ (e.g. reel or klang). Copy the directory, give the effect a new name and an unused fxid in manifest_pedal.json, update the C audio function and build.py, then add it to build_all.py.

Keep the first hardware test boring: audio_nop: true or tiny pass-through DSP, no static arrays, no divides, magic shuttle preserved. The safe path is docs/SAFE-DSP-RULES.md; effect directory conventions are in src/airwindows/README.md.

Building requires Python 3.10+ and the TI C6000 Code Generation Tools (v8.5.0). Installing prebuilt effects from dist/ does not.

The build scripts expect the TI compiler here (edit TI_ROOT in the per-effect build.py if yours differs):

/Applications/ti/ti-cgt-c6000_8.5.0.LTS

python3 -B build_all.py            # all 22 release effects, with load initialization -> dist/
python3 -B build_all.py taffy      # one effect
python3 -B build_all.py --all      # + diagnostic/probe builds (-> build/probes/)

build_all.py also re-extracts the patch editor's inline effect database at the end, so the editor cannot go stale against dist/. It silently did, twice.

Desktop listening previews for the originals (no compiler, no pedal) are in tools/audio_preview/README.md.

There is a headless C674x emulator (Ziddle) that runs these ZDLs, plus a test rig in tools/emulator/ that reports whether _init completes and whether params materialized. It is authoritative about instruction semantics and cannot see firmware readiness — it passed four _init builds that froze the pedal. Setup and limits: docs/EMULATOR-TESTING.md.

build/disassemble_zdl.py disassembles any ZDL, ours or one of the ~830 in stock_zdls/. Diffing a generated handler against the stock equivalent has been the most productive debugging tool in the project.

This repo builds loadable Zoom .ZDL effects without Zoom's unreleased SDK:

Known runtime map for custom ZDLs:

ZoomMultistompZDL/
├── README.md
├── build/                 linker, ELF/ZDL helpers, cover decoder, handler blobs
├── docs/                  install notes, ABI status, and porting guidance
├── dist/                  release ZDLs to load in Zoom Effect Manager
├── graphics/              gallery renders of the on-device covers
├── tools/                 cover editor + desktop audio preview
├── src/custom/            original effects
├── src/airwindows/        Airwindows-derived ports + shared helpers
├── src/hardware_probes/   diagnostic ZDLs for runtime ABI experiments
├── stock_zdls/            tracked stock ZDL corpus used for comparison
└── build_all.py           release/probe build entrypoint

Several research references are useful locally but intentionally git-ignored: airwindows-ref/, zoom-fx-modding-ref/, ZoomPedalFun-main/. If you clone them beside the repo, treat them as read-only references.

Hardware reports are gold. When testing a ZDL, please include:

Open an issue or PR with findings. Keep experimental claims precise: "boots on my MS-70CDR" is more useful than "works everywhere."

See LICENSE. The original work in this fork — the custom effects in src/custom/, the browser tools in tools/, the notes in docs/ and the cover art in graphics/ — is MIT.

That grant deliberately stops there. The upstream toolchain this is forked from, repeat98/ZoomMultistompZDL, publishes no licence file, so inherited material stays under its author's default copyright and is not relicensed here. Airwindows DSP in src/airwindows/ is MIT by Chris Johnson/Airwindows under its own terms. Zoom firmware, stock effect binaries and the TI toolchain belong to Zoom Corporation and Texas Instruments; they are referenced for interoperability and reverse-engineering research only, and none of their code is redistributed here.

Not affiliated with or endorsed by Zoom Corporation. Flashing custom effects is at your own risk.