Signal flow diagram

Axion's audio graph is intentionally flat — there's no DAW-style routing matrix, no aux sends, no parallel buses (yet). One input, one chain, one output. This page is a reference for what runs where.

The main path

interface input
      │
      ▼
  input gain ────────────────────────────────────┐
      │                                          │  (parallel dry path,
      ▼                                          │   level set by master
┌─────────────────────────────────────────┐      │   "Dry" knob)
│ pedal 1 ▸ pedal 2 ▸ … ▸ pedal N         │      │
└─────────────────────────────────────────┘      │
      │                                          │
      ▼                                          │
  amp (analytical OR NAM)                        │
      │                                          │
      ▼                                          │
  cab IR (convolution)                           │
      │                                          │
      ▼                                          │
  master output ◄──────────────────────────────── ┘
      │
      ▼
interface output

Every box runs at sample rate, sample-by-sample, in one AudioWorklet block. There's no render step, no offline buffer, no internal latency above what your interface plus driver already imposes.

The parallel dry path is the master "Dry" knob in the Cab panel — it taps the input gain straight to master output, letting you blend the raw DI signal back in alongside the wet rig. See Stereo output & wet/dry parallel.

Where things tap in and out

A few extra paths feed off and into the chain:

                       tuner ←──┐
                                │  taps INPUT
interface in → input gain ──────┼──→ pedalboard → amp → cab ──┬──→ master → out
                                                              │
                                                  recorder ←──┤  taps POST-CAB
                                                              │
                                                    looper ←──┤  taps POST-CAB
                                                              │  (sums own playback
                                                              │   into master, not
                                                              │   back into the tap)
                                                              │
                                                metronome ────┘  injects POST-CAB,
                                                                 parallel to output
                                                                 only, NOT into recorder

Specifically:

• Tuner taps the input before any processing — so the tuner reads the raw guitar signal, unaffected by gate / drive / detuned chorus / etc.
• Recorder has four modes, each tapping a different point:
  • Wet — post-cab rig output (the default).
  • Dry — the same pre-pedalboard DI signal the tuner sees.
  • Wet + looper — a dedicated summing node that sees both the post-cab signal AND every looper track's playback (the only path that captures loops alongside live playing).
  • Both — wet and dry simultaneously, written to paired files. All four happen before the metronome injection, so the click never bleeds in. See Recording your performance.
• Looper taps the same post-cab point as the wet recorder (so loops contain the full processed signal) and routes its own track mixes directly to the master output, parallel to the rig. The looper's output is deliberately NOT fed back into the wet recorder tap — that would feedback the loop into itself. The wet + looper recorder mode is a separate downstream sum that picks up both. See Multitrack looper.
• Metronome injects after the cab, parallel to the recorder tap. You hear it through your output; the file doesn't. The metronome's clock anchors to the same AudioContext-currentTime grid the looper's SYNC mode uses, so click + loop downbeats stay locked together.

What runs where, technically

A few notes on where each piece of the graph actually lives:

The whole worklet block is a single processing function. That keeps the per-sample overhead minimal and gives you the round-trip the RT chip in the top bar shows.

What doesn't make it to the output

A short list of things to be aware of:

• Bypassed pedals pass the signal through unchanged. They're not removed from the graph; they're DSP-no-ops. The CPU cost of a bypassed pedal is effectively zero.
• The tuner panel being open doesn't mute the rig — the tuner tap is parallel, not a break. You hear yourself through the rig while you tune.
• Metronome ticks are added to the output path only, not the recorder path (above).
• NAM compilation on first load of a model briefly drops audio while the WASM module instantiates. After that first load the module hydrates from IndexedDB in under 80 ms and audio resumes.

What's not yet in the graph

A few things on the roadmap that would change the diagram:

• Stereo input — today the input is summed to mono before entering the pedalboard. A future stereo input path would split into two streams from getUserMedia and carry them through. Deferred until there's user demand; everything downstream is already stereo-capable.
• Effects send / return — currently absent; everything is serial.
• Save-loop-sessions — the multitrack looper's audio buffers are session-only. Round-tripping the audio (not just the config) through a preset would need IndexedDB blob storage and a load UI. Named, not scheduled.

The stereo output side of the path is fully wired today — toggle the STEREO chip in the Cab panel to flip every stereo-capable node between mono and 2-channel operation. See Stereo output & wet/dry parallel for what flips and what it costs.