zpwr-midi-fx

>_ZPWR-MIDI-FX

A modular MIDI effect / generator plugin (VST3 · AU · CLAP · Standalone) built on JUCE, with a cyberpunk WebView UI. Wire a patchable grid of note-stream blocks — chords, arps, scales, Euclidean sequencers, humanize, probability and more — into your own MIDI processor. The audio path is pass-through, so it drops in front of any instrument. The reference below is generated from the live module registry the plugin runs, so it never drifts from the build.

Module Reference

Every patch block with its inputs and parameters, grouped by category. (HTML)

Reference (PDF)

The same reference, paginated for print — built from the same source.

Source

Build instructions, the patch model, and the DSP block implementations.

Overview

Where a fixed chord + arp tool is a single black box, zpwr-midi-fx is a patchable grid of MIDI modules — the same modular-patch model as zpwr-fx, but the signal flowing between blocks is a stream of note events, not audio. Wire MIDI In → blocks → Out, cross-modulate block parameters from a mod matrix, and drive it all from soft keys, LFOs, envelopes and live MIDI / MPE expression.

It is built on the shared zpwr-patch-core (zpc) graph — the same engine as zpwr-fx and zpwr-synth, instantiated on a note-event stream instead of audio samples. Part of the MenkeTechnologies audio stack alongside zpwr-synth and zpwr-fx.

Formats & Platforms

VST3 AU (macOS) CLAP (note-effect) Standalone

Built on JUCE 8.0.13 with a cyberpunk WebView UI. On macOS the build is a universal binary (x86_64;arm64), so the VST3 / AU / CLAP load on both Intel and Apple Silicon hosts. On Windows it ships VST3 + CLAP (AU is macOS-only); x64 and ARM64 are separate builds. The audio path is pass-through, so it drops in front of any instrument.

Patch Model

A dynamic set of blocks (add / remove / reorder), each with a module type, note-stream inputs plus a scalar Mod input (unbounded summed cables per slot), up to six parameters, and one output. Inputs select any source; the two outputs (Out A, Out B) merge to the plugin's MIDI out. The graph is evaluated once per audio block in topological order, and note-offs are scheduled across block boundaries so nothing ever hangs.

MIDI In ▸ [B1 Chord] ▸ [B2 Arp] ▸ Out A ▸ MIDI Out

⚡ EZ WIRE auto-wires MIDI In → your blocks → Out A so a beginner gets a working chain without touching cables.
INIT unplugs every cable & mod while keeping the blocks; 🗑 blanks the whole patch.
INPUTS column exposes every patchable source as a jack — the note input, all scalar modulators (Random + performance / MPE controllers) and the soft keys — so anything usable in the mod matrix can be cabled directly into a block.
Cables are drawn between jacks and can be dragged to re-patch. Right-click a cable for its editor: a Level control (scales note velocity on that connection — 0 mutes it, and cable brightness / width follow the level), a Colour swatch, and Disconnect.

Every control has a hover tooltip explaining what it does. The patch (blocks, routing, mods) is zpc JSON the WebView edits and the plugin persists in its state.

Modules

111 note-stream modules across 10 categories — harmony, sequencing, probability, routing, control sources, dynamics, expression, tuning, MPE / voicing, plus a family of cellular-automaton sequencers (Game of Life, Brian's Brain, Langton's Ant). The reference lists every block with its inputs and parameters, generated from the live registry so it never drifts.

Representative blocks: Chord (one key → a voiced chord, 166 types, with inversion / spread / octave-double / transpose / strum), Arp (host-synced arpeggiator, 9 play modes, divisions, gate, octaves, swing, latch), Scale (snap notes to the nearest in-key pitch), SeqEuclid (Euclidean rhythm gate via Bjorklund), Chance (per-note probability gate), Harmonize (stack fixed intervals), Echo (MIDI delay with feedback), MidiLFO / MidiEnv (scalar control sources), Humanize, Strum, MPEConvert and the cellular-automaton sequencers MidiGameOfLife, MidiBrianBrain, MidiLangton.

Modulation

A dynamic list of routes, each mapping a scalar source → any block parameter with a depth. Routing rebuilds the graph; depth is a live, lock-free tweak. The same sources are available on each block's Mod input. Sources:

Soft Keys — an expandable pool of host-automatable macros (ceiling 32; 16 active by default; + / − to add / remove, active count saved in plugin state).
Auto-param pool — a reserved pool of 96 Auto N host params; right-click any block param to bind it (the Kontakt/Reaktor model), so any module parameter becomes host-automatable / CC-mappable. 32 soft keys + 96 auto params = 128 CC-mappable slots, one per MIDI CC.
LFO and Env block outputs, and Random.
Performance controllers — Mod Wheel, Pitch Bend, Aftertouch, Velocity, Expression (CC11), Sustain (CC64).
MPE — per-note Bend, Pressure and Slide (CC74), read from the most recently active note's channel.

Soft Keys & Automation

The host-automatable parameters are the soft keys — an expandable pool of macros (ceiling 32; 16 active by default, the active count saved in plugin state), with + / − to add / remove — plus a reserved pool of 96 Auto N host params: right-click any block param to bind it (the Kontakt/Reaktor model), so any module parameter becomes host-automatable / CC-mappable. 32 soft keys + 96 auto params = 128 CC-mappable slots, one per MIDI CC. Everything else lives in the patch, saved as zpc JSON in plugin state. Modulation is the patching itself: any LFO / Env block output or soft key patched into a block input — or mod-routed to a param — is a mod-matrix connection.

User Interface

The editor is a WebView hosting the shared zpwr-patch-core cyberpunk patcher — the same UI as zpwr-fx and zpwr-synth: drag-to-patch neon cables (fan-out, feedback, per-cable level + colour), a dynamic block grid (add / delete any number, no fixed block count), and a per-param mod matrix. Every control has a hover tooltip explaining what it does. Tabs:

PATCH — the block grid + cable routing + an expandable row of soft-key macro knobs. The toolbar carries ⚡ EZ WIRE (auto-wire MIDI In → your blocks → Out A), INIT (unplug every cable & mod, keep the blocks) and 🗑 (blank the whole patch). The INPUTS column exposes every patchable source as a jack — the note input, all scalar modulators (Random + performance / MPE controllers) and the soft keys. Cables are drawn between jacks and can be dragged to re-patch; right-click a cable for its editor (Level, Colour, Disconnect).
PERFORM — a macros-and-pads play surface with no patching (see Perform).
PRESETS — browse and manage the factory bank and user patches (see Presets).

Perform

The PERFORM tab is a macros-and-pads view with no patching, for live play:

Preset Morph — a 4-corner XY pad (A/B/C/D) that bilinearly interpolates between four captured presets; X/Y are reserved host params (morphX / morphY), so the morph is host-automatable.
Orb — angle picks one of 8 random scenes (per-macro offset vectors), distance from centre scales intensity; record / loop the orb motion while you drag.
XY macro pads — each pad drives a pair of soft keys; per-pad HOLD keeps the dot, SPRING snaps both axes back to centre on release.
Macro knobs — a dial per active soft key; Snapshots — 8 slots capturing the whole macro surface (per-plugin localStorage).
On-screen keyboard — global Key + Scale quantize of incoming notes and a Chord selector (Off / Oct / 5th / Maj / Min / Maj7 / Min7 / Sus4 / Power), plus a global arp (mode / rate / latch).

MIDI In response — PROGRAM and BANK toggles (both default ON): incoming Program Change switches presets, with Bank Select (CC0 MSB / CC32 LSB) captured for the next Program Change. Both are saved in plugin state.

Presets

A factory bank ships with the plugin (Chord Arp, Strummed Chords, Euclidean Pulse, Fifth Harmonizer, Arp Echo, Random Walk, Step Melody, Tone Cluster, Jazz Voicing, MPE Spread and more) spanning arps, harmony, rhythm, generative and FX chains. User patches are saved as zpwr-midi-fx/Presets/*.zmfxpatch under the user application data directory and managed from the PRESETS tab.