pattrns

Dieser Auszug wurde bei der Prüfung gespeichert. Die externe Quelle enthält die vollständige und aktuelle Version.

---
name: pattrns
description: Guide for creating generative, emergent music with Pattrns, the Lua-based pattern sequencing engine for Renoise. Use when composing algorithmic patterns, generating evolving breakbeats/rhythms, creating generative melodies/harmonies, designing textures, or working with euclidean rhythms and live coding patterns. Covers breakbeat/jungle/DnB, IDM/experimental, jazz, industrial/trip-hop, and ambient styles.
---

# Pattrns - Generative Music Creation

## Overview

Pattrns is a Lua-based pattern generation engine for Renoise that enables algorithmic, generative music creation. Use this skill when working with Pattrns to create emergent, evolving musical patterns across genres including breakbeat/jungle, IDM, jazz, industrial/trip-hop, and ambient music.

**Core Architecture:** Pattrns separates rhythm from melody through a **Pulse → Gate → Event** pipeline:
- **Pulse**: Defines when events occur (rhythm)
- **Gate**: Optional filter for pulse values (probability, complexity)
- **Event**: Generates notes, chords, or sequences (melody/harmony)

This separation enables powerful generative techniques where rhythms and melodies can evolve independently and be recombined in creative ways.

## When to Use This Skill

Invoke this skill when:
- 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

Every Pattrns pattern follows this structure:

```lua
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

**Euclidean Rhythms** (most common starting point):
```lua
pulse = pulse.euclidean(7, 16)  -- 7 hits distributed in 16 steps
```

**Scale-Based Melodies**:
```lua
local s = scale("c4", "minor")
event = s.notes  -- Use scale notes as sequence
```

**Random Generation with Control**:
```lua
event = function(context)
  local notes = scale("c4", "pentatonic minor").notes
  return notes[math.random(#notes)]
end
```

**Tidal Cycles Mini-Notation**:
```lua
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

Identify what to create:
- **Rhythmic**: Drum pattern, breakbeat, groove
- **Melodic**: Bassline, lead, arpeggio
- **Harmonic**: Chord progression, pad, texture
- **Textural**: Atmosphere, drone, evolving soundscape

### 2. Design Rhythm (Pulse)

Start with rhythmic foundation:

**Static Arrays:**
```lua
pulse = {1, 0, 1, 1, 0, 1, 0, 0}  -- Hand-crafted rhythm
```

**Euclidean Distribution:**
```lua
pulse = pulse.euclidean(5, 8)     -- Algorithmic rhythm
```

**Dynamic/Generative:**
```lua
pulse = function(context)
  return math.random() > 0.5      -- Probabilistic rhythm
end
```

**Subdivisions (Cramming):**
```lua
pulse = {1, {1, 1, 1}, 1, 0}      -- Quarter + triplet + quarter + rest
```

### 3. Design Note Generation (Event)

Create melodic/harmonic content:

**Static Sequence:**
```lua
event = {"c4", "e4", "g4", "b4"}
```

**Scale-Based:**
```lua
local s = scale("c4", "minor")
event = function(context)
  return s.notes[math.imod(context.step, #s.notes)]
end
```

**Chord Progressions:**
```lua
local s = scale("c4", "minor")
event = sequence(
  s:chord("i"),   -- Tonic
  s:ch