The Bus Structure

CTZ is not "clip the master harder." It is a hierarchy. Source feeds sub-bus, sub-bus feeds main bus, main bus feeds master, and every single bus owns its own clipper. The summing tree itself is the loudness engine.

1. Why the tree exists

A loud mix wants two things that fight each other: dense bodies and intact transients. One big limiter at the master cannot do both; it has to flatten everything that hits it, so transients die. The CTZ tree solves this by distributing the work.

Every place where signals genuinely sum, a clipper sits at 0 dBFS. Each one shaves only 1 to 3 dB. By the time signal reaches master, the master limiter is doing a small finishing lift, not a rescue.

Many small clips beat one big clip. Clipping at every bus with small amounts sounds far better than one aggressive clip at the master. (Ep 13)

The cascade principle

• Source/track clipper tames that one sound's peaks.
• Sub-bus clipper catches the new peaks born when similar sources sum.
• Main bus clipper (drums bus, tonal bus) catches the next round of summing peaks.
• Premaster clipper catches what happens when drums and tonal collide.
• Master clipper + small limiter does the finish.

2. Baphometrix's full template (Ep 13)

This is the actual studio reference, extended from the Ep 2 overview. Every node marked [Bus CTZ] carries its own clipper at 0 dBFS.

MASTER (dynamics only: optional SSL-G comp, clipper, limiter)
├── Premaster (spectral polish: Smart EQ, Gulfoss, tape sat)
│   ├── DRUMS BUS [Bus CTZ]
│   │   ├── Kicks sub-bus [Bus CTZ]
│   │   ├── Snares sub-bus [Bus CTZ]
│   │   ├── Tops sub-bus [Bus CTZ] (ducked to kick+snare)
│   │   └── Drum FX Returns sub-bus [Bus CTZ] (ducked)
│   │
│   └── TONAL BUS [Bus CTZ]
│       ├── Vocals bus [Bus CTZ]
│       ├── Subs bus [Bus CTZ]
│       ├── Midline bus [Bus CTZ] (ducked to kick+snare)
│       │   ├── Chords (pushed wide + back in depth)
│       │   ├── Melodics (leads, plucks, center + upfront)
│       │   ├── Drops (sound-design noises)
│       │   ├── Lifters (uplifters/downlifters)
│       │   └── Atmospheres & Foleys (deep background)
│       └── Interjects bus (triggers reverse-gate on Midline)
│
└── Listen Bus (monitors, VSX, room correction, NEVER printed)

3. Core bus principles (Ep 13)

• Many small clips beat one big clip. The whole tree exists for this reason.
• Complex signals tolerate less clipping. A bus of all hi-hats can be clipped more aggressively than a bus mixing subs + piano + vocals. The more spectral diversity, the gentler the clip.
• More buses, faster flaw detection. If something sounds over-clipped, the tree tells you which node to dig into. One-master-clipper architecture hides the source.
• FX returns go inside their parent group bus. Their energy gets clipped at the group level and ducked with the rest. (Ep 14)
• Premaster = spectral. Master = dynamics. Never mix them.
• Listen bus is never printed. Everything monitoring-related lives there; the bounce stops one node before it.

4. Each bus owns its own clipper

The CTZ chain on every group, sub-bus and premaster bus is the same shape, end of insert slot:

1. (optional, cheap) sidechain ducker if this node collides with the kick.
2. Hard clipper (K-Clip, Knoc Clipper, FAC Clipper). Drive so summed peaks hit ceiling. Ceiling at 0 dBFS. True "clip to zero."
3. (meter only, optional) a loudness or peak meter, disengaged for CPU.

Master chain only adds: final clipper + one transparent limiter doing a small last lift. Never the rescue.

5. Share the load: how the tree gets loud

Loudness target first. -9 to -8 LUFS for busking and PA, -8 to -7 LUFS for pure EDM playlist. That target is your fixed K-reference for the entire mix.

Then stage drive so:

• Each group's clipper tames that group's summed peaks to ~0 dBFS at working RMS, shaving 1 to 3 dB, not 8.
• The premaster clipper catches the new peaks born when groups sum.
• Master limiter only needs a small final lift. If it is doing more than 2 to 3 dB, a group upstream is under-clipped. Fix it there, not at the master.

Loudness is achieved by many small, distributed clips, not one heroic limiter. That is simultaneously the loudest and the cheapest path.

6. The Loopy Pro translation

A live set on iPad cannot afford the studio template's full node count. Each Audio Bus is another AUv3 instance and another thing to manage mid-performance. The live tree keeps every real summing point and nothing more.

Mapping

Baphometrix term	Loopy Pro equivalent
Track	A loop/clip or a Track widget
Sub-bus (kicks/snares/tops)	A Group with its own FX chain
Roll-up bus (drums/tonal)	An Audio Bus fed by Group/loop sends
Bus CTZ device on every bus	A cheap clipper AUv3 as last insert on each Group/Bus
Premaster	A dedicated Audio Bus all others sum into, before Master
Master	Loopy Pro Master output chain

The live-set tree

LOOPS (kick / snare / hats)   ─► [Group: DRUMS]  ─clip─┐
                                                       │
LOOPS (sub / bass)            ─► [Group: LOW]   ─clip─┐│
LOOPS (chords/melody/lead)    ─► [Group: TONAL] ─clip─┼┼─► (Bus: PREMASTER) ─clip─► MASTER ─clip/limit─►
LOOPS (vocals)                ─► [Group: VOX]   ─clip─┘│
                                                       │
   (FX SEND BUS: reverb/delay, ONE instance) ──duck────┘

4 Groups (DRUMS, LOW, TONAL, VOX) + 1 FX send bus + 1 PREMASTER + Master = ~6 clip stages. Every real summing point, nothing more.

Why this exact shape

• DRUMS / LOW / TONAL / VOX stay separate until PREMASTER. Keep drums and tonal apart until the last minute, so you can clip and duck them independently and re-balance live.
• Time-domain FX = one shared send bus, never per-loop. One reverb + one delay instance serves everything. Huge CPU and workflow win. Its return is ducked to the kick like any other source.
• Groups have their own insert FX chain in Loopy Pro, which means a Group is a sub-bus. Clip there.
• Audio Bus sends carry level + pre/post-fader flag, so they are re-routable live without rebuilding. That is your flexibility lever.
• Clipping is cheap; look-ahead limiting and multiband are expensive. CTZ wants many cheap clip stages, the iPad agrees. Same arrow.

7. Ducking flows along the tree

Kick and snare are the framework, the loudest rhythmic impulse. Everything that overlaps them must duck, including the FX send return and VOX. People always forget the returns.

Place duckers at the highest possible bus level, not on individual tracks. (Ep 14)

Bus	Ducks to	Character
Subs bus / LOW	Kick + snare	Longer kick duck (eighth-note feel), shorter snare
Midline / TONAL	Kick + snare	Covers all mid-range at once
Tops sub-bus	Kick + snare	Genre-dependent length
Vocals	Kick + snare	Very short. Only avoid the transient click. Longer ducks chop syllables. Spectral ducker preferred.
FX returns	Kick + snare	Otherwise tails mush the framework

This is set up once in the template, as part of structure, not patched in live.

8. Live re-routing without rebuilding

The 4-Group + FX + PREMASTER skeleton never changes. Only the loops change per set.

• Send levels are level-automatable and widget-mappable. Mute TONAL into PREMASTER, push VOX, fold LOW into a drop, all by send level. Structure stays untouched.
• Pre-fader vs post-fader sends. Post-fader for normal balance. Pre-fader for an FX-bus feed that should not follow the dry fader (a wash that stays up while you pull the dry down).
• Clip ceilings stay fixed at 0. You perform with drive, input trims and send levels, not by moving ceilings. The CTZ reference stays stable all set.

9. CPU budget tactics (iPad live)

• One clipper per node, not per loop. Group-level clipping shares one instance across every loop in the Group. Biggest single CPU saving.
• Clippers over limiters. Hard-clip is far cheaper than look-ahead limiter. CTZ wanting clips everywhere is convenient: cheap by design.
• One shared FX send bus for reverb/delay (one instance versus N).
• Resample and disable: bounce a heavy wet chain to a loop, then turn the chain off. Frees the AUv3 for the rest of the set.
• Meters disengaged unless actively reading them.
• Fewer summing nodes = fewer clipper instances. "Only where signals truly sum" is a CPU rule, not just tidiness.

10. Build checklist