elias/strudel-docker
1
0
Fork 0
mirror of https://github.com/eliasstepanik/strudel-docker.git synced 2026-01-26 04:58:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

translate rest of workshop to german

Browse Source
This commit is contained in:
Felix Roos 2023-06-07 16:50:54 +02:00
parent a88759ba94
commit 06950a6bd8
11 changed files with 277 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

125
website/src/pages/de/workshop/first-effects.mdx
View File

@ -1,18 +1,16 @@
--- ---
title: First Effects title: Erste Effekte
layout: ../../../layouts/MainLayout.astro layout: ../../../layouts/MainLayout.astro
--- ---
import { MiniRepl } from '../../../docs/MiniRepl'; import { MiniRepl } from '../../../docs/MiniRepl';
import QA from '@components/QA'; import QA from '@components/QA';
# First Effects # Erste Effekte
import Box from '@components/Box.astro'; import Box from '@components/Box.astro';
We have sounds, we have notes, now let's look at effects! ## Ein paar grundlegende Effekte
## Some basic effects
**low-pass filter** **low-pass filter**
@ -27,12 +25,12 @@ We have sounds, we have notes, now let's look at effects!
lpf = **l**ow **p**ass **f**ilter lpf = **l**ow **p**ass **f**ilter
- Change lpf to 200. Notice how it gets muffled. Think of it as standing in front of the club with the door closed 🚪. - Ändere `lpf` in 200. Hörst du wie der Bass dumpfer klingt? Es klingt so ähnlich als würde die Musik hinter einer geschlossenen Tür laufen 🚪
- Now let's open the door... change it to 5000. Notice how it gets brighter ✨🪩 - Lass uns nun die Tür öffnen: Ändere `lpf` in 5000. Der Klang wird dadurch viel heller und schärfer ✨🪩
</Box> </Box>
**pattern the filter** **filter automatisieren**
<MiniRepl <MiniRepl
hideHeader hideHeader
@ -43,14 +41,14 @@ lpf = **l**ow **p**ass **f**ilter
<Box> <Box>
- Try adding more values - Füg noch mehr `lpf` Werte hinzu
- Notice how the pattern in lpf does not change the overall rhythm - Das pattern in `lpf` ändert nicht den Rhythmus der Bassline
We will learn how to automate with waves later... Später sehen wir wie man mit Wellenformen Dinge automatisieren kann.
</Box> </Box>
**vowel** **vowel = Vokal**
<MiniRepl <MiniRepl
hideHeader hideHeader
@ -59,7 +57,7 @@ We will learn how to automate with waves later...
.sound("sawtooth").vowel("<a e i o>/2")`} .sound("sawtooth").vowel("<a e i o>/2")`}
/> />
**gain** **gain = Verstärkung**
<MiniRepl <MiniRepl
hideHeader hideHeader
@ -73,16 +71,16 @@ We will learn how to automate with waves later...
<Box> <Box>
Rhythm is all about dynamics! Bei Rhythmen ist die Dynamik (= Veränderungen der Lautstärke) sehr wichtig.
- Remove `.gain(...)` and notice how flat it sounds. - Entferne `.gain(...)` und achte darauf wie es viel flacher klingt.
- Bring it back by undoing (ctrl+z) - Mach es rückgängig (strg+z dann strg+enter)
</Box> </Box>
**stacks within stacks** **stacks in stacks**
Let's combine all of the above into a little tune: Lass uns die obigen Beispiele kombinieren:
<MiniRepl <MiniRepl
hideHeader hideHeader
@ -101,12 +99,13 @@ Let's combine all of the above into a little tune:
<Box> <Box>
Try to identify the individual parts of the stacks, pay attention to where the commas are. Versuche die einzelnen Teile innerhalb `stack` zu erkennen, schau dir an wie die Kommas gesetzt sind.
The 3 parts (drums, bassline, chords) are exactly as earlier, just stacked together, separated by comma.
Die 3 Teile (Drums, Bass, Akkorde) sind genau wie vorher, nur in einem `stack`, getrennt durch Kommas
</Box> </Box>
**shape the sound with an adsr envelope** **Den Sound formen mit ADSR Hüllkurve**
<MiniRepl <MiniRepl
hideHeader hideHeader
@ -121,29 +120,29 @@ The 3 parts (drums, bassline, chords) are exactly as earlier, just stacked toget
<Box> <Box>
Try to find out what the numbers do.. Compare the following Versuche herauszufinden was die Zahlen machen. Probier folgendes:
- attack: `.5` vs `0` - attack: `.5` vs `0`
- decay: `.5` vs `0` - decay: `.5` vs `0`
- sustain: `1` vs `.25` vs `0` - sustain: `1` vs `.25` vs `0`
- release: `0` vs `.5` vs `1` - release: `0` vs `.5` vs `1`
Can you guess what they do? Kannst du erraten was die einzelnen Werte machen?
</Box> </Box>
<QA q="Click to see solution" client:visible> <QA q="Lösung anzeigen" client:visible>
- attack: time it takes to fade in - attack (anschlagen): Zeit des Aufbaus
- decay: time it takes to fade to sustain - decay (zerfallen): Zeit des Abfalls
- sustain: level after decay - sustain (erhalten): Lautstärke nach Abfall
- release: time it takes to fade out after note is finished - release (loslassen): Zeit des Abfalls nach dem Ende
![ADSR](https://upload.wikimedia.org/wikipedia/commons/thumb/e/ea/ADSR_parameter.svg/1920px-ADSR_parameter.svg.png) ![ADSR](https://upload.wikimedia.org/wikipedia/commons/thumb/e/ea/ADSR_parameter.svg/1920px-ADSR_parameter.svg.png)
</QA> </QA>
**adsr short notation** **adsr Kurznotation**
<MiniRepl <MiniRepl
hideHeader hideHeader
@ -154,7 +153,7 @@ Can you guess what they do?
`} `}
/> />
**delay** **delay = Verzögerung**
<MiniRepl <MiniRepl
hideHeader hideHeader
@ -168,15 +167,25 @@ Can you guess what they do?
<Box> <Box>
Try some `delay` values between 0 and 1. Btw, `.5` is short for `0.5` Probier verschiedene `delay` Werte zwischen 0 und 1. Übrigens: `.5` ist kurz für `0.5`.
What happens if you use `.delay(".8:.125")` ? Can you guess what the second number does? Was passiert wenn du `.delay(".8:.125")` schreibst? Kannst du erraten was die zweite Zahl macht?
What happens if you use `.delay(".8:.06:.8")` ? Can you guess what the third number does? Was passiert wenn du `.delay(".8:.06:.8")` schreibst? Kannst du erraten was die dritte Zahl macht?
</Box> </Box>
**room aka reverb** <QA q="Lösung anzeigen" client:visible>
`delay("a:b:c")`:
- a: Lautstärke des Delays
- b: Verzögerungszeit
- c: Feedback (je kleiner desto schneller verschwindet das Delay)
</QA>
**room aka reverb = Hall**
<MiniRepl <MiniRepl
hideHeader hideHeader
@ -188,13 +197,13 @@ What happens if you use `.delay(".8:.06:.8")` ? Can you guess what the third num
<Box> <Box>
Try different values! Spiel mit verschiedenen Werten.
Add a delay too! Füg auch ein Delay hinzu!
</Box> </Box>
**little dub tune** **kleiner dub tune**
<MiniRepl <MiniRepl
hideHeader hideHeader
@ -209,7 +218,7 @@ Add a delay too!
)`} )`}
/> />
Let's add a bass to make this complete: Für echten Dub fehlt noch der Bass:
<MiniRepl <MiniRepl
hideHeader hideHeader
@ -229,11 +238,11 @@ Let's add a bass to make this complete:
<Box> <Box>
Try adding `.hush()` at the end of one of the patterns in the stack... Füg `.hush()` ans ende eines Patterns im stack...
</Box> </Box>
**pan** **pan = Panorama**
<MiniRepl <MiniRepl
hideHeader hideHeader
@ -243,57 +252,59 @@ Try adding `.hush()` at the end of one of the patterns in the stack...
.slow(2)`} .slow(2)`}
/> />
**speed** **speed = Geschwindigkeit**
<MiniRepl hideHeader client:visible tune={`sound("bd rim").speed("<1 2 -1 -2>").room(.2)`} /> <MiniRepl hideHeader client:visible tune={`sound("bd rim").speed("<1 2 -1 -2>").room(.2)`} />
**fast and slow** **fast and slow = schnell und langsam**
We can use `fast` and `slow` to change the tempo of a pattern outside of Mini-Notation: Mit `fast` und `slow` kann man das tempo eines patterns außerhalb der Mini-Notation ändern:
<MiniRepl hideHeader client:visible tune={`sound("bd*2,~ rim").slow(2)`} /> <MiniRepl hideHeader client:visible tune={`sound("bd*2,~ rim").slow(2)`} />
<Box> <Box>
Change the `slow` value. Try replacing it with `fast`. Ändere den `slow` Wert. Tausche `slow` durch `fast`.
What happens if you use a pattern like `.fast("<1 [2 4]>")`? Was passiert wenn du den Wert automatisierst? z.b. `.fast("<1 [2 4]>")` ?
</Box> </Box>
By the way, inside Mini-Notation, `fast` is `*` and slow is `/`. Übrigens, innerhalb der Mini-Notation, `fast` ist `*` und `slow` ist `/`.
<MiniRepl hideHeader client:visible tune={`sound("[bd*2,~ rim]*<1 [2 4]>")`} /> <MiniRepl hideHeader client:visible tune={`sound("[bd*2,~ rim]*<1 [2 4]>")`} />
## automation with signals ## Automation mit Signalen
Instead of changing values stepwise, we can also control them with signals: Anstatt Werte schrittweise zu automatisieren können wir auch sogenannte Signale benutzen:
<MiniRepl hideHeader client:visible tune={`sound("hh*16").gain(sine)`} punchcard /> <MiniRepl hideHeader client:visible tune={`sound("hh*16").gain(sine)`} punchcard />
<Box> <Box>
The basic waveforms for signals are `sine`, `saw`, `square`, `tri` 🌊 Die grundlegenden Wellenformen sind `sine`, `saw`, `square`, `tri` 🌊
Try also random signals `rand` and `perlin`! Probiere auch die zufälligen Signale `rand` und `perlin`!
The gain is visualized as transparency in the pianoroll. Der `gain`-Wert (Verstärkung) wird in der Visualisierung als Transparenz dargestellt.
</Box> </Box>
**setting a range** **Bereich ändern mit `range`**
By default, waves oscillate between 0 to 1. We can change that with `range`: Signale bewegen sich standardmäßig zwischen 0 und 1. Wir können das mit `range` ändern:
<MiniRepl hideHeader client:visible tune={`sound("hh*8").lpf(saw.range(500, 2000))`} /> <MiniRepl hideHeader client:visible tune={`sound("hh*8").lpf(saw.range(500, 2000))`} />
`range` ist nützlich wenn wir Funktionen mit einem anderen Wertebereich als 0 und 1 automatisieren wollen (z.b. lpf)
<Box> <Box>
What happens if you flip the range values? Was passiert wenn du die beiden Werte vertauschst?
</Box> </Box>
We can change the automation speed with slow / fast: Wir können die Geschwindigkeit der Automation mit slow / fast ändern:
<MiniRepl <MiniRepl
hideHeader hideHeader
@ -305,11 +316,11 @@ We can change the automation speed with slow / fast:
<Box> <Box>
The whole automation will now take 8 cycles to repeat. Die ganze Automation braucht nun 8 cycle bis sie sich wiederholt.
</Box> </Box>
## Recap ## Rückblick
| name | example | | name | example |
| ----- | -------------------------------------------------------------------------------------------------- | | ----- | -------------------------------------------------------------------------------------------------- |

2
website/src/pages/de/workshop/first-notes.mdx
View File

@ -1,5 +1,5 @@
--- ---
title: First Notes title: Erste Töne
layout: ../../../layouts/MainLayout.astro layout: ../../../layouts/MainLayout.astro
--- ---

21
website/src/pages/de/workshop/first-sounds.mdx
View File

@ -61,7 +61,6 @@ Diese 2-Buchstaben Kombinationen stehen für verschiedene Teile eines Drumsets:
- `bd` = **b**ass **d**rum - Basstrommel - `bd` = **b**ass **d**rum - Basstrommel
- `sd` = **s**nare **d**rum - Schnarrtrommel - `sd` = **s**nare **d**rum - Schnarrtrommel
- `sn` = **sn**are
- `rim` = **rim**shot - Rahmenschlag - `rim` = **rim**shot - Rahmenschlag
- `hh` = **h**i**h**at - `hh` = **h**i**h**at
- `oh` = **o**pen **h**ihat - Offenes Hi-Hat - `oh` = **o**pen **h**ihat - Offenes Hi-Hat
@ -104,13 +103,13 @@ Versuch noch mehr Sounds hinzuzfügen!
**Je länger die Sequence, desto schneller** **Je länger die Sequence, desto schneller**
<MiniRepl hideHeader client:visible tune={`sound("bd bd hh bd sn bd hh bd")`} punchcard /> <MiniRepl hideHeader client:visible tune={`sound("bd bd hh bd sd bd hh bd")`} punchcard />
Der Inhalt einer Sequence wird in einen sogenannten Cycle (=Zyklus) zusammengequetscht. Der Inhalt einer Sequence wird in einen sogenannten Cycle (=Zyklus) zusammengequetscht.
**Tempo ändern mit `cpm`** **Tempo ändern mit `cpm`**
<MiniRepl hideHeader client:visible tune={`sound("bd bd hh bd sn bd hh bd").cpm(40)`} punchcard /> <MiniRepl hideHeader client:visible tune={`sound("bd bd hh bd sd bd hh bd").cpm(40)`} punchcard />
<Box> <Box>
@ -128,7 +127,7 @@ Wir werden später noch mehr Möglichkeiten kennen lernen wie man das Tempo ver
**Unter-Sequenzen mit [Klammern]** **Unter-Sequenzen mit [Klammern]**
<MiniRepl hideHeader client:visible tune={`sound("bd [hh hh] sn [hh bd]")`} punchcard /> <MiniRepl hideHeader client:visible tune={`sound("bd [hh hh] sd [hh bd]")`} punchcard />
<Box> <Box>
@ -140,15 +139,15 @@ Genau wie bei der ganzen Sequence wird der eine Unter-Sequence schneller je mehr
**Multiplikation: Dinge schneller machen** **Multiplikation: Dinge schneller machen**
<MiniRepl hideHeader client:visible tune={`sound("bd hh*2 sn hh*3")`} punchcard /> <MiniRepl hideHeader client:visible tune={`sound("bd hh*2 sd hh*3")`} punchcard />
**Multiplikation: Unter-Sequences schneller machen** **Multiplikation: Unter-Sequences schneller machen**
<MiniRepl hideHeader client:visible tune={`sound("bd [hh sn]*2")`} punchcard /> <MiniRepl hideHeader client:visible tune={`sound("bd [hh sd]*2")`} punchcard />
**Multiplikation: Vieeeeeeel schneller** **Multiplikation: Vieeeeeeel schneller**
<MiniRepl hideHeader client:visible tune={`sound("bd hh*16 sn hh*8")`} punchcard /> <MiniRepl hideHeader client:visible tune={`sound("bd hh*16 sd hh*8")`} punchcard />
<Box> <Box>
@ -158,7 +157,7 @@ Tonhöhe = sehr schneller Rhythmus
**Unter-Unter-Sequenzen mit [[Klammern]]** **Unter-Unter-Sequenzen mit [[Klammern]]**
<MiniRepl hideHeader client:visible tune={`sound("bd [[sn sn] hh]")`} punchcard /> <MiniRepl hideHeader client:visible tune={`sound("bd [[sd sd] hh]")`} punchcard />
<Box> <Box>
@ -216,12 +215,12 @@ Das haben wir bisher gelernt:
| Concept | Syntax | Example | | Concept | Syntax | Example |
| --------------------- | ----------- | -------------------------------------------------------------------------------- | | --------------------- | ----------- | -------------------------------------------------------------------------------- |
| Sequenz | Leerzeichen | <MiniRepl hideHeader client:visible tune={`sound("bd bd sn hh")`} /> | | Sequenz | Leerzeichen | <MiniRepl hideHeader client:visible tune={`sound("bd bd sd hh")`} /> |
| Sound Nummer | :x | <MiniRepl hideHeader client:visible tune={`sound("hh:0 hh:1 hh:2 hh:3")`} /> | | Sound Nummer | :x | <MiniRepl hideHeader client:visible tune={`sound("hh:0 hh:1 hh:2 hh:3")`} /> |
| Pausen | ~ | <MiniRepl hideHeader client:visible tune={`sound("metal ~ jazz jazz:1")`} /> | | Pausen | ~ | <MiniRepl hideHeader client:visible tune={`sound("metal ~ jazz jazz:1")`} /> |
| Unter-Sequenzen | \[\] | <MiniRepl hideHeader client:visible tune={`sound("bd wind [metal jazz] hh")`} /> | | Unter-Sequenzen | \[\] | <MiniRepl hideHeader client:visible tune={`sound("bd wind [metal jazz] hh")`} /> |
| Unter-Unter-Sequenzen | \[\[\]\] | <MiniRepl hideHeader client:visible tune={`sound("bd [metal [jazz sn]]")`} /> | | Unter-Unter-Sequenzen | \[\[\]\] | <MiniRepl hideHeader client:visible tune={`sound("bd [metal [jazz sd]]")`} /> |
| Schneller | \* | <MiniRepl hideHeader client:visible tune={`sound("bd sn*2 cp*3")`} /> | | Schneller | \* | <MiniRepl hideHeader client:visible tune={`sound("bd sd*2 cp*3")`} /> |
| Parallel | , | <MiniRepl hideHeader client:visible tune={`sound("bd*2, hh*2 [hh oh]")`} /> | | Parallel | , | <MiniRepl hideHeader client:visible tune={`sound("bd*2, hh*2 [hh oh]")`} /> |
Die mit Apostrophen umgebene Mini-Notation benutzt man normalerweise in eine sogenannten Funktion. Die mit Apostrophen umgebene Mini-Notation benutzt man normalerweise in eine sogenannten Funktion.

63
website/src/pages/de/workshop/intro.mdx
View File

@ -3,20 +3,57 @@ title: Introduction
layout: ../../../layouts/MainLayout.astro layout: ../../../layouts/MainLayout.astro
--- ---
# Introduction # Welcome
## goals Welcome to the Strudel documentation pages!
You've come to the right place if you want to learn how to make music with code.
- be beginner friendly ## What is Strudel?
- teach a representative subset of strudel / tidal
- introduce one new thing at a time
- give practical / musical examples
- encourage self-experimentation
- hands on learning > walls of text
- maintain flow state
- no setup required
## inspired by With Strudel, you can expressively write dynamic music pieces.
It is an official port of the [Tidal Cycles](https://tidalcycles.org/) pattern language to JavaScript.
You don't need to know JavaScript or Tidal Cycles to make music with Strudel.
This interactive tutorial will guide you through the basics of Strudel.
The best place to actually make music with Strudel is the [Strudel REPL](https://strudel.tidalcycles.org/)
- https://github.com/tidalcycles/tidal-workshop/blob/master/workshop.tidal ## What can you do with Strudel?
- https://learningmusic.ableton.com
- live code music: make music with code in real time
- algorithmic composition: compose music using tidal's unique approach to pattern manipulation
- teaching: focussing on a low barrier of entry, Strudel is a good fit for teaching music and code at the same time.
- integrate into your existing music setup: either via MIDI or OSC, you can use Strudel as a really flexible sequencer
## Example
Here is an example of how strudel can sound:
<MiniRepl
client:idle
tune={`stack(
// drums
s("bd,[~ <sd!3 sd(3,4,2)>],hh*8")
.speed(perlin.range(.8,.9)), // random sample speed variation
// bassline
"<a1 b1\*2 a1(3,8) e2>"
.off(1/8,x=>x.add(12).degradeBy(.5)) // random octave jumps
.add(perlin.range(0,.5)) // random pitch variation
.superimpose(add(.05)) // add second, slightly detuned voice
.note() // wrap in "note"
.decay(.15).sustain(0) // make each note of equal length
.s('sawtooth') // waveform
.gain(.4) // turn down
.cutoff(sine.slow(7).range(300,5000)), // automate cutoff
// chords
"<Am7!3 <Em7 E7b13 Em7 Ebm7b5>>".voicings('lefthand')
.superimpose(x=>x.add(.04)) // add second, slightly detuned voice
.add(perlin.range(0,.5)) // random pitch variation
.note() // wrap in "note"
.s('sawtooth') // waveform
.gain(.16) // turn down
.cutoff(500) // fixed cutoff
.attack(1) // slowly fade in
)
.slow(3/2)`}
/>
To hear more, go to the [Strudel REPL](https://strudel.tidalcycles.org/) and press shuffle to hear a random example pattern.

60
website/src/pages/de/workshop/pattern-effects.mdx
View File

@ -1,5 +1,5 @@
--- ---
title: Pattern Effects title: Pattern Effekte
layout: ../../../layouts/MainLayout.astro layout: ../../../layouts/MainLayout.astro
--- ---
@ -7,21 +7,21 @@ import { MiniRepl } from '@src/docs/MiniRepl';
import Box from '@components/Box.astro'; import Box from '@components/Box.astro';
import QA from '@components/QA'; import QA from '@components/QA';
# Pattern Effects # Pattern Effekte
Up until now, most of the functions we've seen are what other music programs are typically capable of: sequencing sounds, playing notes, controlling effects. Bis jetzt sind die meisten Funktionen die wir kennengelernt haben ähnlich wie Funktionen in anderen Musik Programmen: Sequencing von Sounds, Noten und Effekten.
In this chapter, we are going to look at functions that are more unique to tidal. In diesem Kapitel beschäftigen wir uns mit Funktionen die weniger herkömmlich oder auch enzigartig sind.
**reverse patterns with rev** **rev = rückwärts abspielen**
<MiniRepl hideHeader client:visible tune={`n("0 1 [4 3] 2").sound("jazz").rev()`} /> <MiniRepl hideHeader client:visible tune={`n("0 1 [4 3] 2").sound("jazz").rev()`} />
**play pattern left and modify it right with jux** **jux = einen stereo kanal modifizieren**
<MiniRepl hideHeader client:visible tune={`n("0 1 [4 3] 2").sound("jazz").jux(rev)`} /> <MiniRepl hideHeader client:visible tune={`n("0 1 [4 3] 2").sound("jazz").jux(rev)`} />
This is the same as: So würde man das ohne jux schreiben:
<MiniRepl <MiniRepl
hideHeader hideHeader
@ -32,7 +32,7 @@ This is the same as:
)`} )`}
/> />
Let's visualize what happens here: Lass uns visualisieren was hier passiert:
<MiniRepl <MiniRepl
hideHeader hideHeader
@ -46,15 +46,15 @@ Let's visualize what happens here:
<Box> <Box>
Try commenting out one of the two by adding `//` before a line Schreibe `//` vor eine der beiden Zeilen im `stack`!
</Box> </Box>
**multiple tempos** **mehrere tempos**
<MiniRepl hideHeader client:visible tune={`note("c2, eb3 g3 [bb3 c4]").sound("piano").slow("1,2,3")`} /> <MiniRepl hideHeader client:visible tune={`note("c2, eb3 g3 [bb3 c4]").sound("piano").slow("1,2,3")`} />
This is like doing Das hat den gleichen Effekt wie:
<MiniRepl <MiniRepl
hideHeader hideHeader
@ -69,11 +69,11 @@ This is like doing
<Box> <Box>
Try commenting out one or more by adding `//` before a line Schreibe wieder `//` vor eine oder mehrere Zeilen im `stack`.
</Box> </Box>
**add** **add = addieren**
<MiniRepl <MiniRepl
hideHeader hideHeader
@ -86,11 +86,13 @@ Try commenting out one or more by adding `//` before a line
<Box> <Box>
If you add a number to a note, the note will be treated as if it was a number Addiert man eine Zahl zu einer Note, verhält sich diese wie eine Zahl.
z.B. c4 = 60, also ist c4 + 2 = 62
</Box> </Box>
We can add as often as we like: Man kann auch mehrmals addieren:
<MiniRepl <MiniRepl
hideHeader hideHeader
@ -101,7 +103,7 @@ We can add as often as we like:
punchcard punchcard
/> />
**add with scale** **add + scale**
<MiniRepl <MiniRepl
hideHeader hideHeader
@ -112,7 +114,7 @@ We can add as often as we like:
punchcard punchcard
/> />
**time to stack** **Alles zusammen**
<MiniRepl <MiniRepl
hideHeader hideHeader
@ -134,13 +136,13 @@ We can add as often as we like:
<MiniRepl hideHeader client:visible tune={`sound("hh, bd rim").bank("RolandTR707").ply(2)`} punchcard /> <MiniRepl hideHeader client:visible tune={`sound("hh, bd rim").bank("RolandTR707").ply(2)`} punchcard />
this is like writing: das ist wie:
<MiniRepl hideHeader client:visible tune={`sound("hh*2, bd*2 rim*2").bank("RolandTR707")`} punchcard /> <MiniRepl hideHeader client:visible tune={`sound("hh*2, bd*2 rim*2").bank("RolandTR707")`} punchcard />
<Box> <Box>
Try patterning the `ply` function, for example using `"<1 2 1 3>"` Probier `ply` mit einem pattern zu automatisieren, z.b. `"<1 2 1 3>"`
</Box> </Box>
@ -159,11 +161,11 @@ Try patterning the `ply` function, for example using `"<1 2 1 3>"`
<Box> <Box>
In the notation `x=>x.`, the `x` is the shifted pattern, which where modifying. In der notation `x=>x.`, das `x` ist das pattern das wir bearbeiten.
</Box> </Box>
The above is like writing: Das Beispiel oben sieht ohne `off` so aus:
<MiniRepl <MiniRepl
hideHeader hideHeader
@ -176,7 +178,7 @@ The above is like writing:
punchcard punchcard
/> />
off is also useful for sounds: `off` ist auch nützlich für sounds:
<MiniRepl <MiniRepl
hideHeader hideHeader
@ -185,10 +187,10 @@ off is also useful for sounds:
.off(1/8, x=>x.speed(1.5).gain(.25))`} .off(1/8, x=>x.speed(1.5).gain(.25))`}
/> />
| name | description | example | | name | description | example |
| ---- | ------------------------------ | ---------------------------------------------------------------------------------------------- | | ---- | --------------------------------- | ---------------------------------------------------------------------------------------------- |
| rev | reverse | <MiniRepl hideHeader client:visible tune={`n("0 2 4 6").scale("C:minor").rev()`} /> | | rev | rückwärts | <MiniRepl hideHeader client:visible tune={`n("0 2 4 6").scale("C:minor").rev()`} /> |
| jux | split left/right, modify right | <MiniRepl hideHeader client:visible tune={`n("0 2 4 6").scale("C:minor").jux(rev)`} /> | | jux | ein stereo-kanal modifizieren | <MiniRepl hideHeader client:visible tune={`n("0 2 4 6").scale("C:minor").jux(rev)`} /> |
| add | add numbers / notes | <MiniRepl hideHeader client:visible tune={`n("0 2 4 6".add("<0 1 2 1>")).scale("C:minor")`} /> | | add | addiert zahlen oder noten | <MiniRepl hideHeader client:visible tune={`n("0 2 4 6".add("<0 1 2 1>")).scale("C:minor")`} /> |
| ply | speed up each event n times | <MiniRepl hideHeader client:visible tune={`s("bd sd").ply("<1 2 3>")`} /> | | ply | multipliziert jedes element x mal | <MiniRepl hideHeader client:visible tune={`s("bd sd").ply("<1 2 3>")`} /> |
| off | copy, shift time & modify | <MiniRepl hideHeader client:visible tune={`s("bd sd, hh*4").off(1/8, x=>x.speed(2))`} /> | | off | verzögert eine modifizierte kopie | <MiniRepl hideHeader client:visible tune={`s("bd sd, hh*4").off(1/8, x=>x.speed(2))`} /> |

72
website/src/pages/de/workshop/recap.mdx
View File

@ -5,43 +5,43 @@ layout: ../../../layouts/MainLayout.astro
import { MiniRepl } from '../../../docs/MiniRepl'; import { MiniRepl } from '../../../docs/MiniRepl';
# Workshop Recap # Workshop Rückblick
This page is just a listing of all functions covered in the workshop! Diese Seite ist eine Auflistung aller im Workshop enthaltenen Funktionen.
## Mini Notation ## Mini Notation
| Concept | Syntax | Example | | Concept | Syntax | Example |
| ----------------- | -------- | -------------------------------------------------------------------------------- | | --------------------- | -------- | -------------------------------------------------------------------------------- |
| Sequence | space | <MiniRepl hideHeader client:visible tune={`sound("bd bd sn hh")`} /> | | Sequence | space | <MiniRepl hideHeader client:visible tune={`sound("bd bd sn hh")`} /> |
| Sample Number | :x | <MiniRepl hideHeader client:visible tune={`sound("hh:0 hh:1 hh:2 hh:3")`} /> | | Sample Nummer | :x | <MiniRepl hideHeader client:visible tune={`sound("hh:0 hh:1 hh:2 hh:3")`} /> |
| Rests | ~ | <MiniRepl hideHeader client:visible tune={`sound("metal ~ jazz jazz:1")`} /> | | Pausen | ~ | <MiniRepl hideHeader client:visible tune={`sound("metal ~ jazz jazz:1")`} /> |
| Sub-Sequences | \[\] | <MiniRepl hideHeader client:visible tune={`sound("bd wind [metal jazz] hh")`} /> | | Unter-Sequences | \[\] | <MiniRepl hideHeader client:visible tune={`sound("bd wind [metal jazz] hh")`} /> |
| Sub-Sub-Sequences | \[\[\]\] | <MiniRepl hideHeader client:visible tune={`sound("bd [metal [jazz sn]]")`} /> | | Unter-Unter-Sequences | \[\[\]\] | <MiniRepl hideHeader client:visible tune={`sound("bd [metal [jazz sn]]")`} /> |
| Speed up | \* | <MiniRepl hideHeader client:visible tune={`sound("bd sn*2 cp*3")`} /> | | Schneller | \* | <MiniRepl hideHeader client:visible tune={`sound("bd sn*2 cp*3")`} /> |
| Parallel | , | <MiniRepl hideHeader client:visible tune={`sound("bd*2, hh*2 [hh oh]")`} /> | | Slow down | \/ | <MiniRepl hideHeader client:visible tune={`note("[c a f e]/2")`} /> |
| Slow down | \/ | <MiniRepl hideHeader client:visible tune={`note("[c a f e]/2")`} /> | | Parallel | , | <MiniRepl hideHeader client:visible tune={`sound("bd*2, hh*2 [hh oh]")`} /> |
| Alternate | \<\> | <MiniRepl hideHeader client:visible tune={`note("c <e g>")`} /> | | Alternieren | \<\> | <MiniRepl hideHeader client:visible tune={`note("c <e g>")`} /> |
| Elongate | @ | <MiniRepl hideHeader client:visible tune={`note("c@3 e")`} /> | | Verlängern | @ | <MiniRepl hideHeader client:visible tune={`note("c@3 e")`} /> |
| Replicate | ! | <MiniRepl hideHeader client:visible tune={`note("c!3 e")`} /> | | Wiederholen | ! | <MiniRepl hideHeader client:visible tune={`note("c!3 e")`} /> |
## Sounds ## Sounds
| Name | Description | Example | | Name | Description | Example |
| ----- | --------------------------------- | ---------------------------------------------------------------------------------- | | ----- | -------------------------- | ---------------------------------------------------------------------------------- |
| sound | plays the sound of the given name | <MiniRepl hideHeader client:visible tune={`sound("bd sd")`} /> | | sound | spielt den sound mit namen | <MiniRepl hideHeader client:visible tune={`sound("bd sd")`} /> |
| bank | selects the sound bank | <MiniRepl hideHeader client:visible tune={`sound("bd sd").bank("RolandTR909")`} /> | | bank | wählt die soundbank | <MiniRepl hideHeader client:visible tune={`sound("bd sd").bank("RolandTR909")`} /> |
| n | select sample number | <MiniRepl hideHeader client:visible tune={`n("0 1 4 2").sound("jazz")`} /> | | n | wählt sample mit nummer | <MiniRepl hideHeader client:visible tune={`n("0 1 4 2").sound("jazz")`} /> |
## Notes ## Notes
| Name | Description | Example | | Name | Description | Example |
| --------- | ----------------------------------- | -------------------------------------------------------------------------------------------- | | --------- | ---------------------------------- | -------------------------------------------------------------------------------------------- |
| note | set pitch as number or letter | <MiniRepl hideHeader client:visible tune={`note("b g e c").sound("piano")`} /> | | note | wählt note per zahl oder buchstabe | <MiniRepl hideHeader client:visible tune={`note("b g e c").sound("piano")`} /> |
| n + scale | set note in scale | <MiniRepl hideHeader client:visible tune={`n("6 4 2 0").scale("C:minor").sound("piano")`} /> | | n + scale | wählt note n in skala | <MiniRepl hideHeader client:visible tune={`n("6 4 2 0").scale("C:minor").sound("piano")`} /> |
| stack | play patterns in parallel (read on) | <MiniRepl hideHeader client:visible tune={`stack(s("bd sd"),note("c eb g"))`} /> | | stack | spielt mehrere patterns parallel | <MiniRepl hideHeader client:visible tune={`stack(s("bd sd"),note("c eb g"))`} /> |
## Audio Effects ## Audio Effekte
| name | example | | name | example |
| ----- | -------------------------------------------------------------------------------------------------- | | ----- | -------------------------------------------------------------------------------------------------- |
@ -56,16 +56,16 @@ This page is just a listing of all functions covered in the workshop!
## Pattern Effects ## Pattern Effects
| name | description | example | | name | description | example |
| ---- | ----------------------------------- | ---------------------------------------------------------------------------------------------- | | ---- | --------------------------------- | ---------------------------------------------------------------------------------------------- |
| cpm | sets the tempo in cycles per minute | <MiniRepl hideHeader client:visible tune={`sound("bd sd").cpm(90)`} /> | | cpm | tempo in cycles pro minute | <MiniRepl hideHeader client:visible tune={`sound("bd sd").cpm(90)`} /> |
| fast | speed up | <MiniRepl hideHeader client:visible tune={`sound("bd sd").fast(2)`} /> | | fast | schneller | <MiniRepl hideHeader client:visible tune={`sound("bd sd").fast(2)`} /> |
| slow | slow down | <MiniRepl hideHeader client:visible tune={`sound("bd sd").slow(2)`} /> | | slow | langsamer | <MiniRepl hideHeader client:visible tune={`sound("bd sd").slow(2)`} /> |
| rev | reverse | <MiniRepl hideHeader client:visible tune={`n("0 2 4 6").scale("C:minor").rev()`} /> | | rev | rückwärts | <MiniRepl hideHeader client:visible tune={`n("0 2 4 6").scale("C:minor").rev()`} /> |
| jux | split left/right, modify right | <MiniRepl hideHeader client:visible tune={`n("0 2 4 6").scale("C:minor").jux(rev)`} /> | | jux | ein stereo-kanal modifizieren | <MiniRepl hideHeader client:visible tune={`n("0 2 4 6").scale("C:minor").jux(rev)`} /> |
| add | add numbers / notes | <MiniRepl hideHeader client:visible tune={`n("0 2 4 6".add("<0 1 2 1>")).scale("C:minor")`} /> | | add | addiert zahlen oder noten | <MiniRepl hideHeader client:visible tune={`n("0 2 4 6".add("<0 1 2 1>")).scale("C:minor")`} /> |
| ply | speed up each event n times | <MiniRepl hideHeader client:visible tune={`s("bd sd").ply("<1 2 3>")`} /> | | ply | jedes element schneller machen | <MiniRepl hideHeader client:visible tune={`s("bd sd").ply("<1 2 3>")`} /> |
| off | copy, shift time & modify | <MiniRepl hideHeader client:visible tune={`s("bd sd, hh*4").off(1/8, x=>x.speed(2))`} /> | | off | verzögert eine modifizierte kopie | <MiniRepl hideHeader client:visible tune={`s("bd sd, hh*4").off(1/8, x=>x.speed(2))`} /> |
## Samples ## Samples

12
website/src/pages/workshop/first-effects.mdx
View File

@ -176,6 +176,16 @@ What happens if you use `.delay(".8:.06:.8")` ? Can you guess what the third num
</Box> </Box>
<QA q="Lösung anzeigen" client:visible>
`delay("a:b:c")`:
- a: delay volume
- b: delay time
- c: feedback (smaller number = quicker fade)
</QA>
**room aka reverb** **room aka reverb**
<MiniRepl <MiniRepl
@ -261,7 +271,7 @@ What happens if you use a pattern like `.fast("<1 [2 4]>")`?
</Box> </Box>
By the way, inside Mini-Notation, `fast` is `*` and slow is `/`. By the way, inside Mini-Notation, `fast` is `*` and `slow` is `/`.
<MiniRepl hideHeader client:visible tune={`sound("[bd*2,~ rim]*<1 [2 4]>")`} /> <MiniRepl hideHeader client:visible tune={`sound("[bd*2,~ rim]*<1 [2 4]>")`} />

24
website/src/pages/workshop/first-sounds.mdx
View File

@ -13,7 +13,7 @@ import QA from '@components/QA';
Let's start by making some noise: Let's start by making some noise:
<MiniRepl hideHeader client:visible tune={`sound("house")`} /> <MiniRepl hideHeader client:visible tune={`sound("house")`} dirt />
<Box> <Box>
@ -61,7 +61,7 @@ These letter combinations stand for different parts of a drum set:
- `bd` = **b**ass **d**rum - `bd` = **b**ass **d**rum
- `sd` = **s**nare **d**rum - `sd` = **s**nare **d**rum
- `sn` = **sn**are - `sd` = **sd**are
- `rim` = **rim**shot - `rim` = **rim**shot
- `hh` = **h**i**h**at - `hh` = **h**i**h**at
- `oh` = **o**pen **h**ihat - `oh` = **o**pen **h**ihat
@ -103,13 +103,13 @@ Try adding more sounds to the sequence!
**The longer the sequence, the faster it runs** **The longer the sequence, the faster it runs**
<MiniRepl hideHeader client:visible tune={`sound("bd bd hh bd sn bd hh bd")`} punchcard /> <MiniRepl hideHeader client:visible tune={`sound("bd bd hh bd sd bd hh bd")`} punchcard />
The content of a sequence will be squished into what's called a cycle. The content of a sequence will be squished into what's called a cycle.
**One way to change the tempo is using `cpm`** **One way to change the tempo is using `cpm`**
<MiniRepl hideHeader client:visible tune={`sound("bd bd hh bd sn bd hh bd").cpm(40)`} punchcard /> <MiniRepl hideHeader client:visible tune={`sound("bd bd hh bd sd bd hh bd").cpm(40)`} punchcard />
<Box> <Box>
@ -127,7 +127,7 @@ We will look at other ways to change the tempo later!
**Sub-Sequences with [brackets]** **Sub-Sequences with [brackets]**
<MiniRepl hideHeader client:visible tune={`sound("bd [hh hh] sn [hh bd]")`} punchcard /> <MiniRepl hideHeader client:visible tune={`sound("bd [hh hh] sd [hh bd]")`} punchcard />
<Box> <Box>
@ -139,15 +139,15 @@ Similar to the whole sequence, the content of a sub-sequence will be squished to
**Multiplication: Speed things up** **Multiplication: Speed things up**
<MiniRepl hideHeader client:visible tune={`sound("bd hh*2 sn hh*3")`} punchcard /> <MiniRepl hideHeader client:visible tune={`sound("bd hh*2 sd hh*3")`} punchcard />
**Multiplication: Speed up sequences** **Multiplication: Speed up sequences**
<MiniRepl hideHeader client:visible tune={`sound("bd [hh sn]*2")`} punchcard /> <MiniRepl hideHeader client:visible tune={`sound("bd [hh sd]*2")`} punchcard />
**Multiplication: Speeeeeeeeed things up** **Multiplication: Speeeeeeeeed things up**
<MiniRepl hideHeader client:visible tune={`sound("bd hh*16 sn hh*8")`} punchcard /> <MiniRepl hideHeader client:visible tune={`sound("bd hh*16 sd hh*8")`} punchcard />
<Box> <Box>
@ -157,7 +157,7 @@ Pitch = really fast rhythm
**Sub-Sub-Sequences with [[brackets]]** **Sub-Sub-Sequences with [[brackets]]**
<MiniRepl hideHeader client:visible tune={`sound("bd [[sn sn] hh]")`} punchcard /> <MiniRepl hideHeader client:visible tune={`sound("bd [[sd sd] hh]")`} punchcard />
<Box> <Box>
@ -214,12 +214,12 @@ This is what we've leared so far:
| Concept | Syntax | Example | | Concept | Syntax | Example |
| ----------------- | -------- | -------------------------------------------------------------------------------- | | ----------------- | -------- | -------------------------------------------------------------------------------- |
| Sequence | space | <MiniRepl hideHeader client:visible tune={`sound("bd bd sn hh")`} /> | | Sequence | space | <MiniRepl hideHeader client:visible tune={`sound("bd bd sd hh")`} /> |
| Sample Number | :x | <MiniRepl hideHeader client:visible tune={`sound("hh:0 hh:1 hh:2 hh:3")`} /> | | Sample Number | :x | <MiniRepl hideHeader client:visible tune={`sound("hh:0 hh:1 hh:2 hh:3")`} /> |
| Rests | ~ | <MiniRepl hideHeader client:visible tune={`sound("metal ~ jazz jazz:1")`} /> | | Rests | ~ | <MiniRepl hideHeader client:visible tune={`sound("metal ~ jazz jazz:1")`} /> |
| Sub-Sequences | \[\] | <MiniRepl hideHeader client:visible tune={`sound("bd wind [metal jazz] hh")`} /> | | Sub-Sequences | \[\] | <MiniRepl hideHeader client:visible tune={`sound("bd wind [metal jazz] hh")`} /> |
| Sub-Sub-Sequences | \[\[\]\] | <MiniRepl hideHeader client:visible tune={`sound("bd [metal [jazz sn]]")`} /> | | Sub-Sub-Sequences | \[\[\]\] | <MiniRepl hideHeader client:visible tune={`sound("bd [metal [jazz sd]]")`} /> |
| Speed up | \* | <MiniRepl hideHeader client:visible tune={`sound("bd sn*2 cp*3")`} /> | | Speed up | \* | <MiniRepl hideHeader client:visible tune={`sound("bd sd*2 cp*3")`} /> |
| Parallel | , | <MiniRepl hideHeader client:visible tune={`sound("bd*2, hh*2 [hh oh]")`} /> | | Parallel | , | <MiniRepl hideHeader client:visible tune={`sound("bd*2, hh*2 [hh oh]")`} /> |
The Mini-Notation is usually used inside some function. These are the functions we've seen so far: The Mini-Notation is usually used inside some function. These are the functions we've seen so far:

65
website/src/pages/workshop/intro.mdx
View File

@ -3,20 +3,59 @@ title: Introduction
layout: ../../layouts/MainLayout.astro layout: ../../layouts/MainLayout.astro
--- ---
# Introduction import { MiniRepl } from '../../docs/MiniRepl';
## goals # Welcome
- be beginner friendly Welcome to the Strudel documentation pages!
- teach a representative subset of strudel / tidal You've come to the right place if you want to learn how to make music with code.
- introduce one new thing at a time
- give practical / musical examples
- encourage self-experimentation
- hands on learning > walls of text
- maintain flow state
- no setup required
## inspired by ## What is Strudel?
- https://github.com/tidalcycles/tidal-workshop/blob/master/workshop.tidal With Strudel, you can expressively write dynamic music pieces.<br/>
- https://learningmusic.ableton.com It is an official port of the [Tidal Cycles](https://tidalcycles.org/) pattern language to JavaScript.
You don't need to know JavaScript or Tidal Cycles to make music with Strudel.
This interactive tutorial will guide you through the basics of Strudel.<br/>
The best place to actually make music with Strudel is the [Strudel REPL](https://strudel.tidalcycles.org/)
## What can you do with Strudel?
- live code music: make music with code in real time
- algorithmic composition: compose music using tidal's unique approach to pattern manipulation
- teaching: focussing on a low barrier of entry, Strudel is a good fit for teaching music and code at the same time.
- integrate into your existing music setup: either via MIDI or OSC, you can use Strudel as a really flexible sequencer
## Example
Here is an example of how strudel can sound:
<MiniRepl
client:idle
tune={`stack(
// drums
s("bd,[~ <sd!3 sd(3,4,2)>],hh*8")
.speed(perlin.range(.8,.9)), // random sample speed variation
// bassline
"<a1 b1\*2 a1(3,8) e2>"
.off(1/8,x=>x.add(12).degradeBy(.5)) // random octave jumps
.add(perlin.range(0,.5)) // random pitch variation
.superimpose(add(.05)) // add second, slightly detuned voice
.note() // wrap in "note"
.decay(.15).sustain(0) // make each note of equal length
.s('sawtooth') // waveform
.gain(.4) // turn down
.cutoff(sine.slow(7).range(300,5000)), // automate cutoff
// chords
"<Am7!3 <Em7 E7b13 Em7 Ebm7b5>>".voicings('lefthand')
.superimpose(x=>x.add(.04)) // add second, slightly detuned voice
.add(perlin.range(0,.5)) // random pitch variation
.note() // wrap in "note"
.s('sawtooth') // waveform
.gain(.16) // turn down
.cutoff(500) // fixed cutoff
.attack(1) // slowly fade in
)
.slow(3/2)`}
/>
To hear more, go to the [Strudel REPL](https://strudel.tidalcycles.org/) and press shuffle to hear a random example pattern.

10
website/src/pages/workshop/recap.mdx
View File

@ -35,11 +35,11 @@ This page is just a listing of all functions covered in the workshop!
## Notes ## Notes
| Name | Description | Example | | Name | Description | Example |
| --------- | ----------------------------------- | -------------------------------------------------------------------------------------------- | | --------- | ----------------------------- | -------------------------------------------------------------------------------------------- |
| note | set pitch as number or letter | <MiniRepl hideHeader client:visible tune={`note("b g e c").sound("piano")`} /> | | note | set pitch as number or letter | <MiniRepl hideHeader client:visible tune={`note("b g e c").sound("piano")`} /> |
| n + scale | set note in scale | <MiniRepl hideHeader client:visible tune={`n("6 4 2 0").scale("C:minor").sound("piano")`} /> | | n + scale | set note in scale | <MiniRepl hideHeader client:visible tune={`n("6 4 2 0").scale("C:minor").sound("piano")`} /> |
| stack | play patterns in parallel (read on) | <MiniRepl hideHeader client:visible tune={`stack(s("bd sd"),note("c eb g"))`} /> | | stack | play patterns in parallel | <MiniRepl hideHeader client:visible tune={`stack(s("bd sd"),note("c eb g"))`} /> |
## Audio Effects ## Audio Effects

2
website/src/repl/prebake.mjs
View File

@ -23,7 +23,7 @@ export async function prebake() {
}), }),
samples(`./EmuSP12.json`, `./EmuSP12/`, { prebake: true, tag: 'drum-machines' }), samples(`./EmuSP12.json`, `./EmuSP12/`, { prebake: true, tag: 'drum-machines' }),
]); ]);
await samples('github:tidalcycles/Dirt-Samples/master'); await samples('github:tidalcycles/Dirt-Samples/master'); // TODO: remove
} }
const maxPan = noteToMidi('C8'); const maxPan = noteToMidi('C8');