Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

https://github.com/carrierdown/mutateful

Add-on for Ableton Live that enables live coding functionality fully integrated into Live's session view.
https://github.com/carrierdown/mutateful

ableton ableton-live algorithmic-composition csharp dotnet6 live live-api live-coding m4l maxforlive

Last synced: 3 months ago
JSON representation

Add-on for Ableton Live that enables live coding functionality fully integrated into Live's session view.

Lists

README

        

mutateful

**tl;dr:** `mutateful` enables live coding in Ableton Live's session view. Set up transformations that trigger whenever a source clip is changed, including arpeggiation, shuffling, and ratcheting/retriggering.


mutateful in action

> With live coding being all the rage this looks like a groovy new idea to bring that excitement and its new possibilities to Ableton. I’m watching closely.
>
> — Matt Black, co-founder of Ninja Tune & Coldcut.

## Concept
`mutateful` transforms Ableton Live's session view into a live coding environment similar to a spreadsheet. It allows you to create formulas for shuffling, arpeggiating, constraining, scaling, retriggering, and transforming clips in various ways. These formulas use other clips and/or textual inputs to generate new clips. By utilizing Live's built-in sequencing functionality, mutateful allows you to use any existing MIDI clip as a starting point for new creative ideas.

## Installing

Visit the [latest release](https://github.com/carrierdown/mutateful/releases/latest) for installation instructions and download links for Windows and macOS.

## See it in action

creating beat variations with mutateful

Creating beat variations

mutateful demo video 1

Demo #1: concat, constrain, transpose

mutateful demo video 2

Demo #2: ratchet, shuffle, interleave

## A musical spreadsheet

The easiest way to understand what `mutateful` does is by comparing it to a traditional spreadsheet. Let's say you have two numbers that you'd like to multiply. You put one number in cell `A1`, another in `A2`, and in `A3` you enter the following (very simple) formula: `=A1 * A2`. Cell `A3` will then contain the result of this operation, and will update automatically whenever `A1` or `A2` changes.

Since the session view in Ableton Live presents clips in a spreadsheet-like grid, `mutateful` works the same way, only with more musically interesting commands. For instance, you could shuffle the contents of clip `A1` using the contents of clip `A2`. The pitch values of the various notes in clip `A2` would then be used to shuffle the order of notes in `A1`. Similar to the example above, we would like the result to be inserted into clip `A3`, but instead of using a spreadsheet command we will use a `mutateful` command, as follows: `=A1 shuffle -by A2`. In this example, `A1` is a *source clip* (i.e. the clip that will be transformed), and `A2` is the *control clip* (i.e. the clip that controls the transformation). The latter could be omitted, in which case clip `A1` would be shuffled using itself as the control clip. The formula for this would simply be `=A1 shuffle`.

## Usage examples

### Creating an arpeggio from a sustained note and a chord

`=B1 slice 1/2 transpose 0 7 slice 1/16 1/8 transpose -by C1`

This formula does the following: Start with the single sustained note contained in the clip at position `B1`. Slice it in half, keeping the first note unchanged and transposing the second note 7 semitones up (a perfect fifth). Now, slice the resulting two half-notes into a pattern alternating between 1/16 and 1/8th notes. Finally, transpose this pattern with the chord contained in the clip located at position `C1`.

![Arpeggio from note and chord](./assets/Generated637068518186284593-clip.svg)

### Interleaving two clips together

`=B1 C1 interleave -mode event`

This formula combines the notes contained in the clips located at positions `B1` and `C1`, so that the notes from each clip are played one after the other in an alternating fashion.

![Interleaving two clips](./assets/Generated637012367962797269-clip.svg)

### Adding retriggering to a beat

`=A4 ratchet 1 2 3 6 1 2 5`

This formula adds retriggering (also called ratchets) to the beat contained in clip `A4`. The numbers specify the retrigger amount for each note encountered in the clip. In this case, the first note in the clip will be divided into one (i.e. it will be kept as is), the second one will be divided into two, and so on. When the last number is reached it will loop back to the beginning if there are still unprocessed note events left in the clip.

![Adding retriggering](./assets/Generated637069227069985789-clip.svg)

Ratchet accepts a number of other parameters to scale the resulting retriggers in various ways, including starting fast and going gradually slower towards the end of the note. This can be achieved by adding the `-shape` parameter and specifying EaseIn (the default is Linear). In addition, the resulting output can be tamed slightly by adding the `-strength` parameter and setting it to 0.5 (i.e. 50% strength):

`=a4 ratchet 1 2 3 6 1 2 5 -shape easein -strength 0.5`

![Adding retriggering with shaping](./assets/Generated637069235238519840-clip.svg)

## Support

If you're having trouble getting Mutateful to work, you can start a new discussion in the [Q&A section](https://github.com/carrierdown/mutateful/discussions/categories/q-a) here on Github. If you think you have encountered a bug or something that needs additional work to resolve, feel free to file a [new issue](https://github.com/carrierdown/mutateful/issues).

If you're looking for ways to support this project, you can support me by checking out/supporting my music on [Bandcamp](https://upland.bandcamp.com/).

## Quick command reference

Command | Parameters (default values in **bold**) | Description
--- | --- | ---
arpeggiate
arp | ‑rescale <[Number](#parameter-types): **2**>
‑removeoffset
‑by <[Clip reference](#parameter-types)> | Arpeggiates the given clip using another clip, or itself.
concat
cat | | Concatenates two or more clips together.
crop | | Crops a clip to the desired length, or within the desired region.
filter
flt | <[Musical fraction](#parameter-types): **1/64**>
‑invert | Filters out notes shorter than the length specified (default 1/64). If -invert is specified, notes longer than the specified length are removed.
interleave
il | ‑chunkchords
‑solo
‑mode NotSpecified|Event|**Time**
‑ranges 
‑repeats 
‑skip | Combines notes from two or more clips in an interleaved fashion.
legato
leg | | Removes silence between notes. Basically the same as the built-in legato function in Live, but often useful in the context of a mutateful formula as well.
loop | <[Decimal number](#parameter-types): **1**> | Lengthens the incoming clips according to the factor specified (e.g. 2 would double the clip length)
mask | ‑by <[Clip reference](#parameter-types)> | Creates a masking clip which is used to remove or shorten notes not overlapping with the mask clip. If no -by clip is specified, a sustained note is used instead, effectively inversing the clip rhythmically.
monophonize
mono | | Makes the clip monophonic by removing any overlapping notes. Lower notes have precedence over higher notes.
padding
pad
p | <[Musical fraction](#parameter-types): **2**>
‑length <[Musical fraction](#parameter-types): **-1**>
‑post | Adds silence (i.e. padding) at the start of a clip, or at the end of a clip if -post is specified. If -length is specified, padding is calculated so that the total length of the clip matches this. If length is shorter than the current clip length, the clip is cropped instead.
quantize
qnt
q |
‑amount <[Decimal number](#parameter-types): **1.0**>
‑by <[Clip reference](#parameter-types)> | Quantizes a clip by the specified amount against a regular or irregular set of divisions, or even against the timings of another clip.
ratchet
rat |
‑autoscale
‑by <[Clip reference](#parameter-types)>
‑mode Velocity|**Pitch**
‑shape **Linear**|EaseInOut|EaseIn|EaseOut
‑strength <[Decimal number](#parameter-types): **1.0**>
‑velocitytostrength | Creates retriggers/ratchets in the current clip, based on a sequence of passed in values or another clip. The ratchets produced can be scaled and shaped in various ways.
relength
relen
rl | <[Decimal number](#parameter-types): **1.0**> | Changes the length of all notes in a clip by multiplying their lengths with the specified factor.
remap
rm | ‑to <[Clip reference](#parameter-types)> | Remaps a set of pitches to another set of pitches
resize
rs | <[Decimal number](#parameter-types): **1.0**> | Resizes the current clip based on the specified factor (i.e. 0.5 halves the size of the clip, effectively doubling its tempo)
scale
constrain
scl | ‑by <[Clip reference](#parameter-types)>
‑strict | Uses a clip passed in via the -by parameter as a scale to which the current clip is made to conform. If -strict is specified, notes are made to follow both the current pitch and octave of the closest matching note.
setlength
length
len
sl | | Sets the length of all notes to the specified value(s). When more values are specified, they are cycled through.
setpitch
pitch
sp |
‑by <[Clip reference](#parameter-types)> | Sets the pitch of all notes to the specified value(s). When more values are specified, they are cycled through.
setrhythm
rhythm
sr | ‑by <[Clip reference](#parameter-types)> | Retains pitch and velocity from the current clip while changing the timing and duration to match the clip specified in the -by parameter.
shuffle
shf |
‑by <[Clip reference](#parameter-types)> | Shuffles the order of notes by a list of numbers of arbitrary length, or by another clip. When another clip is specified, the relative pitch of each note is used to determine the shuffle order.
skip | | Creates a new clip by skipping every # note from another clip. If more than one skip value is specified, they are cycled through.
slice
slc | | Slices a clip (i.e. cutting any notes) at a regular or irregular set of fractions.
take | | Creates a new clip by taking every # note from another clip. If more than one skip value is specified, they are cycled through.
transpose
tran
tp |
‑by <[Clip reference](#parameter-types)>
‑mode **Absolute**|Relative | Transposes the notes in a clip based on either a set of passed-in values, or another clip.
velocityscale
vel
vs
v | <[Musical fraction](#parameter-types)> | Scale a clips notes' velocities.

## Parameter types

Type | Description
--- | ---
Clip reference | Cells in the session view are referenced like they would be in a spreadsheet, i.e. tracks are assigned letters (A-Z) and clip rows are assigned numbers (1-N). Example: track 1 clip 1 becomes A1, track 2 clip 3 becomes B3.
Musical fraction | These are commonly used in sequencer software to denote musical fractions like quarter notes, eight notes and so on. Examples: quarter note = 1/4, eighth note = 1/8.
Number | Whole number (integer), either negative or positive
Decimal number | Decimal number, from 0.0 and upwards

## Full documentation

I've started adding more in-depth documentation in our [wiki](https://github.com/carrierdown/mutateful/wiki). There's still a long way to go, though.

Be sure to star this repo and/or follow me at [twitter.com/KnUpland](https://twitter.com/KnUpland) for updates.

## Compiling from source

### Pre-requisites

- Git
- .NET 6 SDK

### Building

Using the command line/terminal, navigate to the src folder inside the mutateful repository and run:

Windows: `dotnet publish -c Release /p:RuntimeIdentifier=win-x64 /p:PublishSingleFile=true /p:UseAppHost=true`

MacOS / OS X: `dotnet publish -c Release /p:RuntimeIdentifier=osx-x64 /p:PublishTrimmed=false`