Sharp/flat notes in chords + (...) + maqam scales

Hi Alex and hi all!

I've been thinking about asking about a couple of simple things which are not clear for me. I'm a bit stuck, I would like to share my doubts, hoping someone could help!

1-Scales and notes : I can't seem to find how to play sharp and flat notes, is it possible?

d1 $ n"a a# ab" # s "supersaw" doesn't work.

I can do it with numbers : d2 $ n"9 10 8" # s "supersaw"

Accessing sharp and flat chords thus relies on counting well, rather than thinking fast:

d1 $ n"a#'maj" # s "supersaw" warning

d1 $ n"{10, 14, 17}" # s "supersaw"

Am I missing something?

Passing rhythmic structures through the euclidean pattern was also "challenging", I will dig deeper.

2-The patterning system is very efficient but I still get surprised. With a given kit I can do this :

d1 $ n"0 2 1 2 0 2 1 2" # s "dr"

Which is super easy to tinker with :

d1 $ n"<0 1 2 3> <2 [2 2 ] 3*2> <1 [1 2 3]> <2 0 1> <0 1> <2 2*2> <1 [1 4]> <2 2*2>" # s "dr"

Let's say I want to make a drum kit on the fly and pattern it (thinking of live contexts where choosing the samples and duplicating them into a new folder is not a great option).
Let's say I want to make a simple 4 beat rhythm with 3 samples :
d1 $ n"0 2 1 2" # s "kick kurt hat"

The result I want can be attained by patterning on the right hand side :

d1 $ n"0 0 0 0" # s "kick hc kurt hc"

But this quickly gets messy. Scrolling through sound banks is great, but makes tinkering with the rhythm more cumbersome :

d1 $ n"<0 1 2 3> 0 0 0 0 0 0 0" # s "kick hc snare hc"

Am I missing something really elementary?

3-Ergonomy : in the videos, you seem to use Atom. When you hush the music, you just go to the next line and press shift-enter. My experience is that I must add an empty line between a given command and the hush, otherwise the parser doesn't accept it. Why is that and can I do anything about it? Here is the console log :

• Couldn't match expected type ‘IO () -> Pattern ControlMap’ with actual type ‘Pattern ControlMap’ 
• The function ‘s’ is applied to two arguments, but its type ‘Pattern String -> Pattern ControlMap’ has only one In the second argument of ‘(#)’, namely ‘s "kick snare hat" hush’ In the second argument of ‘($)’, namely ‘n "0 2 1 2" # s "kick snare hat" hush’

4-Last but not least : as I'm working with eastern music a lot, I keep producing uneven beats and playing with notes in order to reach quarter-tone values. How about implementing maqam scale structures in tidal? I would be glad to help in doing this ; actually the common ignorance of non-tempered scales in music-making tools is not so far from what is commonly referred to as "algorithmic bias".

With mainstream synthesizers, MIDI, etc.. It's super rare that non dodecaphonic scales are on the table. As I said, I'm working with those a lot so I'm very interested in developing these tools for tidal ; but at the same time it's an actual political/ideological/technological issue which deserves to be fought, so why not do it in tidal? I'm really thinking about arpeggio-like syntax (quarter tones in chords are not... easy to deal with). Could I take this issue to the innards category...?

Cheers and see you soon!

1 Like

you will need to use "f" for flat and "s" for sharp instead of the standard "b" for flat and "#" for sharp. so, "gs" and "af" will give you the same result.

1 Like

Yes! That's exactly what I couldn't find :upside_down_face:
Thanks a lot for the tip!

Yes a tricky one. I tend to have one 'sound' per pattern and then only patttern 'n', or use : like:

d1 $ sound "bd:4 kurt:5"

There is also a function inhabit that lets you do lookups like this:

kit :: Pattern String -> Pattern String
kit = inhabit [("bd", "bd:3"),
               ("cp", "cp:5")
              ]

d1 $ sound (kit "bd cp")

3 - Not sure what's going on there - shift-enter should only run one line. Ctrl or cmd-enter should run a block - you should only need the blank line around in the latter case.

4- SuperCollider has a flexible tuning, there are a couple of files from @julian in the 'hacks' folder for giving different pitch models to different orbits: https://github.com/musikinformatik/SuperDirt/blob/develop/hacks/pitch-model.scd , and also controlling the pitch model from tidal: https://github.com/musikinformatik/SuperDirt/blob/develop/hacks/pitch-model-from-tidal.scd

It'd be great to talk more about this ! I'm not sure if it's innards or not, the distinction isn't always clear..

2 Likes

that's what is called dirt, after all …

1 Like

Thanks a lot for looking into this @yaxu !

I will duly check out inhabit and the pitch model as you suggested, and I will get back to you. What I can do, with the help of some friends, is provide around 8 modular sub-scales, the combination of which could produce all the maqams. But I should first take a deep dive into the existing tweaks. I think it could be reasonably easy to achieve!

I've just remembered someone has contributed these to Tidal's scales:

bayati :: Fractional a => [a]
bayati = [0, 1.5, 3, 5, 7, 8, 10]
hijaz :: Fractional a => [a]
hijaz = [0, 1, 4, 5, 7, 8.5, 10]
sikah :: Fractional a => [a]
sikah = [0, 1.5, 3.5, 5.5, 7, 8.5, 10.5]
rast :: Fractional a => [a]
rast = [0, 2, 3.5, 5, 7, 9, 10.5]
iraq :: Fractional a => [a]
iraq = [0, 1.5, 3.5, 5, 6.5, 8.5, 10.5]
saba :: Fractional a => [a]
saba = [0, 1.5, 3, 4, 6, 8, 10]

This isn't my area, but does this look useful?

Then you can do e.g. n (scale "iraq" "0 1 2 3 4 5 6 7)

3 Likes

Wow, that's really great. I will start working with those right away!

I'm not a maqam scholar either, but I work a lot with eastern music instruments. As I understand it, all these scales are based on two sub-scales each. Combining those mini-scales (ajnas) produces all the maqams, the number of which varies depending on how we render styles and variations.

One thing I had in mind which would be full of combinatory madness : writing the 3-5 notes scales and specifying what other such scale they are usually associated with. This could lead to very efficient cyclic melodic patterning.

The other thing (probably simpler) would be to produce arpeggio-like patterns to produce pseudo-random melodies on the fly. Without going into more detail, those would behave like "pinkyfigerupdown" except they can be modular. One pattern could be associated with some others, pattern sequences could also be specified.

The result would be relatively close to having traditional maqamic improvisation "going on". One of my friends is currently working on an FX pedal which samples an audio source and produces arbitrary melody lines, I will keep you updated when it's ready. If this is of any interest to more people, I'd be glad to contribute in implementing something of the sort in tidal.

ps : this project is based on maqams!

1 Like

Here's a way to use additional scales:

let scale = getScale (scaleTable ++ [("sus2", [0, 2, 7])])
d1 $ n (scale "sus2" $ struct "t*8" $ (irand 8) - 4) # s "supervibe"

Spotted here:
https://chat.toplap.org/channel/tidal-snippets

1 Like

Nice! Thanks for the tip and also for pointing there, lots of things happening it seems. I will try to play with these custom scales asap.