Is there a command I can type that will list a scale's definition? For example, If I'm running
d1 $ slow 2 $ n (scale "bhairav" "0 .. 6") # "superpiano"
and I want to change the scale on the fly, but I don't know how many notes are in a particular scale. Is there a command I can type that will display:
pelog = [0,1,3,7,8]
in the command pane so that I can count the number of notes in the scale and adjust accordingly?
d1 $ slow 2 $ n (scale "pelog" "0 .. 4") # "superpiano"I'm loving the direction this thread is taking, thanks @nilhartman @heavy.lifting for the info!
OK so I've sat down with this, and it is exactly the info that I was looking for - I've been trying to resolve in my head how to manage the different scales by preprogramming them but just transposing them from C is such a great solution (I did actually do something similar in my video earlier in the thread modulating the chord progression, just needed the toScale functionality to join the dots).
I've been trying to wrap my head around struct too - it makes perfect sense in @yaxu's videos, then when I try and use it... splat ... so a massive thankyou for the examples too 
I think there's a small mistake in there though,
This is actually C Mixolydian (with the dominant/flat 7) - C Major is:
[0,2,4,5,7,9,11]
Indeed, thanks for noticing / correcting 
thank you! I did the setup on Windows with 'LoopBe internal midi' and works perfectly! 
Sorry to keep going off-topic here, but since you also are on Windows I was wondering: can you recommend any "virtual audio cable" software? I'd like to be able to route supercollider's output back into the DAW, possibly on separate channels; I think I know how to set this up on the supercollider/tidal side but I'm not sure what's a good option to route audio. I used to have soundflower on a mac but I'm not sure what's the best windows alternative (if any).
I use VB Virtual Audio Cable - always worked very well for me. Im pretty sure VB will only do stereo (I.e. 2 channels) though. For multichannel (I.e. if you want to send d1, d2 etc to separate channels in your DAW) you'll need a multichannel audio device. Nerds.de (the LoopBe people) make one, it's not free though (but it is cheap)
There is some discussion about this here.
Hola(:
I really love this thread, I would like to know if someone has experience with creating a list of chords from scratch, instead of using - the library of chords - I would like to explore other possibilities - adding some other notes and exploring stuff that I usually play on the guitar, actually that is something I would like to share, as part of my process, I usually play some chord progressions/melodies in the guitar and then translate that to tidal (the translation is never exact, which I really like, to see how code brings me somewhere else) - recently I recorded this track with tidal and vcv -
Thanks for all the inspiration and all the cool music!
Hola @yecto,
You could do it with inhabit.
mychords = inhabit [("hola", "[0,4,2]" :: Pattern Double),
("hello", "[0,5,7,12]")
]
d1 $ n (mychords "hello hola") # s "superpiano"
You have to use :: Pattern Double to tell haskell what kind of pattern you're making, but you only have to do that on one of the values, it can work out the rest.
Really nice!
Thanks!
As an FYI, a snippet from the latest video (week5/2) where Alex shows how to generate this list within tidal:
[edit]
scaleList
also
import Sound.Tidal.Chords
chordList
That's the chords, to get the scales you can do
scaleList
This is amazing. Been playing with it for a couple hours.
Is there a way to pattern the iteration limit, or even the operator / function? I couldn't get it working myself. Its fun modifying these things as it plays, really expressive.
I don't think there is an easy way of patterning that parameter but its a good idea. Very unpredictable results with that one. I might try to add that later and see how its sounds.
Reopening the discussion to deal with another important aspect of melodic expression: intention, nuances, musical phrasing. Not being able to phrase things correctly might be my biggest frustration with live-coding. Were you able to reproduce a "natural" phrasing using code?
I sometimes wonder if it wouldn't be best to play using some sort of weird modal velocity sensitive keyboard that allow you to switch between writing characters and triggering MIDI events but I couldn't find anything capable of doing that.
I had a go at this for my solstice set - I think it's getting pretty close to what you're looking for tbh,
I had at least one listener mistake the superpiano for a sampled line -
whether you can enact the lines more "deliberately" is probably the question - there's quite a bit of chance in there
Adding my 2 cents to this great thread -- I think that sequencing fixed melodies or phrases, while apparently not an expression of livecoding, can serve as a good start to mash, warp and re-pattern them with e.g. struct, bite or sometimes rev, and end up with something pretty different and open for experimenting.
Patterning euclidean values also works wonderfully to find interesting phrases and keep things under control without using randomness.
I've also been after more "natural" progressions (ofc "natural" could mean a lot), and maybe this snippet can work as a small example of melodic outputs with Tidal:
p "piano"
$ jux rev
$ rarely (# octave 4)
$ sometimes (# octave 6)
$ sometimes (# velocity 0.6)
$ struct "t([9|13]*16,16,1)"
$ n (scale "minor" (sometimes rev $ "[0 2 3 4 6 7 6 [8|10]]*2"))
|+ n "<6 1 4 4 3!4>" |+ n "-7"
# sound "superpiano" # velocity 0.5 # sustain 7
(@cleary that piano sounds so good, really curious if you have any composition/variation techniques to share?)
why does it create rests and parallel events? Simplified (and using fast only to show more cycles):
draw $ fast 3 $ "a b c"
|abcabcabc
draw $ fast 3 $ rev $ "a b c"
|cbacbacba
draw $ fast 3 $ sometimes rev $ "a b c"
|.bcabc.bc
|..a.....a
rests and parallel notes definitely make the piece more interesting (less uniform). But why exactly does sometimes rev work that way?
I suspect it's because sometimes operates on an event in isolation, rather than a cycle (see someCycles) - so in your example the two a's were subtracted from the original pattern as individual events:
|a........| -> rev -> |........a|
|......a..| -> rev -> |..a......|
Add/blend the two resulting patterns -> |..a.....a| and you get your result.
Without deferring to the specific detail of the sometimes function innards, this makes sense to me, at least 
Thanks! brain is not in the space to parse old code ideas atm, but let me consider it and I'll write something if I can come up with anything useful 