PhaseFlux Track — manual

A 16-cell pulse synthesizer. Each cell of a 4×4 grid fires a scheduled burst of gate pulses with an independent temporal shape and pitch shape, walked through a selectable traversal with per-stage accumulators and sequence-wide macros.

Introduction

The PhaseFlux track is a 16-cell pulse synthesizer. The 16 cells form a 4×4 grid; each cell is a stage that, when its slot comes up in the cycle, fires a scheduled burst of gate pulses. Every stage carries two independent shapes: a temporal shape that decides when the pulses land inside the slot, and a pitch shape that decides what note each pulse plays. Stages are walked in a selectable traversal (a top-down snake plus seven René-mk2 access patterns), drift over time through per-stage note and pulse accumulators, and respond live to sequence-wide macro nudges.

It generates everything itself from the per-stage parameter matrix — there is no source track to sample. One stage with four pulses across a beat is the default; push the curves, warps, windows, repeats and accumulators and the same grid produces evolving polyrhythmic phrases.

Everything here is grounded in the firmware as built — defaults, ranges, enum members, key bindings, and step-grid maps come from the model, engine, and UI code.

Prerequisites

• Familiarity with the xformer track/sequence/edit page model (Page+S2 / Page+S1 / Page+S0).
• Understanding of CV/gate concepts in modular synthesis, and scale-degree pitch.
• A track set to PhaseFlux mode; the engine drives one gate + one CV output.

Part 1 · Overview

A PhaseFlux sequence holds 16 stages laid out as a 4×4 grid. The engine builds a cycle from the in-range, non-skipped stages and walks them slot by slot:

1. Cycle build — each stage's length (in divisor units) sets its slot width. Skipped/out-of-range stages contribute zero (Adaptive) or stay as a silent slot (Fixed). The sum is the cycle length in ticks.
2. Per-slot schedule — when a slot becomes active, the engine builds a list of pulses for that stage: pulseCount triggers placed by the temporal shape, each carrying a CV from the pitch shape.
3. Pulse fire — at each tick the engine fires any scheduled pulse whose trigger time was reached, raising the gate for its gate-length and pushing the pulse's CV to the output.

The two shapes per stage are orthogonal:

• Temporal curve / warp / response / window / repeat / mask / phase shift / gate length / pulse count. Decides pulse timing and density inside the slot.
• Pitch curve / warp / response / range / direction / base pitch / window / repeat / melody mask / tilt. Decides the note each pulse plays, snapped to the sequence scale.

On top of both sit per-stage Accumulators (note + pulse counters that drift the values each cycle) and sequence-wide macros (uniform nudges, global phase, cycle warp).

Part 2 · The Stage Parameter Matrix

Every stage stores the same field set. Two axes (temporal, pitch) plus per-stage accumulator wiring. All per-stage edits target the cursor cell, or every cell in an active multi-select.

Temporal fields

Mask patterns (set bit mutes that pulse): Off, OneInTwo, OneInThree, OneInFour, TwoInThree, TwoInFour, ThreeInFour, OneInEight.

Pitch fields

Mask Melody and Tilt Melody form an orthogonal union: a pulse plays if it passes either filter (mask keeps central scale tones, tilt keeps the outliers). Final note = base pitch + accumulator offset + octave + transpose + the direction-applied curve offset, converted to volts through the sequence scale.

Per-stage accumulator fields

The step value is the per-stage amount; the scope, order, polarity, reset, and limits that govern how the counter walks are sequence-level (Part 6).

Part 3 · Cycle, Traversal & Timing

How the cycle is built

Each in-range non-skipped stage's length (plus the Len Nudge macro) sets its slot's tick width. length × divisor, scaled by clock multiplier, gives the ticks; the cumulative table over the traversal order yields the cycle length. An all-skipped sequence is idle (gate held low, counters frozen).

• Loop bounds — First Stage / Last Stage restrict the played cycle to stages [first..last] by grid index. Out-of-range stages contribute zero. A single stage loops when first == last.
• Cycle Length — Adaptive (default in clear): skipped stages drop out of the cycle entirely. Fixed: skipped stages keep their slot but emit silence (Note-track-like grid feel).

Traversal patterns

Timing params (per sequence)

• Divisor — default 12 (1/16 at PPQN 48), clamped to the divisor table.
• Clock Mult — 50-150%, default 100% (1.00x).
• Reset Measure — off / N bars, default off. A light reset: re-anchors the cycle, clears pulse-fire and gate, preserves accumulator counters.
• Global Phase — 0.00-1.00, fraction of the cycle to shift the read position.
• Cycle Warp (GWarp) — ±64 PowerBend on the cycle position, bending where each stage sits without changing total cycle length.

Part 4 · Pitch Mode — Cell vs Global

Pitch Mode (per sequence) sets where the pitch curve comes from:

• Cell (default) — each stage uses its own pitch curve, evaluated against the pulse positions inside its slot.
• Global — every stage's pitch is driven by stage 0's curve, sampled against a free-running pitch phase that advances at Pitch Rate. Stages share one evolving contour instead of carrying their own.

Pitch Rate (Global mode)

Pitch Rate is a P:T ratio index, 17 entries, default 1:1 (index 9, locked). Off-ratios drift the curve across cycles. The full table:

The pitch-phase accumulator advances every tick regardless of mode, so flipping Cell↔Global is seamless — Global picks up wherever the accumulator is.

Part 5 · The Pulse / Curve Pipeline

For each pulse the engine runs two parallel chains, then masks and schedules.

Temporal chain — seed the pulse at index / pulseCount, apply Warp then split by Repeat into a sub-section + local position; drop it if the local position is outside the Window band; run it through the Curve, then Response and FlipV; add the Phase Shift; place it at position × slot ticks. FlipH reflects the whole schedule around the slot midpoint at the end.

Pitch chain — take the pulse's phase (Cell: the pulse position; Global: the free-running pitch phase projected to the trigger time); run Warp → Repeat → Window-hold → FlipH → Curve → Response → FlipV; scale by the range in degrees and apply the direction; add base pitch, accumulator offset, octave, transpose; pass the melody-mask / tilt filter; convert to volts.

Mask gates on the original pulse index (survives reordering). Accepted pulses are sorted by trigger time; overlapping gates merge via gate retrigger. Up to 16 pulses (kMaxPulses) per slot.

Part 6 · Accumulators

Two per-sequence counters drift the output as the cycle repeats: a note counter (degrees) and a pulse counter (pulse-count). Each stage contributes its own step (Part 2); the config below governs the walk.

Scope — Local gives each stage its own counter (each cell drifts alone); Track shares counter 0 across all stages (the whole pattern transposes together). Trigger (per stage) picks whether each step lands per completed stage or per fired pulse. The pulse counter clamps on the output (pulse-count clipping is independent of the counter's wrap/pendulum bounds). Reset fires on cycle wrap.

Part 7 · The Edit Page

Page+S0 opens the PhaseFlux edit page. The left side is the 4×4 stage grid; the right side is the per-cell scope + parameter list (or a full-width scope for ACCUM / MACRO). One topic SET is active at a time, cycled with Left/Right:

TEMP → PTCH → ACCUM.N → ACCUM.P → MACRO

Within a topic, F1-F4 address parameter slots and F5 = Next cycles the topic's pages. F1-F4 either select a slot for the encoder, or — for binary fields on page 2 — flip directly on press. The encoder edits the selected slot; Shift (or encoder-press) is the coarse/secondary modifier.

Step grid

• Single press — move the edit cursor to that cell (drives scope + grid focus).
• Double press (no shift) — toggle skip on that cell.
• Shift+press / hold — multi-cell select; encoder edits apply to all selected.
• Shift+Shift — select-all / clear (StepSelection).

LEDs: red = playhead (active cell) or edit cursor; green = cell will fire (not skipped and length > 0); overlap shows yellow. With Page held, the bottom row is masked dark (quick-edit slots reserved).

TEMP topic (_currentSet 0, 3 pages)

* = press-to-flip toggle. Re-pressing F1 Len on P1 arms Len-TR: the encoder transfers length between the cursor cell and the next, conserving the sum (mirrors Indexed DUR-TR).

PTCH topic (_currentSet 1)

Cell mode (3 pages):

Global mode (2 pages, header reads PTCH.G):

In Global mode Curve/Warp/Resp/FlipV/FlipH and Rate edit stage 0 (the master curve); Note and Span still edit the cursor cell.

ACCUM.N / ACCUM.P topics (_currentSet 2 / 3, 2 pages)

F2 on P0 shows the current Accum Mode (Stage/Sequence) but is not editable from here — change it on the sequence list (Part 8). Ac.St and Trig are per-stage (multi-cell aware); Order/Reset/Polar are sequence-level. The full-width strip draws each cell's counter offset with glyphs for Order, Polarity, and Reset.

MACRO topic (_currentSet 4, 2 pages)

P0 nudges are uniform per-cell offsets added to every stage. Snap (press) quantizes each non-skipped stage's length to the nearest binary note value, conserving total length. Zero (press) resets the five magnitude macros (the four nudges + GWarp) to 0; Global Phase is left alone. MACRO draws a full-width scope of all 16 stages stitched along X, live to every macro.

Quick-edit (Page + bottom row)

• Page+S15 — shake the whole current topic (randomize all its pages).
• Page+S16 — shake only the current page.

Shake excludes "chassis-feel" fields (length, base pitch, skip) and never sets pulse count to 0. TEMP/PTCH shake the cursor cell; ACCUM shakes non-skipped cells + config; MACRO is sequence-level.

Context menu

Long-press opens INIT / COPY / PASTE / DUP. INIT opens a sub-menu:

• STAGE — clear the cursor stage to defaults.
• TOPIC — reset the current topic's params (TEMP/PTCH = cursor cell, preserving length/base pitch; ACCUM = non-skipped cells + config; MACRO = macros + traversal + phase).
• SEQUENCE — clear the whole sequence.
• TRACK — clear the whole PhaseFlux track.

COPY/PASTE move the sequence via the clipboard; DUP clones the current sequence into the next pattern slot and jumps there.

Part 8 · Setup & Routing

Track-scope list (Page+S2)

Track-wide params, in display order:

• Play Mode (Aligned / Free / …)
• Fill Mode (None / Gates / Next Pattern / Condition)
• CV Update (Gate / Always)
• Slide Time (0-100)
• Octave (±10)
• Transpose (±100; routed range ±60)

Sequence-scope list (Page+S1)

Per-pattern params, in display order: Divisor, Clock Mult, Global Phase, Pitch Mode, Pitch Rate, Traversal, First Stage, Last Stage, Cycle Length, Note Accum Mode, Pulse Accum Mode, Warp Nudge, Resp Nudge, Pulse Nudge, Len Nudge, Cycle Warp, Scale, Root, Scale Rotate, Reset Measure.

What is routable

The Sequence list exposes Divisor / Clock Mult / Scale / Root Note as routable rows; the Track list exposes Slide Time / Octave / Transpose. The five macro nudges, Cyc Warp, and Phase are routable through the param table. A/B inlets are not implemented. Per-stage fields and the accumulator configs are not routable.