summerschool.tidal

-- wifi:
-- tidalclub
-- firstrule
-- https://github.com/supercollider/sc3-plugins


https://github.com/Qirky/Troop

{-
11th August
5pm-7pm – optional session covering basics of installation and sequencing

12th August
10am-5pm – repetition, symmetry, interference and glitch, ensemble play
from 5pm – potential excursion to the peak district for battery-powered group improv

13th August
9:30am-5pm –
  recap /
  - slowcat,
  - fastcat
  - randcat
  - choose / rand / sine / saw
  - # |=| |+| |*| |/|
  - weave
  - whenmod
  - hurry / making your own abstraction
  - flexible time / escaping the grid / nudge
  - accelerate

  osc / processing,
  customisation,
  multichannel,
  midi control (external synths),
  dmx control (lights),
  visualisation,
  troop

from 5pm – pub?
-}

# - |=|
|+| |*| |/|

-- Installation

https://tidalcycles.org/getting_started.html

-- Sequencing

d1 $ sound "bd sd cp sd"

https://slab.org/tidalcycles-summer-school/

-- Silencing

d1 $ silence

hush

-- The longer the sequence, the faster it runs

d1 $ sound "bd(7,16)"

d1 $ sound "bd ~ ~ bd ~ bd ~ ~"

d1 $ sound "bd*3 bd bd*8 bd"

d1 $ sound "bd bd? sd*2 bd(3,8)"

d1 $ sound "bd*16?"

(2,5) : A thirteenth century Persian rhythm called Khafif-e-ramal.
(3,4) : The archetypal pattern of the Cumbia from Colombia, as well as a Calypso rhythm from Trinidad.
(3,5,2) : Another thirteenth century Persian rhythm by the name of Khafif-e-ramal, as well as a Rumanian folk-dance rhythm.
(3,7) : A Ruchenitza rhythm used in a Bulgarian folk-dance.
(3,8) : The Cuban tresillo pattern.
(4,7) : Another Ruchenitza Bulgarian folk-dance rhythm.
(4,9) : The Aksak rhythm of Turkey.
(4,11) : The metric pattern used by Frank Zappa in his piece titled Outside Now.
(5,6) : Yields the York-Samai pattern, a popular Arab rhythm.
(5,7) : The Nawakhat pattern, another popular Arab rhythm.
(5,8) : The Cuban cinquillo pattern.
(5,9) : A popular Arab rhythm called Agsag-Samai.
(5,11) : The metric pattern used by Moussorgsky in Pictures at an Exhibition.
(5,12) : The Venda clapping pattern of a South African children’s song.
(5,16) : The Bossa-Nova rhythm necklace of Brazil.
(7,8) : A typical rhythm played on the Bendir (frame drum).
(7,12) : A common West African bell pattern.
(7,16,14) : A Samba rhythm necklace from Brazil.
(9,16) : A rhythm necklace used in the Central African Republic.
(11,24,14) : A rhythm necklace of the Aka Pygmies of Central Africa.
(13,24,5) : Another rhythm necklace of the Aka Pygmies of the upper Sangha.


-- Add gaps

d1 $ sound "bd ~ hh bd sd ~ hh bd"

-- Pick from a sampleset

d1 $ sound "arpy arpy:4 arpy:5"

-- Where do these sounds come from?

-- In the menus in SuperCollider (not atom):
-- - File > Open user support directory > downloaded-quarks > Dirt-Samples

-- How do I add more sounds? Here's some..
http://slab.org/tmp/extra-samples.zip

-- Change the superdirt startup, instructions here:
https://github.com/musikinformatik/SuperDirt

-- Composing effects

d1 $ sound "bd sd cp sd"
   # vowel "a e"

-- All the effects:
https://tidalcycles.org/functions.html#synth_parameters

-- Types

:t slow
:t fast
:t sound

sound :: Pattern String -> ParamPattern

d1 $ fast 4 (sound (fast 2 "bd(3,8)") # vowel "a e")

(1 + 3) * 2
1 + (3 * 2)
-- fast takes a number and a pattern
-- sound takes a single pattern of words

d1 $ fast "1 2 3" $ sound "cp"

d2 $ sound "jv:50 jv:50 jv:50 jv:50"
  # lpf "1000 3000 400"
  # lpq 0.2

d1 $ vowel "a [e e i o] i*4 u*2" # sound "bd"
  # lpf 1000

d2 (n "50 55 43 ~" # sound "jx")

d1 $ (n $ "3 5 2 1" + "10 20 30") # sound "jv"

d1 $ n ("40 50 60 30" + "<0 7>") # sound "jv"
h
d1 $ n ("40 50 60 30" + "<10 20>") # sound "jv"

d1 $ every 4 (shuffle 4) $ loopAt 2 $ chop 32 $ sound "arc" # gain 1.1

d1 $ every 4 (rev) $ sound "arpy ~ arpy:2"

d1 $ every 3 (# speed 2) $ every 4 (# vowel "a") $ sound "arpy arpy:5 arpy:2 arpy:4"

d1 $ iter 4 (loopAt 2 $ chop 16 $ sound "arc")

d1 $ iter 4 $ sound "bd sd*2 cp ~"

-- phasing


d1 $ sound "cp ! ! ~ cp ! ~ cp ~ cp ! ~"

d2 $ (2/12) ~> (sound "cp ! ! ~ cp ! ~ cp ~ cp ! ~")

d3 $ do x <- slow (pure $ 12 * 12) $ run  12
        jux ((pure $ x/12) <~) $ sound "cp ! ! ~ cp ! ~ cp ~ cp ! ~"

d3 $ sound "[bd arpy]*3 sd"

d3 $ sound "[bd arpy]!3 sd"

v1 $ fast 4 $ iter 4 "red blue green orange"

d1 $ slow 2 $ (chop 128 $ sound "bd cp*4 sd arpy")
  # nudge (slow 4 sine)

hush

d1 $ loopAt 8 $ sound "bev"




d1 $ sound "jv:40 jv:50"

"3 5 2 1" :: Pattern Int

d3 $ sound "superpiano"
   # freq 2000

-- frequency

d1 $

:t lpq

d2 $ sound "{jx:50 jx:40 jx:42 jx:53, bd sd bd}%2"

d1 $ slow "  2 3" (sound "bd cp")

d1 $ sound "[bd cp sd cp] [arpy [arpy:2 bd [bd bd] bd] arpy:4]"

d1 $ sound "<arpy arpy:3 arpy:2> bd bd bd"


-- gives:

slow :: Pattern Time -> Pattern a -> Pattern a

-- Slow takes a pattern of time, a pattern (of something) and results in a pattern (of that something)

d1 $ slow 2 (sound "arpy arpy:2")

-- We have to wrap that last pattern in brackets so that it gets passed as the second parameter of `slow`.

-- Instead we can do this:

d1 $ slow 2 $ sound "arpy arpy:2"

-- The $ means 'pass everything on the right, to the function on the
-- left'. It saves having to remember to put the closing bracket in.
-- `d1` is a function as well, which takes exactly one pattern, which
-- it sends to the synthesiser. We could do this instead:

d1 (slow 2 (sound "arpy arpy:2"))

-- .. but we'd quickly end up with a lot of closing brackets to keep
-- track of.

-- Earlier we noticed that the first parameter was a *pattern* of
-- time. This means we can pattern it:

d1 $ slow "2 4" $ sound "arpy arpy:2"

-- There are a lot of patterns in the above! Lets look at the bits.

-- This is a pattern of words (also known as 'strings'):
"arpy arpy:2"

-- This is a pattern of names of sounds:
sound "arpy arpy:2"

-- This is a pattern of whole numbers (also known as 'integers'):
"2 4"

-- This isn't actually a pattern, but a function that takes a pattern as input, and returns a slowed down pattern
slow "2 4"

-- This isn't a pattern either, but a strange little function that
-- takes everything on the right and gives it to the function on the
-- left:
$

-- But it together and you get a pattern again, a pattern of sounds
slow "2 4" $ sound "arpy arpy:2"

-- This is also a function, that takes a pattern as input and starts
-- sending it off to the synthesiser to be turned into sound.
d1

-- There's another one of these dollars to take everything on the right and pass it to d1
$

-- And the whole thing, which is an action to change what is being sent to the synthesiser
d1 $ slow "2 4" $ sound "arpy arpy:2"

-- Functions like "slow" will work on any pattern. We could have
-- slowed down the pattern of words rather than the pattern of sounds:
d2 $ off 0.25 (# speed 2) $ sound (slow "2 4" "arpy(3,8) arpy:2")
 # crush 3

d1 $ off 0.25 (# crush 3) $

d1 $ off 0.125 (# crush 3)
   $ n (shuffle 4 "0 [3 6] [~ 2] 4") # sound "micron"

d1 $ off 0.125 (# crush 3)
   $ n ("0 [3 6] [~ 2] 4" + irand 4) # sound "micron"

d1 $ sound "supermandolin"

d1 $ jux (slow 2) $ off 0.125 (# sound "pulse") $
                 slow 2 $ n (off 0.125 (+12) $ off 0.25 (+ "<7>")
                 $ slow 2 "d6(3,8) a7(3,8) [c7*2 c6] e7(3,8)")
                 # sound "rash"


d1 jux rev $

d1 $ jux rev $ n "0 [~ 3] [~ 2*2] 5" # sound "micron"


d1 $ n ("0 [3 6] [~ 2] 4" + 4) # sound "micron"

d1 $ n ("0 [3 6] [~ 2] 4" + irand 4) # sound "micron"

d1 $ n ("0 [3 6] [~ 2] 4" + "<0 2>") # sound "micron"

d1 $ n ("2 [5 8] [~ 4] 6") # sound "micron"

d1 $ sound ("micron:0 [micron:3 micron:6] [~ micron:2] micron:4")


d1 $ cat [chop 8 $ sound "bd",
          rev $ chop 3 $ sound "cp"
         ]

cps (140/60/2)

cps 1

d1 $ n "0 [3 6] [~ 2] 4" # sound "micron"

d2 $ 0.125 <~ (n "0 [3 6] [~ 2] 4" # sound "micron")
   # crush 3


-- Playing long samples

-- legato
-- loopAt

-- Granular Synthesis

-- every

-- off

-- sometimes

-- hurry
let hurry x = (|*| speed (fromRational <$> x)) . fast x

-- logorithmic shortening of samples

d1 $ sound "bev*3 bev*8"
  # end (slow 2 $ sine * 0.04)

d1 $ sound "superpiano"

-- scratchpad

d1 $ sound "bev arc"
   # gain 1.5
   # legato 1

d1 $ degradeBy 0.6 $ sometimes (|+| n "-12") $ every 3 (0.25 <~) $
    jux rev $ slow 2 $ off 0.25 (# s "pulse") $
    n (off 0.125 (+12) $ off 0.25 (+7)
    $ slow 2 "d5*2 e6(3,8) a6*2 c6(3,8)") # sound "rash"
   # lpf (scale 1000 3000 sine)
   # lpq 0.2
   # room 0.7

d2 $ jux rev $ slow 2 $ struct "x(6,16)" $ loopAt 2 $ chop 8 $ sound "arc"

d3 $ (slow 2 $ jux rev $ chunk 4 (hurry 2) $ sound "bd [~ bd*2] sd cp")
   # orbit 1
   # room (slow 4 "0.2 0.99")
   # size 0.7

d1 $ echo 0.25 $ sound "bd cp"

d2 $ slow 1.001 $ sound "bd(3,8)"


-- vis

brew install cairo
brew install pkg-config
cabal install tidal-vis

import Sound.Tidal.Vis

import qualified Graphics.Rendering.Cairo as C

let vis name pat = vLines (C.withSVGSurface) (name ++ ".svg") (600,50) pat 1 1

vis "test" $ "red blue green orange"

d1 $ sound "arpy(3,8)"
   # speed "-2"

d1 $ every 3 (fast 2) $ stack [every 3 (# speed "-1") $ sound "arpy sd",
                               sound "cp(3,8)" # speed 2
                              ]
    # crush 4

d1 $ cat [sound "bd(3,8)",
          sound "arpy",
          sound "jvbass*4"
         ]

d2 $ every 3 (const (sound "jvbass*4")) $ sound "arpy cp"

d3 $ seqPLoop [
  (1,4, n "c7 a7" # sound "xx"),
  (0,8, sound "bd(3,8)"),
  (6,8, loopAt 4 $ chop 16 $ sound "arc")
]

x x x x x x x x
  x x x

d1 $ n ("c6 a7") # sound "supermandolin"
  # sustain 2

d3 $ sound "cp(3,8)"


d1 $ slow 2 $ n (choose [0 .. 15]) # sound "amencutup"

d1 $ n ("0 7 ~ 3")
  # sound "supermandolin"
  |+| n "<0 7 12>"

d1 $ sound "drum*8" # n (irand 8)

d1 $ sound "cp*8"
   # speed (scale 0.5 2 rand)
   # pan (fast 2 rand)

import Sound.Tidal.MIDI.Context

import Sound.Tidal.MIDI.Synth

displayOutputDevices >>= putStrLn

devices <- midiDevices

m2 <- midiStream devices "X18/XR18 MIDI 1" 1 synthController

d1 $ sometimesBy 0.2 (rev) $ sound "cp sn:2"

d1 $ swingBy (1/16) 4 $ sound "cp*8"

d1 $ sound "bd*64"
  # nudge (scale 0 0.2 sine)

d1 $ (chop 63 $ sound ("bd cp ~ sn:2"))
  # nudge (slow 4 sine)


d2 $ sound "drum(3,8)"

m2 $ n "0 7*3"



https://github.com/musikinformatik/SuperDirt


d1 $ sound "bd"
  # room 0.9
  # size 0.9
  # orbit 1

d2 $ sound "arpy arpy"
  # orbit 0

d1 $ sound "bd*32"
  # pan saw


  -- quadrophonic, five orbits

(
// configure the sound server: here you could add hardware specific options
// see http://doc.sccode.org/Classes/ServerOptions.html
s.options.numBuffers = 1024 * 16; // increase this if you need to load more samples
s.options.memSize = 8192 * 16; // increase this if you get "alloc failed" messages
s.options.maxNodes = 1024 * 32; // increase this if you are getting drop outs and the message "too many nodes"
s.options.numOutputBusChannels = 4; // set this to your hardware output channel size, if necessary
s.options.numInputBusChannels = 2; // set this to your hardware input channel size, if necessary
// boot the server and start SuperDirt
s.waitForBoot {
	~dirt = SuperDirt(4, s); // two output channels, increase if you want to pan across more channels
	~dirt.loadSoundFiles;   // load samples (path containing a wildcard can be passed in)
	~dirt.loadSoundFiles("/home/alex/extra-samples/*");

	s.sync; // wait for samples to be read
	~dirt.start(57120, [0, 0, 0, 0, 0]);   // start listening on port 57120, create two orbits, each sending audio to channel 0. You can direct sounds to the orbits from tidal e.g. by: `# orbit "0 1 1"
}
)

--

-- eight stereo channels, going to eight tracks on a DAW (via soundflower or something)

(
// configure the sound server: here you could add hardware specific options
// see http://doc.sccode.org/Classes/ServerOptions.html
s.options.numBuffers = 1024 * 16; // increase this if you need to load more samples
s.options.memSize = 8192 * 16; // increase this if you get "alloc failed" messages
s.options.maxNodes = 1024 * 32; // increase this if you are getting drop outs and the message "too many nodes"
s.options.numOutputBusChannels = 16; // set this to your hardware output channel size, if necessary
s.options.numInputBusChannels = 2; // set this to your hardware input channel size, if necessary
// boot the server and start SuperDirt
s.waitForBoot {
	~dirt = SuperDirt(2, s); // two output channels, increase if you want to pan across more channels
	~dirt.loadSoundFiles;   // load samples (path containing a wildcard can be passed in)
	~dirt.loadSoundFiles("/home/alex/extra-samples/*");

	s.sync; // wait for samples to be read
	~dirt.start(57120, [0, 2, 4, 6, 8, 10, 12, 14]);   // start listening on port 57120, create two orbits, each sending audio to channel 0. You can direct sounds to the orbits from tidal e.g. by: `# orbit "0 1 1"
}
)

-- stereo, six orbits

(
// configure the sound server: here you could add hardware specific options
// see http://doc.sccode.org/Classes/ServerOptions.html
s.options.numBuffers = 1024 * 16; // increase this if you need to load more samples
s.options.memSize = 8192 * 16; // increase this if you get "alloc failed" messages
s.options.maxNodes = 1024 * 32; // increase this if you are getting drop outs and the message "too many nodes"
s.options.numOutputBusChannels = 2; // set this to your hardware output channel size, if necessary
s.options.numInputBusChannels = 2; // set this to your hardware input channel size, if necessary
// boot the server and start SuperDirt
s.waitForBoot {
	~dirt = SuperDirt(2, s); // two output channels, increase if you want to pan across more channels
	~dirt.loadSoundFiles;   // load samples (path containing a wildcard can be passed in)
	~dirt.loadSoundFiles("/home/alex/extra-samples/*");

	s.sync; // wait for samples to be read
	~dirt.start(57120, [0,0,0,0,0,0]);   // start listening on port 57120, create two orbits, each sending audio to channel 0. You can direct sounds to the orbits from tidal e.g. by: `# orbit "0 1 1"
}
)

-- install TidaLink
mkdir src
cd src
git clone https://github.com/tidalcycles/TidaLink.git
cd TidaLink

-- You might need to do:
brew install cmake

/bin/bash compile.sh

-- to run TidaLink
cd build
./TidaLink

-- install the development version of tidal
cabal install https://hackage.haskell.org/package/tidal-0.9.5/candidate/tidal-0.9.5.tar.gz

-- and tidal-midi
cabal install https://hackage.haskell.org/package/tidal-midi-0.9.4/candidate/tidal-midi-0.9.4.tar.gz

d1 $ fast 2 $ whenmod 8 6 (fast 4) $ sound "odx"
   # pan 0.25

d2 $ slow 2 $ sound "blue"
   # pan 0.25


let revchop p = rev $ chop 16 p
                 # speed 2
    fastspeed p = fast 2 $ p # speed 2

d1 $ revchop $ sound "bd"
   # pan 0.25

d1 $ every 3 fastspeed $ sound "bd"
   # pan 0.25

d1 $ sound "arpy(3,8)" # accelerate (slow 4 $ sine)
   # pan 0.25

d1 $ weave 16 (pan saw)
    [sound "bd(3,8)",
     sound "arpy*2" # crush 3,
     sound "~ cp",
     sound "sn:2*2"
    ]

d1 $ weave 16 (n "0 1 2 3 4 5 6 7" # sound "arpy")
   [vowel "a e i",
    vowel "o i*2",
    speed "1 0.25*2 2*2 0.5",
    speed "0.5 1"
   ]

d1 $ n "0 .. 7" # sound "arpy"

d1 $ weave 16 (n "0 .. 7" # sound "arpy")
   [vowel "a o",
    vowel "i"
   ]

import Sound.Tidal.Scales

d1 $ slow 2 $ n (toScale egyptian "0 .. 15") # sound "supermandolin"

-- see here for the available scales:
https://github.com/tidalcycles/Tidal/blob/master/Sound/Tidal/Scales.hs

d1 $ jux rev $ weave 8 (palindrome $ n "0 3 5 7 10 12 15 17" # sound "supermandolin")
    [vowel "a o",
     vowel "i(3,8)",
     speed "1 0.5",
     speed "1 ~ 0.25"
    ]

-- superDirt hacks:
https://github.com/musikinformatik/SuperDirt/tree/master/hacks

d1 $ sound "cp"
   # tsdelay 0.4
   # xsdelay 4

let tsdelay = make' VF tsdelay_p
    tsdelay_p = F "tsdelay" Nothing

let xsdelay = make' VI xsdelay_p
    xsdelay_p = I "xsdelay" Nothing

chord names:
https://github.com/tidalcycles/Tidal/blob/master/Sound/Tidal/Chords.hs

-- import the chords:
import qualified Sound.Tidal.Chords as Ch


d1 $ n (Ch.enchord [Ch.major, Ch.minor, Ch.minor7]
        "c g e f*2" "2")
     # sound "superpiano"

-- or make an abstraction:
let chs = Ch.enchord [Ch.major, Ch.minor, Ch.minor7]


d1 $ n (chs "c g e f*2" "0 2")
     # sound "superpiano"

d1 $ spread ($) [fast 2,
                 (# speed 2),
                 (# crush 3)
                ]
   $ sound "bd(3,8)"

d1 $ ifp ((> 2).(flip mod 4))
     (striate 4)
     (# coarse "24 48") $
     sound "hh hc"

-- need to write a better function for this
d1 $ chop 16 $ sound "sd:2 arpy"

-- striate is the same as chop but mixes up the bits
d1 $ striate 16 $ sound "sd:2 arpy"