Harnessing Screams with Tidal Looper
Tags: haskell, tidalcycles, livecoding, music
Published: 2024-05-12 19:38:45

Since 2017, I have performed as [Messica Arson](https://messicaarson.bandcamp.com/), my live coded noise project. A defining feature of this work is the use of looping screams, which adds a potent rawness to my sound. Over the years, I've used many different technologies, from playing audio files in Audacity to a custom script entitled [scream.py](https://github.com/JessicaGarson/scream.py) that allows me to create vocal samples on the fly quickly. 

Since then, I've been working more and more with [TidalCycles](https://tidalcycles.org/). TidalCycles is an open-source live coding framework for creating patterns written in [Haskell](https://www.haskell.org/). TidalCycles uses [SuperCollider](https://supercollider.github.io/) on the backend, another language I've been using for live coding. Recently, I started using [Tidal Looper](https://github.com/thgrund/tidal-looper) for live vocal processing. This blog post will walk you through what you need to get started with vocal looping with Tidal Looper. 

The code for this blog post is available in the corresponding [GitHub repository](https://github.com/JessicaGarson/Harnessing-Screams-with-Tidal-Looper/tree/main). It includes the [file I use to start Tidal Cycles](https://github.com/JessicaGarson/Harnessing-Screams-with-Tidal-Looper/blob/main/start_looper.scd) for shows featuring the use of Tidal Looper, as well as a [code from my live performance](https://github.com/JessicaGarson/Harnessing-Screams-with-Tidal-Looper/blob/main/murder_by_modulation.tidal) at [Murder by Modulation](https://www.thetranspecos.com/cal/2023/10/20/murder-by-modulation), an event hosted by the New York Modular Society during the fall at Trans Pecos.

## What you need to get started 

First, you will need to have [SuperCollider](https://supercollider.github.io/) and [TidalCycles](https://supercollider.github.io/) installed locally. Then, to get started with vocal looping, you will need a microphone and a way to connect to your computer. 

My current setup is as follows:

- [Motu M4](https://motu.com/en-us/products/m-series/m4/)

- [Shure SM-58 with a switch](https://www.shure.com/en-US/products/microphones/sm58?variant=SM58S) - The switch is necessary because I often use feedback in my work, and having control over when I use it can make my performance more dynamic.

Before getting started you will need to make sure your audio input is set to use your audio interface or the method through which your microphone is connected to your computer.


## Why Tidal Looper

Tidal Looper allows you to sample live on the fly natively within TidalCycles. You don’t have to switch between different frameworks and programs. Tidal Looper aims to recreate the capabilities of a looping pedal, with recording, a replace mode, and an overdub mode. You also have the [full patterning capabilities](https://tidalcycles.org/docs/innards/what_is_a_pattern/) of TidalCycles on the loops you record.

## Installing Tidal Looper

The steps to installing Tidal Looper are as follows:

1. Download the [Tidal Looper](https://github.com/thgrund/tidal-looper) repository.

2. Install Tidal Looper as SuperCollider Quark by selecting where it says "Language," then selecting where it says "Quarks," and finally selecting "Install a folder."

3. In SuperCollider, create a new file called `start_looper.scd` that contains the following:

```SuperCollider
~dirt = SuperDirt.start

~looper = TidalLooper(~dirt)
```

For sets where I’m using Tidal Looper this is how I load SuperCollider before starting my set. 

Many adjust their startup script so that Tidal Looper automatically loads when they open SuperCollider. Directions on how to do this can be found in the README of [Tidal Looper](https://github.com/thgrund/tidal-looper). Since I use various live coding frameworks for different sets (sometimes multiple in the same set), this doesn't quite work for me.

## Using Tidal Looper

Now, you can start creating sounds with Tidal Looper. For this section, I’ll walk you through a track created and performed live in the fall.

I usually start in my live sets by defining the cycles per second or tempo of the sounds. I'll typically begin by setting the `cps` to 2, meaning each cycle of the rhythm or pattern you're programming will last half a second. This setting effectively determines the speed at which your musical patterns progress and loop. I often increase the `cps` to 3 during the peak of my live sets, which means that the tempo of the music or rhythm is defined so that each cycle of the loop takes one-third of a second.

```haskell
setcps 2
```

I often start my sets by screaming. The line `once $ s "looper"` plays the first scream while I’m recording it. I can use this scream throughout my performance. 

```haskell
once $ s "looper"
```

I frequently use TidalCycles to create drum beats and synth sounds that are almost danceable. However, to add a unique twist and throw the rhythm off balance, I incorporate recordings of my screams recorded on the fly with Tidal Looper. This technique introduces an unexpected element contrasting with the otherwise rhythmic and melodic flow.

`d1` defines a music pattern. This pattern plays a bass drum sample (`bd`) and then a sequence involving the samples `bubble`, `loop` repeated three times, and `control`. The `#` operator is used to apply effects: `leslie 0.3` applies a Leslie speaker effect at level 0.3, and `enhance 0.5` applies an enhancement effect at level 0.5. The sample `loop` is the scream recorded using Tidal Looper in the first line of the code. 

```haskell
d1 $ "bd drum! [bubble loop*3 control]" # leslie 0.3 # enhance 0.5
```

I’ll often like to make use of the overdub or `olooper` mode in Tidal Looper. This mode is similar to an overdub in a looping pedal where new sounds can be added on top of existing loops. I use this to create a more full sound.

`d2` uses `qtrigger 1` to quantize the start of the pattern, ensuring it starts at the beginning of a cycle. Stack layers multiple samples: `olooper` created from the overdub function of Tidal Looper, `loop` - the original scream recorded at the beginning of the set, `scream` and `gabba` repeated seven times, playing them simultaneously. The sample `scream` is a sound I've recorded using [scream.py](https://github.com/JessicaGarson/scream.py) and have [loaded into Tidal Cycles.](https://tidalcycles.org/docs/configuration/AudioSamples/audiosamples/) I'll use this technique to create a loud rhythmic beat mixed in with a chorus of screams. 

```haskell
d2 $ qtrigger 1 $ stack [s "olooper", s "loop", s "scream", s "gabba*7"]
```

I enjoy blending ambient sounds with my screams. This combination produces a harsh yet calming effect. This approach allows me to explore the dynamic interplay between tranquility and turbulence in my soundscapes. The distortion and reverb applied to this pattern allow me to add a level of physicality to my sound. 

In `d3`, I play the `seawolf` sample three times, interspersed with a variant of the `loop`sample recorded at the beginning of the set and two screams. It also includes effects: `distort 1.2` significantly distorts the sound, and `room 0.5` applies a reverb effect at level 0.5.

```haskell
d3 $ s "seawolf*3 {loop! ~ scream:2}" # distort 1.2 # room 0.5
```

In `d4`, I use Tidal Cycles patterning capabilities to create a more exciting sound. This code block utilizes the function `every 3 (fast 2)` to double the speed of the pattern every third cycle. It specifies a sequence of note indices with `n "0 1 [~ 2] 3"` and dictates the samples to be played, which include `arpy` and `scream` repeated six times. The samples `feel` and `less` are layered simultaneously. Additionally, `legato 0.3` is employed to smooth the transitions between notes, enhancing the fluidity of the sound.

```haskell
d4 $ every 3 (fast 2) $ n "0 1 [~ 2] 3" # sound "arpy scream*6 {feel less}" # legato 0.3
```

In `d5,`  I created a pattern with the sample `fire` played on repeat, a rest (`~`), and then a group with `sid` played three times and `808` played twice. The effect `squiz 0.5` compresses the sound, and `decay 0.3` shortens the sound's decay time.

```haskell
d5 $ "fire! ~ [sid*3 808*2]" # squiz 0.5 # decay 0.3
```

One of my favorite tricks in Tidal Cycles is to chop up and slice my screams. `d6` uses `chop 16` to cut the pattern into 16 pieces. It plays a variation of `scream` followed by the original scream loop recorded with Tidal Looper `loop` and another variant of `scream.` `detune 0.3` slightly detunes the samples.

```haskell
d6 $ chop 16 $ "scream:3 loop*3 scream:4" # detune 0.3
```

## What does this sound like

You can hear a jam using the code from this blog post:

{% embed https://soundcloud.com/jessica-garson/tidal-looper-jam %}

## Conclusion

By using TidalCycles alongside Tidal Looper, it becomes a canvas for sonic experimentation. While this is the setup I use for live vocal processing of my screams in some of my performances, you can use the same process to record instruments or other vocal work. Something I love about the livecoding community is its supportive nature, so if you run into any trouble, you can reach out on [Tidal Club](https://club.tidalcycles.org/) or[ Discord](https://discord.com/invite/HGEdXmRkzT).

_This blog post was made possible by a TidalCycles microgrant, with thanks to the_ [_Open Collective contributors_](https://opencollective.com/tidalcycles)