Pattrns - Generative Music Creation

Overview

• Pulse: Defines when events occur (rhythm)
• Gate: Optional filter for pulse values (probability, complexity)
• Event: Generates notes, chords, or sequences (melody/harmony)

When to Use This Skill

• Creating generative or algorithmic patterns in Renoise
• Working with euclidean rhythms or polyrhythms
• Designing evolving, emergent musical structures
• Generating breakbeats, complex drum patterns, or rhythmic variations
• Creating generative melodies, harmonies, or chord progressions
• Building textural, ambient, or atmospheric patterns
• Using Tidal Cycles mini-notation for pattern creation
• Developing patterns that resample and resequence for iterative composition

Quick Start

Basic Pattern Structure

return pattern {
  unit = "1/16",              -- Time grid (1/16, 1/8, 1/4, bars, etc.)
  resolution = 1,             -- Multiplier (2/3 for triplets)
  offset = 0,                 -- Delay pattern start
  repeats = true,             -- Loop pattern
  pulse = {1, 0, 1, 1},      -- Static rhythm array
  event = {"c4", "e4", "g4"} -- Static note sequence
}

Essential Techniques at a Glance

pulse = pulse.euclidean(7, 16)  -- 7 hits distributed in 16 steps

local s = scale("c4", "minor")
event = s.notes  -- Use scale notes as sequence

event = function(context)
  local notes = scale("c4", "pentatonic minor").notes
  return notes[math.random(#notes)]
end

return cycle("kd ~ sn ~, [hh hh]*4"):map({
  kd = "c4 #1",  -- Kick drum
  sn = "c4 #2",  -- Snare
  hh = "c4 #3 v0.5"  -- Hi-hat, quieter
})

Core Workflow

1. Choose Musical Goal

• Rhythmic: Drum pattern, breakbeat, groove
• Melodic: Bassline, lead, arpeggio
• Harmonic: Chord progression, pad, texture
• Textural: Atmosphere, drone, evolving soundscape

2. Design Rhythm (Pulse)

pulse = {1, 0, 1, 1, 0, 1, 0, 0}  -- Hand-crafted rhythm

pulse = pulse.euclidean(5, 8)     -- Algorithmic rhythm

pulse = function(context)
  return math.random() > 0.5      -- Probabilistic rhythm
end

pulse = {1, {1, 1, 1}, 1, 0}      -- Quarter + triplet + quarter + rest

3. Design Note Generation (Event)

event = {"c4", "e4", "g4", "b4"}

local s = scale("c4", "minor")
event = function(context)
  return s.notes[math.imod(context.step, #s.notes)]
end

local s = scale("c4", "minor")
event = sequence(
  s:chord("i"),   -- Tonic
  s:chord("iv"),  -- Subdominant
  s:chord("v")    -- Dominant
)

event = function(init_context)
  local state = initial_value
  return function(context)
    -- Update and use state to create evolution
    state = state + delta
    return generate_from(state)
  end
end

4. Add Variation (Optional Gate)

gate = function(context)
  -- Higher probability on downbeats
  local is_downbeat = (context.pulse_step - 1) % 4 == 0
  local probability = is_downbeat and 0.9 or 0.3
  return math.random() < probability
end

5. Add Control (Parameters)

parameter = {
  parameter.integer("variation", 1, {1, 4}),
  parameter.number("density", 0.5, {0.0, 1.0}),
}

-- Access in functions
event = function(context)
  local var = context.parameter.variation
  -- Use var to select different patterns
end

6. Iterate & Evolve

1. Generate pattern → Test in Renoise
2. Render/bounce to audio
3. Resample and chop
4. Create new patterns using resampled material
5. Layer and arrange into parts
6. Repeat process for continuous evolution

Common Musical Tasks

Creating Breakbeats

references/genre_recipes.md

-- Euclidean-based break
local kick = pulse.euclidean(4, 16)
local snare = pulse.euclidean(3, 16, 2)
local hats = pulse.from{1,0,1,0}:repeat_n(4)

-- Use cycle notation to combine
return cycle("[kd*16], [sn*16], [hh*16]"):map({
  kd = function(ctx) return kick[math.imod(ctx.step,16)] and "c4 #1" end,
  sn = function(ctx) return snare[math.imod(ctx.step,16)] and "c4 #2" end,
  hh = function(ctx) return hats[math.imod(ctx.step,16)] and "c4 #3" end
})

Generative Melodies

references/core_techniques.md

return pattern {
  unit = "1/16",
  pulse = pulse.euclidean(7, 16),  -- Rhythmic interest
  event = function(init_context)
    local notes = scale("c4", "pentatonic minor").notes
    local last_idx = 1
    return function(context)
      -- Prefer small intervals (smoother melody)
      local next_idx = last_idx
      while math.abs(next_idx - last_idx) > 2 do
        next_idx = math.random(#notes)
      end
      last_idx = next_idx
      return notes[next_idx]
    end
  end
}

Chord Progressions

references/core_techniques.md

local s = scale("c4", "minor")
return pattern {
  unit = "1/4",  -- Whole notes
  pulse = {1, 1, 1, 1},
  event = sequence(
    s:chord("i", 3),   -- i minor
    s:chord("iv", 3),  -- iv minor
    s:chord("v", 3),   -- v minor
    s:chord("i", 3)    -- i minor
  )
}

Evolving Textures

references/genre_recipes.md

return pattern {
  unit = "1/16",
  pulse = function(context)
    return math.random() > 0.85  -- Sparse
  end,
  event = function(context)
    local notes = scale("c4", "phrygian").notes
    return note(notes[math.random(#notes)])
      :volume(0.2 + math.random() * 0.3)
      :delay(math.random() * 0.5)
      :panning(math.random() * 2 - 1)
  end
}

Polyrhythms

references/core_techniques.md

-- 3:4:5 polyrhythm
cycle("[c4*3]/4, [e4*4]/4, [g4*5]/4")

Key Techniques Reference

Core Techniques (

references/core_techniques.md

)

• Euclidean rhythms and pulse operations
• Randomization and controlled chaos
• Scale-based generation
• Pattern evolution and stateful generators
• Polyrhythms and unusual time signatures
• Note transformations
• Tidal Cycles mini-notation
• Texture generation

• grep -i "euclidean" references/core_techniques.md

• grep -i "random" references/core_techniques.md

• grep -i "scale" references/core_techniques.md

Genre-Specific Recipes (

references/genre_recipes.md

)

• Breakbeat/Jungle/DnB: Complex breaks, swing, reese bass
• IDM/Experimental: Glitchy effects, algorithmic complexity
• Jazz: Swing, walking bass, chord substitutions
• Industrial/Trip-Hop: Heavy grooves, dark textures
• Ambient: Slow evolution, drones, sparse atmospheres

• grep -i "breakbeat\|jungle\|dnb" references/genre_recipes.md

• grep -i "idm\|experimental\|glitch" references/genre_recipes.md

• grep -i "jazz\|swing\|walking" references/genre_recipes.md

API Quick Reference (

references/api_quick_reference.md

)

• Function signatures and parameters
• Available scale modes
• Context object properties
• Utility functions
• Common code patterns
• Workflow tips and gotchas

Pattern Templates

assets/

• euclidean_drum.lua

  : Euclidean-based drum pattern

• generative_melody.lua

  : Scale-based melody with constraints

• evolving_chord.lua

  : Slowly evolving chord progression

• texture_cloud.lua

  : Sparse atmospheric texture

Best Practices

Start Simple, Add Complexity

1. Begin with static pulse and static event
2. Make one dynamic (usually event first)
3. Add gate for probability/filtering
4. Add parameters for control
5. Layer multiple patterns

Controlled Randomness

event = function(init_context)
  local rand = math.randomstate(12345)  -- Consistent seed
  return function(context)
    return generate_with(rand)
  end
end

State Management

• Global state: Shared across all triggers (use sparingly)
• Local state (in generators): Per-trigger isolation (preferred)
• Use init function + inner function pattern for local state

Performance Optimization

• Cache expensive calculations in init functions
• Use local variables
• Avoid creating tables in inner loops
• Return

  nil

  for rests, not 0 or false

Tracker Context for Programmers

• Lua uses 1-based indexing:

  array[1]

  is first element
• Use

  math.imod(step, #array)

  for array wrapping
• Patterns run in musical time (beats/bars), not CPU time
• BPM and time signature from Renoise project settings

Troubleshooting

• Check

  unit

  is appropriate for tempo
• Verify

  pulse

  returns non-zero values
• Check

  gate

  (if present) isn't filtering all events

• Use

  scale()

  to constrain note generation
• Check root note and mode are correct

• Add randomization with

  math.random()

• Use euclidean rhythms with different parameters
• Implement constrained random walk for melodies

• Use seeded random for consistency
• Add constraints to random generation
• Use scale-based generation for harmonic coherence
• Lower probability in gates

• Check 1-based indexing
• Verify init function returns inner function for generators
• Use

  math.imod

  for array wrapping, not

  %

Generative Workflow Summary

IDEA → ALGORITHM → PATTERN → EVENTS → AUDIO → RESAMPLE → NEW PATTERN

1. Generate: Create algorithmic patterns with controlled randomness
2. Evolve: Use stateful generators to create evolving material
3. Render: Bounce patterns to audio in Renoise
4. Resample: Chop and manipulate rendered audio
5. Resequence: Create new patterns using resampled material
6. Iterate: Repeat for continuous evolution and emergence

Resources

references/

• core_techniques.md

  : In-depth technique explanations and code patterns

• genre_recipes.md

  : Complete examples for different musical styles

• api_quick_reference.md

  : Function signatures and API reference

assets/

• Starter templates for common musical tasks
• Genre-specific boilerplate patterns