Skip to main content

Tidal CyclistEloi Isern
akaEloi el Bon Noi
LocationCentelles (Spain)
Years with Tidal4 yrs
Other LiveCoding envSonicPi, Hydra
Music available onlineYouTube, BandCamp
Code onlinehttps://github.com/eloielbonnoi
Other music/audio swAbleton Live, Audacity
CommentsClub Tidal Forum Thread
Eloi with logo

Livecoding

What do you like about livecoding in Tidal?
For me tidal cycles is a compositional tool because it allows me to make the complex music I've always dreamed of and do it very quickly, and more importantly, it allows me to perform it by myself in any circumstance. I'm particularly interested in the ability to create complex iterative structures and the flexibility it gives you to manipulate the sound. Sometimes, when I finish writing one of my endless scripts, I'll run it and spend some time listening to what Tidal comes up with. I'm fascinated by the code's ability to generate unexpected structures all the time.

What inspires you?
I am often inspired by the work of other composers and live coders. I'm always looking for sessions on YouTube of artists I'm interested in. I don't have a programming background so I often design my processes starting from those of other colleagues. In terms of genres, I spent a few years listening to a lot of 20th and 21st century contemporary music, but now I'm quite interested in the experimental electronic music scene. Lately I've been listening to a lot of glitch music that I discover on Bandcamp. I love browsing Bandcamp.

How do you approach your livecoding sessions?
I am currently presenting a series of short pieces, the "Rumble machines", which is basically a catalogue of algorithmic processes for generating sound and modeling it on the fly. It's a show designed to be listened to in good conditions, but it is not oriented to the dance floor. I'm working on the possibilities of a script that allows me to mix pieces from other artists and manipulate them with the typical Tidal Cycles processes because I want to be able to offer a rave show.

What functions and coding approaches do you like to use?
I'm super fan of the slice function. It works well with quantized loops. I use to modify the inner pattern on the fly. Starting here...

d1
$ slice 8 "0 1 2 3 4 5 6 7"
$ s "yourLoop"

...and ending somewhere close to this

d1
$ slice 8 "<0 [ 3 4]> 1!2 3*[4|8|2] [2 4 6] 5 <~ 6> <7 2>*[1|8|12]"
$ s "yourloop"

Thanks to live coders like Hiroki Matsui I've rediscovered the spread($) function. I learned a lot from his work.

do
setcps (90/60/4)
d1
$ fast 2
$ stack [
spread ($) [id, rev, (|+| accelerate "1 2"), (|+| coarse "16 32 24"), chop 16, stut 4 0.25 0.05 ] $
cat [
(sound "amencutup*8" # n (irand 32)) |+ accelerate (2),
(sound "v*4" # n (irand 6)) |+| pan "[0 1]*4",
(sound "casio*8" # n (irand 6)),
(sound "ulgab*8" # n (irand 6)) |+| pan "[0 1]*4"
]|+| unit "c" |+| speed 8 # room 0.4,
whenmod 8 3 (const silence) $
stack [
midinote (slow 2 $ (run 16) * 10 + 60)
# s "supergong"# pan (slow 7 $ range 0.8 0.2 $ sine) ,
midinote (fast 1 $ (run 16) * 10 + 60)
# s "supermandolin" # pan (slow 7 $ range 0.2 0.8 $ sine)
]]
# decay "[1 0.2]/4"
# voice "[0.5 0]/8"
# sustain (slow 7 $ range 5 0.5 $ sine)
# room (range 0.4 0.9 $ slow 17 sine) # size(range 0.3 0.6 $ slow 17 sine)

Eloi w

How do you contribute to Tidal Cycles? What have you worked on?
I try to stay connected with the activities scheduled by the TopLap Barcelona community - attending our monthly from scratch sessions, being part of the festivals we program and giving Tidal workshops whenever I can. I'm very fortunate to belong to this community and I feel very close to them. I'm recently creating a live coding community in one of the universities in Barcelona. It is still an early project, but I hope that next year many students will join us.

I take this space to make a reflection: is the global live coding community getting old? In other words, are we managing to engage young people (post teenagers in their twenties)?

Do you use Tidal with other tools / environments?
Yes, I drive every orbit to a single track in Ableton Live adding compression, EQ and some limiter to each one. I also add some mastering patch to the main output.

Music

How has your music evolved since you have been livecoding?
Without Tidal Cycles I would not be able to produce my music or at least not as quickly. I try to think of my pieces as sound sculptures. Sound that moves and mutates structured by a chaotic order. I like the contrast between minimalist, almost pointillist fragments and noisy passages. Working with other musicians has always been conflicting for me for several reasons: the commitment, my questionable leadership skills... Discovering Tidal cycles has allowed me to make all the noise I wanted without needing anyone. This autonomy has then allowed me to collaborate with other artists in a much "healthier" way. Thank you Alex!

What projects are you currently working on or planning? What's next?

  • My live coding practice is mainly focused on the creation of new material to be published at the end of the year and to be able to do many concerts in 2024. Although Tidal is a tool that saves you a lot of time, I'm quite slow in composing and very demanding on myself. The preparation of the live shows takes me a lot of time.

  • I collaborate with Eloy Fernández Porta, a very interesting writer and thinker with whom we do spoken word sessions. Curiously we are both named Eloi, an unusual name.

  • I also have a project Noi$ with White Pèrill in which we make improvised electronic music from scratch. In our shows I use the screen to tell the biography of a composer with humor interspersed with code and writing.

  • In 2024 I will collaborate with a very interesting poetess and a flamenco singer. I will keep you posted. I am very excited!

Music / recorded livecoding sessions:

Comments: Club Tidal Forum Thread

Introduction

Hello, I'm Pierre Krafft, aka Zalastax, a software engineer and hobby-musician from Gothenburg, Sweden. I've been enjoying Tidal since late 2021 after first dabbling a bit with Orca and, way before that, Sonic Pi. I primarily use Tidal to control hardware synthesizers using MIDI. Tidal is a really neat sequencer and I think there's a lot of untapped potential which I hope to explore more in the future.

This post shares my experience of replacing a significant part of the Tidal internals. What I achieved is a direct integration from Tidal with Link, which is a library for synchronizing musical time between applications.

In this post, I'll explain why Link integration was important to me, provide an introduction to Tidal internals (with a focus on scheduling), some important concepts of Link, and how I overcame some really tough challenges!

The idea

I make music with friends who use traditional synth setups. To have our synths play in sync, we connect them over MIDI. But when I started using Tidal, setting up the MIDI clock was not so convenient and I was afraid of it crashing, which would stop the show for everyone. So I started looking for a way to have a stable MIDI clock and connect it with Tidal. Soon thereafter, I learned about Link.

The purpose of Link is to "synchronize musical beat, tempo, phase [...] across multiple applications running on one or more devices." Unlike traditional MIDI clock synchronization, which relies on a single device acting as the master clock and sending timing information to all connected devices, Link uses a peer-to-peer network protocol to allow all devices to communicate with each other and agree on a common tempo and beat phase. This allows for more accurate and stable synchronization between devices, even if the tempo changes or if devices are added or removed from the network. Additionally, Link provides a way to sync devices wirelessly, eliminating the need for physical connections between devices.

My idea was to have some application listen to the MIDI clock and use Link to sync Tidal with that MIDI clock. I learned later that Link is not meant to be used that way, but the idea got me started on integrating Tidal with Link...

I get started

November 2021 is the start of my journey for adding Link support to Tidal. I started discussing the path forward with Yaxu, Tidal's inventor, in two Github Issues (1, 2). Yaxu had already done some thinking about adding Link to Tidal and he had also done some exploration that I could learn from. His positive responses motivated me and brought me confidence that this was a pursuit worth taking!

One of the main challenges of integrating Link with Tidal was that Tidal is written in Haskell, while Link is a C++ library. I knew that C++ libraries can be exposed as C libraries, and Haskell can interact with C libraries through a mechanism called the "Foreign Function Interface" (FFI), but I had never done so before. Nonetheless, I set out to create a basic Link integration in Haskell and I fairly quickly had something that compiled. In the world of Haskell, this is often a huge success which means you can pack up - work's done! But in this case, work was far from done...

Challenges

Some parts of the Link library was working, but when calling the crucial code this->link.enable(true);, GHC (the Haskell compiler / interpreter) crashed.

Debugging internal GHC crashes is tricky for most people, so I made many twists and turns to find out what might be wrong. Several long nights were spent reinstalling Haskell and battling build system configuration. The full details are documented in the issue for Link support in Tidal, but the short story is that I found out that could avoid the crash by including Link as a shared Library. This workaround was not suitable for the final release of Link support, but it let me continue the work.

After making great progress on the Link integration, I became ready to start replacing the workaround. 6 weeks into my ambitious project, I was ready to report an issue to the Haskell maintainers. I reported that my program worked when using cabal v2-run but not cabal v2-repl. Since Tidal uses GHCi (the REPL), this problem was crucial to resolve.

Several GHC maintainers pitched in, offering suggestions and trying to reproduce my issue. Unfortunately, I could reproduce the issue, but the GHC maintainers were not as successful so interest faded.

I went ahead and reproduced the issue several times, but only on Windows - not Linux, and even got a friend to reproduce it on their machine. However, this did not immediately rekindle the interest of the maintainers.

I started digging deeper to identify the root cause. First by using WinDbg, but the call stacks and multiple threads were too convoluted for me to digest. So I resorted to print-debugging, working my way through the C++ code, adding printouts everywhere. Soon thereafter, I had my eureka moment! I isolated the issue to be caused by using C++ Exceptions! Even caught exceptions caused issues for GHCi, but not for the compiled executable.

I could now provide a minimal example and, one day later, a Haskell maintainer replied with a detailed analysis, which I quote here in full:

The RTS's Runtime linker doesn't support C++ exceptions on any platform in non-dynamic way. Historically we've never needed to as not many C++ code was being used. It works on Linux because it defaults to dynamic way, which gets the system loader to handle the heavy lifting.

On Windows we don't handle .xdata and .pdata sections, so once you get an exception the OS unwinder asks us if we can handle the exception and we say no and move on and the crash occurs. You don't see GHC's panic message because the dynamic code is created outside of GHC's VEH region.

If I instead build a .dll and make my FFI calls towards that .dll, the code does not crash in GHCi

Yes for the same reason as it works on Linux, the exception will be handled by the system unwinder.

Now supporting this on Windows these days is a lot easier than it used to be. GHC Already has a native exception handling in place for itself in the VEH handlers. and we've dropped support for x86. x86_64 uses exception tables but gives us an easy way to extend the exception tables for dynamic code like JITed code.

3 months later, the issue was fully fixed and ready to be included in GHC 9.4.2. This let me finally remove the workaround, use Link directly instead of as a shared library, and integrate my work to the Tidal repository. This bug in GHC is the reason Tidal 1.9 requires GHC 9.4.2 or later on Windows.

I'm very proud of my perseverence to resolve this issue. I started my attemps late November 2021 and merged the code to Tidal early July 2022.

The integration of Link with Tidal posed several challenges but the end result was a success. In this section, we provide an overview of the architecture of the Link and Tidal integration and discuss the design choices made along the way. This information can serve as a guide for those who wish to create their own Link integration in different projects.

Tidal Innards

Let's start by exploring some Tidal Innards. For a more complete reference, please refer to What is a pattern?.

Some important concepts in Tidal innards are Arc, Part and Event:

-- | A time arc (start and end)
type Arc = (Time, Time)

-- Tidal often needs to represent a Part of an Arc.
-- It does so with two arcs, the first representing the whole of the part,
-- and the second the part itself.
-- Often both arcs will be the same,
-- which simply means that we have a whole that has a single part.
--
-- | The second arc (the part) should be equal to or fit inside the
-- first one (the whole that it's a part of).
type Part = (Arc, Arc)

-- | An event is a value that's active during a timespan
type Event a = (Part, a)

Tidal processes musical patterns by querying for all Events within an Arc. The Events returned by the query are distributed to targets such as SuperCollider. These details remained unchanged when moving to Link as the base for the scheduler.

The Link API is responsible for converting between beats/cycles on a shared timeline and a clock that corresponds to when the sound should play from the speaker. The concept is visualized in a timeline diagram below. Two Link instances are shown. The top and bottom of the diagram show how the two instances have their own beat counter. However, the beats have a shared phase - they align over bar or loop boundaries. I created the diagram below with alignment every 8 bars.

link timeline diagram

The API between Tempo.hs and Stream.hs hides how Link is called. This helps separate concerns but could also enable alternative time keeping mechanisms. It should not be too difficult to implement the API using the local system clock and memory to keep track of a local timeline. Please reach out if you would like to create such an implementation! Doing so could open the door for adding back other synchronization mechanisms again :)

The API between Tempo.hs and Stream.hs includes the following operations:

data LinkOperations = LinkOperations {
timeAtBeat :: Link.Beat -> IO Link.Micros,
timeToCycles :: Link.Micros -> IO P.Time,
getTempo :: IO Link.BPM,
setTempo :: Link.BPM -> Link.Micros -> IO (),
linkToOscTime :: Link.Micros -> O.Time,
beatToCycles :: CDouble -> CDouble,
cyclesToBeat :: CDouble -> CDouble
}

As mentioned in Troubles, Link is a C++ library and the Haskell integration is done using the "Foreign Function Interface" (FFI). Haskell has some support for integrating directly with C++, but it seemed too difficult to use for my taste.

Fortunately, while I was working on my implementation, Link released a C-wrapper of their library. Integrating with C-libraries from Haskell is fairly easy, and mostly comes down to setting up the compiler correctly and defining the C-functions in a .hsc-file.

Conversion is straight forward:

-- Haskell
data AbletonLinkImpl
data SessionStateImpl

newtype AbletonLink = AbletonLink (Ptr AbletonLinkImpl)
newtype SessionState = SessionState (Ptr SessionStateImpl)

foreign import ccall "abl_link.h abl_link_commit_app_session_state"
commitAppSessionState :: AbletonLink -> SessionState -> IO ()
// C

typedef struct abl_link
{
void *impl;
} abl_link;

typedef struct abl_link_session_state
{
void *impl;
} abl_link_session_state;

void abl_link_commit_app_session_state(
abl_link link, abl_link_session_state session_state);

Ticks and Processing Ahead

Tidal needs to process events a few hundred milliseconds early so that the event can reach the sound engine/synthesizer in time. Otherwise, the event would play late from the speaker, and we would not be synchronized with others in the same Link session. The processing ahead is configured via cProcessAhead.

The scheduler is based on "logical time" that uses a tick based system. This means that the implementation keeps track of the starting time and the length of each "tick" in order to step time forward in equal chunks. To turn the tick number into a "logical time", the following formula is used:

logicalTime startTime ticks' = startTime + ticks' * frameTimespan

Working with logical time / ticks is a common approach to avoid time drifts which I kept from the original scheduler. I'm not sure how much difference it still makes now that Link does the heavy lifting, but it felt safest to keep it.

Putting it together

With the different components explained, I can now explain the whole:

  • Tidal processes events ahead of time by querying for events within an Arc that has not happened yet (based on the tick system).
  • Processing events ahead of time is common to all Link based systems since it's the only way to not play the sound too late due to the Link API being based on when the sound should play from the speaker.
  • The translation from cycles in Tidal to a timestamp is performed by the Link API.

The picture below shows the relation between Link, the logical clock, and the current time. The current time is greater than the logical time of Tick 24, which means that we should be processing all Events that happen between the Arc (Tick 24, Tick 25). We query for all Events within this Arc and convert the start and end cycle of each Event to a clock time by using the Link API. As mentioned earlier, the events that we currently query for should all happen in the future. This is why the mapping from Logical clock to Link instance time is a diagonal arrow that goes forward in time.

logical clock

A note about multithreading

The scheduler runs in a separate thread, so Tidal is multithreaded. This follows the approach used by the previous scheduler and ensures that the GHCi REPL keeps being responsive.

The original design used several MVars to copy data between processes. MVars are a concept from concurrent Haskell. They act as synchronising variables and are used for communication between concurrent threads.

However, the design based on several MVars made the code difficult to follow and hard to verify for correctness. In the new design, we communicate between threads using a list of actions, similar to dispatching Actions to Redux in JavaScript or calling an actor in Erlang. This puts all the tricky logic that deals with the internal state in a single place. Following this approach makes the code much more easy to reason about and is why I like Erlang so much ;)

The list of actions is communicated using an MVar [TempoAction]. The definition of TempoAction is as follows:

data TempoAction =
SetCycle P.Time
| SingleTick P.ControlSignal
| SetNudge Double
| StreamReplace ID P.ControlSignal
| Transition Bool TransitionMapper ID P.ControlSignal

Each action can thus be handled in sequence, making the logic easy to reason about.

Final words

Contributing to Tidal was (and continues to be) a very fun experience! The community is very nice and supportive and I enjoy working in the codebase.

It was surprising to see that I appear to be the first person to integrate between Haskell and C++ on Windows. At least I am the first to report an error instead of giving up. I mean, the error I stumbled upon would have been found in most efforts to use C++ from Haskell because exceptions are very common in C++.

Once I could avoid the bugs in GHC, reworking the Tidal internals was quite straight forward. Even though I ripped most of the scheduler apart, the Haskell type system guided me through the refactoring. The next goal was always visible and I had direction for what next step to take.

Finally, I want to thank my girlfriend Moa for supporting me through this project and for listening to me explaining my ups and downs. The details must have been inpenetrable to understand, but she still listened and shared my joy or despair. For that, and incountable other things: Moa, I love you!

To the rest of the Tidal community, you're awesome too, and I'm happy to be a part of your world!

References

Keeping it on the rails

About Me

Hello, I am ghostchamb3r and this is my Masterclass. 👻

For lack of a better term I produce electronic dance music. I take influences from a variety of genres and as a result I use a variety of production techniques and sound design approaches. When I go to upload my music to Spotify I just tell Spotify that it's Hard Techno, because sure, why not? I'm pretty sure it's not actually hard Techno or any of the other genres from the pulldown list. I don't know what it is. What I do know is that it's danceable and it hits hard on a club room floor.

I produce in Ableton Live and I perform in Tidal Cycles.

I spent a considerable amount of time deciding on how I was going to go about performing my music. At the end of the day turntables were not for me. I love Tidal Cycles and what it lets you do with samples. I love how portable it makes performing electronic music. All of my sets are just a laptop, an audio interface, and two 1/4 inch jack outputs to the house system. It doesn't get any more complicated than that and it makes the sound techs lives easier. Getting a projector set up to share my screen is probably the only troublesome thing I encounter but a lot of times the house has a projector and it's not a huge issue. I looked into other live coding environments as well and tried Sonic Pi for a short while. Ultimately I just like Tidal better than the others and that's purely my preference.

I work with prepared code for my live sets and I do so for a number of reasons. Ultimately I'm not someone who uses live code to realize my ideas, or rather I don't use live code out of the gate as a compositional tool.

I'm comfortable with a certain set of tools (probably too comfortable) and how they support my creative process. My process starts in Ableton. I consider the slick, polished studio version of a piece and it's live code counterpart as two different entities. One exists as a fine-tuned, finessed experience intended for listening as a fixed-media representation of a musical idea. The other is a live interpretation of that with room for improvisation and deviation, so that each live performance is a unique experience. Maybe that approach riles some feathers, I can't say for sure, but it's fun for me and doesn't hurt anyone and that's all I care about.

Preparation of Code

I like to think of preparation of code more as a consideration for the audience than as something intended to help me perform. There's a lot of cool things that can happen if you just improvise freely but even if people can see my screen, ultimately what I'm experiencing is far different than the audience in an improvisational setting because ultimately I'm making decisions and the audience is not. They might experience anticipation and their response might influence my performance but in the end they don't have any sort of direct control over the music and so it's important to me to consider their experience when I perform.

For me, that means having the skeleton of a piece prepared in advance so that I have room to improvise and react to the audience's response while still being able to move from one section of a piece to another and maintain a sense of movement or progression through musical ideas to keep the audience engaged. A piece doesn't constantly need to be grabbing the listener's attention, in my opinion, but I want to maintain a flow between getting lost in the music and having it bring the listener into the present moment.

Skeleton

Here's a track I made, titled Birth Machine, in Ableton.

Birth Machine DAW track

I personally love the work of HR Giger and have since I was very young. The piece was a reflection on the Giger painting of the same name. I don't agree with some of Giger's ideas in regards to that particular piece of art, but I think it's still a really solid piece of artwork.

Birth Machine - 2 Versions

Polished studio versionwildly unhinged live coded version
Birth Machine: tr 2 of NECRONOMBirth Machine: Live at Ice House MPLS

Here's the signal chain for the main synth track:

Birth Machine signal chain
  • I have Serum piped out to LFO Tool to smooth out some of the rumbliness of the overall signal
  • Compression a'la FabFilter-C with aggressive limiting a'la FabFilter-L
  • Sidechain compression to attenuate the signal when one of the other synths come in
  • An FFT spectrum analyzer set to a K-14 meter to monitor the signal loudness see the frequency spectrum
  • Automation on the cutoff frequency of the low pass filter inside serum's FX chain.

Over the course of a few bars the cutoff opens up more and more and lets the signal through, giving it a nice smooth fade in as the track plays through it's opening lines. I've also automated some pitch bending on the mod wheel to give it a sense of organic movement in the signal that gives it a nice sense of liveness, for lack of a better term.

Serum patch - Bhad Bhabie for Birth Machine

Birth Machine Serum patch
  • The patch is tuned to a Maqam tuning using a tun file loaded into the global settings. The tun file was generated from Scala. I started getting board with 12 TET a while ago and Scala has been a really fun way for me to get excited about writing synth lines again.
  • The piece consists of 8 tracks and the sections are evenly written into 1-bar, 2-bar, or 4-bar phrases.
    • 1 drum rack
    • 5 instances of Serum
    • 1 instance of Cthulhu
    • a track for some sample files
    • a mastering chain on the Master track

Performing Birth Machine in TidalCycles

I just start by rendering samples from each section (in 1-bar, 2-bar, or 4-bar durations depending on their length) and saving them in my Dirt Samples folder each in their own sub folder within the main Dirt Samples folder.I also put a lot of consideration into the way I name my sample files. I usually include the track name or an acronym/abbreviation of it and a description of the sound.

With my brain anxiously trying to keep all the channels sorted while people are watching me, a phrase that describes the sample sound just tends to be much more useful because I will 100% forget what "BM_MainSynth" sounds like or does in the whole mix while "BMGrind" is instantly identifiable and my brain says "oh that's the thing that's making the grindy sound, okay that's the one I need to adjust right now." Or if I'm hearing something coming from a channel that needs to be turned off I can listen and think "okay there's something making a scattering sort of sound" and then I look through my channels and voila, there's "BMScatter".

Drums the "Whole-Chunk" way

If you're the kind of person who starts in the DAW and moves everything over to code afterwards, there are two approaches to performing the drum tracks.

  1. Render the drum samples individually, save them to the Dirt Samples folder and write patterns using those samples, like:

    d1 $ s "Kick [Kick, Snare] Kick [Kick, Snare]"

That can work but there can be drawbacks:

  • Velocity information from MIDI drum racks might be lost
  • Anything very slightly off the beat grid will be lost
  • Drum sections made with sequencers can be a painstaking process to recreate, depending on the specific sequencer and pattern used
  1. Whole-chunk: render the drum track as one full sample, then transform it
    This is what I did for Birth Machine. So even though the opening drum section is just a quarter kick on the first beat and nothing else - I can use splice, fast, and randslice commands to transform that into something else and seamlessly transform it back into a simple quarter kick on the first beat just by changing or erasing the opening segment of that one line of code. Or just copy and paste the change into a new line so you can easily go back to something you thought was pretty neat without the hassle of remembering it and rewriting it.
d1 $ s "BMDrums:1" # gain 1.1
d1 $ splice 8 " 1 3 4 2 8 7 7 6" $ s "BMDrums:1" # gain 1.1

You can also do really neat stuff with rhythms when you approach them the "whole-chunk" way. This section:

d1 $ s "BMDrums:2" # gain 1.1

was 2 bars of drum patterns which could have been coded as:

d1 $ s "[Kick, OpenHat:1] [Kick, Snare, OpenHat:2] [Kick, OpenHat:1] [Kick, Snare, OpenHat:2]"

or

d1 $ s "[[Kick, OpenHat:1] [Kick, Snare, OpenHat:2]]*2"

followed by

d2 $ s "[closed:1, closed:2, closed:1, closed:2]*4"

but, in my opinion, it's fun and easier to just write:

d1 $ s "BMDrums:1"

and then to radically transform by simply adding:

d1 $ splice 8 " 1 3 4 2 8 7 7 6" $ s "BMDrums:1" # gain 1.1

I also like to use additional FX onto my drum sections in Ableton. If you slap a reverb from Tidal onto your drum channel then you'll get what you'd expect, a drum section with some reverb. But if you render a sample of a drum section that already has a reverb baked into it or maybe some reverb and additional FX and then do something like:

d1 $ splice 8 " 1 3 4 2 8 7 7 6" $ s "BMDrums:1" # gain 1.1

Then you're suddenly going to get not only the drum samples themselves chopped and rearranged around but also the pre-rendered reverb, delay, or distortion you baked into the sample and sometimes it can sound really cool, depending on the pattern of the chop you programmed into Tidal.

For me the whole-chunk approach leads to some really next-level drum patterns that I've found tend to get an extremely positive response from audiences. People in general are accustomed to a kick drum hitting very regular beats. A kick drum that flies all over the place in a pattern so wild it almost feels random is something very raw that alerts people's senses and it's something I use in a lot of my tracks to build up to different sections.

With the live performance of Birth Machine you start with a very regular kick drum beat that quickly starts flying all over the place and once enough synth layers have built up everything releases and drops back to a very regular quarter kick beat. The effect is something similar to a drop or build up in EDM but it's uniquely a live coding sort of technique.

I like to do the same thing with synth lines. In Birth Machine you have a very predictable sort of synth line that, once the track enters its second A section, suddenly changes to feel more synced to the beat but in an erratic way. It's unexpected and when triggered at the right moment the audience responds to it very positively.

Birth Machine code

Birth Machine: full code I start with for performance
setcps (144/60/4)
d1 $ s "BMDrums:1" # gain 1.1
d1 $ splice 8 " 1 3 4 2 8 7 7 6" $ s "BMDrums:1" # gain 1.1

d1 $ fast 16 $ randslice 8 $ s "BMDrums:1" # gain 1.1

d2 $ fast 4 $ randslice 4 $ s " BMGrind:1" # shape 0.2 # lpf 3200 # gain 1.2
d2 $ fast 16 $ randslice 8 $ s " BMGrind:2" # shape 0.2
d2 $ splice 8 " 1 3 4 2 8 7 7 6" $ s " BMGrind:2" # shape 0.2

d2 $ slice 16 "16 15 14 13 12 1 2 3 4 15 14 13 12 5 6 7 8 11 10 9" $ s "BMGrind:1" # shape 0.4
d3 $ slow 2 $ s "BMPulse" # delay 0.4 # delayfb 0.5 # delaytime 0.4 # lpf 2400

d3 $ slow 2 $ striateBy 16 (1/8) $ jux rev $ s "BMPulse" # lpf 700 # delay 0.4 # delayfb 0.5 # delaytime 0.4

d4 $ slow 2 $ s "[BMChop:2 BMChop:2 BMChop:2 BMChop:2] [~~~~]" # delay 0.8 # delayfb 0.6 # delaytime 1.4
d4 $ slow 2 $ s "[BMChop:2 ~ ~ ~] [~~~~]" # delay 0.8 # delayfb 0.6 # delaytime 1.4
d4 $ slow 2 $ jux rev $ s "[BMChop:2 ~ ~ ~] [~~~~]" # delay 0.8 # delayfb 0.6 # delaytime 1.4

d4 $ slow 2 $ s "[[BMChop:2 BMChop:2] ~ [BMChop:2 BMChop:2] ~] [~~~~]" # delay 0.8 # delayfb 0.6 # delaytime 1.4

d5 $ striateBy 16 (1/8) $ s "BMScatter:2"
d5 $ splice 8 " 6 6 6 5 5 5 3 2" $ striateBy 16 (1/8) $ jux rev $ s "BMScatter:2"
d5 $ chew 8 "7 6 5 1 " $ striateBy 8 (1/8) $ jux rev $ s "BMScatter:2"

d5 silence

d1 $ s "BMChop:1" # gain 1.1

d3 $ slow 2 $ splice 8 " 6 8 7 5 3 3 2 1" $ s "BMPulse" # delay 0.4 # delayfb 0.5 # delaytime 0.4
do
d1 $ s "BMDrums:2" # gain 1.1
d2 $ s "BMGrind:1"
d3 silence
d4 silence
d5 silence
d6 silence

d2 $ striateBy 4 (1/4) $ s "BMGrind:2" # shape 0.6

d1 $ s "BMChop:1" # gain 1.1

d1 $ splice 8 "1 4 1 3 2 6 1 7" $ s "BMDrums:1" # gain 1.1
d2 $ splice 8 "[2*8 4 16 2 7 32 16 8]" $ jux rev $ s "BMGrind:2" # shape 0.3
d3 $ slow 2 $ slice 8 "8 8 8 ~ ~ 2 2 1" $ s "BMPulse" # delay 0.4 # delayfb 0.5 # delaytime 0.4

d3 $ slow 2 $ slice 8 "8 8 8 ~ ~ 2 2 1" $ jux rev $ s "BMPulse" # delay 0.4 # delayfb 0.5 # delaytime 0.4

d4 $ slow 2 $ s "[BMChop:2 BMChop:2 BMChop:2 BMChop:2] [~~~~]" # delay 0.8 # delayfb 0.6 # delaytime 1.4
d5 $ striateBy 16 (1/8) $ s "BMScatter:4"
d5 $ splice 16 " 3 2 16 15 14 12 11 8 7 6 5 3 1" $ striateBy 16 (1/8) $ jux rev $ s "BMScatter:4"

d6 $ s "BMGrind:1" # gain 1.1
d4 $ fast 8 $ randslice 8 $ jux rev $ s "BMChop:2" # delay 0.8 # delayfb 0.6 # delaytime 1.4
do
d1 $ s "BMDrums:2*8" # gain 1.1
d2 $ s "BMGrind:3*4"
d3 silence
d4 silence
d5 silence
d6 silence

d2 silence
d3 silence
d4 silence
d5 silence

I also like to keep an entire set in one file with comment breaks for each piece. I also keep all channels silence commands saved somewhere either at the beginning or very end of the whole document so I can always jump to the command I need if things go too far off the rails. Depending on the pieces I have planned to perform or how much improvising I plan to do I try to keep at least 10 channels ready to silence but sometimes as many as 20.

Code saving strategy

With Birth Machine I have some changes to the studio/vanilla version prepared ahead of time. I don't have the original code saved either, so whatever I forget to change back at the end of a performance remains in the code, so it sort of permanently changes and mutates with every performance. On other pieces I keep both a 1) slightly modded version and 2) a very vanilla version that is completely faithful to the studio version so that I can do entirely new and different things to it live spontaneously.

Sapphica

I did something similar with a piece commissioned by the Minnesote Opera, titled Sapphica.

YouTube PerformanceRemixed version on Bandcamp
Sapphica: Minnesota OperaSapphica Redux
Sapphica code: vanilla version of Act 2
setcps (120/60/4)

d1 $ slow 5 $ s "Sapph2intro"
do
d1 $ sound "wolfkick [BehemothSnare, BehemothKick] wolfkick [BehemothSnare, BehemothKick, BehemothClap]"
d2 $ sound "[BehemothOpen BehemothClosed BehemothOpen BehemothClosed]*4"
d3 $ sound "[~] [BehemothMini BehemothMini ~ ~] [~] [BehemothMini BehemothMini ~ ~]"
d4 $ slow 3 $ sound "Sapph2Bass1:1" # gain 1.1

do
d4 $ slow 2 $ s "Sapph2Bass1:2" # gain 1.1
d5 $ slow 3 $ s "Sapph2rythym:1"
d6 $ slow 3 $ s "Sapph2rythym:2"

do
d4 $ slow 3 $ s "Sapph2inter:1"
d5 $ slow 3 $ s "Sapph2inter:2"
d6 $ slow 3 $ s "Sapph2vocalchop:1"
d7 $ slow 3 $ s "Sapph2vocalchop:2"

d7 silence

do
d1 silence
d2 silence
d3 silence
d4 $ slow 4 $ s "Sapph2trans"
d5 $ slow 4 $ s "Sapph2out:3"
d6 silence
d7 silence
d8 silence
d9 silence

d4 silence

do
d1 $ sound "wolfkick [BehemothSnare, BehemothKick] wolfkick [BehemothSnare, BehemothKick, BehemothClap]"
d2 $ sound "[BehemothOpen BehemothClosed BehemothOpen BehemothClosed]*4"
d3 $ sound "[~] [BehemothMini BehemothMini ~ ~] [~] [BehemothMini BehemothMini ~ ~]"
d4 silence
d5 silence
d6 $ slow 4 $ s "Sapph2out:1"
d7 $ slow 4 $ s "Sapph2out:2"

d1 silence
d2 silence
d3 silence
d4 silence
d5 silence
d6 silence
d7 silence
d8 silence
hush
Sapphica code: slightly modded version
setcps (120/60/4)

d1 $ slow 5 $ s "Sapph2intro"

do
d1 $ sound "wolfkick [BehemothSnare, BehemothKick] wolfkick [BehemothSnare, BehemothKick, BehemothClap]"
d2 $ sound "[BehemothOpen BehemothClosed BehemothOpen BehemothClosed]*4"
d3 $ sound "[~] [BehemothMini BehemothMini ~ ~] [~] [BehemothMini BehemothMini ~ ~]"
d4 $ slow 3 $ sound "Sapph2Bass1:1" # gain 1.1

d4 $ slow 3 $ striateBy 16 (1/4) $ rev $ s "Sapph2Bass1:1" # gain 1.1

do
d4 $ slow 2 $ s "Sapph2Bass1:2" # gain 1.1
d5 $ slow 3 $ s "Sapph2rythym:1"
d6 $ slow 3 $ s "Sapph2rythym:2"

do
d4 $ slow 3 $ s "Sapph2inter:1"
d5 $ slow 3 $ s "Sapph2inter:2"
d6 $ slow 3 $ s "Sapph2vocalchop:1"
d7 $ slow 3 $ s "Sapph2vocalchop:2"

do
d6 $ slow 3 $ rev $ striateBy 12 (1/4) $ s "Sapph2vocalchop:1"
d7 $ slow 3 $ striateBy 12 (1/2) $ s "Sapph2vocalchop:2"

d7 $ slow 3 $ rev $ slice 12 "12 11 10 9 4 5 6 7 1 2 3 8" $ s "Sapph2vocalchop:2"
d7 silence

do
d1 silence
d2 silence
d3 silence
d4 $ slow 4 $ s "Sapph2trans"
d5 $ slow 4 $ s "Sapph2out:3"
d6 silence
d7 silence
d8 silence
d9 silence

do
d4 silence
d5 $ slow 4 $ striateBy 16 (1/4) $ s "Sapph2out:3"

do
d1 $ sound "wolfkick [BehemothSnare, BehemothKick] wolfkick [BehemothSnare, BehemothKick, BehemothClap]"
d2 $ sound "[BehemothOpen BehemothClosed BehemothOpen BehemothClosed]*4"
d3 $ sound "[~] [BehemothMini BehemothMini ~ ~] [~] [BehemothMini BehemothMini ~ ~]"
d4 silence
d5 silence
d6 $ slow 4 $ s "Sapph2out:1"
d7 $ slow 4 $ striateBy 16 (1/4) $ s "Sapph2out:2"

hush

With the code that already has some variations:

  • I have changes that I know I like and can adjust the values.
  • I can also easily transition from things that work to things that I haven't tried before.

With the completely vanilla versions:

  • I have a structure that aligns with the studio version.
  • I can change and reinterpret in a much more improvised manner.

I usually choose one version of the code to commit to and then keep that in my file for that set.

SuperCollider template

I also keep a template for all my SuperCollider code. It contains all the code I would want ready on-the-fly to save time during a performance. I comment all the lines so that I know what does what. I find it helpful to have these things ready in one file. I'd rather have the code do what I expect while performing rather than have it send back an error because I made a typo and didn't capitalize something. If an error is going to happen I want it to be because I pushed the limit of the hardware or software, but that's just me.

SuperCollider setup and customizations
//To check what audio devices you have available.
ServerOptions.devices

//To boot the server on your ASIO device. You'll want to replace the Focusrite with your own device as it's referred to in the string array shown after running the code on line 10.
s.options.inDevice_("Focusrite USB ASIO").outDevice_("Focusrite U SB ASIO"); s.boot;

//Set the sample rate
s.options.sampleRate = 44100;

//Create 20 channels for 10 stereo channels
s.options.numOutputBusChannels = 20;

//Start superdirt and specify the numer of orbits or stereo channels
~dirt.start(57120, \[0, 2, 4, 6, 8, 10, 12, 14, 16, 18\]);

//Blocksize, change depending on your hardware and latency
s.options.blockSize = 128;
s.options.hardwareBufferSize = 128;

//Start superdirt
SuperDirt.start;

// In case you need to increase the memory allocated to supercollider
s.options.memSize = 3145728;
s.options.memSize = 8192*32;

//Kills the server and cuts all audio from supercollider
Server.killAll

//If you get latency issues you can set it here
s.latency = 0.05;

//To record your session
s.record;
s.stopRecording

//Set the orbits up for Tidal

~dirt.orbits[1].set(\fadeTime, 4);
~dirt.orbits[2].set(\fadeTime, 4);
~dirt.orbits[3].set(\fadeTime, 4);
~dirt.orbits[4].set(\fadeTime, 4);
~dirt.orbits[5].set(\fadeTime, 4);
~dirt.orbits[6].set(\fadeTime, 4);
~dirt.orbits[7].set(\fadeTime, 4);
~dirt.orbits[8].set(\fadeTime, 4);
~dirt.orbits[9].set(\fadeTime, 4);
~dirt.orbits[10].set(\fadeTime, 4);

//code for Sidechain compressor taken from https://github.com/musikinformatik/SuperDirt/blob/develop/hacks/filtering-dirt-output.scd
~bus = Bus.audio(s, numChannels:2); // assuming stereo, expand if needed

~dirt.orbits[0].outBus = ~bus; // play into that bus.

// make a side chain controlled by second orbit, affecting the first
(
Ndef(\x, {
var control = InBus.ar(~dirt.orbits[1].dryBus, 2).sum;
var dirt = InBus.ar(~bus, 2);
Compander.ar(dirt, control, thresh:0.006, slopeBelow:1, slopeAbove: 0.1, clampTime:0.05, relaxTime:0.1)
//dirt * (1 - (Amplitude.kr(control) > 0.007).poll.lag(0.01));
}).play;
)

/*
cleaning up when you're done (run the code below to release the sidechain):
*/
(
Ndef(\x).clear;
~busses.do { |x| x.free };
~dirt.orbits.do { |x| x.outBus = 0 };
);

// algorave mastering, roughly according to
// https://mccormick.cx/news/entries/heuristic-for-algorave-mastering
(
~busses = ~dirt.orbits.collect { |each|
var bus = Bus.audio(~dirt.server, ~dirt.numChannels);
each.outBus = bus;
bus
}
);

(
Ndef(\x, {
var level = 1;
var distortion = 3;
var reverbFeedback = 0.1;
var all = ~busses.collect { |each| InBus.ar(each, each.numChannels) };
var mix = all.sum { |x|
var d = { 0.01.rand } ! x.size;
DelayN.ar(x, d, d)
};
var loop = LocalIn.ar(~dirt.numChannels);
5.do { loop = AllpassL.ar(loop, 0.15, { ExpRand(0.03, 0.15) } ! 2, 3) };
mix = loop * reverbFeedback + mix;
mix = LeakDC.ar(mix);
LocalOut.ar(mix);
mix = Compander.ar(mix, mix, 0.3, slopeBelow:1, slopeAbove:0.5, clampTime:0.01, relaxTime:0.01);
mix = (mix * distortion).tanh * (level / distortion.max(1));
mix
}).play;
);

/*
cleaning up when you're done:
*/
(
Ndef(\x).clear;
~busses.do { |x| x.free };
~dirt.orbits.do { |x| x.outBus = 0 };
);

Closing

I don't think my approach is right for everyone. In fact, it might only be right for me and only me. The intent of this article was just to share my coding practice and open the discussion up further. If anyone found anything useful or inspiring in any capacity I think that would be wonderful.

This article also came about after some forum thread posts I made in response to Heavy Lifting's blog post: Working with samples the Heavy Lifting way. The discussion thread from her article is really interesting and I was inspired to respond with my own approach.

I think each coder's approach is going to be unique in some capacity and they're all valid. People change too and that's especially true with musicians, producers, and composers. The approach I take now might not be the one I take seven years from now or even between one performance to the next and I think there's room to move between approaches fluidly if it sparks your creativity and brings you joy. I would hope that we are all doing this to have fun, and ultimately we should do what is fun for us.


Comments: Share your thoughts and keep the discussion going via this Club Tidal forum thread.

Tidal CyclistLina Bautista
akaLinalab
LocationBarcelona
Years with Tidal10?
Code onlineGitHub
Other music/audio swMaxMSP, VCVRack, ...
HardwareAnalog Four, Modular synths
CommentsClub Tidal Forum Thread

I’m Lina, I’m a composer and live coder, I see myself as a long-distance runner in live coding. I’m not a fast learner, but I’ve always been enthusiastic to see and to analyse other live coders' techniques, especially in live sessions (it’s not the same to see a streamed or pre-recorded session, than to feel the space and share it with the live coder), that’s probably why I’ve organised many performances, workshops, Algoraves and projects around live coding and Tidal.

Livecoding

How do you approach your livecoding sessions?

If we talk about two main approaches of a live coding session: the fully pre-composed material on the one, and a from scratch/blank screen session on the other, I’m closer to the second.

It was great to read the Heavy Lifting post about this approach, it’s great to see I’m part of the blank screeners team :). Personally, I’m not able to craft the session the way I want if I have too many lines, I’ve tried, but I get lost in the code, I’m not able to dig deep into everything that’s happening. It’s probably because I have to control every note, every sound. Besides, I think there’s a special beauty in writing a single line of code, that goes beyond the musical aspect, it can be performative, almost poetic.

(… but don’t get me wrong, I totally admire live coders who are able to prepare everything in advance).

Most of the time (when I can carry them) I use synthesizers to perform, I know Tidal is the best with samples with all the incredible functions to manipulate them, but I come from the DIY modular synth scene, so I really enjoy analogue sounds. I currently use MIDI and sometimes audio signals to control my synths.

What functions and coding approaches do you like to use?

I guess what I like most about Tidal is the pattern structures and the possibility to create and modify algorithms on-the-fly, I’m a fan of mini-notation and creating complex polyrhythms and structures with just a simple line, like:

d1 $ s "[bd(<9 5 4>,16),can:4(7, 16, 14) ]" 

haha, not really my style, but you can get the idea…

Other functions that define my sessions are arpeggios and scales, I usually make changes between the notes, number of notes, modes of arpeggios and so on.

d1 $ fast 2 $ arp "up" $ n "e'min'6" # s "superchip" # octave 2

And combining all that, I try to reach things like this during a session:

d1 $ s "bd*4"
d2 $ fast 2 $ arp "up" $ n "e'min'<6 8>" # s "superchip" # octave 2
d3 $ s "superchip(<7 5 1>,12)" # n (scale "minor" "<0 2> .. <12 7 3>"|+ 4)

I’ve found a useful way of making transitions by transforming the rhythms between binary patterns to ternary and vice versa. It creates interesting polyrhythms and with different subdivisions I have a lot of performative options.

I'd like to be able to switch to something completely different more quickly sometimes, but I guess that’s the problem of not having written anything else… Or not being able to think fast enough to create something new…

Tidal Contributions

How do you contribute to Tidal Cycles? What have you worked on?

A few years ago we created (with Iván Paz, and thanks to many enthusiastic live coders) the Toplap Barcelona node, and since 2018, maybe before, we’ve being organising workshops, concerts, festivals, projects non-stop … we’re always planning exciting things around live coding.

What motivates you to work on Tidal?

I like the active community that is always changing, creating new functions and developing things, for example I’ve been dreaming for years to implementing functions to use CV (control voltage), and it seems it’s already there, so I’ll give this a try.

Music

Tell us about your livecoding music.

My music varies from melodic ideas to noisy/ambient textures. I enjoy making multichannel experimental sessions as well as dance sessions, and everything in between. Making people dance has been a challenge for me for years, but I think I’m finally getting there.

What projects are you currently working on or planning? What's next?

I’m not sure yet, but I have been working with new material lately and spending more time on live coding than with my other practices (I also have a band), so maybe it’s time to record something new, we’ll see…

Comments: Club Tidal Forum Thread

Tidal Cyclistdigital selves
LocationLondon, UK
Years with Tidal5ish yrs
Other LiveCoding envSupercollider, p5.js, hydra, marching.js,Max (and/or) pd
Music available onlineSoundCloud, Bandcamp
Code onlineGitHub
Other music/audio swAudacity, Renoise Tracker DAW @_@
Forum ThreadAutonomous Computer Music Tidal Forum Thread
digital selves

photo credit: Antonio Roberts

Livecoding

What do you like about livecoding in Tidal? What inspires you?

I think the main thing that I like about Tidal for me is working, transforming, shaping and shifting patterns, and listening to the changes in real time. I recently co-ran a workshop with Iván Paz, Alex McLean and Dave Griffiths in Sheffield and at Hangar in Barcelona (we did it remotely at the same time- thanks to On The Fly for having us :) ). We talked a lot about patterns in the context of other traditions, like weaving. To me, it's interesting to think about computer music in this way.

I'm also super inspired by everyone else who is contributing through making music, creating forums for discussion, or working hard to make it an inclusive space. The community has always been one of the best things about TidalCyles <3

How do you approach your livecoding sessions?

I feel like I have two "modes" when it comes to live coding- testing things out and performing things. They're not mutually exclusive though, and often I will test things live on stage, or perform things to nobody else but me.

What functions and coding approaches do you like to use?

I find it hard to have more than one or two functions in my head at the same time, and tend to go through phases when perfoming live of only using the same ones because they're the ones I remember under pressure.

Some of my favourites recently are using press and fshift on drum patterns:

(All of the samples I use are available to download here)

d1
$ rarely press
$ almostAlways (jux rev)
$ stack [
s "sfe-fx/4" # n (irand 4),
gain "1*8?" # s (choose ["idmhit2", "revkit"])
#n (irand 16) # speed "[0.75 0.5]/16"
]
# fshift (range 100 300 $ slow 16 $ sine)
# gain 1.124
# speed "[1, 1.02]"
# krush 3

I also wrote a piece for the posthumanist magazine recently, as they had an issue on "rhythms", where I tried to compose some prose text embedded with TidalCycles functions, and it re-ignited my interest in the use of the sew and stitch functions, which I think is a super cool way to add sonic variation to patterns. E.g.

d1
$ sew (iter 4 "1 0")
( n "0 .. 7" # sound "cps1")
(n "0 .. 7" # sound "cpu")
# orbit 2

and

d4
$ stitch (binary "<127 63>") (sound "hjdsynth:12") (sound "hjdsynth")
# cutoff (range 200 4000 $ slow 8 $ saw)
# resonance (range 0.1 0.2 $ slow 8 $ saw)
# note (choose [5,9,0, 12, 16,17, 19])
# room 0.89 # orbit 3

Using the binary pattern notation to calculate where the two melodic sounds counteract with each other is super fun!

Do you use Tidal with other tools / environments?

Tidal is super cool as it doesn't have to be used with Supercollider and it's been fun to work on how to pattern sources other than just samples or synthesisers.

I've had a go in the recent past at using it to try and program the sounds of an artificial voice. Alex and I worked on first using it to pattern the Pink Trombone vocal synthesis - if you've not heard it, worth checking out here - and then more recently working on creating a voice model using "Neural Audio Synthesis", with a tool called RAVE which has come out of research at IRCAM, and then live programming this artificial voice from Tidal.

We don't have any public facing documentation at the moment, but hoping to be able to share something more extensive on this soon 👀

Tidal Contributions

How do you contribute to Tidal Cycles? What have you worked on?

A little while ago now, I worked on creating an autonomous agent that created its own patterns of Tidal code. This was a fun project during the summer of 2020, which I wrote up a bit about on the old TidalCycles blog here. This was part of the Summer of Haskell project, which I would encourage anyone who wants to work on the Tidal development to be a part of!

I guess the other way I have contributed is through running workshops on TidalCycles, which I've done in the past but not so many recently. It's always a nice way to get more people engaged and the install part has become much easier in recent years :)

What motivates you to work on Tidal?

Being part of a friendly community and wanting to help make new and exciting ways for humans to interact with algorithms.

Also I want to help inspire other women to be a part of the process of developing software! If there are any women out there that would be interested but don't know where to start please reach out and I'd love to help in any way I can.

Music

Tell us about your livecoding music.

I would say my music is meant to be equal measures fun and playful but also serious and emotional. I like to tow this line in the sounds that I make, making people confused if they can dance to the music or not. Been super insipered by some other artists that do the same kind of thing, e.g. Aeoi, sv1, DJH, Asia otus, 5ubaruu & saves, +777000, sleepsang.

How has your music evolved since you have been livecoding?

I've learnt a lot about creating complexity in rhythms, how to elicit surprise in listeners by introducing random variations in both structure and timbre. I've learnt a lot about collaboration too from the people I've worked with since I started live coding! And from working with my machine partner sometimes too └[∵┌]

Also I find myself trying to recreate a lot of rhythms I hear into TidalCycles structures, which is a part of my brain I can't turn off now :S

What samples or instruments do you like to work with?

I basically pick up a lot of samples here and there that I like to work with. I think Lucy's recent post about this outlines a lot of the similarity with her practice in being a sample collector.

I have been using the Serum VST for some midi sounds recently too, as it's a nice tool to work with for shaping melodic sounds.

What projects are you currently working on or planning? What's next?

I'm having a bit of an unplanned creative hiatus at the moment due to a lot of work (have to finish a PhD at some point in the near future) but I've got a few bits that I was working on before that I'm hoping at some point can turn into another release.

Add your comments in the Club Tidal thread.

Thinking about approaches to from-scratch improvised live code performance.
(As I write this it's sort of turning out to be everything I think about Tidal!)

Intro

Hi, I'm Lucy, and I'm a live coder. In this blog post I'm going to be talking about some of my strategies for using samples and approaches to from-scratch or blank-screen live coded performance.

What is 'from-scratch' anyway?

Some things to bear in mind:

  • I didn't build my software, or my computer
  • I've listened to music before
  • I practice
  • I have 'ideas'
  • Why do we even care?

I dunno where the original idea came from that live coding performances should start with a blank screen. I thought it might be from the toplap manifesto or the generative manifesto, but I looked back through both of those and don't think they're really saying that.

At any rate, when I started live coding, and in the context I was in (Sheffield, 2015) it felt like blank-screen was the only way. It excited me (and continues to excite me) but it doesn't excite everyone. I feel (maybe wrongly?) that the emphasis on fully from-scratch performances can be a barrier for some people, and when I run workshops I always try to emphasize that while I start from a blank screen, it's not compulsory. But I do feel that the Algorave/live coding approach of starting with a blank screen, and embracing error is really exciting and necessary - without this forum for experimental risky performances I wouldn't be able to do what I do.

Lately it seems the blank-screeners have decreased in number and I see more and more pre-prepared performances. I'm often the only blank-screener at a gig.

Disclaimer: I'm not a die hard - I have used pre prepared code in performances, and particularly if I'm using MIDI I have a few snippets prepped. And I have pre-prepped code in supercollider, and I've done performances where all the code was written in advance, and I've recorded performances and edited them and played them live in Ableton (shh, don't tell the live code gods).

I guess what I'm trying to say is it doesn't really matter anyway, it's just something I personally enjoy doing that I find exhilarating, and that I want other people to enjoy, while also recognising that it can be a bit scary.

I think I said this before in my newsletter - but here is an anecdote I like to remember when I'm thinking about this stuff:

I mentioned in work that I needed to practice for a gig and my colleague said "if you make it all up, why do you need to practice?"

-- which is such a great question! What I need to practice is making it up and here's how I do it.

1. Choosing samples

While I often use (usually hardware) synths in my set, what drew me to Tidal in the first place (and what forms the core of my performance) is the seemingly limitless opportunities for sample manipulation.

Of course you have your drums, synths, loops, acapellas, whatever, but what I really like is incorporating non-musical sounds into my sets. My go-to resource for this is freesound.org.

\m/ blessed be the freesound contributors \m/

I'll search for whatever I'm thinking about (bells, bats, woodwork, helicopters, notifications etc etc), have a listen and download a batch of sounds - anything that catches my interest. At this stage I don't know if they'll work or not, but that's ok.

Some other favourite sources:

  • Blood Sport sample pack
  • Legowelt
  • samples obtained from YouTube etc, legally or otherwise*
  • Plundering the sample libraries of collaborators (particularly Graham Dunning's - sorry Graham)
  • Recording sounds on your phone (or fancier equipment if you have it)
  • Plundering friends' recordings for remix material (usually a good idea to ask first)

*Side note on my ethics for sampling: if the person is extremely rich I will steal their sounds. If they are not then I don't. I don't feel bad about it. You should make your own mind up about this though.

2. Editing

I usually do a bit of sample editing in Ableton or Reaper next - trimming off silences, roughly normalising volume, checking for loop-ability. I don't spend too long on this - tbh I probably should and it would make things sound better.

3. Experimentation

This is the bulk of how I prepare. I usually update/refresh my samples every few months, but I might reach back into the archives for some oldies too. I don't use many of the standard Tidal/SuperDirt sounds (although I used to use them almost exclusively). I do a bunch of experimenting with my new sounds, combining them with old favourites and using my favourite functions to come up with some sketches that sound good to me. This is a semi-mystical process and obviously very personal, but I find this to be extremely enjoyable and almost hypnotic sometimes.

My favourite functions

Over time I've come up with my 'favourite functions' - actually these haven't really changed very much from the ones I used in my early sets, which I chose by going through the entire Tidal documentation and trying everything - you can do this too! It's a bit tedious at times, but for me it really helped me get my head round how Tidal thinks.

I pull the new samples into Tidal, and try a few of my typical function combos to see how they feel.

Short sounds

I'll use the mininotation and some simple functions to play with rhythms.

  • {} - for polyrhythms
  • speed hurry
  • chop
  • density (aka fast/slow)

Patterns

I'll start playing around with putting some patterns/sequences together.

  • iter
  • jux
  • sometimes/often/every
  • chunk

Longer sounds

I'll use the following functions to test out loops and textures.

  • loopAt
  • slice/splice
  • chop/striate
  • randslice
  • legato

Effects

I'll try some simple effects to manipulate the sounds

  • vowel/hpf/lpf
  • shape

And honestly, those functions, plus a bit of randomness/continuous functions, make up 99% of what I do in performances. You can get so much complexity with just a very little bit of Tidal syntax! Having a limit on the functions and sounds I'm using, for me, really supports from-scratch improvisation! (I actually wrote about this before on the Tidal forum).

While I'm experimenting I'm not worrying too much about what it sounds like, or the timings, but I'm more looking for a feel, and thinking about how something might work in a set (my criteria: do I like it?). Often at this stage I will discard individual samples or whole groups of samples. I might go back and edit them, or I might go hunting for similar or complementary sounds. I can spend a few hours doing this, and usually when I'm in the zone I will break into sections that would be more like what I do live (which is essentially the same as the experimentation outlined above, but with more consideration to structure and timing).

Sketches

So this way I come up with some little sketches which sort of act as the inspiration for my set. They won't be exactly what I play live (although I might refer to them if I have a panic), but they give me an idea of the approaches I might use with each sample or set of samples.

All samples referenced below available here on google drive).

Sketch 1

setcps (137/60/4)

d1
$ chunk 4 (hurry "<2 0.5>")
$ slice 8 "7 6 5 4 3 2 1 0"
$ loopAt 2
$ sound "skel:8 skel:8"
# legato 1
# gain 1.2

d2
$ chunk 4 (# gain 0)
$ jux (iter 4)
$ sound "{kick kick kick kick, 9sd*3 ~ ~, ~ ~ 9hh 9hh*2 [9hh*2 9oh]}"

d3
$ sometimes (hurry "0.5 2")
$ chunk 4 (# speed (range 1 2 sine))
$ sound "vkb*8"
# speed "0.5"
# legato 0.5
# shape 0.8

Sketch 2

d4
$ every 2 (density 2)
$ slice 8 "0 <0 1 2 3>"
$ sound "bev:1 bev:2"
# legato "0.5 1"
# gain 1.2
# shape 0.2
# speed 2

d5
$ sometimes (hurry 2)
$ chop "[1,4]"
$ sound "9rs*16?"
# shape 0.4

d6
$ every 4 (density "8 1")
$ sound "vkl"
# speed (choose [1,1,1,4,7])

d7 $ sound "kick kick(3,8)"

Sketch 3

d1
$ striate 4
$ sound "emub*8"

d2
$ sound "{emud, emud*8}"
# n (irand 8)
# legato 1
# shape 0.4

d3
$ iter 4
$ chunk 4 (# speed (range 1 2 saw))
$ sound "emustab:1(<3 5 6>,8)"
# legato 1

d4
$ sound "emupiano"
# n (irand 4)
# size 0.4
# room 0.1
# cut 1

4. Choosing a palette

From my experiments above I choose a palette of sounds. I usually try to think about sounds in the following categories:

  • Drums/percussion
  • Bass
  • Lead
  • 'Weird'/texture

5. Performing the set!

Usually I don't practice a full set before the gig, but from my experiments I will have some ideas/sections that I want to go for. I used to always write myself a crib sheet but I've mainly stopped doing that now (although I often miss it - just laziness really!). Usually they look something like the below - prompts for a feel or a texture, or the names of specific samples.

  • percussive bit
  • skel (or name of another stand-out/central sample)
  • ambient synth bit
  • dense textures
  • degrade/breakdown
  • etc

One thing I struggle with is transitions. Tidal has some functionality with this but I've never got on with it. digital selves is amazing at this <3 - I need to work on it!

Anyway, despite all this preparation, on the day I might do something totally different anyway. While I have ideas, it never sounds the same as it did in practice (particularly given the particulars of an individual PA or venue environment), and if there's a sound or a texture that pops up in the live environment that I really like then I'll follow that idea and see where it goes. I also try to pitch things in line with the other performers on the night, or where I am on the bill. If it's a chill vibe then I tend not to go in hard with like 180bpm harsh noise (and vice versa).

EMERGENCY TIP: If in doubt stick a big fat 4:4 kick under everything and it will probs sound decent :)

It doesn't always go well! But I usually enjoy myself regardless. If I have a crash or like accidentally set the BPM to like 120000 then it always feels like a very authentic live coding set and I enjoy that. It can be hard sometimes if you're the only blank-screener and everyone else's set is super polished and yours is a bit of a shit show, but I have to remind myself that's part of the fun. I find from-scratch live coding performances to be genuinely exhilarating and one of the best things in my life! (phew...)

6. De-mystifying the blank screen

What I'm trying to say with all this - (and well done if you've made it this far) - is that while the from-scratch approach might seem super cool and gonzo, there is a degree of prep that goes into it that I really feel is a process anyone can follow if they want to get into performing in this way. I actually find it super freeing to plug my laptop into the PA and just see where the sound goes, and I think given the nature of Tidal this can be a very relaxing way to play, rather than starting with strong preconceived ideas about what you want something to sound like or how you might like the structure to be. For me there are better tools than Tidal for performing in that way.

I also find this approach to be a really beautiful way to develop my relationship with my computer - it's a wonderful tool that does so much for me, but it can also be a friend and musical collaborator - I learn so much from our performances together <3.

From scratch coding can also feel safer with a human collaborator - find a friend and use Troop, Estuary or Flok to jam together. When you don't have to do everything yourself it can be easier to find the space and confidence to improvise.

Have a go from the safety of your favorite spot and try to enjoy the process!

7. Final warning

Having said all the above - this approach does require a certain FU attitude!!!! I still can't believe that people actually want not only to watch me perform and to listen to my music but actually to write and talk and teach about it, when I'm doing all this for purely selfish and personal reasons! Of course it makes me so happy when people like my stuff, but honestly I would do it even if they didn't, and that's why I think the from-scratch approach works so well for me, it's pure expression and experimentation, with a good dose of on-stage adrenaline. I'm super grateful for all the friendships and experiences live coding has given me. TY!

And if anyone is still reading. . . If you want to check out more:

Comments

  • What do you think? Does this from-scratch process resonate? Do you have different ideas?
  • Add your Comments in the Club Tidal thread.

Tidal CyclistMel Laubscher
akadjmelan3 (dee-jay-muh-lun-dree)
LocationCape Town, South Africa
Years with Tidal3 yrs
Other LiveCoding envEstuary, SuperCollider
Music available onlineYouTube - djmelan3
Other music/audio swPure Data, Logic, ProTools and similar DAWs
CommentsClub Tidal Forum Thread

Livecoding

What do you like about livecoding in Tidal? What inspires you?

I love the community around live coding and TidalCycles. What inspires me is how welcoming the community is and how simple it is to become involved. If you're new to TidalCycles there's a large community keen to help. In terms of TidalCycles itself I really enjoy the interactive aspect of the language, something that traditional DAWs lack. Live coding allows me to express myself musically much faster than a DAW can offer. I also find it easier to make creative decisions with Tidal whereas using a DAW often leads to overthinking and never actually finishing any projects.

How do you approach your livecoding sessions?

I largely participate in collaborative work, in which the group I collaborate with will brainstorm and decide upon a variety of strategies to use when we're jamming together. In both solo and collaborative work, depending on the context, I'll take an improvisational approach and randomly select audio samples, functions or write patterns I'd like to use in combination with one another. This is mainly because I'd like to discover (and be surprised by) all kinds of musical possibilities that any combination of functions, samples and patterns can create in Tidal.

What functions and coding approaches do you like to use?

My approach is mostly improvisational/experimental, but recently I've been experimenting with longer form composition attempting to create more structured patterns - i.e. placing a few stack functions within a cat function or a few cat functions within a stack function and then proceeding to expand on these.

I also enjoy using a number of functions that control the loudness (e.g #gain (range 0.35 0.85 fast 12 sine)) and spatiality (pan) of the audio I work with within confines of stereo monitoring. To do this I combine pan and gain and place the audio at different areas within the stereo field. For example:

d3 $
-- slow 2 $
fast 2 $
sometimes (slow 2) $
almostAlways (#gain 0.65) $ s "[[x*2][~ x][x@2][x]]" #s "hh27"
#delay (choose[1/12,1/4,1/8])
#pan (fast 2 $ sine)
#gain 1.15

Do you use Tidal with other tools / environments?

I've mostly used MiniTidal in Estuary when collaborating simply because it's an easy-to-access platform, especially for non-programmers such as myself. When I work on my own I do experiments with SuperCollider and Tidal in VS code. I have some experience with Pure Data as well and it was actually through creating small patches in Pure Data that I became interested in using programming languages to solve musical problems.

Music

Tell us about your livecoding music.

Since 2020 I've been a co-collaborator of SuperContinent. We've performed together at various conferences, online events and even at an online meeting. Locally, I've worked alongside students in a small university ensemble where we performed in online environments as well. As with collaborative contexts, one has to be aware of others in the group at all times. I find this to be an exciting challenge, especially when my co-collaborators come from varying musical backgrounds. Using the predetermined strategies we improvise and live code our performances from scratch. When I do my own experiments the goal is to write pre-composed code that's ready to run and which will be adjusted throughout the performance to create as much variation as possible.

How has your music evolved since you have been livecoding?

I've experimented a lot through my use of the language and observed a lot through collaboration. Alongside learning from my collaborators, I taught myself how to code with Tidal by watching what everyone else did. I now find that I'm able to use Tidal as a tool to express ideas far clearer than I ever could with any other tool.

What samples or instruments do you like to work with?

I work with all kinds of samples. I don't limit myself to use particular samples, but when I am looking for a particular overall "sound" I'll usually pick samples that will fit with what I'm going for.

What projects are you currently working on or planning? What's next?

Currently, I have a series of upcoming talks hosted by the University of Cape Town's South African College of Music. In these I'll be demonstrating the technique of live coding as it is still very much a newer approach to performing music in South Africa. I'll also be performing solo for the first time ever as part of this demonstration. Subsequent talks in this series will cover some of the work I've done during collaborations, and I hope to meet new people who might take in interest in learning how to live code themselves.

Comments: Club Tidal Forum Thread

Tidal CyclistAtsushi Tadokoro
akatado, yoppa
LocationMaebashi Japan
Years with Tidal7 yrs
Other LiveCoding envSuperCollider, SonicPi, Hydra, Kodelife
Music available onlineSoundCluod, Vimeo
Code onlineGitHub
Other music/audio swAudacity, Pure Data, Ableton Live
CommentsClub Tidal Forum Thread

photo: Phont @phont1105 (ANGRM™)

Livecoding

What do you like about livecoding in Tidal? What inspires you?

What I like about live coding with TidalCycles is that I can improvise and change the pattern flexibly per-part basis (connections, d1, d2, d3). It also combines musical and coding ideas at a high level.

How do you approach your livecoding sessions?

In my case, I pre-code a rough flow in TidalCycles according to the time I need to perform. However, I leave as much room for improvisational changes and extensions to the code, making for improvisational and varied performances.

What functions and coding approaches do you like to use?

The function I currently use most often is the combination of scale and remainder operations to generate various phrases. For example, the following code is used.

d1
$ s "supersaw*16"
# sustain "0.1"
# note (scale "minPent" "{-12..0}%5")

If the scale (minPent) used is changed to something else, the impression of the melody changes drastically. It is like improvisation in modal jazz.

Furthermore, by using the left and right channels effectively and by adding filters, you can add more depth to the performance.

d1
$ s "supersaw*16"
# pan (rand)
# sustain "0.1"
# note (scale "indian" "{-12..[0, 5]}%[5, 7]")
# lpf (range 200 10000 $ slow 8 $ sine) # resonance "0.2"

More complex rhythmic swells can be generated by using functions such as "jux" and "rev" that create changes on the time axis.

d1
$ sometimesBy 0.3 (jux (iter 16))
$ sometimesBy 0.1 (rev)
$ s "supersaw*16"
# pan (rand)
# sustain "0.1"
# note (scale "indian" "{-12..[0, 5]}%[5, 7]")
# lpf (range 200 10000 $ slow 8 $ sine) # resonance "0.2"

Do you use Tidal with other tools / environments?

I use TidalCycles in combination with other applications that generate visuals for audiovisual performance. Initially I used openFrameworks, but recently I have been using TouchDesigner.

However, it is difficult for one person to do live coding for sound and visuals at the same time. So I am currently using a method where the results of coding in TidalCycles are linked via OSC (Open Sound Control) to generate the visuals. I do the following.

First, I determine the names of the parameters to be sent from TidalCycles to TouchDesigner. For example, let's say we want to send out a numeric value of type Integer "td_s" that specifies the scene number in TouchDesigner. First, add the following statement to "BootTidal.hs"

let td_s = pI "td_s"

Next, add the following statement to the SuperCollider initialization file "startup.scd". This instruction forwards the OSC from TidalCycles to SuperCollider to yet another application, specifying an OSC argument of "\tidalplay" and a port number of "3333".

a = NetAddr.new("localhost", 3333);
OSCdef(\tidalplay, {
arg msg;
a.sendMsg(*msg);
}, '/dirt/play', n);

This OSC is parsed and used by the application generating the visuals. For example, in the case of TouchDesigner, the number can be retrieved by writing the following Python script in OSC In DAT.

from os import times
from time import time

def onReceiveOSC(dat, rowIndex, message, bytes, timeStamp, address, args, peer):
lst = message.split()
try:
td_s = lst[lst.index('"td_s"') + 1]
op('scene_no').par.value0 = td_s
except:
pass
return

This allows for live-coded audiovisual performances with synchronized sound and visuals, as shown in the video below!

youtube

For more details on the code, please refer to the Github repository below.

Tidal Contributions

How do you contribute to Tidal Cycles? What have you worked on?

My focus is on education and the popularization of live coding with TidalCycles. I give lectures at universities on the central theme of live coding. The first half of the class covers the basics of live coding with Sonic Pi, and the second half is a full-scale live coding performance using TidalCycles. This type of lecture is rarely offered in Japan and has been well received.

What motivates you to work on Tidal?

The appeal of Tidal is its ability to generate very complex and diverse music and sounds with a few simple codes. The scalability of samples and instruments is also attractive.

Music

Tell us about your livecoding music.

As I mentioned in the Livecoding section, I am interested in audio-visual expression through livecoding. In addition to that, I am interested in rhythmic expressions that sound natural but are a little bit twisted. For example, I am interested in polyrhythms, polymeters, and asymmetrical rhythms.

How has your music evolved since you have been livecoding?

Livecoding has made me more sensitive to rhythmic structure than before. I used to use a lot of simple four-beat repetitions, but I have started to create rhythms with more complexity.

What samples or instruments do you like to work with?

I use the sound samples and instruments included in SuperDirt as well as adding my own original samples and instruments. I have made them available in the following Github repository.

What projects are you currently working on or planning? What's next?

I am currently working on live coding of laser beams. I hope to show the results of my various experiments on Algorave. The current status is as shown in the video below.

youtube

https://www.youtube.com/shorts/ITRwjJPO2dY

Comments: Club Tidal Forum Thread

Tidal CyclistFelix
akafroos
LocationFrance / Germany
Years with Tidal1 yrs
Other LiveCoding envStrudel
Music available onlineYouTube
Code onlineGitHub
Other music/audio sw/hwAbleton, Trumpet, DIY Synth
CommentsClub Tidal Forum Thread

srudel wac

Livecoding

What do you like about livecoding in Tidal? What inspires you?

There are many things that inspire me.. I generally like the minimalistic, text-based approach to music making, where everything is visible at all times on one screen. When I started making music with an MPC1000, menu-diving was a key part of the process. A similar thing can be said about DAWs like Ableton (and Push), where there are many different UI layers and hidden items. Combining Tidal's simplistic interface with a terse and nestable syntax, it becomes a powerful tool full of rabbit holes to explore. Also, I like the fact that it is open source and thus hackable + the community around it is really refreshing.

How do you approach your livecoding sessions?

Being fairly new to livecoding, I don't have a goto approach, but I tend to either just start with something really simple and go with the flow, or I am exploring a specific function or idea and build on that. When I code for myself, I don't pay as much attention to the overall flow of the "performance", but rather try to find a loop that I like to listen to. I guess much of my approach is still influenced by many years of making beats with a more traditional setup. That might change though...

What functions and coding approaches do you like to use?

I am really into chord voicings and "harmony hacking". While I also like music with simpler / less / no chords, I sometimes miss the rich harmonic colors of the past. Writing (and changing) chord progressions in a DAW can be tedious, which is probably one of the reasons why they faded in general. If you don't play the piano fluently, you cannot quickly jot it down.. In a live coding setting, chord progressions and voicings can be automated and simulated, which has great potential. This is especially fun with arpeggios, for example:

"<C^7 Dbo7 Dm7 C7>"
.voicings('lefthand') // voice chords
.arp("0 3 <2 0> [1 3]".iter(4))
.add(perlin.range(0,.5))// pitch warble
.add("<0 12>/16,.1") // hippie chorus
.sometimes(add("12")) // vary octaves
.almostNever(ply("2")) // little rhythmic glitches
.note().s('sine')
.decay(.125).gain(.8)
.sustain(sine.range(0,.5).slow(32))
.jux(rev).room(.8).fast(3/4)

Open in Strudel REPL

A while back I wrote 2 posts about voicing dictionaries and voicing permutation, which now partly found their way into Strudel.

Do you use Tidal with other tools / environments?

Most of the time, I use Strudel to write Tidal patterns. Sometimes I visit my friend Lui Mafuta where I use livecode stuff via MIDI. It's also fun to add some trumpet notes on top.

Tidal Contributions

How do you contribute to Tidal Cycles? What have you worked on?

In the last year, I was all in on developing Strudel! I was exciting to see this lovely thing grow into what it is now. Maybe you're interested in the whole story and the recap after 1 year.

What led you to work on Tidal?

Long before I found Tidal, I wanted to build a hackable backing track player. I've spent many hours practising the trumpet using iReal Pro, which is a popular practise software in the jazz / pop / improvised music sphere. I always dreamed of a software that could generate such tracks from minimal input (just chord progressions) whilst being able to freely control the musical style. After having built several prototypes, I still was not satisisfied. Luckily, I found Tidal and its emerging JavaScript port, whose flexible abstractions are perfect to implement such a thing. Being more involved in computer music now (practising trumpet less :P), the dream from a hackable backing track player morphed into a more general dream of an instrument that allows improvising electronic music, which is already becoming a reality!

Music

Tell us about your livecoding music.

I am still dipping my toes in, so far I am mostly translating and recontextualize things I've done prior to livecoding. For example, I've created a video album of hip hop beats created with strudel. Apart from that, I really like making music with frequencies only, mostly using pure intervals.

How has your music evolved since you have been livecoding?

I am starting to appreciate the glitch! It will probably get worse..

What samples or instruments do you like to work with?

Samplewise, I love to sample single notes and sounds of old recordings, for example, I've used the first note of this lovely album for the pluck sound in the last link above. High quality sample banks are cool, but there is something special about single sample repitches, maybe they just trigger tiny doses of nostalgia to my inner child, which consumed wavetable synthesis while playing super nintendo for hours.

What projects are you currently working on or planning? What's next?

Still busy hacking on Strudel! I am not the type to plan too far ahead, but I am excited of what's to come

Some non-livecoded music I did as Puste using mostly the trumpet:

Thanks

Last but not least huge thanks to all the people that are part of this space! Special thanks to Alex for building not only Tidal as a software but also as a community, making the world of digital music making a little less boring, one cycle at a time :)

guy with fatty hair

Comments: Club Tidal Forum Thread |

Tidal CyclistMartin Gius
akapolymorphic_engine
LocationVienna
Years with Tidal3 yrs
Other LiveCoding envSuperCollider, Hydra, ORCA
Music available onlineBandcamp
Code onlineGitHub
Other music/audio swReaper, PureData, Audacity
CommentsClub Tidal Forum Thread

Livecoding

What do you like about livecoding in Tidal? What inspires you?

I find the way Tidal allows me to approach music in a structural way fascinating. I like it's concise but still verbose syntax, especially combined with the mini-syntax.

How do you approach your livecoding sessions?

When I make music on my own, I like to start out with simple rhythmic patterns and start to layer them with different versions of themselves (slower & lower / faster & higher / ..). Now apply the MI clouds effect and you can have fun for hours adjusting the parameters! (Note: see the clouds section in the Mi-UGens page of the User docs.)

I also like to use a traditional game controller and map the controls to conditional functions or effects in the code. For example, playing a drum pattern twice as fast when I press the 'A' button, or adjust the pan according to a joystick. I like the thought that I am programming the functionality of a game live, while I am also playing it.

What functions and coding approaches do you like to use?

Probably my most used Tidal functions are layer and while. I also use the control bus feature a lot to manipulate the FX of longer sounds. I really like how randomness in Tidal works and how easy it is no generate arbitrary, but repeating sequences or rhythms.

Here is an example of a jungle inspired, abstract dance track. To make a four cycle loop, evaluate the line

all $ timeLoop 4 . (rotL 4)

and change the number in rotL to shift the pattern. Try to play around with the parameters of the clouds effect aswell, but be careful, it might get loud! :)

let
setbpm x = setcps (x/60/4)
_add :: Time -> Pattern a -> Pattern a -> Pattern a
_add t value pat = slow (pure $ 1+t) $ timeCat [(shift,pat),(1-shift, value)]
where shift = 1 / (t + 1)
add :: Pattern Time -> Pattern a -> Pattern a -> Pattern a
add pt x y = innerJoin $ fmap (\t -> _add t x y) pt

setbpm 160

all $ timeLoop 4 . (rotL 4)

all $ id

d1
$ while "t(4,16)" (|+ krush 1)
$ while "[0 | 1]*16" (superimpose (plyWith 4 (|* speed 1.25) . slow 2))
$ layer [id
,\x -> degradeBy (segment 16 perlin)
$ slow 2
$ x
# speed 0.75
# shape 0.1
,\x -> add "[0.5 | 0.25]*4" (s "jungbass:1" # speed 0.8 # shape 0.2 # krush 2)
$ x # speed "[2 | -2]*8"
]
$ s "[drum drum:1 [~ drum] drum:1, drum:3*[[8 | 16]*4]]"
# krush 2
# cloudswet 1
# cloudsgain 1
# cloudspitch (segment 16 $ smooth "[-1 | 1 | 0]*16")
# cloudstex (segment 16 $ smooth "[0.3 | 0.1 | 0.9]*4")
# cloudspos "[0 | 1]*8"
# cloudssize 0
# cloudsfb 0.3
# cloudsspread 0
# cloudsdens 0
# cloudsrvb 0
# cloudsfreeze 0

Do you use Tidal with other tools / environments?

I like to use Tidal together with Hydra and Vimix and like to use a game controller for external hardware.

Tidal Contributions

How do you contribute to Tidal Cycles? What have you worked on?

  • I had the opportunity to work on Tidal as part of the Haskell Summer of Code 2021. There, I mainly worked on packaging Tidal to allow users to use it without an installation of the whole Haskell environment. This led to me developing a whole code editor/interpeter with some features especially designed for Tidal, like the display of which patterns are playing/muted, the current cps/bpm and the ability to control all features of the editor via OSC.

  • I'm also working on the tidal-listener which also provides a standalone intrepreter that editor plugins etc. can use as an alternative to ghci.

  • Now I am mostly working on things that are related to the mini-notation and how it is parsed and interpreted. Most notably, I found a way to make the chord notation patternable and made it easier to add new custom chord modifiers.

What motivates you to work on Tidal?

Curiosity of the inner workings of Tidal and the great community!

Music

Tell us about your livecoding music.

  • I often improvise together with people who play more traditional instruments. I find it very interesting to use microphones to get what the others are playing as an input that I can manipulate through coding.
  • I'm also interested in multi-channel sound / acousmatic music and the possibilities of live-coding in this context. I think live-coding could be a great tool to be able to precisely control an acousmonium (a speaker orchestra, where each speaker has it's seperate channel). This means to not just make the sounds that are being heard, but also to distribute them across the speakers in real-time (this is often called diffusion).

What samples or instruments do you like to work with?

Recently, I like to use very tiny grains of samples and process them with Tidal. What I like about this approach is that it is easy to manipulate and add effects to each grain individually. I also like to record my own samples with various microphones.

What projects are you currently working on or planning? What's next?

  • I would like to work on a bigger scale AV performance using Tidal, Hydra and Vimix together, to create something like a short film.
  • I'm also working on an interactive sound installation where I will probably use Tidal to generate the sound.
  • I'm working on a new acousmatic piece for a composition competition.

Other

I'm currently working on a live-coding language that will extend the mini-notation to a full programming language. It is still in early development, but maybe somebody is interested in helping me out! I'm working on it here.

youth photo with computer

Comments: Club Tidal Forum Thread

Tidal CyclistPondskater (aka Axel Ganz)
akaganz
LocationDüsseldorf, Germany and Telavi, Georgia
Years with Tidal3 yrs
Other LiveCoding envSonicPi, Hydra
Music available onlineBandcamp
Other music/audio swAudacity, Ableton Live with Granulator 2 and Wavetable
HardwareSequential Circuits Six-Trak, Faderfox PC4
pondskater with controller

(photo: Heike Kurth)

Livecoding

What do you like about livecoding in Tidal? What inspires you?

  • Although I have been making electronic music for decades, I have never been the analytical type of music producer. I have always found it difficult to create more complex rhythmic structures and work out arrangements. And although I am not a developer and have no knowledge of programming at all, I was able to get into TC very quickly and find the approach very intuitive. In particular, I now find it easy to create complete rhythmic structures. Sometimes I don't know exactly what I'm doing, but some results speak for themselves. This fascinates and motivates me, even after three years. Tidal never gets boring. Besides, I have always been interested in new approaches and new musical territory. Live coding offers a great and ever-expandable field of experimentation.

How do you approach your livecoding sessions?

  • I usually start with a new feature, or an example or snippet of a new feature. I read a lot in the Tidal Club and often find inspiration in other people's questions and examples. Since my repertoire of tracks has been growing, I've also started to put key elements of previous tracks that I particularly like back on the dissecting table of my editor and vary them again and again. Variation, variation, variation. And - after three years, I find that my code tends to get simpler - but in do blocks.

What functions and coding approaches do you like to use?

  • I am a fan of echoWith, chop, degradeBy, repeatCycles, mask. And it changes. Some days ago I was very busy with while which I now rediscover. Now I like cat combined with euclidian rhythms very much.
d1 $ slow 2 $ cat [s "tabla:04(3,8) tabla:04(5,8)"] # gain 0.9 # speed 0.25
d2 $ cat [s "kick(3,8)", "kick(2,8)", "kick(3,8)"]

I also like to work with isorhythms, especially to get a tonal dynamic into a percussion pattern.

d1 $ struct "7(7,8)" $ sound "tah" # nCountTo "list" "<7 7 7 7 7 8 9>"
# gain 0.9 # room 0.3 # size 0.5 # speed 0.5
# shape (slow 4 $ range 0.0 0.5 tri)
# pan (slow 2 $ range 0.1 0.9 saw)

Recently I started to experiment with @jwaldmann's fantastic random-not-random ideas. https://club.tidalcycles.org/t/random-not-random/4522

do
let scale = getScale (scaleTable ++ [("wavemorphian", [3,7,8,10,11])])
d1 $ s "r808(5,8)" # gain 0.9 # room 0.5 # size 0.9
d2 $ jux rev $ stack [
n ( scale "wavemorphian" $ cat $ replicate 8 $ segment "<4>" $ irand 5) # s "sxt22" # gain 0.5
,n ( scale "wavemorphian" $ cat $ replicate 8 $ segment "<4>" $ irand 5) # s "sxt31" # gain 0.5
,n ( scale "wavemorphian" $ cat $ replicate 8 $ segment "<4>" $ irand 5) # s "sxt50" # gain 0.5 # legato 1.25
,n ( scale "wavemorphian" $ cat $ replicate 8 $ segment "<2>" $ irand 5) # s "sxt31" # gain 0.6 # speed 2.0
,n ( scale "wavemorphian" $ cat $ replicate 8 $ segment "<3>" $ irand 5) # s "sxt42" # gain 0.5 # speed 2.0
,n ( scale "wavemorphian" $ cat $ replicate 8 $ segment "<1>" $ irand 5) # s "sxt60" # gain 0.7 # speed 2.0 # nudge 0.25
,n ( scale "wavemorphian" $ cat $ replicate 4 $ segment "<1>" $ irand 5) # s "sxt69" # gain 0.7 # speed 2.0 # nudge 0.675
] # room 0.5 # size 0.9

In this context, perhaps this could also be interesting: Elizabeth Margulis On Repeat: How Music Plays the Mind

Do you use Tidal with other tools / environments?

  • In the beginning, I really wanted to use Tidal to control hardware synthesizers (Six-Trak, Juno 106, etc.), based on sonic demands. In the meantime, I have largely discarded this approach. Instead, I create a sound on the Six-Trak, then sample a chromatic octave and continue working with these samples directly in TC. The many possibilities of sample chopping and editing functions within TC offer many more sonic possibilities that I don't have within the hardware. I also like to use a hardware controller to adjust parameters live in Tidal.

Tidal Contributions

How do you contribute to Tidal Cycles? What have you worked on?

  • Since I don't have a clue about Haskell, I can't directly contribute to the further development of Tidal. I can only share my experiences as a user, which I do e.g. at Toplap Düsseldorf meetups. I also try to contribute to the development of the community and the use of Tidal Cycles by planning and running livecoding events and LiveCoding beginners workshops in Düsseldorf, Germany and in Tbilisi, Georgia. Not least for this reason, I would now like to take a look at Strudel.

What motivates you to work on Tidal?

  • Basically, it's the curiosity to scratch musical boundaries and - if it goes well - to enter new musical terrain here and there.

Future perspectives

  • Yaxu’s Learning Tidal Cycles Course was my general door opener to using Tidal. Thank you so much for this wonderful introduction, @Yaxu! And since then the Tidal Club is a permanent resource of knowledge, which I receive as a great gift at any time. I hereby expressly would like to thank the entire Tidal community!

  • On the other hand, many more advanced techniques and knowledge about Haskell and Tidal have remained hidden from me until now. For example, the type signatures are still a mystery to me. I can't really use them. I could imagine that I'm not the only musician who likes to work with Tidal but has no basic knowledge of programming or Haskell and would welcome the opportunity for some kind of further self-help training.

Music

Tell us about your livecoding music.

  • It's never easy to talk about your music. I think I hang somewhere in between. Between dancefloor music on the one hand and really abstract conceptual contemporary music on the other. My music is certainly more influenced by a pop music context than an academic one. Maybe you could call it downbeat electronic, somehow influenced by industrial and IDM. I want to counterbalance this with a certain melodic touch and erratic voices.

How has your music evolved since you have been livecoding?

  • Hm, I hope that since then at least the rhythms have become a bit more interesting.

What samples or instruments do you like to work with?

  • In order not to succumb to the danger of repeating classic analogue sounds over and over again, I process the Six-Trak sounds in Robert Henke's Granulator 2 within Live. Alternatively, I now also create sounds and loops with the Ableton Live Wavetable Synthesizer.

What projects are you currently working on or planning? What's next?

  • I thought I should take the opportunity of the proximity of this years ICLC in Utrecht, so I am currently planning a small live tour of Europe for April and May. I am also helping to organize another satellite event on 05 and 06 May 2023 in Düsseldorf. After that I would like to finally try the MrReason's Tidal Looper.

Tidal Cyclistndr_brt
LocationItaly
Years with Tidal4 yrs
Other LiveCoding envHydra, Supercollider, Threnoscope, ByteBeat
Music available onlineBandcamp
Code onlineGitHub
Other music/audio swsox, ffmpeg, Ardour, Audacity

Livecoding

What do you like about livecoding in Tidal? What inspires you?

  • When I met it for the first time everything was a wow, the cycle concept, function composition, mini-notation, patternization... Nowadays I'm still able to find inspiration watching other people livecoding or reading the posts on tidal club, especially when there are custom functions listed.

How do you approach your livecoding sessions?

  • I always try to start from scratch, when I code alone I usually focus on a single function and try to get everything out of it, while I'm in front of an audience I just go with the flow.

What functions and coding approaches do you like to use?

  • I'm a huge fan of superimpose (used with the si shortand), especially mixed with hurry, in my "single sample runs" I create layers of the same sample playing at different speed/density to create rhythm and melodic patterns. For example:
let sh t f p = superimpose ((hurry t).f) p

d1
$ sh 5 id
$ sh "e" id
$ sh 3 id
$ s "sine"

this is a really simple example, and from here you can start and mixup all sort of other functions, I also love chunk, that moves things a lot:

d1
$ chunk 7 (|* speed 1.5)
$ sh 5 id
$ sh "e" id
$ sh 3 id
$ s "sine"

The fun is that, if you replace sin with, for example, a percussive sample like bd, here you have a nice drum pattern.

Then to completely unhinge the structure, chew and bite are also good friends:

d1
$ chew 4 (iter 3 "3 1 0")
$ chunk 7 (|* speed 1.5)
$ sh 5 id
$ sh "e" id
$ sh 3 id
$ s "sine"

-- or

d1
$ bite 4 (iter 5 "3 0 1")
$ chunk 7 (|* speed 1.5)
$ sh 5 id
$ sh "e" id
$ sh 3 id
$ s "sine"

I often try to escape from this mindset but at the end I fall into it most of the times.

Do you use Tidal with other tools / environments?

  • I tried it to control some drum machines circuit bent by me but at the end I find the hardware overcomplicated and I prefer to play soft-synths, especially Supercollider: everything in a box and controllable with the keyboard.
  • I used Tidal also to draw stuff with p5 during some sessions.

Tidal Contributions

How do you contribute to Tidal Cycles? What have you worked on?

  • I learned Haskell only to contribute to Tidal. I'm passionate about reading code and get the insights of the software, on the main codebase I solved some bugs and added some features mainly in the mini-notation section (tidal commits).
  • I took care of the migration from Travis CI to GitHub Actions.
  • Atom -> Pulsar: At a certain point I noticed that the Atom Plugin was practically unmaintained so I proposed to be its maintainer, and I brought it back on track. Now Atom has been disbanded but luckily the Pulsar community is vibrant and the Tidal plugin is already fully compatible with it. It was a pretty satisfying migration (Pulsar-tidalcycles).

What motivates you to work on Tidal?

  • Not to be selfish but most of the work I did had direct impact on the use I'm doing of Tidal, I guess because it's easy to contribute when you know why something needs to be improved/fixed.

Music

Tell us about your livecoding music.

  • Well, most of the time it is noisy, sometimes mellow, always not danceable.

How has your music evolved since you have been livecoding?

  • For sure it changed, I'm not sure it "evolved", sometimes I think I was more creative when I was learning how to use the instrument, now it's easier to get into the loop of being repetitive.

What samples or instruments do you like to work with?

  • I try not to use the default samples nor the default synths, I sometimes write my own synths, sometimes I record my own samples or I get them from various sources.

What projects are you currently working on or planning? What's next?

  • I recently finished a record that was a collaboration with Naotodate, that's a non-livecoding noise friend from Italy (on bandcamp).
  • Now I'm working to another collaboration record, this time with ETOL, an amazing italian livecoder. To be fair the project it is still in an embryonic state.

Other

  • I'm a software engineer by day and a punk "musician" by night, I played and still play guitar/drums/bass in various bands
  • I'm also part of Toplap Italia, I organize livecoding shows sometimes
  • I've been a Linux user for like 20 years
  • I like diy electronics, circuit bending and fixing broken stuff found in the trash
  • Either I talk too much or I don't talk at all

Tidal CyclistRaphaël Maurice Forment
akaBuboBubo
LocationLyon/Paris, France
Years with Tidal4 yrs
Other LiveCoding envSuperCollider, ORCA, FoxDot
Music available onlineBandcamp
Code onlineGitHub
Other music/audio swSuperCollider, MaxMSP, SunVox, VCVRack

Livecoding

What do you like about livecoding in Tidal? What inspires you?

TidalCycles taught me a lot about music and improvisation. I used not to care too much about rhythm and structures when improvising. The emphasis that Tidal is putting on rhythm can actually be beneficial. It pushes you to explore some aspects of music you might be neglecting: complex time signatures, intriguing rhythms, etc... I also like the fact that it feels like a "metaphoric" language to talk about music that ends up taking shape while typing on the keyboard. Making music with Tidal, you quickly start to put a name on specific patterning concepts.

Tidal is also super fun: I usually have a great time when improvising during a jam session using it, especially when it blends with other non algorithmihc instruments :)

How do you approach your livecoding sessions?

I like to setup a system that I find interesting or playful. I spend quite some time organising my instruments, effects, mixing desk, controllers, etc... Whenever I find a system that I find interesting to play with, I'm generally not preparing much more. I know that music will just flow if I really start improvising and exploring the system. I just start tinkering to discover what I have on my hands. Preparing such systems takes most of my time before gigs. I think that I've never played twice with the same exact setup!

I really like jamming with friends as well without preparing much, using my own collection of audio samples. When coding alone, you almost mechanically end up doing too much for your own sake. Friends will not allow such things to happen. You must listen and adapt! Nowadays, synchronizing Tidal with pretty much anything has also became much more simpler than it used to be. One more reason to do it!

One other thing is that.. I usually don't record my stuff! I play live, and then boom, I'm gone. Live coding is great because it's ephemeral. Once you stop coding, you should start again to get the same result.. except it's never the same.

What functions and coding approaches do you like to use?

I'm not very good at learning the standard library, which is why I ended up writing documentation to actually discover more of it! I have some techniques I always like to play with:

  • playing with a large collection of samples, without ordering or sorting them beforehand. Iterating through a directory, finding iterations that sound good.
  • writing structures: using cat, ur, stack, etc...
  • Nesting groupings ([]) and using <> a lot to get the most out of patterns that are short to write.
  • using superimpose and sometimes too much, to the point where your pattern ends up being a totally different thing compared to what you started with.
  • soloing by just writing a one-note pattern that I edit really fast.

Some people use extensive collections of custom functions. I never could quite grasp Haskell, so I ended up maximising what I truly understood in the language!

Do you use Tidal with other tools / environments?

All the time. I usually separate my orbits (stereo tracks) to a DAW or to another software for post-processing. I end up adding some controls to Tidal to control send/returns and effects without leaving the keyboard. Tidal is now also one of my favorite way to interact with any piece of gear that I can lay my hands on.

Tidal Contributions

How do you contribute to Tidal Cycles? What have you worked on?

I used to contribute a lot to the documentation ~1 year ago. When I first started playing with Tidal, all the good stuff was documented in the old wiki website. My first "invisible" contribution was to write some amount of french translation that wasn't easily accessible because the system had its quirks. When the new website suddenly appeared, I ported most of the old website to the new website, reorganising pretty much everything to my liking :)

I was very cautious, trying to make information easy to discover, specifically because I spent so much time digging in the past! This effort has now turned into a very healthy collective effort and the Tidal documentation is something to proud of for everyone who contributed to it!

What motivates you to work on Tidal?

Nowadays, I don't contribute that often by writing/coding stuff so I can't say that I'm motivated to make the system any better! However, I really love to teach Tidal whenever I can. I had the opportunity to teach it in a graduate class at my current university. I also teach Tidal to whoever is interested and sometimes during formal/informal workshops, etc...

Music

Tell us about your livecoding music.

I love it when the music I play serves as an outlet and a release. I don't really play the music I enjoy listening which is something that I always found intriguing... I've learned to somehow accept it. I usually listen to folk / rock music with a fair amount of jazz but what I love playing the most with Tidal is hard/fast rhythmic music! Meaning a deluge of drums, saturation and distortion, mangled samples, etc... I also think that Tidal forces you to go in that direction but it's a topic for another day!

How has your music evolved since you have been livecoding?

It changed a LOT about the way I approach music-making. Before I started learning Tidal, I had a mild interest in computers and synthesizers. Nowadays, I'm living in a room full of audio cables / computers. Tidal was very influencial in the way I think about music, but that's also because I've read a lot of the things Alex wrote about livecoding / Tidal. The most important thing that Tidal has taught me is that algorithmic music can actually be simple. Its simplicity is what allows you to go deep, by combining simple ideas and processes and ending up with fascinating results.

I also don't play much piano anymore, and it forced me to pick up my guitar again... just to stretch my fingers after typing so much on a keyboard!

What samples or instruments do you like to work with?

  • I like "joke" samples. I ended up soloing with the sound of my oven cooking a pizza a few months ago. crow, without doubt, is the best audio sample in the default library. By trying hard enough, you can make them sound like the best thing you've ever heard, or fail!
  • Nowadays, I'm specifically looking for instruments with few parameters to tweak. Few parameters means that you are more likely to remember all of them when writing a pattern!
  • I feel like I'm repeating myself but: large collections of unsorted samples!

Sometimes, I also try to play with having the minimum amount of control on the Tidal side and relying more on real instrumentst that I can tweak with my hands: modular synthesizers (sending CV and GATE only), drum machines, etc... It feels more natural to launch a pattern and to tweak its output afterhands.

What projects are you currently working on or planning? What's next?

I'm working on my PhD manuscript... which is about live coding! I've been studying live coding languages and techniques for quite some time now and I'm trying to write about this delicate topic by giving it justice! It's an incredibly dense topic and I feel inclined not to give up on any detail that I find fascinating about this art practice. To be more specific, my angle is to think about how live coding languages are inspired by certain aesthetical/political/technical ideas or concepts and how the implementation of these are giving rise to a new range of ideas inspired by the result we're now experiencing :)

I've also been working for quite some time on my own live coding environment named Sardine. It started out as an experiment to reimplement some of the things I saw during my study; trying to understand them by doing! Then.. it started to mutate into its own thing! I'm still actively working on it and I use it for my own performances nowadays. I have a group of friends and contributors that have been helping me to make it, and they also added their own ideas to it. I love to craft things where you put so much energy and craft! Alex was right saying that patterns are a valuable area of study! I see patterns all the time, and sometimes cross the path with some ideas already explored by Tidal! Sardine is also quite inspired by Tidal, it can even piggy-back on SuperDirt!

My current plan is to end all of this! Being done with both developing Sardine -- at least most of what I would like it to be -- and writing my manuscript!

... If I have one thing to confess ...

My wildest dream would be to actually play bossa nova with grace using a live coding language. I don't think that I'll ever succeed but dreams are never big enough! I feel that live coding performances are missing some of that expressivity that "real" musicians have!

Other

Big shout out to my friends from the Cookie Collective and from the Digital Audio Community in Lyon! They are also part of why I find live coding so interesting nowadays. It's a treat to make music / chat / collaborate with them. The french scene is more alive than ever but I feel that not much is said about it. Hope to meet with other live coders from all accross the world in the coming years!

Thanks to the Tidal community and to the wider TOPLAP / live coding community as well!

Tidal CyclistJ Simon van der Walt
akatedthetrumpet
Time with Tidal3 yrs
Other LiveCoding envSuperCollider, Hydra, Strudel, Punctual
Music available onlineBandcamp, SoundCloud, YouTube
Other music/audio swAudacity, MuseScore, Logic
ttt birding

Livecoding

What do you like about livecoding in Tidal?

  • I have no background in computer science, but I find the syntax suprisingly intuitive. Also, by comparison with SuperCollider, you can get a lot of music going with very little typing.

How do you approach your livecoding sessions?

  • Two main approaches, I guess. Usually it's just quick improvisations on the spur of the moment, often ending up with nothing more than a one minute long sketch. I'm not particularly trying to create anything specific, and I just stop when I have something that sounds interesting.
  • The other approach is when I have an idea for a particular sound or gesture or structure that I want to create. This is usually less succesful: I've got a lot of abandoned projects where I tried and failed over a period of days or weeks to achieve some aim or other.

What functions and coding approaches do you like to use?

  • My favourite technique is one that some people frown on: making random but fixed patterns that repeat themselves. So, for instance, rather than explicitly creating a pattern in the mini notation, I usually start with something like d1 $ n (loopFirst $ shuffle 8 $ run 8) # s "peri". (Which is actually one place where SuperCollider wins in conciseness, it's basically Pshuf).

Music

Tell us about your livecoding music. What musical genre(s) or style(s) describe it best?

  • Three main approaches: er… gamelan, algorave, and abstract? I should say 'gamelan': in other words music that may use gamelan samples and ideas from Javanese or Balinese music without really being gamelan music. I have no proper skills, knowledge or understanding when it comes to dance music, but it's always fun to try to improvise an algorave banger live. 'Abstract' might be when I use something like slowstripe to defeat any sense of pulse and start pitching samples down a couple of octaves.

How has your music evolved since you have been livecoding?

  • I could say that livecoding saved my musical creativity after I finished my PhD! I got kind of burned out after spending seven years creating a conventional portfolio of 'compositions'. With code I was able to just make stuff for myself without having to score it or get other people to play it or justify it to anyone.

What samples or instruments do you like to work with?

  • My own samples. For me, creating and using my own sets of sounds is kind of fundamental to the creative process. For the purposes of a quick rave-up I'll happily turn to the standard Tidal set, but for me to really feel ownership of a piece I need to use samples and synths that I have a personal stake in.

What projects are you currently working on / planning? What's next?

  • I need to find a way to release my actual first album. I finished it several years ago, but the label who were going to release it stopped functioning, so… I don't feel like I want to release it myself but I haven't found anyone else who is interested. Yet.

Tidal Contributions

How do you contribute to Tidal Cycles? What have you worked on?

  • I'm a musician not a developer, so I'm not really able to 'contribute' in the sense of code! However, I have made some gamelan sample banks available, asked (hopefully useful) questions on forums, taught Tidal at my institution, and initiated the Floating Gold project that used MiniTidal in Estuary.

Other

youth photo with vintage synth

Tidal CyclistBernard Gray
akacleary
Time with Tidal3 yrs
Contributor since2017
Other LiveCoding envEstuary, Punctual, Hydra, ORCA
Music available onlineSoundCloud
Code onlineGitHub
Other music/audio swUbuntu Studio/Ardour/Carla/Vital/mi-ugens

Tidal Contributions

How do you contribute to Tidal Cycles? What have you worked on?

I think I've had a go at just about everything:

  • I developed and maintain a Linux installer in Ansible
  • I've added a few simple patches to/nutted out ideas for tidal itself, particularly around the chords module
  • I've written documentation
  • I often play in, and have helped organise some of the Solstice Marathon Livestreams
  • I am active and support others on the forums and the discord support channels
  • For the last 2 years I've been hosting a weekly collaborative (mostly tidal) livecoding session called WeekendJam for anyone to come along and have a jam with me
  • I've written and run tidal-based workshops, online and in person to try and network/raise the profile of the livecoding scene in Australia

What motivates you to be a Tidal contributor?

  • The community is lovely, they give/have given me a lot and I like to return that where I can. The project allows for such vast and varied possibilities in learning and creation, and that's what keeps me interested. The focus on inclusivity, sharing and generally "anti-gatekeeping" is a huge drawcard for me too.
  • I particularly enjoy the WeekendJams - I get to meet new people, share inspirations with all the different ideas all mashed together, learn, and just generally have a great time. I've made some great friends through jams.

Livecoding

(photo: Jason Richardson)

What do you like about livecoding in Tidal?

  • It's concise, it's (fairly) self-explanatory, and it's very easy to be both creatively specific and random as required.

How do you approach your livecoding sessions?

  • For solo performances, I prepare something - usually a "scaffolded" set of code which allows for creative path choosing during the set.
  • For the WeekendJam sessions, I never prepare anything beyond the occasional group idea for exploration (which is broached 5 mins before start time).

What functions and coding approaches do you like to use?

  • I tend to make a point to separate my rhythmic and harmonic elements for easy reuse (struct and n/note) - which is a hangover from the collaborative nature of the WeekendJam sessions. I keep the code for most sets I play on Github. An example of this is from one of my patternuary pieces (full code, video):
  $ struct "t(6,8,<0 1>)"
$ n "<a3!2 f4!2 e3!2>"
# s "braids"

Doing it in this way makes it very easy to take the rhythmic structure and apply it for percussion (for example), or take the notes and use them as a foundation for a chord arpeggio sequence in another orbit. If you are collaborating, it's very easy and obvious for others to borrow and build off too.

Do you use Tidal with other tools / environments?

  • I've done some external software synth control (Vital/Yoshimi), I also have a Midi Fighter Twister controller which sometimes gets a run. I tend to keep it pretty vanilla though, particularly since doing the workshop tours last year. Also, estuary of course.

Music

Tell us about your livecoding music. What musical genre(s) or style(s) describe it best?

How has your music evolved since you have been livecoding?

  • Yeah, a lot - I played "traditional" instruments before I started. The biggest evolution has involved trying to break out of all the subconscious composer lockin that comes with that (fixed tempos, chords limited by number of fingers/how far they can stretch, increasing the number of simultaneous voices). It's moved from what I could do on a guitar/bass/piano with 10 fingers and a looper to beyond orchestral possibilities (and exposed my lack of compositional knowledge in that area!).

What samples or instruments do you like to work with?

What projects are you currently working on / planning? What's next?

  • I'd like to develop the livecode.au domain into a tool for organisation/promotion of Australian livecoding events/personalities, that one is going to take more time than I currently have available, so it's on the backburner for now (unless anyone wants to give me hand!)
  • To try and claw back a little time, I'm looking at sharing the WeekendJam load a little, and hopefully moving it into a general stream/yt account so that multiple organisers can have control depending on availability.
  • I'd also like to finish and release some music, just to learn a bit more about the whole process chain - that's a hope item for this year :)

Other

Just a big thank you for all the people I've chatted to/jammed with/learned from over the years, you've all been a huge inspiration, and I'm very glad to have been able to share my livecoding journey with you.

(photo: Jason Richardson)

Purpose

The Tidal Cycles blog is intended to be by -- for -- about the Tidal community. Anyone engaged with Tidal Cycles is encouraged to submit a blog post. Topics can be about Tidal practices, music made with Tidal, live coding, event coverage, new developments & releases, community, etc. Topics can also be broader -- anything that would be of interest to this community, and it doesn't have to be limited to just about Tidal!

Templates

To make participation and submitting posts easier, there are a set if templates. These produce a set of patterned blog posts. Each template includes a suggested set of content sections, but consider this just a starting point. The most important thing is to provide content that reflects your unique perspective.

Templates are maintained in GitHub in the tidalcycles/tidal-doc repo / templates branch.

  • Tidal Blog Profile Intended to highlight your livecoding practices, music, and use of tidal. Contains a set of questions to respond to.
  • Tidal music Use this to describe a music project such as a new album or music release, a review of a music project, Algorave or concert, or discussion of music made with Tidal or other live coding program.
  • Event coverage (planned)
  • Blog Topic Open topic - use this for a more free-form approach. One option is to present your own approach to Tidal and live coding (see Working with Samples the Heavy Lifting way). Other topics could be discussion of a new release and the coding behind it, or discussion of other environments like Strudel, Vortex, Sardine, etc.

We encourage posts to include:

  • code sections with Tidal examples
  • links into the Tidal user documentation
  • links to recordings, YouTube, Bandcamp, SoundCloud, etc.

Submission Instructions

Detailed posting instructions are included in the template files. Options:

  • Submit via GitHub pull request
  • Work with a blog editor and send your content via Discord DM or email.

Do what works for you!

Markdown

Submitting you content in markdown format is preferred, but it is not required. If you aren't familiar with markdown, no problem. Write your content and we'll take care of the rest.

Docusaurus, MDX and markdown enhancements

The Tidal blog is rendered in Docusaurus which uses MDX as the parsing engine. It supports more layout features including React components. To see the full list of options, check out the Docusaurus Markdown Features page. Here are some examples. There are many more!

Admonitions - triple colon syntax

tip

This is a tip and is called by the triple colon syntax :::tip. You can also customize admonitions.

caution

When using admonitions - be sure to add empty lines before and after your text lines.

Details element

Toggle to see more
This is the detail revealed. This is useful for a long code block, allowing users flexibility in how they read through your post.

Toggle for code block
``` h1 $ s "sound" h2 h3 ```

Toggle for code block - (no div)
``` h1 $ s "sound" h2 h3 ```

Raphaël Forment

I've started working on a major overhaul / reorganization of the old Tidal Userbase website. I think that this new documentation is now pretty much on par with the old one. I hope that you will like it.