Timing, Triggers and Probability

Before we build a self-running patch, we need to separate three questions: When does something happen? How often does it happen? What value should it use? Timing modules answer the first two questions. Random modules can answer the third.

Keeping these jobs separate makes a generative patch much easier to understand. A clock should decide when a note can happen. Probability may decide whether it happens. A random value can then decide which note or modulation amount is used.

Gates and Triggers

A gate stays high for a duration. Holding a key creates a gate that remains active until you release the key. Gates are useful for ADSR envelopes and anything that needs a clear on/off state.

A trigger is a very short pulse. It does not describe a duration; it only says, "do this now." Triggers are useful for AD envelopes, Sample & Hold, counters, sequencers, and random modules.

The difference matters. An ADSR needs to know how long the note is held, while Sample & Hold only needs to know the exact moment when it should capture a value.

Create a Clock Family

The Grid device has its own phase signal. A Triggers module can read that phase through its pre-cord and place a chosen number of events across each cycle. Set it to 8 and you get eight evenly spaced triggers during the device phase.

Send that trigger stream into Clock Divide. A division of 4 passes every fourth event, giving you a slower clock related to the original one. Both lanes stay connected to the same timing source.

Device Phase -> Triggers (8) -> fast lane
                         |
                         -> Clock Divide (4) -> slow lane

Clock Quantize solves a different problem. It receives an event and waits until the next pulse of a reference clock before releasing it. For example, quantizing 5 evenly spaced triggers against a 16-step clock creates an uneven pattern that still lands on the sixteenth-note grid.

Chance and Dice Are Different

Chance makes a yes/no decision. Feed it a trigger and it either passes an event or skips it according to the probability setting. Use it for note density, missing percussion hits, occasional accents, and rare texture events.

Dice produces a random value. Trigger it when you want a new value for pitch, filter cutoff, envelope length, or another parameter. Dice does not decide whether the note plays unless you deliberately turn its value into logic.

This separation is useful:

clock -> Chance -> event
                 |
                 -> Dice -> new value

Chance controls whether. Dice controls what.

Build a Small Probabilistic Synth

  1. Open a Poly Grid and set it to monophonic so it can run without a played note.
  2. Add a Triggers module and set it to 8 events per device phase.
  3. Send the triggers into Chance and start around 70 percent.
  4. Connect Chance to an AD envelope controlling the level of a sine or triangle oscillator.
  5. Branch the accepted triggers into Dice so every played event creates a new random value.
  6. Put Attenuate after Dice to keep the pitch range small.
  7. Send the result into Pitch Quantize, select a few notes, and connect it to the oscillator pitch.
  8. Branch the original trigger stream through Clock Divide and use the slower output for a filter envelope or occasional accent.

You now have a patch with a stable clock, missing notes, changing pitch, and a slower structural lane. If it feels too chaotic, reduce the pitch range before changing the probability. If it feels too empty, increase Chance or use fewer divisions.

Keep Randomness Musical

Randomness becomes useful when it has boundaries:

The goal is not maximum surprise. The goal is a system that produces variations while keeping its musical identity. In the next lesson we use these ideas inside a feedback patch that listens to its own output and turns the past into future notes.

▶ Next Lesson: Self Running Patches
◀ Previous Lesson: Physical Modeling
▲ Bitwig Grid Course Overview