Strudel

https://strudel.cc/
Admin
Strudel is a free and open-source live coding platform for writing dynamic music pieces in the...
Tokens:164,147
Snippets:1,588
Trust Score:9.2
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Start @strudel/sampler local server

Source: https://strudel.cc/learn/samples

Run these commands in the samples directory to start a local file server that auto-generates strudel.json. Requires NodeJS installed.

```bash
cd samples
npx @strudel/sampler
```

--------------------------------

### fastcat vs stepcat sound examples

Source: https://strudel.cc/learn/stepwise

When to use: when starting with stepwise patterning to understand how stepcat distributes steps evenly across a cycle compared to fastcat, which squashes cycles.

```javascript
fastcat("bd hh hh", "bd hh hh cp hh").sound()
```

```javascript
stepcat("bd hh hh", "bd hh hh cp hh").sound()
```

--------------------------------

### Basic Device Motion Example

Source: https://strudel.cc/learn/devicemotion

A simple example that uses device motion to control a synthesizer. It creates a melody, then uses gravity to control the filter cutoff, rotation for reverb amount, and orientation for volume.

```javascript
enableMotion()
// Create a simple melody
$:n("0 1 3 5")
.scale("C:major")
// Use tilt (gravity) to control filter
.lpf(gravityY.range(200, 2000)) // tilt forward/back for filter cutoff
// Use rotation to control effects
.room(rotZ.range(0, 0.8)) // rotate device for reverb amount
.gain(oriX.range(0.2, 0.8)) // tilt left/right for volume
.sound("sawtooth")
```

--------------------------------

### Example folder structure for importing sounds

Source: https://strudel.cc/learn/samples

This example shows the folder structure expected when importing sounds from a local folder. The selected folder can contain subfolders with audio files. After import, the user tab will contain sounds like 'swoop(3) smash(3)'.

```text
└─ samples
   ├─ swoop
   │  ├─ swoopshort.wav
   │  ├─ swooplong.wav
   │  └─ swooptight.wav
   └─ smash
      ├─ smashhigh.wav
      ├─ smashlow.wav
      └─ smashmiddle.wav
```

--------------------------------

### prelease release time example

Source: https://strudel.cc/learn/effects

Sets the release time of the pitch envelope. The example includes a release to hear the pitch release effect.

```javascript
note("<c eb g bb> ~")
.release(.5) // to hear the pitch release
.prelease("<0 .1 .25 .5>")
```

--------------------------------

### Mini-Notation Syntax Examples

Source: https://strudel.cc/workshop/first-sounds

Examples of each Mini-Notation concept: sequence, sample number, rests, alternate, sub-sequences, sub-sub-sequences, speed up, and parallel.

```strudel
sound("bd bd sd hh")
```

```strudel
sound("hh:0 hh:1 hh:2 hh:3")
```

```strudel
sound("metal - jazz jazz:1")
```

```strudel
sound("<bd hh rim oh bd rim>")
```

```strudel
sound("bd wind [metal jazz] hh")
```

```strudel
sound("bd [metal [jazz [sd cp]]]")
```

```strudel
sound("bd sd*2 cp*3")
```

```strudel
sound("bd*2, hh*2 [hh oh]")
```

--------------------------------

### Mini-Notation Function Examples

Source: https://strudel.cc/workshop/first-sounds

Examples of the functions sound, bank, setcpm, and n used with the Mini-Notation.

```strudel
sound("bd sd [- bd] sd")
```

```strudel
sound("bd sd [- bd] sd").bank("RolandTR909")
```

```strudel
setcpm(45); sound("bd sd [- bd] sd")
```

```strudel
n("0 1 4 2 0 6 3 2").sound("jazz")
```

--------------------------------

### cpm example

Source: https://strudel.cc/learn/time-modifiers

Sets the tempo to 90 cycles per minute, equivalent to 90 bpm.

```javascript
s("<bd sd>,hh*2").cpm(90) // = 90 bpm
```

--------------------------------

### Scope visual example

Source: https://strudel.cc/learn/visual-feedback

Example of using the _scope visual with a sawtooth synth. This renders an oscilloscope for the time domain of the audio signal.

```javascript
s("sawtooth")._scope()
```

--------------------------------

### Use xen with frequency ratios

Source: https://strudel.cc/learn/xen

Uses xen with an array of frequency ratios. This is equivalent to the previous 31edo example.

```javascript
// You can also use xen with frequency ratios.
// This is equivalent to the above:
i("0 1 2").xen([
Math.pow(2, 0/31),
Math.pow(2, 8/31),
Math.pow(2, 18/31),
]).piano()
```

--------------------------------

### pickRestart example with scale and piano

Source: https://strudel.cc/learn/conditional-modifiers

Uses pickRestart to select patterns by index, restarting the chosen pattern each time its index is triggered. The example maps indices a, b, c, d to note patterns and applies a C major scale with a piano sound.

```javascript
"<a@2 b@2 c@2 d@2>".pickRestart({
a: n("0 1 2 0"),
b: n("2 3 4 ~"),
c: n("[4 5] [4 3] 2 0"),
d: n("0 -3 0 ~")
}).scale("C:major").s("piano")
```

--------------------------------

### early

Source: https://strudel.cc/learn/time-modifiers

Nudges a pattern to start earlier in time.

```APIDOC
## early

### Description
Nudge a pattern to start earlier in time. Equivalent of Tidal's <~ operator.

### Method
Function

### Parameters
- **cycles** (number|Pattern) - Required - Number of cycles to nudge left

### Example
```js
"bd ~".stack("hh ~".early(.1)).s()
```
```

--------------------------------

### Recap: room effect

Source: https://strudel.cc/workshop/first-effects

Example of using the room effect with a fixed room size.

```javascript
s("bd rim bd cp").room(.5)
```

--------------------------------

### Table: add

Source: https://strudel.cc/workshop/pattern-effects

Table example for add: adds numbers to the pattern.

```strudel
n("0 2 4 6 ~ 7 9 5".add("<0 1 2 1>")).scale("C:minor")
```

--------------------------------

### Manual ply with *2

Source: https://strudel.cc/workshop/pattern-effects

Equivalent to the ply example, manually writing each event twice with the *2 notation.

```strudel
sound("hh*2 hh*2, bd*2 rim*2 [~ cp*2] rim*2").bank("RolandTR707")
```

--------------------------------

### Recap: $: play patterns in parallel

Source: https://strudel.cc/workshop/first-notes

Plays patterns in parallel. Example shows two patterns with $:.

```strudel
$: s("bd sd")
$: note("c eb g")
```

--------------------------------

### Table: ply

Source: https://strudel.cc/workshop/pattern-effects

Table example for ply: speeds up each event n times, with n patterned.

```strudel
s("bd sd [~ bd] sd").ply("<1 2 3>")
```

--------------------------------

### take

Source: https://strudel.cc/learn/stepwise

Takes a specified number of steps from a pattern, from the start or end depending on sign.

```APIDOC
## take

### Description
Takes the given number of steps from a pattern (dropping the rest). A positive number will take steps from the start of a pattern, and a negative number from the end. This is an experimental function.

### Method
take

### Parameters
- **steps** (pattern) - Required - The number of steps to take. Positive numbers take from the start, negative from the end.

### Example
```js
"bd cp ht mt".take("2").sound()
// The same as "bd cp".sound()

"bd cp ht mt".take("1 2 3").sound()
// The same as "bd bd cp bd cp ht".sound()

"bd cp ht mt".take("-1 -2 -3").sound()
// The same as "mt ht mt cp ht mt".sound()
```
```

--------------------------------

### iter: Play subdivisions in order with shifting start

Source: https://strudel.cc/learn/time-modifiers

Divides a pattern into n subdivisions and plays them in order, incrementing the starting subdivision each cycle. Example: note("0 1 2 3".scale('A minor')).iter(4)

```javascript
note("0 1 2 3".scale('A minor')).iter(4)
```

--------------------------------

### fastGap example

Source: https://strudel.cc/learn/time-modifiers

Speeds up the pattern 'bd sd' to play once in the first half of the cycle, leaving a gap in the remaining space.

```javascript
s("bd sd").fastGap(2)
```

--------------------------------

### drop: drop steps from pattern

Source: https://strudel.cc/learn/stepwise

Drops the given number of steps from a pattern. Positive numbers drop from start, negative from end. Examples show various drop patterns.

```javascript
"tha dhi thom nam".drop("1").sound().bank("mridangam")
```

```javascript
"tha dhi thom nam".drop("-1").sound().bank("mridangam")
```

```javascript
"tha dhi thom nam".drop("0 1 2 3").sound().bank("mridangam")
```

```javascript
"tha dhi thom nam".drop("0 -1 -2 -3").sound().bank("mridangam")
```

--------------------------------

### inside example

Source: https://strudel.cc/learn/time-modifiers

Applies the reverse operation inside each cycle, with the commented equivalent using slow, rev, and fast.

```javascript
"0 1 2 3 4 3 2 1".inside(4, rev).scale('C major').note()
// "0 1 2 3 4 3 2 1".slow(4).rev().fast(4).scale('C major').note()
```

--------------------------------

### Load samples from GitHub with samples()

Source: https://strudel.cc/learn/samples

Use the samples() function with the 'github:' prefix to load samples from a GitHub repository. The format is samples('github:<user>/<repo>/<branch>'). If branch is omitted, the main branch is used. It assumes a strudel.json file at the repository root.

```javascript
samples('github:tidalcycles/dirt-samples')
s("bd sd bd sd,hh*16")
```

--------------------------------

### Voicing with note letters

Source: https://strudel.cc/understand/voicings

The same voicing example as the previous one but using note letters instead of semitone numbers. Notes that are 12 semitones apart get the same note letter.

```javascript
note("<[c3,eb3,g3] [c4,eb3,g3] [c4,eb4,g3] [c4,eb4,g4]>")
.room(.5)
```

--------------------------------

### Pianoroll with Post Transformations Example

Source: https://strudel.cc/learn/visual-feedback

Shows that pianoroll renders the pattern directly, so the color applied after is not visible in the visual.

```strudel
note("c a f e").color("white")
._pianoroll()
.color("cyan")
```

--------------------------------

### zoom: Play a portion of a pattern

Source: https://strudel.cc/learn/time-modifiers

Plays a portion of a pattern specified by start and end times, over the original pattern's time period. Example includes an equivalent commented line.

```javascript
s("bd*2 hh*3 [sd bd]*2 perc").zoom(0.25, 0.75)
// s("hh*3 [sd bd]*2") // equivalent
```

--------------------------------

### Load samples from disk in Strudel desktop app

Source: https://strudel.cc/blog

Loads samples from a local folder in the Strudel desktop app. The path must start with '~/music/' and point to a folder in the system's audio directory. On first run, the app creates a strudel.json file in that directory to map available samples.

```javascript
samples('~/music/xxx');

s('my_sound');
```

--------------------------------

### take: take steps from pattern

Source: https://strudel.cc/learn/stepwise

Takes the given number of steps from a pattern, dropping the rest. Positive numbers take from start, negative from end. Examples show various take patterns.

```javascript
"bd cp ht mt".take("2").sound()
// The same as "bd cp".sound()
```

```javascript
"bd cp ht mt".take("1 2 3").sound()
// The same as "bd bd cp bd cp ht".sound()
```

```javascript
"bd cp ht mt".take("-1 -2 -3").sound()
// The same as "mt ht mt cp ht mt".sound()
```

--------------------------------

### binary() binary pattern from number

Source: https://strudel.cc/learn/factories

Creates a binary pattern from a number. The example shows the equivalent Mini Notation.

```javascript
"hh".s().struct(binary(5))
// "hh".s().struct("1 0 1")
```

--------------------------------

### distort effect examples

Source: https://strudel.cc/learn/effects

Three examples of the distort effect (alias: dist). The first uses a pattern for distortion amount with optional postgain (e.g., 10:.5). The second applies distortion to a sine note with envelope settings. The third uses the optional third parameter to set the waveshaping type to 'diode'. Caution: distortion can get loud.

```javascript
s("bd sd [~ bd] sd,hh*8").distort("<0 2 3 10:.5>")
```

```javascript
note("d1!8").s("sine").penv(36).pdecay(.12).decay(.23).distort("8:.4")
```

```javascript
s("bd:4*4").bank("tr808").distort("3:0.5:diode")
```

--------------------------------

### All chords with root C using chord().voicing().room()

Source: https://strudel.cc/understand/voicings

Example of using the chord function with all possible chords rooted at C, then applying voicing and room. The default dictionary contains multiple voicings per chord symbol; the voicing function minimizes jumps by default.

```javascript
chord(`<
C2 C5 C6 C7 C9 C11 C13 C69
Cadd9 Co Ch Csus C^ C- C^7 
C-7 C7sus Ch7 Co7 C^9 C^13 
C^7#11 C^9#11 C^7#5 C-6 C-69 
C-^7 C-^9 C-9 C-add9 C-11 
C-7b5 Ch9 C-b6 C-#5 C7b9 
C7#9 C7#11 C7b5 C7#5 C9#11 
C9b5 C9#5 C7b13 C7#9#5 C7#9b5 
C7#9#11 C7b9#11 C7b9b5 C7b9#5 
C7b9#9 C7b9b13 C7alt C13#11 
C13b9 C13#9 C7b9sus C7susadd3 
C9sus C13sus C7b13sus C Caug 
CM Cm CM7 Cm7 CM9 CM13 CM7#11 
CM9#11 CM7#5 Cm6 Cm69 Cm^7 
C-M7 Cm^9 C-M9 Cm9 Cmadd9 
Cm11 Cm7b5 Cmb6 Cm#5
>`).voicing().room(.5)
```

--------------------------------

### shrink: progressively shrink pattern

Source: https://strudel.cc/learn/stepwise

Progressively shrinks the pattern by n steps until nothing left, or a given number of times. Positive drops from start, negative from end. Examples show various shrink patterns.

```javascript
"tha dhi thom nam".shrink("1").sound()
.bank("mridangam")
```

```javascript
"tha dhi thom nam".shrink("-1").sound()
.bank("mridangam")
```

```javascript
"tha dhi thom nam".shrink("1 -1").sound().bank("mridangam").pace(4)
```

```javascript
note("0 1 2 3 4 5 6 7".scale("C:ritusen")).sound("folkharp")
.shrink("1 -1").pace(8)
```

--------------------------------

### Initialize Hydra and create a basic visual

Source: https://strudel.cc/learn/hydra

Call `await initHydra()` at the top to enable Hydra in Strudel. This example creates a complex visual using oscillators, color, and modulation, and also plays a note pattern with a sawtooth synth.

```javascript
await initHydra()
// licensed with CC BY-NC-SA 4.0 https://creativecommons.org/licenses/by-nc-sa/4.0/
// by Zach Krall
// http://zachkrall.online/
  

osc(10, 0.9, 300)
.color(0.9, 0.7, 0.8)
.diff(
osc(45, 0.3, 100)
.color(0.9, 0.9, 0.9)
.rotate(0.18)
.pixelate(12)
.kaleid()
)
.scrollX(10)
.colorama()
.luma()
.repeatX(4)
.repeatY(4)
.modulate(
osc(1, -0.9, 300)
)
.scale(2)
.out()
  

note("[a,c,e,<a4 ab4 g4 gb4>,b4]/2")
.s("sawtooth").vib(2)
.lpf(600).lpa(2).lpenv(6)
```

--------------------------------

### Play multiple patterns simultaneously with $ operator

Source: https://strudel.cc/learn/faq

Use the $ operator to play several patterns at once. Each line starts with $: followed by a pattern. The example plays a bass drum pattern and a snare pattern using different banks.

```javascript
$: s("bd*4").bank("tr707")
$: s("- sd").bank("tr909")
```

--------------------------------

### grow: progressively grow pattern

Source: https://strudel.cc/learn/stepwise

Progressively grows the pattern by n steps until full pattern played, or a given number of times. Positive grows from start, negative from end. Examples show various grow patterns.

```javascript
"tha dhi thom nam".grow("1").sound()
.bank("mridangam")
```

```javascript
"tha dhi thom nam".grow("-1").sound()
.bank("mridangam")
```

```javascript
"tha dhi thom nam".grow("1 -1").sound().bank("mridangam").pace(4)
```

```javascript
note("0 1 2 3 4 5 6 7".scale("C:ritusen")).sound("folkharp")
.grow("1 -1").pace(8)
```

--------------------------------

### Send a string pattern over MQTT with .mqtt()

Source: https://strudel.cc/learn/input-output

Sends the string pattern "hello world" to an MQTT broker using the .mqtt() method. Requires a broker accepting secure websocket connections; the example uses the public broker wss://mqtt.eclipseprojects.io:443/mqtt with topic '/strudel-pattern' and client id 'mystrudel'. The last argument sets latency/delay before sending (0 = no delay).

```javascript
"hello world"
.mqtt(undefined, // username (undefined for open/public servers)
undefined, // password
'/strudel-pattern', // mqtt 'topic'
'wss://mqtt.eclipseprojects.io:443/mqtt', // MQTT server address
'mystrudel', // MQTT client id - randomly generated if not supplied
0 // latency / delay before sending messages (0 = no delay)
)
```

--------------------------------

### Slider widget for filter frequency

Source: https://strudel.cc/blog

Example of using the slider function to render an inline UI widget for gradual changes. The slider controls the low-pass filter frequency between 100 and 2000 Hz, starting at 500. Useful for manual fading and interactive adjustments.

```strudel
note("<c eb g bb>*8")
.s("sawtooth").lpenv(2).lpq(8)
.lpf(slider(500, 100, 2000, 1))
```

--------------------------------

### Load samples from file URLs with samples()

Source: https://strudel.cc/learn/samples

Assigns sample names to audio files on a server. The base URL and each sample path must form a correct URL. Sample names become available in the s function and can override default sounds.

```javascript
samples({
  bassdrum: 'bd/BT0AADA.wav',
  hihat: 'hh27/000_hh27closedhh.wav',
  snaredrum: ['sd/rytm-01-classic.wav', 'sd/rytm-00-hard.wav'],
}, 'https://raw.githubusercontent.com/tidalcycles/Dirt-Samples/master/');
```

```javascript
s("bassdrum snaredrum:0 bassdrum snaredrum:1, hihat*16")
```

--------------------------------

### JSDoc comment example for function documentation

Source: https://strudel.cc/technical-manual/docs

Example JSDoc comment format used to document a function. Includes @name, @param, and @example tags. These comments are processed into doc.json during build.

```javascript
/**
 * Select a sound / sample by name.
 *
 * @name s
 * @param {string | Pattern} sound The sound / pattern of sounds to pick
 * @example
 * s("bd hh")
 *
 */
// implementation of s function
```

--------------------------------

### Spectrum visualizer example

Source: https://strudel.cc/learn/visual-feedback

Use with the Spectrum visualizer to analyze the audio signal. The chain creates a rhythmic pattern with offsets, applies a pentatonic scale, uses a sine oscillator, and sets decay and reverb before applying the visualizer.

```javascript
n("<0 4 <2 3> 1>*3")
.off(1/8, add(n(5)))
.off(1/5, add(n(7)))
.scale("d3:minor:pentatonic")
.s('sine')
.dec(.3).room(.5)
._spectrum()
```

--------------------------------

### reset: Reset pattern to cycle start

Source: https://strudel.cc/learn/conditional-modifiers

Resets the pattern to the start of the cycle for each onset of the reset pattern.

```javascript
s("[<bd lt> sd]*2, hh*8").reset("<x@3 x(5,8)>")
```

--------------------------------

### Example strudel.json sample map

Source: https://strudel.cc/learn/samples

Shows the JSON format expected for a strudel.json file. The _base key defines the base path for the sample files.

```json
{
  "_base": "https://raw.githubusercontent.com/tidalcycles/Dirt-Samples/master/",
  "bassdrum": "bd/BT0AADA.wav",
  "snaredrum": "sd/rytm-01-classic.wav",
  "hihat": "hh27/000_hh27closedhh.wav"
}
```

--------------------------------

### Jazz Blues in F example

Source: https://strudel.cc/understand/voicings

Example of a Jazz Blues in F. The chords are reused for melody, chords, and bassline of the tune.

```javascript
let chords = chord(`
<F7 Bb7 F7 [Cm7 F7]
Bb7 Bo F7 [Am7 D7]
Gm7 C7 [F7 D7] [Gm7 C7]
>`)
$: n("7 8 [10 9] 8").set(chords).voicing().dec(.2)
$: chords.struct("- x - x").voicing().room(.5)
$: n("0 - 1 -").set(chords).mode("root:g2").voicing()
```

--------------------------------

### Recap: signals list and gain with saw

Source: https://strudel.cc/workshop/first-effects

Lists the available signals and shows an example of using a saw signal with gain.

```javascript
s("hh*16").gain  (saw)
```

--------------------------------

### ribbon examples

Source: https://strudel.cc/learn/time-modifiers

Three examples of the ribbon function: looping a note pattern, looping a portion of randomness, and a rhythm generator.

```javascript
note("<c d e f>").ribbon(1, 2)
```

```javascript
// Looping a portion of randomness
n(irand(8).segment(4)).scale("c:pentatonic").ribbon(1337, 2)
```

```javascript
// rhythm generator
s("bd!16?").ribbon(29,.5)
```

--------------------------------

### Initialize multiple gamepads

Source: https://strudel.cc/learn/input-devices

Initializes two gamepads with different indices to support multiple controllers.

```javascript
const pad1 = gamepad(0); // First gamepad
const pad2 = gamepad(1); // Second gamepad
```

--------------------------------

### Load livecode.orc and play FM1

Source: https://strudel.cc/learn/csound

Loads the livecode.orc file from GitHub using the github: shortcut and plays a note sequence with the FM1 instrument.

```javascript
// livecode.orc by Steven Yi
await loadOrc('github:kunstmusik/csound-live-code/master/livecode.orc')
note("c a f e").csound('FM1')
```

--------------------------------

### Using full sample names with s

Source: https://strudel.cc/learn/samples

Shows how to use full sample names prefixed with the drum machine name, e.g., RolandTR808_bd. This is verbose and motivates the bank function.

```strudel
s("RolandTR808_bd RolandTR808_sd,RolandTR808_hh*16")
```

--------------------------------

### gamepad()

Source: https://strudel.cc/learn/input-devices

Initializes a gamepad input device. Returns an object with properties for buttons and analog sticks that can be used to modulate patterns.

```APIDOC
## gamepad()

### Description
Initializes a gamepad input device. Returns an object with properties for buttons and analog sticks that can be used to modulate patterns.

### Method
`gamepad()`

### Parameters
- **index** (number) - Optional - The gamepad index (defaults to 0).

### Returns
An object with gamepad controls (buttons, analog sticks, button sequences).

### Example
```js
const gp = gamepad(0)
```
```

--------------------------------

### pcurve curve type example

Source: https://strudel.cc/learn/effects

Sets the curve of the pitch envelope, with 0 for linear and 1 for exponential. The example uses a sine wave with a long decay.

```javascript
note("g1*4")
.s("sine").pdec(.5)
.penv(32)
.pcurve("<0 1>")
```

--------------------------------

### Create custom sample alias with soundAlias()

Source: https://strudel.cc/learn/samples

Creates a custom alias 'kick' for the existing sample 'RolandTR808_bd' using soundAlias, then plays it with s(). Note that only sample maps are loaded initially; audio loads lazily on first play.

```javascript
soundAlias('RolandTR808_bd', 'kick')
s("kick")
```

--------------------------------

### Mondo notation example with brackets and multi-cycle sequences

Source: https://strudel.cc/learn/mondo-notation

Example of Mondo notation using `[]` for 1-cycle sequences, `<>` for multi-cycle sequences, and `{}` for stepped sequences. This pattern uses nested brackets and `~` for rests.

```mondo
note <
[e5 [b4 c5] d5 [c5 b4]]
[a4 [a4 c5] e5 [d5 c5]]
[b4 [~ c5] d5 e5]
[c5 a4 a4 ~]
[[~ d5] [~ f5] a5 [g5 f5]]
[e5 [~ c5] e5 [d5 c5]]
[b4 [b4 c5] d5 e5]
[c5 a4 a4 ~]
>
```

--------------------------------

### Initialize gamepad and mask with button

Source: https://strudel.cc/learn/input-devices

Initializes a gamepad with an optional index parameter (defaults to 0) and uses the 'a' button to mask a note pattern.

```javascript
// Initialize gamepad (optional index parameter, defaults to 0)
const gp = gamepad(0)
note("c a f e").mask(gp.a)
```

--------------------------------

### Broken Strudel syntax examples

Source: https://strudel.cc/learn/code

Three broken syntax examples: missing quotes, missing dot before the chained function, and using brackets instead of parentheses. None of these work in Strudel.

```javascript
note(c a f e).s(piano)
```

```javascript
note("c a f e")s("piano")
```

```javascript
note["c a f e"].s{"piano"}
```

--------------------------------

### Set loop begin point with .loopBegin

Source: https://strudel.cc/learn/samples

The .loopBegin effect sets the point where looping starts, between begin and end. The time parameter is between 0 and 1. Samples starting with wt_ automatically loop.

```javascript
s("space").loop(1)
.loopBegin("<0 .125 .25>")._scope()
```

--------------------------------

### expand(2) and expand(4) sound examples

Source: https://strudel.cc/learn/stepwise

When to use: to see how expand changes steps per cycle but may not affect sound on its own. Both sound the same, but change the number of steps per cycle.

```javascript
"c a f e".expand(2).note().sound("folkharp")
```

```javascript
"c a f e".expand(4).note().sound("folkharp")
```

--------------------------------

### Load samples from local server

Source: https://strudel.cc/learn/samples

Load samples from the local server started by @strudel/sampler. The server runs at http://localhost:5432/.

```javascript
samples('http://localhost:5432/');
```

--------------------------------

### firstOf: Apply function every n cycles starting from first

Source: https://strudel.cc/learn/conditional-modifiers

Applies the given function every n cycles, starting from the first cycle. The function is applied to the pattern on the first cycle of each group of n cycles.

```javascript
note("c3 d3 e3 g3").firstOf(4, x=>x.rev())
```

--------------------------------

### Query samples from freesound.org using shabda

Source: https://strudel.cc/learn/samples

Use samples('shabda:...') to query sample names from freesound.org. The example selects bass, hihat, and rimshot samples and assigns them to patterns.

```javascript
samples('shabda:bass:4,hihat:4,rimshot:2')
  

$: n("0 1 2 3 0 1 2 3").s('bass')
$: n("0 1*2 2 3*2").s('hihat').clip(1)
$: n("~ 0 ~ 1 ~ 0 0 1").s('rimshot')
```

--------------------------------

### lastOf: Apply function every n cycles starting from last

Source: https://strudel.cc/learn/conditional-modifiers

Applies the given function every n cycles, starting from the last cycle. The function is applied to the pattern on the last cycle of each group of n cycles.

```javascript
note("c3 d3 e3 g3").lastOf(4, x=>x.rev())
```

--------------------------------

### Polyrhythm Example

Source: https://strudel.cc/recipes/recipes

Creates a simple polyrhythm by specifying two different tempos in the s method. The bass drum plays twice while the hi-hat plays three times.

```javascript
s("bd*2,hh*3")
```

--------------------------------

### Spiral visual example

Source: https://strudel.cc/learn/visual-feedback

Example of using the _spiral visual with a note pattern, euclidean rhythm, sawtooth synth, lowpass filter, and envelope. The steady option is set to 0.96 to control the spiral's movement relative to the playhead.

```javascript
note("c2 a2 eb2")
.euclid(5,8)
.s('sawtooth')
.lpenv(4).lpf(300)
._spiral({ steady: .96 })
```

--------------------------------

### Use xen with scale names like hexany15

Source: https://strudel.cc/learn/xen

Shows that xen supports all scale names that tune does. The example uses hexany15 and notes the equivalence to tune with mul and freq.

```javascript
// xen also supports all scale names that
// tune does:
i("0 1 2 3 4 5").xen("hexany15")
// equiv to:
// "0 1 2 3 4 5".tune("hexany15").mul("220").freq()
```

--------------------------------

### late

Source: https://strudel.cc/learn/time-modifiers

Nudges a pattern to start later in time.

```APIDOC
## late

### Description
Nudge a pattern to start later in time. Equivalent of Tidal's ~> operator.

### Method
Function

### Parameters
- **cycles** (number|Pattern) - Required - Number of cycles to nudge right

### Example
```js
"bd ~".stack("hh ~".late(.1)).s()
```
```

--------------------------------

### Play a sequence with sound()

Source: https://strudel.cc/workshop/first-sounds

Plays a sequence of samples separated by spaces. The currently playing sound is highlighted in the editor and visualized below. Adding more sounds makes the sequence run faster because the same cycle is compressed.

```javascript
sound("bd hh sd hh")
```

--------------------------------

### Select MIDI output with midiport()

Source: https://strudel.cc/learn/input-output

Selects the MIDI output device using `midiport()`. The first line sets the device by name, and the second uses a pattern to switch between devices. The `midiport()` method sets the MIDI port for the event.

```javascript
$: midiport('IAC Driver');
$: note('c a f e').midiport('<0 1 2 3>').midi();
```

--------------------------------

### Equivalent division by 4

Source: https://strudel.cc/learn/mini-notation

Equivalent to the angle bracket example above.

```strudel
note("[e5 b4 d5 c5]/4")
```

--------------------------------

### Play sounds with sound()

Source: https://strudel.cc/workshop/recap

Plays the sounds bd and sd in sequence.

```javascript
sound("bd sd")
```

--------------------------------

### Table: off

Source: https://strudel.cc/workshop/pattern-effects

Table example for off: copies, shifts time, and modifies the copy.

```strudel
s("bd sd [~ bd] sd, hh*8").off(1/16, x=>x.speed(2))
```

--------------------------------

### Send a control pattern over MQTT with .mqtt()

Source: https://strudel.cc/learn/input-output

Sends a control pattern (sound and speed) over MQTT using the same .mqtt() configuration as the string example. Control patterns are encoded as JSON messages, e.g., {"s":"sax","speed":2}.

```javascript
sound("sax(3,8)").speed("2 3")
.mqtt(undefined, // username (undefined for open/public servers)
undefined, // password
'/strudel-pattern', // mqtt 'topic'
'wss://mqtt.eclipseprojects.io:443/mqtt', // MQTT server address
'mystrudel', // MQTT client id - randomly generated if not supplied
0 // latency / delay before sending messages (0 = no delay)
)
```

--------------------------------

### Global Punchcard Visual Example

Source: https://strudel.cc/learn/visual-feedback

Renders the visual to the background of the page.

```strudel
note("c a f e").color("white").punchcard()
```

--------------------------------

### voicing() with dict and layer for chords and bassline

Source: https://strudel.cc/learn/tonal

Creates a chord voicing with the 'ireal' dictionary and layers a bassline using the root mode. The bassline uses a sawtooth synth with a cutoff filter.

```javascript
chord("<C^7 A7b13 Dm7 G7>*2")
.dict('ireal').layer(
x=>x.struct("[~ x]*2").voicing()
,
x=>n("0*4").set(x).mode("root:g2").voicing()
.s('sawtooth').cutoff("800:4:2")
)
```

--------------------------------

### lfo

Source: https://strudel.cc/learn/lfo

Documentation for the `lfo` method, including its parameters and usage examples.

```APIDOC
## lfo

### Description
Creates a low-frequency oscillator that modulates a parameter of the pattern. The `rate` parameter determines the oscillation frequency in Hz, and `sync` can be used to synchronize the LFO with the pattern's cycle.

### Method
`lfo`

### Parameters
- **c** (string) - Required - The parameter to modulate (e.g., 'gain').
- **rate** (number or pattern) - Optional - Frequency in Hz. Alias: `r`.
- **sync** (number or pattern) - Optional - Frequency as times per cycle.
- **depth** (number or pattern) - Optional - Relative depth (default 1). Aliases: `dr`, `dep`.
- **depthabs** (number or pattern) - Optional - Absolute depth. Alias: `da`.

### Example
```js
s("saw")
.lfo({c:'gain', rate:"<2 4>"})
.lpf(800)
._spectrum({height: 300, width: 800})
```
```

--------------------------------

### reset

Source: https://strudel.cc/learn/conditional-modifiers

Resets the pattern to the start of the cycle for each onset of the reset pattern.

```APIDOC
## reset

### Description
Resets the pattern to the start of the cycle for each onset of the reset pattern.

### Usage
`pattern.reset(resetPattern)`

### Parameters
- **resetPattern** (Pattern) - The pattern that triggers the reset.

### Example
```
s("[<bd lt> sd]*2, hh*8").reset("<x@3 x(5,8)>")
```
```

--------------------------------

### Generate desktop app with nativefier

Source: https://strudel.cc/learn/pwa

Run this command in a terminal with NodeJS installed to generate a standalone desktop app for Strudel using nativefier.

```bash
npx nativefier strudel.cc
```

--------------------------------

### Table: rev

Source: https://strudel.cc/workshop/pattern-effects

Table example for rev: reverses the pattern within each cycle.

```strudel
n("0 2 4 6 ~ 7 9 5").scale("C:minor").rev()
```

--------------------------------

### restart

Source: https://strudel.cc/learn/conditional-modifiers

Restarts the pattern for each onset of the restart pattern, starting from cycle 0.

```APIDOC
## restart

### Description
Restarts the pattern for each onset of the restart pattern. While reset will only reset the current cycle, restart will start from cycle 0.

### Usage
`pattern.restart(restartPattern)`

### Parameters
- **restartPattern** (Pattern) - The pattern that triggers the restart.

### Example
```
s("[<bd lt> sd]*2, hh*8").restart("<x@3 x(5,8)>")
```
```

--------------------------------

### Arpeggio using off()

Source: https://strudel.cc/recipes/recipes

Builds an arpeggio using the off() function to add offsets. The add() calls create the sequence, n() converts to notes, scale() sets the scale, and s() selects the guitar sample.

```strudel
"0"
.off(1/3, add(2))
.off(1/2, add(4))
.n()
.scale("C:minor")
.s("gm_electric_guitar_clean")
```

--------------------------------

### Recap: speed effect

Source: https://strudel.cc/workshop/first-effects

Example of using the speed effect with a pattern of speed values.

```javascript
s("bd rim bd cp").speed("<1 2 -1 -2>")
```
Tokens:
Raw