mirror of
https://github.com/eliasstepanik/strudel-docker.git
synced 2026-01-11 21:58:31 +00:00
189 lines
8.7 KiB
Markdown
189 lines
8.7 KiB
Markdown
---
|
||
bibliography: citations.json
|
||
date: 2022-06-24
|
||
title: "Strudel: Algorithmic Patterns for the Web"
|
||
---
|
||
|
||
# Introduction
|
||
|
||
This paper introduces Strudel (or sometimes 'StrudelCycles'), an
|
||
alternative implementation of the Tidal (or 'TidalCycles') live coding
|
||
system, using the JavaScript programming language. Strudel is an attempt
|
||
to make live coding more accessible, by creating a system that runs
|
||
entirely in the browser, while opening Tidal's approach to algorithmic
|
||
patterns [@mcleanAlgorithmicPattern2020a] up to modern audio/visual web
|
||
technologies. The Strudel REPL is a live code editor dedicated to
|
||
manipulating Strudel patterns while they play, with builtin visual
|
||
feedback. While Strudel is written in JavaScript, the API is optimized
|
||
for simplicity and readability by applying code transformations on the
|
||
syntax tree level, allowing language operations that would otherwise be
|
||
impossible. The application supports multiple ways to output sound,
|
||
including Tone.js, Web Audio nodes, OSC (Open Sound Control) messages,
|
||
Web Serial and Web MIDI. The project is split into multiple packages,
|
||
allowing granular reuse in other applications. Apart from TidalCycles,
|
||
Strudel draws inspiration from many prior existing projects like
|
||
TidalVortex [@mcleanTidalVortexZero2022], Gibber
|
||
[@robertsGibberLiveCoding2012], Estuary
|
||
[@ogbornEstuaryBrowserbasedCollaborative2017], Hydra [@jackHydra2022],
|
||
Ocarina [@solomonPurescriptocarina2022] and Feedforward
|
||
[@mcleanFeedforward2020].
|
||
|
||
# Porting from Haskell
|
||
|
||
The original Tidal is implemented as a domain specific language (DSL),
|
||
embedded in the Haskell pure functional programming language, taking
|
||
advantage of Haskell's terse syntax and advanced, 'strong' type system.
|
||
Javascript on the other hand, is a multi-paradigm programming language,
|
||
with a dynamic type system. Because Tidal leans heavily on many of
|
||
Haskell's more unique features, it was not always clear that it could
|
||
meaningfully be ported to a multi-paradigm scripting language. However,
|
||
this already proved to be the case with an earlier port to Python
|
||
\[TidalVortex; @mcleanTidalVortexZero2022\], and we have now
|
||
successfully implemented Tidal's pure functional representation of
|
||
patterns in Strudel, including partial application, and functor,
|
||
applicative and monad structures. Over the past few months since the
|
||
project started in January 2022, a large part of Tidal's functionality
|
||
has already been ported, including its mini-notation for polymetric
|
||
sequences, and a large part of its library of pattern manipulations. The
|
||
result is a terse and highly composable system, where just about
|
||
everything is a pattern, that may be transformed and combined with other
|
||
patterns in a myriad of ways.
|
||
|
||
# Representing Patterns
|
||
|
||
Patterns are the essence of Tidal. Its patterns are abstract entities
|
||
that represent flows of time as functions, adapting a technique called
|
||
pure functional reactive programming. Taking a time span as its input, a
|
||
Pattern can output a set of events that happen within that time span. It
|
||
depends on the structure of the Pattern how the events are located in
|
||
time. From now on, this process of generating events from a time span
|
||
will be called **querying**. Example:
|
||
|
||
<MiniRepl tune={`const pattern = sequence(c3, [e3, g3]);
|
||
const events = pattern.query(0, 1);
|
||
console.log(events.map(e => e.show()))`} />
|
||
|
||
In this example, we create a pattern using the `sequence` function and
|
||
**query** it for the time span from `0` to `1`. Those numbers represent
|
||
units of time called **cycles**. The length of one cycle depends on the
|
||
tempo, which defaults to one cycle per second. The resulting events are:
|
||
|
||
<MiniRepl tune={`[{ value: 'c3', begin: 0, end: 1/2 },
|
||
{ value: 'e3', begin: 1/2, end: 3/4 },
|
||
{ value: 'g3', begin: 3/4, end: 1 }]`} />
|
||
|
||
Each event has a value, a begin time and an end time, where time is
|
||
represented as a fraction. In the above case, the events are placed in
|
||
sequential order, where c3 takes the first half, and e3 and g3 together
|
||
take the second half. This temporal placement is the result of the
|
||
`sequence` function, which divides its arguments equally over one cycle.
|
||
If an argument is an array, the same rule applies to that part of the
|
||
cycle. In the example, e3 and g3 are divided equally over the second
|
||
half of the whole cycle.
|
||
|
||
In the REPL, the user only has to type in the pattern itself, the
|
||
querying will be handled by the scheduler. The scheduler will repeatedly
|
||
query the pattern for events, which then will be used for playback.
|
||
|
||
{width="43%"}
|
||
|
||
# Making Patterns
|
||
|
||
In practice, the end-user live coder will not deal with constructing
|
||
patterns directly, but will rather build patterns using Strudel's
|
||
extensive combinator library to create, combine and transform patterns.
|
||
|
||
The live coder may use the `sequence` function as already seen above, or
|
||
more often the mini-notation for even terser notation of rhythmic
|
||
sequences. Such sequences are often treated only a starting point for
|
||
manipulation, where they then are undergo pattern transformations such
|
||
as repetition, symmetry, interference/combination or randomisation,
|
||
potentially at multiple timescales. Because Strudel patterns are
|
||
represented as pure functions of time rather than as data structures,
|
||
very long and complex generative results can be represented and
|
||
manipulated without having to store the resulting sequences in memory.
|
||
|
||
# Pattern Example
|
||
|
||
The following example showcases how patterns can be utilized to create
|
||
musical complexity from simple parts, using repetition and interference:
|
||
|
||
<MiniRepl tune={`"<0 2 [4 6](3,4,1) 3*2>".scale('D minor')
|
||
.off(1/4, scaleTranspose(2))
|
||
.off(1/2, scaleTranspose(6))
|
||
.legato(.5)
|
||
.echo(4, 1/8, .5)
|
||
.tone((await piano()).chain(out()))
|
||
.pianoroll()`} />
|
||
|
||
The pattern starts with a rhythm of numbers in mini notation, which are
|
||
interpreted inside the scale of D minor. Without the scale function, the
|
||
first line can be expressed as:
|
||
|
||
<MiniRepl tune={`"<d3 f3 [a3 c3](3, 4, 1) g3*2>"`} />
|
||
|
||
This line could also be expressed without mini notation:
|
||
|
||
<MiniRepl tune={`slowcat(d3, f3, [a3, c3].euclid(3, 4, 1), g3.fast(2))`} />
|
||
|
||
Here is a short description of all the functions used:
|
||
|
||
- `slowcat`: play elements sequentially, where each lasts one cycle
|
||
- `brackets`: elements inside brackets are divided equally over the
|
||
time of their parent
|
||
- `euclid(p, s, o)`: place p pulses evenly over s steps, with offset o
|
||
[@toussaintEuclideanAlgorithmGenerates2005]
|
||
- `fast(n)`: speed up by n. `g3.fast(2)` will play g3 two times.
|
||
- `off(n, f)`: copy each event, offset it by n cycles and apply
|
||
function f
|
||
- `legato(n)`: multiply duration of event with n
|
||
- `echo(t, n, v)`: copy each event t times, with n cycles in between
|
||
each copy, decreasing velocity by v
|
||
- `tone(instrument)`: play back each event with the given Tone.js
|
||
instrument
|
||
- `pianoroll()`: visualize events as midi notes in a pianoroll
|
||
|
||
# Future Outlook
|
||
|
||
The project is still young, with many features on the horizon. As
|
||
general guiding principles, Strudel aims to be
|
||
|
||
1. accessible
|
||
2. consistent with Tidal's approach to pattern
|
||
3. modular and extensible
|
||
|
||
The main accessibility advantage over Tidal is the zero install browser
|
||
environment. It should also now be accessible to screen reader users,
|
||
with the recent integration of the CodeMirror 6 editor. While Strudel
|
||
can control Tidal's SuperDirt audio system via OSC, that requires the
|
||
user to install SuperCollider and its sc3plugins library, which can be
|
||
difficult. Without SuperDirt, Strudel is able to output sound itself via
|
||
Tone.js, however this is limited both in terms of available features and
|
||
runtime performance. For the future, it is planned to integrate
|
||
alternative sound engines such as glicol [@lanChaosprintGlicol2022] and
|
||
faust [@FaustProgrammingLanguage2022]. To improve compatibility with
|
||
Tidal, more Tidal functions are planned to be ported, as well as full
|
||
compatibility with SuperDirt. Besides sound, other ways to render events
|
||
are being explored, such as graphical, and choreographic output. We are
|
||
also looking into alternative ways of editing patterns, including
|
||
multi-user editing for network music, parsing a novel syntax to escape
|
||
the constraints of javascript, and developing hardware/e-textile
|
||
interfaces.
|
||
|
||
# Links
|
||
|
||
The Strudel REPL is available at <https://strudel.tidalcycles.org>,
|
||
including an interactive tutorial. The repository is at
|
||
<https://github.com/tidalcycles/strudel>, all the code is open source
|
||
under the GPL-3.0 License.
|
||
|
||
# Acknowledgments
|
||
|
||
Thanks to the Strudel and wider Tidal, live coding, webaudio and
|
||
free/open source software communities for inspiration and support. Alex
|
||
McLean's work on this project is supported by a UKRI Future Leaders
|
||
Fellowship \[grant number MR/V025260/1\].
|
||
|
||
# References {#references .unnumbered}
|