Many hours later, and now I have a Euclidean Rhythm Generator sequencing blips. It's quite underwhelming, but the implementation is fully documented using #literateprogramming. It should end up in #sndkit in the next few days.

This sound patch converts a metro signal into a euclidean rhythm which drives an envelope generator. It randomizes the pulse variable at every bar to regenerate the pattern:

metro 8
hold zz
regset zz 0

regget 0
dup
tdiv zz 8 0
trand zz 2 8
param 8
euclid zz zz zz
env zz 0.001 0.01 0.01
sine 1000 0.5
mul zz zz
wavout zz "euclid.wav"
computes 10
unhold [regget 0]

Some words on signal routing with #sndkit

https://pbat.ch/sndkit/signal_routing/

I finally got around to making a clock-synced delay line that works with #sndkit.

Code for the sound can be found here:

https://paste.sr.ht/~pbatch/3867c56d0099b21b43c21a1228d166139a7ca124

More experiments using #uxn to sequence Gesture in #sndkit!

This one implements a concept I am calling "temporal skewing", which is the ability to locally warp tempo in a region without gaining or losing time overall. The neat thing about this is that it's all done using audio DSP!

The melodic sequence below would have otherwise been playing linear eighth note rhythms, but was subjected to a exponential temporal skewing curve lasting 9 beats, causing an accelerando to happen. While the beats do get faster, the overall time is still 9 beats.

Code found here:

https://paste.sr.ht/~pbatch/0616f870f506ee24365205acd677edef28c696d6

Some initial experiments getting #uxn to sequence #gestures.

The featured gesture here is controlling the pitch of an oscillator with a small bit of glissando. Every time the gesture loops back, the speed changes: eighths (2), triplets (3), sixteenths (4), quintuplets (5), etc. until it reaches a really high value and then it goes backwards and slows down.

I also programmed a secondary gesture that is controlling filter cuttoff. This is a line that rises up and down every 4 beats.

Uxn program (tal) and #sndkit patch (LIL) can be found here.

https://paste.sr.ht/~pbatch/62a21dc28095031690ecca0cafd08679716c67ec

Messing around with my new qgliss algorithm in #sndkit

A randomly generated line is used to produce a quantized melody via qgliss. this line also maps to other parameters in the patch as an expression curve.

sndkit patch:

https://paste.sr.ht/~pbatch/560654ba675a0557ea408aaf9afec85f55e6b781

qgliss:

https://pbat.ch/sndkit/qgliss/
https://git.sr.ht/~pbatch/sndkit/tree/9e8a7d543fe28813742acd06b6883e012764504a/item/dsp/qgliss.org

Yet another experiment using #uxn as a sequencer with #sndkit (#uxnseq).

This time, the goal was to build coordinated sequences. In other words, be able to have a sequence that has an awareness of another sequence, and reacts and behaves accordingly.

The uxn program controls two sequences simultaneously. The first sequence controls a 7/8 bass line groove, and at each bar randomly chooses a new measure. The second sequence controls a sparse melody on top. It picks one of 2 pre-composed sequences based on what the first sequence chose.

code (uxntal for sequence, LIL for sounds) can be found here:

https://paste.sr.ht/~pbatch/c0a4ca5ab1b3788017cfa551a722322432fc59a9

More sequencing tests with #uxn and #sndkit (aka #uxnseq).

The Uxn program here is randomly selecting from a set a pre-made musical sequences that control the pitch of the subtactive saw oscillator patch in sndkit.

synth patch and uxn code here:

https://paste.sr.ht/~pbatch/85e9cee9b1d0826c24b549e2b97f16a80fe71351

Music sequencing test with #uxn, #uxntal, and #sndkit

This is my first attempt at uxn. Not sure if I'm doing it right?

|0100
BRK

%NOTE { #37 ADD #20 DEO }
%DUR { #21 DEO }

&top
#00 NOTE #02 DUR BRK
#02 NOTE #01 DUR BRK
#0b NOTE #02 DUR BRK
#09 NOTE #01 DUR BRK
#00 #01 SUB NOTE #02 DUR BRK
#02 NOTE #01 DUR BRK
#09 NOTE #02 DUR BRK
#07 NOTE #01 DUR BRK
,&top JMP