Bytebeats (now with beginner's guide!)

Here’s something I came up with ... using trial and error

SLEVOLODY

This is so much fun! I just wish I understood what was happening

I played with Bytebeats a while back on the Axoloti when one of the contributors was building an object for it
they are quite a lot of fun.


Robert was demonstrating algodrone at Superbooth, and I think he has taken a really nice approach.
I think (?!) you cannot provide new algos, but rather select from some predefined ones (not sure how many he has).
but what he has done that's nice, is allow you to hone in on interesting places within the algo.

the way I view this, is some of the good algos are a bit like a fractal pattern, they at first feel completely random, and noise like, but the more you zoom into particular parts, they start playing interesting patterns. play them at different speeds, different directions and you get something slightly different.

whats cool about this approach is unlike random patterns, these are completely reproducible (like a preset), once you know the algo, and the seed, it will always play the same...
(and because the algo generates sufficiently complex streams, theres no danger of running out of possibilities)

I guess, you can think of it as a kind of non-random, random sequence generator  

 
I have to say I wasn't particularly interested in algodrone before superbooth, but after seeing/hearing it, I became really excited for it.

also... lets remember, unlike these synths, we will not only be able to use it for pitch, but also modulation... and if its running fast enough perhaps as waveforms!?

Spent some more time with the Bytebeats on the weekend and I'm slowly starting to get my head around programming them. Here, I made a step sequencer:

MELANCHOLOGIC (click to listen)

// 180908 melanchologic by the tuesday night machines

(
(
// lead melody
//gate start   gate stop     note
(t%16000>=100 & t%16000<1000)*t*4
|
(t%16000>=1000 & t%16000<1500)*t*2
|
(t%16000>=2000 & t%16000<3000)*t*12
|
(t%16000>=4000 & t%16000<5000)*t*10
|
(t%16000>=8000 & t%16000<9000)*t*18
|
(t%16000>=12000 & t%16000<14000)*t*12
|
(t%16000>=14000 & t%16000<14500)*t*10
)

//fun stuff
^
(
-t*8*(t%16000<2000)
^
(-t/32)*(t%16000>12000)
)
&
(
t>>4
&
-t>>8
)

// bass notes
|
(
(
(t%64000>100 & t%64000<16000)*t*4
|
(t%64000>16100 & t%64000<32000)*t*3
|
(t%64000>32100 & t%64000<48000)*t*5
|
(t%64000>48100)*t*8
)
/(2+(1*(t%128000>=64000))) // div frequency by 3 after 64000
%128                       // reduce bass amplitude by half
)
)

// ducking and phasing
|
(t%16000)/32
&
(t*2)%127+64

//percussion
|
(
(t%8000>0 & t%8000<200)*-t/10
|
(t%8000>4000 & t%8000<4200)*t*200
|
(t%32000>14000 & t%32000<14200)*t*50000
)

I’ll see if I can write a rudimentary beginner’s guide soon, explaining some of the basic functionality of Bytebeat programming, in a way that one actually understands what is going when coding the simple, bread and butter stuff. I find this much more fun now, being able to combine the happy random accidents with more consciously coded parts, giving a beat some structure. Of course my coding skills still suck though and I always think that there must be way more efficient ways of doing things.

Ok, I know we usually want to stay in hardware land, but I looked further into Bytebeat implementations and found that:

There is a module for VCVRack: github.com/FrankBuss/Formula

And also this really cool VST plugin: damikyu.itch.io/evaluator

For the latter this introduction video is really nice with some more examples

Here’s a first version of “The absolute beginner’s guide to coding Bytebeats!”   Haha!

XXXXX OLD LINK REMOVED - GO HERE FOR THE LATEST VERSION XXXXX

I’d love to get some general feedback on it, before I release and promote it more widely. Is it easy enough to follow and understand? Does the structure make sense to you? Did I get something wrong? If you find spelling errors or really bad grammatical stuff, let me know via PM or e-mail preferably though. If it’s just some quirky but understandable, non-native speaker English then I’m okay with that.

Personally, I don’t like long winded explanations and prefer simple examples. I tried to write the guide like that.

Thank you very much

I wasn’t sure about the loose relationship to C, so that is good to know and I’ll update the guide accordingly. I’m more of a “designer” with only two semesters of basic Java under my belt, so I’m not really at home with the actual languages and their concepts.

Regarding addition and subtraction you’re absolutely right! I even do a tiny phase shift in my triangle wave example at the end, to fix the drop to 0. I’ll include phase shifting in the addition and subtraction paragraph then, with a little exercise. I just played around with this for a minute and it indeed adds a lot of character when modulated with counters, as you mentioned!

Thanks! I didn't have time yet to check this out from earlier, but I'll include it in the guide as well

Aaaand another new version. Now with pictures!
nightmachines.tv/bytebeats-tutorial
v1.2 2018-09-22

Thanks! I posted it on Reddit and a bunch of other places too.