Harnessing Screams with Tidal Looper

Since 2017, I have performed as Messica Arson, 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 that allows me to create vocal samples on the fly quickly. 

Since then, I've been working more and more with TidalCycles. TidalCycles is an open-source live coding framework for creating patterns written in Haskell. TidalCycles uses SuperCollider on the backend, another language I've been using for live coding. Recently, I started using 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. It includes the file I use to start Tidal Cycles for shows featuring the use of Tidal Looper, as well as a code from my live performance at 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 and TidalCycles 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

• Shure SM-58 with a switch - 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 of TidalCycles on the loops you record.

Installing Tidal Looper

The steps to installing Tidal Looper are as follows:

1. Download the 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:
   

~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. 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.

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.

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.

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 and have loaded into Tidal Cycles. I'll use this technique to create a loud rhythmic beat mixed in with a chorus of screams.

 

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 loopsample 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.

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.

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.

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.

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:

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 or Discord.

This blog post was made possible by a TidalCycles microgrant, with thanks to the Open Collective contributors