STEPS combines a comparator and a stepped CV generator.

The stepper moves through a voltage window and can be used as a bounded sequencer, scale generator, or interval walker.

Key controls:
- IN (comparator input)
- BIAS (window center)
- RANGE (window size)
- TRIG (advance)
- RESET (return to start)
- STEP (step size)
- OUT1 / OUT2 (comparator gates)
- STEPPER OUT (stepped CV)
- MIXER (internal mix/output routing)

1. Set the window:
   - Use BIAS to place the window.
   - Use RANGE to set the window width.

2. Set step behavior:
   - Use STEP to choose the step size (knob is ±1V; CV is scaled so ±5V sweeps the full range).

3. Advance and reset:
   - Patch a trigger to TRIG to step.
   - Patch a trigger to RESET to restart.

4. Comparator vs normalization:
   - If IN is unpatched, the comparator is normalized to support the stepper.
   - Patching IN breaks the normalization so the comparator and stepper can be used independently.

5. Outputs:
   - Use OUT1/OUT2 for gate logic derived from the window.
   - Use STEPPER OUT for the stepped CV.

• Dynamic rhythms: Modulate STEP with an LFO to create shifting gate patterns; use OUT1/OUT2 as clock divisions.

• Melodic stepping: Patch STEPPER OUT to an oscillator V/Oct input (optionally quantize).

• Phrase sequencing: Use a slow sequencer to modulate BIAS/RANGE/STEP so you sequence phrasing and contour instead of single notes.

• Counting / step length: The ratio of RANGE to STEP approximates the number of steps before a boundary event (use OUT1/OUT2 as the “wrap” indicator).

ENVELOPE ARRAY is a 6-stage envelope/function generator designed for families of related envelopes.

FIRST/LAST define endpoint timing, and the middle channels interpolate between them. SLANT and CURVE provide global shape control.

Key controls:
- FIRST / LAST (WIDTH) (endpoint times)
- RANGE (time range)
- SLANT (time skew)
- CURVE (log ↔ linear ↔ exp)
- ENVELOPES (CV outs)
- GATES (end-of-cycle / utility gates)
- BUTTON (manual trigger)

1. Set timing endpoints:
   - Adjust FIRST and LAST width.
   - Channels between them interpolate automatically.

2. Shape the curve:
   - SLANT adjusts rise/fall bias (time skew).
   - CURVE morphs response from log to linear to exp.

3. Modulate:
   - Patch CV into the attenuverted inputs for SLANT, CURVE, and FIRST/LAST.

4. Use gates:
   - Use GATES for end-of-cycle timing, resets, or chaining.

Context menu:
- Retriggering: allow retrigger during fall.
- Poly out on channel 1: outputs 6-channel poly from ENVELOPES/GATES channel 1.

• Complex modulation: Drive filters/VCAs/wavefolders with related envelope shapes.

• Chained envelopes: Patch GATE 1 → IN 2 → IN 3 → ... to build long phrases. Patch GATE 6 → IN 1 to loop.

• Six LFOs: Patch each channel’s GATE back to its IN to self-cycle (not phase-aligned).

• Sub-harmonic / sync textures: Run at audio-rate ranges, trigger from an external oscillator, and mix the envelope outputs for harmonic motion.

PENTA SEQUENCER rotates a 5-knob value set across 5 outputs using two mapping modes.

Instead of “one knob per step,” the mapping between knobs and outputs rotates as you advance.

Key controls:
- TRIG (advance)
- RESET (return to first step)
- SHAPE (Circle / Star mapping select)
- DIR (CW / CCW)
- SLEW (timing/interval-aware slew)
- I–V (value knobs)
- A–E (outputs + position indicators)

1. Set values:
   - Dial knobs I–V to the voltages you want.

2. Advance:
   - Trigger TRIG to rotate the current mapping.
   - Trigger RESET to return to the start.

3. Choose mapping:
   - Gate SHAPE selects Circle (≤1V) vs Star (>1V) while held.

4. Choose direction:
   - Gate DIR selects CW (≤1V) vs CCW (>1V) while held.

5. Slew:
   - SLEW morphs from stepped to smooth.
   - Slew speed is tied to both trigger timing and interval size (bigger jumps slew faster).

• Slewed octave lanes: Set knobs to -2, -1, 0, +1, +2 and use moderate SLEW for smooth transpositions.

• 5 slow LFOs: Clock slowly and set SLEW high for continuous ramps.

• Fixed root anchor: Reset so the bottom output is your reference; change SHAPE/DIR for variations while keeping the anchor stable.

• 5-channel fader scene: Set only one knob high and rotate; use SLEW for smooth crossfades across mixer channels.

Context menu:
- Poly out on channel A: outputs 6-channel poly from A.

IMPULSE CONTROLLER simulates wave propagation through a connected 24-node network.

Each node outputs a decaying envelope when activated, and the network spreads energy through child nodes based on timing and thresholds.

Key controls:
- IN (excite the network)
- LAG (propagation timing)
- SPREAD (propagation threshold + timing scaling)
- DECAY (global decay)
- IMPULSES (24 node outputs + visual)

1. Set propagation:
   - LAG sets how quickly nodes can wake their children.
   - SPREAD sets the “ready” threshold; far left makes nodes fire together.

2. Set envelope length:
   - DECAY controls how long nodes ring out.

3. Excite:
   - Patch a signal into IN or press the button to inject an impulse.

4. Modulate:
   - Use the dedicated CV inputs (with attenuverters) for LAG/SPREAD/DECAY.

5. Patch outputs:
   - Use node outs as a bank of related envelopes for VCAs, filters, panning, or sequencer controls.

• Spatial motion: Patch groups of node outputs to panners/mixers for drifting stereo movement.

• Evolving CV field: Use different nodes to modulate multiple destinations for correlated-but-not-identical motion.

• Network building: Patch node outputs back into IN (or into parameter CVs) to create self-sustaining rhythmic systems. Use the manual impulse to “start” the network.

SIGNALS is a compact 6-channel monitor for tuning envelopes, LFOs, and utility CV.

Key controls:
- RANGE (timebase)
- SLOW (range mode)
- RETRIG (reset/trigger viewing behavior)
- IN (1–6)
- OUT / POLY (through/utility routing depending on mode)

1. Patch up to six signals into IN 1–6.
2. Use RANGE/SLOW to set the timebase.
3. Use RETRIG when you want stable, reset-aligned envelope viewing.

• Put SIGNALS inline to inspect CV without disrupting patch flow.
• Use retrig/reset visualization when tuning attack/decay shapes.
• Compare related modulation lanes side-by-side (e.g., multi-env, LFO bank, sequencer lanes).

RANGES outputs a bank of evenly spaced voltages between TOP and BOTTOM.

With CV control, it can act as a scale source, multichannel attenuator/crossfader, or scan-driven sequencer.

Key controls:
- TOP (high endpoint)
- BOTTOM (low endpoint)
- DIVS (number of divisions: 0–12)

1. Set TOP and BOTTOM (and their CV if needed).
2. Set DIVS to choose how many intermediate steps are generated.
3. Patch one or more outputs as fixed voltages, a scale bank, or a crossfade set.

• 12-tone scale: TOP=0V, BOTTOM=1V, DIVS=12.
• Fifths/interval bank: TOP=0V, BOTTOM=5V, DIVS=12.
• Crossfade ladder: Patch two sources to TOP/BOTTOM and use outputs as fixed blend ratios.
• Multi-channel panning: Use a fader to drive TOP/BOTTOM and patch outputs to mixer channels.
• Gate scanning: Set TOP=BOTTOM=5V, DIVS=0; scan DIVS with CV to “walk” a gate across outputs.

HEX MOD is a 6-channel LFO bank with controllable phase relationships.

The NODES control morphs between phase “constellations” (spread, unison, grouped distributions) for coherent multi-lane modulation.

Key controls:
- RATE (speed)
- NODES (phase clustering)
- RANGE (output amplitude scaling)
- SYNC (clock sync input)
- RESET / PHASE RESET inputs (phase alignment)
- LIGHTS (visual feedback / optional disable)

1. Set motion:
   - Use RATE for base speed.
   - Use NODES to choose phase distribution.

2. Reset/phase shaping:
   - Patch triggers into the top reset inputs to pull phases into patterns and let them relax back.

3. Sync (optional):
   - Patch SYNC to lock rate to an external clock.
   - Context options can change whether sync also locks phase.

4. Output range:
   - Use RANGE like a bipolar VCA to scale the LFO amplitudes.

• Phased panning: Patch the six outs to panner CVs or mixer level CV for animated spatial motion.
• Waveshaping: Patch one output into RATE and another into NODES (with attenuation) for evolving patterns.
• Audio-rate timbres: Enable v/oct mode (context) and explore NODE modulation as a timbre control.

Context menu highlights:
- Lights on/off
- Rate multiplies sync
- Sync locks clock+phase (or not)
- Rate input v/oct mode
- Poly out on channel 1

COLLATZ generates rhythmic trigger patterns by iterating the Collatz rule on an integer:
- even → divide by 2
- odd → multiply by 3 and add 1

Key controls:
- NUMBER (start value)
- MODULUS (pulse density cap per clock)
- CLOCK (required)
- START (latch a new run)
- RESET (stop)
- OUT / ACC (rhythm outputs)
- END (goes high when the run reaches 1)

1. Patch a clock to CLOCK (module does nothing without it).
2. Set NUMBER and MODULUS.
   - Lower MODULUS is better for drum-tempo patterns.
   - Higher MODULUS can reach very fast rates depending on settings.
3. Trigger START to sample NUMBER and begin on the next clock edge.
4. Trigger RESET to stop and clear outputs.
5. Use END as a completion flag (patch END→START to loop).

• Drum generator: Clock it from your main tempo, patch outputs to percussion triggers, and loop with END → START.
• Strumming: Use multiplied outputs to excite Karplus-Strong plucks.
• Nested patterns: Try NUMBER=4/8/16/32 for predictable “division-like” runs; try odd numbers for longer evolving sequences.
• Safety: For very long runs, keep RESET reachable.

STRINGS outputs 6-note guitar-style chord voicings with a button grid and chord-bank logic.

It supports per-string bend, global whammy bend, capo transposition, and mute gates for realistic voicings.

Key controls:
- CHORD (column select)
- ROW (row select)
- CHORD BANK (I/II) (bank select)
- BUTTON GRID (fingering selection)
- CAPO (semitone transpose)
- PITCH BEND (per string)
- WHAMMY (global bend)
- V/OCT OUT (6)
- MUTE gates (6)
- TRIG (fires on chord/fingering change)
- ROOT (root note V/Oct)

1. Choose harmony:
   - Set ROW and CHORD.
   - Use I/II to select chord bank.

2. Play/trigger:
   - TRIG outputs a trigger whenever the chord/fingering changes.

3. Mutes:
   - Muted strings output -10V at V/Oct; use MUTE gates to silence downstream voices.

4. Bends:
   - PITCH BEND inputs bend individual strings.
   - WHAMMY bends all strings together.
   - Bend inputs are rectified; 10V ≈ 2 semitones.

5. Capo:
   - CAPO transposes in semitones (1V = 1 semitone). Negative values tune down.

6. Poly patching:
   - Patching only the leftmost V/OCT/MUTE outs enables 6-channel poly outs.

• Guitar voice: Patch the 6 V/Oct outs into 6 Karplus-Strong voices; use MUTE gates to close VCAs/decays when strings are muted.
• Bend accents: Trigger an envelope on TRIG, send it to a single string’s bend for expressive licks.
• Slide: Patch a decay envelope into CAPO for fret-slide effects.
• Sequencing: Enable CHORD input V/oct in the context menu and drive chord selection from a keyboard/sequencer.

Context menu highlights:
- Classical chord set
- CHORD input V/oct mode
- Invert mute gate outputs

OUROS is a stereo phase-modulation oscillator with phase-feedback distortion.

Two oscillators interact on a polar display, making phase relationships visible while you morph through complex wave shapes.

Key controls:
- V/OCT
- FM
- POLYPHONY
- MULTIPLY (feedback/operator ratio)
- POSITION / NODE (shape/phase distribution)
- FEEDBACK (distortion depth)
- PHASE / SPREAD (stereo phase relationship)
- SYNC / RESET (alignment)

1. Pitch:
   - Patch V/OCT as usual; use FM for modulation.

2. Stereo motion:
   - PHASE offsets both sides together.
   - SPREAD offsets L vs R for width and motion.

3. Distortion / complexity:
   - Increase FEEDBACK to bend the waveform via phase perturbation.
   - Use MULTIPLY to emphasize harmonic ratios (integer-ish settings are most stable).

4. Visualization:
   - The polar display renders waveform interaction relative to the fundamental.

Context menu:
- Factory presets: Classic waveforms / Instruments / Shapes.

• Stereo animation: Modulate SPREAD slowly and process with chorus/delay.
• Harmonic metals: Use integer-ish MULTIPLY with moderate FEEDBACK for bright partials.
• Controlled chaos: Patch an LFO into NODE/POSITION while keeping feedback below runaway levels.

PRESSED DUCK is a stereo mixer with a dedicated stereo sidechain channel.

It provides mix compression, tanh saturation, optional filtering, and a feedback gain stage for pushing into distortion.

Key controls:
- SIDE (stereo sidechain in)
- LEVELS (per-channel faders)
- DUCK (duck amount / envelope control)
- MUTES (clickless)
- PRESS (compression)
- FEED (post-comp gain / drive)
- LEVEL (final output range)
- PAN (per-channel)
- L/R OUT

1. Patch inputs:
   - Patch up to six stereo channels into the main inputs.
   - Patch a stereo sidechain source into SIDE.

2. Set gain and dynamics:
   - Use faders for input gain (0→2x).
   - Use PRESS for compression.
   - Use FEED to drive saturation/distortion.
   - Use LEVEL to set final voltage range.

3. Ducking:
   - Use DUCK (and its CV) to duck the main mix from the sidechain.
   - You can drive DUCK with an external envelope or use the internal follower (depending on how you patch).

4. Utility:
   - Use clickless mutes for performance.

Context menu:
- Enable/disable DC-block filtering.
- “Muted sidechain still ducks” mode.

• Clean mixer: PRESS=0, FEED=0.
• Sidechain pump: Patch kick to SIDE, set DUCK amount, tune PRESS for glue.
• Drive bus: Increase FEED for tanh saturation; keep an ear on aliasing at extreme drive.
• Chaining: Feed one instance’s OUT into another instance’s SIDE to build staged ducking and bus dynamics.

PREEEEEEEEEEESSED DUCK expands the Pressed Duck concept to 16 stereo channels.

Designed for large patches and poly sources, with a stereo sidechain path and the same dynamics/drive workflow.

Key controls:
- STEREO INPUTS (16 channels)
- SIDE (sidechain)
- PRESSED DUCK controls (PRESS/FEED/DUCK/LEVEL/mutes, as on the 6ch version)

1. Patch a poly/stereo bank into the leftmost inputs (or patch channels individually).
2. Patch a sidechain source into SIDE if you want ducking.
3. Set PRESS for compression, FEED for drive, DUCK for sidechain amount, and LEVEL for output range.

• Large mix bus: Use it as the main stereo bus for a full rack.
• Poly spread: Feed a polyphonic stereo source into the leftmost channel to distribute across lanes.
• Sidechain glue: Use SIDE to make the entire mix breathe with a kick or rhythm bus.

FLOWER PATCH visualizes signals as responsive polar “flower” shapes.

It’s designed for musical pitch-class visualization (12-tone) and animated spectrum-aware motion.

Key controls:
- INPUTS
- HUE
- FILL
- FLOWER (shape/response)
- POWER (intensity/scale)

1. Patch audio (or CV) into INPUTS.
2. Use FLOWER/FILL/POWER to set response and intensity.
3. Use HUE (and CV) to animate color states if desired.

• Audio display: Put it on a voice or master bus for tonal/energy feedback.
• CV visualization: Feed slow modulation to see motion symmetry.
• Performance: Use hue modulation as a state indicator for sections/scenes.

MAGNETS runs a Metropolis/Monte-Carlo Ising-style lattice and outputs 24 related CV signals.

Temperature, interaction, and polarity let you steer the system from stable clusters to turbulent motion.

Key controls:
- TEMP (randomness / phase state)
- RATE (simulation update speed)
- POLARITY (global bias)
- INTERACT (neighbor coupling)
- RESET (reseed)
- TAPE HEAD (read/scan behavior, depending on mode)

1. Set RATE for update speed (faster = more CPU).
2. Set TEMP:
   - low TEMP tends to “freeze” into stable regions
   - high TEMP increases randomness
3. Set INTERACT to control how strongly nodes influence neighbors.
4. Use POLARITY to bias the whole lattice.
5. Trigger RESET to reseed according to polarity bias.

Context menu:
- Switch output range ±10V ↔ ±5V.

• 24-lane random mod: Patch adjacent nodes to related parameters for correlated movement.
• Biased randomness: Use POLARITY CV to push the system toward “up” or “down” states.
• Tempo-ish motion: Clock RATE from a slow divider via CV (if available in your patch design) to make changes land on musical boundaries.

SYNCRO is an 8-channel clock multiplier/divider with fractional ratios.

Each channel has its own ratio, optional “fill” behavior, and a global swing engine that modulates the master clock.

Key controls:
- CLOCK (internal BPM)
- EXT CLOCK (tap/clock in)
- X / 1/Y (per-channel ratio)
- FILL (adds beats at cycle start)
- SWING (global)
- ROTATE (rotate ratio assignment vs outputs)
- WIDTH (gate width, or phasor phase offset in phasor mode)
- RESET

1. Set master clock:
   - Use CLOCK for BPM (0.1 BPM precision).
   - Or patch EXT CLOCK (tap tempo works well).

2. Set per-channel ratios:
   - Use X and 1/Y for multiplication/division.

3. Use fills:
   - FILL adds a programmable number of beats at the start of a cycle.

4. Swing:
   - SWING modulates the master timing; it affects all channels.

5. Rotation:
   - ROTATE shifts which output receives which ratio.

6. WIDTH:
   - In gate mode: pulse width.
   - In phasor mode: phase offset between the two outs.

Context menu:
- Phasor mode (phasor + inverted phasor)
- Clock CV as v/oct (0V = 120 BPM).

• Tap tempo: Use VCV Push → EXT CLOCK.
• Fill-based drum variation: Use a long division to trigger FILL inputs or modulate the FILL amount.
• Harmonic clock-as-pitch: In v/oct mode, drive CLOCK with pitch CV and set ratios to harmonic relationships.
• Mute rows by rotation: Set X=0 on some channels; ROTATE will bring different rows in/out.

NONA is a CV utility for scaling, offsetting, and mixing signals.

Outputs normalize downward so you can use it as 9 independent processors, a mixer, or a hybrid.

Key controls:
- GAIN (± gain up to 2x, with inversion)
- OFFSET (-5V to +5V)
- OUT (normalized mix chain)

1. Patch CV into any of the nine inputs.
2. Set GAIN to scale (negative values invert).
3. Set OFFSET to shift the signal.
   - With no input, OFFSET acts as a DC source.
4. Use OUT normalization:
   - Outputs mix downwards.
   - Patching an OUT breaks the chain at that point.

Context menu:
- “Row 1 as master VCA” mode multiplies the other 8 outputs by channel 1.

• Range matching: Convert ±10V LFOs into ±5V destinations cleanly.
• Mod mixing: Combine several slow modulators into one lane.
• Macro control: Use master VCA mode to scale an entire modulation “bundle” with one knob/CV.

DECIMA is a 10-step gate sequencer with a direct button interface and per-step probability.

Key controls:
- CLOCK (advance)
- DIR (reverse on high gate)
- RESET
- PROB (per-step probability)
- OUT (main 50% pulse)
- INV (inverse 50% pulse)
- GATE 1–10 (step-active outputs)

1. Clock the sequencer via CLOCK.
2. Use RESET to return to step 1.
3. Hold DIR high to run in reverse.
4. Set PROB per step to thin or randomize patterns.
5. Use outputs:
   - OUT: 50% duty pulse when step is active.
   - INV: 50% duty pulse when step is inactive.
   - GATE 1–10: high for the full step duration (use a step gate to RESET to shorten sequence length).

Context menu:
- Option to map “active step” outputs into the main GATE output behavior.

• Probability hats: Use low PROB on high-frequency steps.
• Self-reset patterns: Patch a later step gate to RESET for variable loop lengths.
• Complementary rhythms: Use OUT + INV to drive alternating percussion voices.

MORTA is a macro controller that generates 16 related outputs from one knob (or CV input).

It’s designed for “one gesture controls many parameters” patches, with a built-in voltage display.

Key controls:
- INPUT (automation CV)
- DISPLAY (current value)
- RANGE (output scaling modes)
- POLYPHONY (poly routing behavior)

1. Turn the main knob (or patch CV into INPUT).
2. Choose an output RANGE mode.
3. Patch any of the 16 outputs to targets (VCAs, filters, wavefolders, sequencer params).

• Scene control: Use one MORTA to move multiple mix/FX parameters together.
• Poly macro: Patch a poly mod source into INPUT and fan out poly to multiple destinations.
• Feedback gestures: Send one output back into INPUT (with attenuation) for shaped response curves.

STEP WAVE is an 8-stage sequencer that outputs a continuous waveform.

You can control not only each stage’s value and shape, but also the boundary timing via rhythmic displacement.

Key controls:
- CLOCK (sets stage length)
- ON/OFF (pause behavior)
- RESET
- VALUE (per-stage value)
- SHAPE (per-stage morph)
- BEATS (subdivisions per stage)
- LINK (shape repeats within stage)
- DISPLACEMENT (boundary offset)
- SLEW (final output smoothing)
- CV OUT / GATE OUT / STAGE outs
- DISPLAY

1. Clocking:
   - Patch CLOCK (or run at default internal tempo).
   - CLOCK sets stage duration; it does not “advance steps” directly.

2. Set the waveform:
   - Use VALUE for each stage.
   - Use SHAPE to morph between shape families.

3. Rhythm:
   - BEATS sets subdivisions per stage (1–10).
   - LINK ties BEATS to SHAPE repetition.

4. Timing feel:
   - DISPLACEMENT offsets stage boundaries against the grid.

5. Output shaping:
   - Use SLEW to smooth the final CV; the display reflects the result.

Context menu:
- Option for VALUE CV to modulate SHAPE instead.
- TRACK mode: stages continuously track VALUE CV instead of sampling at stage start.

• CV melody lane: Use CV OUT → quantizer → V/Oct.
• Gate rhythm lane: Use GATE OUT to drive envelopes/drums aligned to BEATS.
• Audio-rate shaping: With fast clocks and TRACK enabled, treat it as a complex wavetable-ish mod source.
• Humanize: Modulate DISPLACEMENT slowly for drifting groove.

ARRANGE is a compact 7-stage CV recorder/sequencer.

Each stage can store a value (or pass through live CV when armed), and stages can be advanced or addressed directly.

Key controls:
- END (sequence length)
- STAGE (select stage)
- FWD / BACK (advance)
- RESET
- REC (arm record)
- IN (per-stage inputs; poly spreads downward)
- MODE (Voltage / V/Oct / Probability)
- OUT

1. Set END to choose the number of active stages (rescales STAGE).
2. Select stages with STAGE (or use FWD/BACK).
3. Recording:
   - Enable REC to write the incoming CV into the active stage.
   - With REC off, knobs edit stage values without writing.
4. Inputs:
   - Per-stage inputs override that stage’s knob; poly inputs spread downward.
5. Modes:
   - Voltage: raw CV.
   - V/Oct: pitch-friendly scaling.
   - Probability: stage sets trigger probability (−10V=0%, +10V=100%).

Context menu:
- Set max sequence length
- Stop record at end
- Enable poly out (7ch from top channel)

• Parameter automation: Record slow CV gestures into stages and loop.
• Live sampling: Punch REC rhythmically to capture evolving modulation.
• Probability gates: Use probability mode lanes to drive trigger logic rather than pitch.

TRI DELAY is a stereo 3-tap delay with a visual UI.

Envelope followers on dry/wet make dynamics easy to read, and each tap shows time/feedback/pan state.

Key controls:
- IN
- DELAY (time)
- FEEDBACK
- PAN (tap placement)
- HOLD (freeze-style behavior)
- CLEAR (buffer clear)
- OUT

1. Patch audio into IN and take stereo from OUT.
2. Set DELAY and FEEDBACK for repeat structure.
3. Use PAN to distribute taps in stereo.
4. Use HOLD for sustained textures and CLEAR to reset the buffer.

• Rhythmic echoes: Clock-related delay times + moderate feedback.
• Stereo shimmer: Pan taps wide and modulate DELAY slightly.
• Freeze washes: Engage HOLD, then automate feedback/pan for evolving pads.

TATAMI is a stereo polyphonic wavefolder.

It morphs continuously across folding shapes, with controls for symmetry, compression/drive, and output density.

Key controls:
- IN
- SHAPE (fold type/morph)
- SYMMETRY (even/odd bias)
- COMPRESS (drive/level behavior)
- DENSITY (fold intensity)
- OUT

1. Patch audio into IN and take stereo from OUT.
2. Sweep SHAPE to choose fold character.
3. Use DENSITY and COMPRESS to push from subtle to aggressive.
4. Use SYMMETRY to bias harmonics and change tone center.

• Animated fold: Modulate SHAPE slowly for evolving timbre.
• Stereo grit: Use slight L/R differences (via poly lanes or pre-processing) into the stereo inputs.
• FM-friendly shaping: Fold a sine before FM for controlled brightness.

CARTESIA is a 3D 4×4×4 sequencer with an interactive z-slice panel.

The LED display shows the active slice and dynamically maps knobs/buttons to the current edit context.

Key controls:
- XYZ (position/address)
- SCAN (motion through the grid)
- MIN/RANGE (value bounds)
- POLY (poly routing)
- RANDOM
- OFFSET
- SLICE PANEL (z-slice interaction)
- GATE
- QUANTIZE

1. Select a slice and position with XYZ.
2. Edit values via the slice panel / mapped controls.
3. Use SCAN to move through positions over time.
4. Enable QUANTIZE if using it for pitch CV.
5. Patch up to 4 outputs for parallel lanes (pitch, mod, gate, etc.).

• 3D phrase sequencing: Use different slices for sections and scan between them.
• Mod grid: Use outputs as related automation lanes (filter, wavefold, FX).
• Probabilistic motion: Blend RANDOM with SCAN for semi-controlled variation.

JUNK DNA generates and scans a circular DNA buffer.

You enter a text pattern (A/T/C/G plus degenerate IUPAC-like codes). The pattern repeats to fill a longer sequence, with randomized variation at degenerate positions.

Key controls:
- DNA text input (pattern)
- FWD / REV (scan)
- RESET (return to start)
- ATCG gates (base gates)
- Pattern gates (degenerate code gates)
- N (trigger every position)
- DNA OUT (voltage encoding)

1. Enter a pattern using:
   - Bases: A, T, C, G
   - Degenerate codes: R,Y,S,W,K,M (two-choice)
   - Exclusion codes: D,H,B,V (NOT one base)

2. Scan:
   - Use FWD/REV to move through the circular buffer.

3. Outputs:
   - ATCG outputs go high when the current position matches that base.
   - N outputs a trigger at every position.
   - Repeats can hold gates high (e.g., AAA).

4. Reset:
   - RESET returns to position 0 so you can replay the same generated sequence (as long as the pattern stays the same).

Context menu:
- Trigger pulses instead of gates
- Customize DNA OUT voltages

• Bio-logic drums: Use base outputs to fire different percussion voices.
• Pattern gating: Use degenerate-code outputs (e.g., S) as longer structural gates.
• CV melody: Use DNA OUT into a quantizer for semi-random melodic lines tied to the pattern.

PICUS is a 2-channel trigger burst generator.

You program up to seven stages of clock ratios and patterns for structured bursts and fills.

Key controls:
- SELECT (stage select)
- BEATS (burst density)
- CYCLES (repeat count)
- CLOCK
- RESET
- CHAIN
- PATTERN LENGTH

1. Patch a clock into CLOCK.
2. Program stage ratios and burst density with BEATS/CYCLES.
3. Use SELECT to move through stages.
4. Use RESET to restart; use CHAIN to link behavior across stages if desired.

• Drum fills: Use burst stages to generate rapid rolls before bar boundaries.
• Ratchet lanes: Burst one channel while keeping the other steady for accent structure.
• Chain systems: Combine with other clock tools (e.g., Hammer/Syncro) for nested polyrhythms.

NODE is a small stereo mixer/crossfader with clickless mutes.

It’s tuned for CV/audio utility work and can amplify weak signals up to 5×.

Key controls:
- GAIN (up to 5×)
- SATURATION (drive/soft-clip character)
- Crossfade/mix routing (module-specific panel behavior)

1. Patch two stereo sources (or poly sources) into the inputs.
2. Use the crossfade/mix control to blend.
3. Use GAIN to match levels or boost quiet signals.
4. Use SATURATION to add soft clipping and density.

• Stereo crossfade: Fade between two textures without clicks.
• Utility booster: Use 5× gain to lift low-level modulation into full-range CV.
• Parallel drive: Saturate one branch and crossfade into it for performance intensity control.

WEAVE is a chord quantizer designed around playable voicings.

It’s intended for “strummed” poly patches: related voices with controlled permutation rather than stacked identical intervals.

Key controls:
- DISPLAY (state + chord/voicing feedback)

1. Patch pitch CV into WEAVE (per your module’s input scheme).
2. Select/scan chords and voicings using the display controls.
3. Patch the six outputs to six voices (or a poly voice input).

• Strummed chords: Use a burst/strum trigger to excite six voices in sequence.
• Spatial voicing: Pan each voice differently for wide harmonic motion.
• Harmony as CV: Use chord tones to drive filter cutoffs/wavefold amounts in a harmony-locked way.

WONK is a 6-channel BPM-locked LFO with phase-feedback distortion.

It morphs from tight, synchronous modulation into controlled drift without losing tempo relationship.

Key controls:
- RATE X (multiplier of the clock/BPM)

1. Patch a clock (or set internal timing if available in your build).
2. Use RATE X to set the modulation speed relative to the clock.
3. Patch outputs as a 6-lane modulation bus.

• Tempo motion: Drive pans/filters with coherent clock-locked movement.
• Controlled instability: Increase wonk/feedback controls (if present in your panel) for drift that stays musical.
• Poly modulation: Treat it as one poly source feeding many related destinations.

HAMMER is a sample-accurate multi-channel clock generator.

Each channel can multiply/divide to form beat ratios and polyrhythms, and it can chain with related modules.

Key controls:
- RATE (master)
- RATIO (per-channel)
- OUTPUTS (8 lanes)

1. Set the master RATE.
2. Set each channel RATIO.
3. Patch outputs to clocks, triggers, resets, or burst drivers.
4. Use chaining features to expand timing networks across modules.

• Polyrhythm grid: Patch different ratios to percussion voices.
• Macro timing: Use one lane as a slow reset/scene clock.
• Chained clock system: Combine Hammer + Picus for structured bursts within polyrhythms.

HUB is a macrocontroller + CV processing hub for two polyphonic lanes.

Each lane supports gain, offset, and VCA-style control with a voltage display for quick calibration.

Key controls:
- DISPLAY
- CORN COB (module-specific macro control cluster)

1. Patch poly CV into the two inputs.
2. Use gain/offset/VCA controls to shape each lane.
3. Use the display to match voltage ranges across modules.

• Two-lane macro: Control pitch-related CV separately from modulation CV.
• Range adapter: Convert between ±10V and ±5V ecosystems.
• Performance hub: Use HUB as the “front panel” for a larger patch’s key controls.

Use as a spacer / layout tool in your rack.

Use as a spacer / layout tool in your rack.

RAT generates polyphonic ratio CV intended for FM operator relationships.

The ratio knob is intentionally non-linear to provide higher precision near musically useful detuned ratios.

Key controls:
- RATIO (non-linear mapping)
- Poly outputs (per-lane ratios)

1. Patch V/Oct (or a reference pitch) depending on how you’re using RAT.
2. Dial RATIO to set operator relationships.
3. Patch outputs into oscillator FM ratio/scale inputs (or into pitch paths for harmonic experiments).

• FM ratio bank: Use separate lanes for different operators.
• Detune clusters: Slightly offset lanes for thick metallic textures.
• Quantized ratios: Combine with a quantizer if you want strict harmonic locking.

COUNT is a counting module with a large display.

It supports looped, bounded, or unbounded counting and outputs gate and stepped phase signals for patch logic.

Key controls:
- MODE setting (operation mode + behavior)

1. Select an operation mode (looped / bounded / unbounded).
2. Clock or trigger the counter (per your module’s input design).
3. Use outputs as:
   - gate logic (events/thresholds)
   - stepped phase (sequencing/indexing)

• Clock divider logic: Use count boundaries as structural triggers.
• Addressing: Use stepped phase to index switches/routers.
• Reset scenes: Use bounded mode to fire resets every N steps.

CLPY is a stereo polyphonic waveshaper.

It combines wavefolding with clipping that can be driven by a target CV or an audio reference input.

Key controls:
- (Add your panel controls here when ready)

1. Patch audio into the main input(s).
2. Patch a target CV/audio reference if using external clipping targets.
3. Adjust fold/clip controls to taste (and modulate via CV for motion).

• CV-shaped distortion: Use an envelope as the clip target for dynamic drive.
• Stereo fold: Slightly different modulation on L/R for width.
• Poly shaping: Use per-voice modulation for animated chords.

TUNER provides two independent autocorrelation tuners plus a zero-centered waveform display.

Use it to calibrate oscillators, check tracking, and confirm pitch stability under modulation.

Key controls:
- (Add your panel controls here when ready)

1. Patch audio into channel 1 (and 2 if needed).
2. Read pitch and stability on the displays.
3. Use the waveform display to detect DC offset, clipping, and periodicity.

• FM calibration: Verify pitch drift while sweeping FM depth.
• Multi-osc tuning: Tune two voices side-by-side.
• Tracking checks: Confirm V/Oct scaling across octaves.

ALLOY is a physical-model sound generator focused on metallic, shimmering attacks.

It uses Karplus–Strong-style fractional delay networks to produce percussive resonances and inharmonic clusters.

Key controls:
- (Add your panel controls here when ready)

1. Excite the model with a trigger/noise burst (per your design).
2. Tune the resonant structure and decay.
3. Modulate parameters for evolving metallic tails.

• Metallic percussion: Trigger from a gate sequencer; modulate decay per hit.
• Shimmer textures: Slow modulation on tuning/spread parameters.
• Poly strikes: Use poly triggers for clustered impacts.

ONION is a polyphonic fader utility built around the idea of layered control.

Use it to generate structured macro gestures across multiple ranges or lanes.

Key controls:
- (Add your panel controls here when ready)

1. Patch CV/audio into the layer inputs (as designed).
2. Use the fader to scan/blend across layers.
3. Use outputs as a multi-lane macro source.

• Scene blend: Crossfade between two modulation “states.”
• Poly mix: Use as a poly crossfader for stacked voices.
• Gesture control: Combine with Morta/Hub for performance macro systems.

STRATA is a step sequencer built around layered patterning.

Use multiple layers as independent lanes or combine them to build evolving composite sequences.

Key controls:
- (Add your panel controls here when ready)

1. Program each layer’s steps.
2. Clock and reset as needed.
3. Combine layers via mixing/logic/routing depending on your patch intent.

• Layered drums: One layer for kick/snare structure, another for hats/ghost notes.
• Melody + modulation: Use one layer for pitch, another for timbre automation.
• Long-form evolution: Modulate layer enable/weighting over bars.