V-ConvoStudio

Fwuzeem Audio C-Series

What it is

V-ConvoStudio is a modular serial processing suite with four reorderable modules: LinearEQ, GuitarML, NAM, and Convolution. The editor shows the convolution module as IR. The default chain is Linear EQ -> GuitarML -> NAM -> Convolution. Reordering uses a processing-order combo box and Up/Down buttons; it is not drag-and-drop. Each model or convolution module can blend its processed result with its stage input, so the chain can make parallel-style dry blends even though the plugin does not contain a true parallel routing graph.

Controls & parameters

Chain and module actions

The Processing Order combo box lists the four modules with their current positions. Select a module in the list and use Up or Down to swap it with its neighbor. The order is stored in plugin state as processorOrder and is restored when all four valid module entries are present.

IR, GuitarML, and NAM module views provide:

• Load and Unload buttons.
• < and > buttons for sorted sibling-file navigation.
• A Bypass button for the module.
• Five parameter controls: In Gain, Out Gain, Phase Invert, Mix, and Stereo Width.

LinearEQ has no file buttons. Its five controls are relabeled HP Freq, LS Freq, LS Gain, HS Freq, and HS Gain, and its Bypass button is attached to the linearEQEnabled parameter.

Convolution, GuitarML, and NAM controls

The same six-parameter pattern is used for each of the three non-EQ modules. The prefix is ir, guitarML, or nam as shown below.

The three model/convolution modules use the Fwuzeem Audio BS law: +1 BS is x2, -1 BS is x1/2, and each integer step is 6.0206 dB of ratio change. Mix is a linear percentage blend around the stage input.

LinearEQ controls

Global controls and file types

Workflow / how to use it

1. Insert V-ConvoStudio on a mono or stereo audio path. Begin with the default order: Linear EQ -> GuitarML -> NAM -> Convolution.
2. Select a row in Processing Order and use Up/Down to place the modules where the signal flow needs them. Use LinearEQ before a model for input shaping, or after Convolution for output shaping; remember the current EQ limitations below.
3. Load the files needed by the chain. Use a .nam file in the NAM module, a .json model in GuitarML, and an IR in the module displayed as IR. Loading is synchronous in this implementation, so avoid changing large models during a critical live pass.
4. Start each In Gain and Out Gain at 0 BS. Raise In Gain by whole doublings to drive a model harder and use the inverse Out Gain when level matching is needed.
5. Set each module Mix. 100% is fully processed when the module is active; lower values retain the stage input. Use Bypass to compare a module without changing the chain order.
6. Use Phase Invert and Stereo Width only on stereo layouts when the signal requires them. The current width implementation has a restricted effective range; see Notes / caveats.
7. If using LinearEQ, treat LS Gain as the only currently audible EQ control. The other EQ controls can still be saved and automated, but their filter code is not in the active processing path.
8. Save the plugin state. IR and model paths, processor order, current program data, and APVTS parameters are written to the state when available.

Use cases

• Guitar rig: NAM amp plus IR cab. Load an amp or pedal capture into NAM, load a speaker cabinet IR into the IR module, and keep NAM before Convolution. Use NAM Out Gain and IR Out Gain for whole-shift level matching.
• Convolution plus LinearEQ. Put the convolution module before LinearEQ when the cabinet or reverb result needs post-shaping, or put LinearEQ first when the source should be shaped before convolution. The current LinearEQ implementation only provides its LS Gain broadband stage, not working HP/LS/HS filters.
• Dual neural serial chain. Load a GuitarML model and a NAM model, then reorder them to audition GuitarML -> NAM or NAM -> GuitarML. Use each module’s Mix to retain some input signal while comparing the nonlinear stages.
• Parallel-style module blends. Lower a module Mix to keep its stage input alongside the processed output. This is a dry blend inside a serial chain, not a true parallel module graph; use multiple V-ConvoStudio instances for independent parallel chains.
• Stereo narrowing or widening. Apply a module’s Stereo Width control to a stereo result after an amp and cabinet stage. Confirm the actual image behavior, because the current parameter mapping does not implement the full labeled -100 to +100 range as expected.

Specs & requirements

• Brand: Fwuzeem Audio; manufacturer code Fwzm.
• Formats: AU, VST3, and Standalone in the current CMake target.
• Audio I/O: Mono or stereo input/output, with matching layouts. No MIDI input or output.
• Modules: LinearEQ, GuitarML, NAM, and Convolution. There is no separate Stereo Width module in the current four-module editor; width is a control on IR, GuitarML, and NAM.
• Processing precision: Native audio path is FP32. FP64 host callbacks are converted through a float buffer path.
• Convolution: Partitioned convolution with a 256-sample head partition; IRs are resampled to the session rate, mixed to mono, normalized toward a 0.5 peak, and limited to 10 seconds.
• Models: GuitarML loads .json files; NAM loads .nam files. The module file navigators cycle sorted sibling files.
• Latency: The host is told that the plugin latency is 256 samples. Internal stage compensation does not match that report; see Notes / caveats.
• Tail: getTailLengthSeconds() reports 0 seconds.
• Sample rates: No fixed sample-rate list is declared by the processor.
• Programs and state: The program list starts with Init and can be populated by a construction-time scan of common user model directories. State stores APVTS values, processor order, current program index, and currently loaded IR/model paths when present.
• Build: The current project is a CMake/C++17 JUCE build with RTNeural and NAM-related dependencies.

Notes / caveats

• Latency compensation is a known limitation. The plugin reports 256 samples, but it allocates a 256-sample compensation buffer for each non-convolution stage. In the default Linear EQ -> GuitarML -> NAM -> Convolution order, those three stage delays accumulate to about 768 samples before the convolution stage’s own 256-sample head partition is considered. Actual timing can therefore exceed the host report, and reordering can change the timing relationship. This is likely a latent bug.
• Model loading is synchronous on the UI thread. GuitarML and NAM model loading is initiated from the editor and can block audio while the model is read and built. IR loading in this processor is also synchronous rather than an asynchronous live-safe handoff.
• LinearEQ filters are in development. LinearEQProcessor::processBlock currently applies only lsGain as broadband gain. The HP, low-shelf, and high-shelf filter processing functions are not called by the active path, so the frequency controls and intended filter behavior are not currently effective.
• Per-band EQ enable parameters are unwired. hpEnabled, lsEnabled, and hsEnabled exist in state and are read, but they do not activate working filters in the current audio path. There is no per-band enable control in the module view.
• Global Bypass and M/S Mode have no GUI control. The bypass and msMode parameters exist and can be stored or automated, but the current editor does not expose buttons for them. The LinearEQ module’s linearEQEnabled button is a separate module enable control.
• Stereo Width mapping is not the labeled sweep. The parameter range is -100 to +100, but the DSP clamps the raw value to 0 to 2 before applying it to the Side signal. Values at or below 0 become mono, values from 0 to 2 are the effective range, and values at or above 2 are the same 2x Side setting. The text labels therefore overstate the usable range.
• Reordering is not drag-and-drop. The source implementation uses a combo box and Up/Down buttons. Older project descriptions that say drag-and-drop do not describe the current editor.
• The EQ is not currently a working linear-phase equalizer. The source prepares IIR filters and does not run them in the active path; do not rely on the older LinearEQ marketing description for filter behavior or phase claims.
• Tail reporting is zero. Hosts receive a zero-second tail report even when an IR is loaded.