Kyma Studies

bphenix · 2020-12-03T04:02:12.250Z

I may package some various examples. I keep finding new areas to explore or approaches so I never go back and tidy up aspects of it into an end state so I tend to leave in various hacks or inelegant approaches that work but may require fixing if someone wants to build on them.

AndersSkibsted · 2020-12-05T12:41:11.167Z

This is really good and well layed out material!
Looking forward to reading and working with the next chapter.

muied_lumens · 2020-12-05T13:36:14.758Z

This is a fantastic resource, thank you. Hopefully I can contribute as well at some point.

alexvicar · 2020-12-05T18:50:49.012Z

just wanted to say thank you for this awesome tutorial!!
Will definitely come back to that when I have a bit more time and check it out in detail!

AndersSkibsted · 2020-12-07T21:07:54.049Z

Do you mind giving a hint on how to make the sample rate setreset / latch mechanism for sampleaccurate grain triggering?
Loving the tutorials, but a bit stuck on how to do this.

bphenix · 2020-12-07T21:44:23.190Z

Screen Shot 2020-12-07 at 1.43.17 PM2310×648 106 KB

latch.kym (872 Bytes)

Here is an example to get you started. This is based on work contributed via the kata community. I try to limit the number of feedback loops in my sounds so I tend to stick with the capytalk version most of the time.

bphenix · 2020-12-09T06:40:40.970Z

Random strategies

This section may be a bit meandering. There are so many avenues to go down and side topics to explore when we talk about randomization.

Within music contexts we talk about topics like white, pink, blue, and grey noise. Within the context of jitter as it applies to granular synthesis, it isn’t always clear what the randomization strategies are being deployed. Is it pure random (as much as such a thing is possible in digital systems) or is weighted in some way? For example, a glance at the Tasty Chips GR-1 manual discusses ‘spray’ aka jitter but doesn’t define the behavior nor seem to provide control over it. The wonderful Borderlands app is no less opaque. Madrona Labs Kaivo, one of my personal favorites, does give us control over a noise source and hence some jitter structures but not all.

Before we go too much further let’s define two related concepts when it comes to randomization within our context. Jitter is typically the random variation generated at a sampling point. However, we have another important concept, which is time based randomization. This can be expressed as the chance that a trigger should occur at sampling point. These names may be different in different implementations (for example, the aforementioned GR-1).

For our proposes and to follow Kyma convention: density is the chance a grain will be triggered and jitter is the amount of variation for a given parameter of the grain.

Jitter

While Kyma has a wealth of CapyTalk expressions for generating random values we are going to stick with a generalized approach that translates to almost any environment and may be useful in understanding how other systems are approaching their implementation.
We’ll use a white noise as our primary source. White noise will generate an even distribution of values over a reasonably high number of sample points. If we only take 10 samples of white noise, the values may be weighted towards some values but as we add more and more samples, that weighting will be more even. After 10,000 samples, any weighting will be extremely small.

An easy way to create different weights is use a waveshaper, mix multiple noise sources together, raise the value to a power, or use the ‘saturator’ module. The ‘saturator’ module is a bit deceiving in name, to be honest. At the core is a S-shaped (polynomial) waveshaper that can be dynamically adjusted. Feed a 1-order saturator with a curve of 1 with a triangle and you’ll receive a sine output.

Let’s take a bit of time to explore how white noise can be redistributed using the later approach.

white noise - flat1232×1688 280 KB

white noise - curve1226×1668 248 KB

white noise - curve 21218×1680 261 KB

white - 8 order1238×1700 184 KB

As you can see, via this approach we can shift our values to the extremes so there a re a lot of little values and fewer larger values or the inverse. When these values are sorted in order, they can make up a power law or exponential curve depending on our approach. Power laws are extremely common in the natural world and as such we recognize and react to them in very different ways to random or sudden state changes.

Our brains love pattern matching. There is a vast amount of research that can occupy years of reading and endless exploration on the topic of how pattern matching influences our perspective of the world around us, how we may make decisions, and ultimately evolutionary responses. One of the fun aspects as it relates to granular synthesis and music in general is that we can exploit the listeners’ need to pattern match. When we decide to generate values out of order, our brain may or may not reconstruct the distribution curve depending on factors including length of time between sample points, number of data points, deviation range, and what is being modulated. Variations within that expected model can engage our brain and create moments that range from engagement and understanding to confusion and emotional responses as varied as calm, delight, and anxiety.

Building on this concept we can modulate or vary our distribution patterns over time to interesting effect. We can have the jitter slowly drift the center point or narrow the jitter down over time. Or we can have multiple overlapping distribution patterns and see what macro patterns emerge. Another suggestion is to feed the jitter into “interpolateFrom: To:” CapyTalk expression and modulate the From and To values whether by hot parameters or via modulation. Using this method we can easily create a min / max for your Jitter boundaries.

Time based variations and density

Earlier, we defined chance as the likelihood a trigger would happen at our sample point.

Our sample point could be:

44,100 times per second (global sample rate example)
Triggered by an event
Time based (every 100ms)
Combinations of the above

Density is typically a combination of the number of maximum grains possible and the likelihood they will be triggered.

If we have 8 grains, we may want them to be spread out so they don’t all trigger at once. We can take a couple of approaches here. The basic approach is just set the chance low enough that there are unlikely to be multiple triggers at once and, over sufficient time, the spacing will even out over time. At the other extreme is using grains in the context of pitch shifting. In that case, we offset the grains so they are out of phase so that as one fades out, the other grain fades in, providing a smooth amplitude response.

There are other times where we may want to cluster our triggers for rhythmic or other effects. There is a handy set of CapyTalk expressions called randomTrigger, randomExpTrigger, normalTrigger, and BrownianTrigger. I highly recommend using and exploring these expressions as they are useful in a number of situations and tend to be my default choices as they are quick, easy to use, and efficient.

But in the spirit of building some examples from scratch let’s try some other approaches.

A simple structure is a noise source into a threshold detector to create the trigger. Depending on the density we want, we have a few approaches to slow down the rate of triggers. We can either scale everything down so the chance is very small that the grain will trigger upon each clock cycle or we can slow down the clock. The later approach is compelling if we want to work with longer grains or want them to trigger on a clock division, for example, the probability that a grain will fire on each 16th note.

To create clusters of triggers, we dynamically modify the threshold. For example, add an LFO to the threshold going from 1 (no triggers) down to 0. To see how this can cluster triggers, let’s slow the sample rate down to one sample per 50 ms. We can see the triggers clusters around center points (the top of the LFO) every 6 seconds (the frequency of the Triangle LFO). By adding a distribution here we can create different distribution patterns by applying our methods outlined above in the jitter section.

distributed triggers806×376 53.5 KB

cluster flat1226×1686 266 KB

cluster curve 11216×1680 227 KB

cluster curve 21226×1696 194 KB

There are other approaches to explore here. One easy example is to gate the noise by a pattern generator (step sequencer, logic gates, euclidean, etc). Add a gate duration so you can control how long the gate is open. Then pass that through to the threshold. You can use this to create a swing or simply a gated burst of random triggers. Other examples include random ratchets clusters or oddities like controlling trigger density based on an envelop follower.

Correlated random changes

If you want to correlate your changes so that they are a deviation from the prior value rather than a completely random value, you can use a feedback loop and interpolate it with the input. Here is a rough example of the Buchla 265 stored random voltage with correlation:

2651592×712 79.2 KB

This is very much a brownian or random walk and there are examples within the prototype library using a lossy integrator as well as a pre-existing Capytalk expression for this. I recommend those for most implementations within Kyma. The feedback method may be useful to create correlated signals or other types of governor systems when those other methods may not be appropriate.

Wrap-up

In the interest of time and getting this part published, I am going to stop here. We didn’t even get into topics like hotpink noise, chaotic maps, random index distributions, or creating interdependent systems where one set of random values influence other parts of the structure. If there is one takeaway I want to impress from this section it is to encourage you to explore beyond the normal random distributions choices offered.

I may have glossed over a lot here so feel free to ask questions. I’d love to hear your thoughts on your different approaches to building randomization into your structures.

bphenix · 2020-12-26T00:35:50.405Z

Following up on the last post on random strategies here is an example of patch outlined in Allen Strange’s book when discussing the Buchla 266. Within this patch is a basic implementation of QRV that runs at audio / sample accurate rates. Also included is the new oversampling filter built by the kyma kata group.

Kyma patch
blipboxmas.kym.zip (912.3 KB)

I suggest porting this into the heart of your custom granular engine.

Rhialto · 2021-01-05T05:55:21.421Z

This is incredibly helpful, I really hope you will do many more.

bphenix · 2021-01-05T06:17:25.341Z

Thank you for the feedback. I have more to add here but I got a bit distracted with some other explorations. I would welcome some suggestion on particular areas or topics that people may find helpful so please let me know if there is an aspect that could warrant more of deep dive.

bphenix · 2021-01-16T05:12:52.773Z

This isn’t specific to grain clouds and perhaps it may be time to update the title of the post

Modulation Matrix

This is a bit of dive into building a modulation matrix. I wanted something that provided some quick switching between modulation states or playability that we find with a modulation matrix made famous by, though not exclusive to, EMS. There isn’t anything particularly difficult about this in Kyma so much of this post may be fairly 101 so to compensate, I provided a starting kym for the capytalk version a custom granular engine discussed above.

Background

Before we get to the matrix implementation let’s quickly review some different approaches to mixing of sources. Here are those that we’ll cover:

Sum Mix
Wrap Mix
Fold Mix
Self-normalizing Mix
Product Mix

These are likely fairly well understood by most but I want to highlight them again as a way to encourage people to look beyond summing mixers as I know we all tend to default to those for that vast majority of our use cases but when it comes to modulate wrapping mixers offer a lot and in some contexts normalizing mixers are very handy.

Sum Mixer (with Clip)

This is likely the most common approach. Input two or more signals are added together and if the sum is greater than -1 to 1, the signal clips. The straightforward nature of this makes it easy to understand what is happening though the likelihood of clipping increases with the number of sources. Thankfully, Kyma mixers include a global input gain that will scale all inputs down so you can easily normalize the mix without having to individually adjust each individual level.

Wrap Mix

The AddWrap and GainWrap prototype takes the sum of the input and if the value exceeds the -1 to 1 range, the signal wraps back around the other side. 1.5 becomes -0.5 for example. This is designed specially for index sounds where you want to mix a number of signals but can also be used for modulating signals. One example would be a sample start where you want to wrap back around to earlier in the file instead of saturate at the end point. Another example would be panning.

Fold Mix

Similar to AddWrap except that when the signal hits the boundary, it reflects back. This is also known as a wavefolder. Example: 1.25 becomes 0.75. The signal continues to reflect if the range exceeds -2 to 2. Due to the method of implementation, there is a practical limit to the number of reflections at least in the implementation I posted on the community library for download. If you need more than 255 folds, you may want to consider another approach.

The Fold/Flip/Reflect approach is also useful for panning. Both Fold or AddWrap can be useful for spreading values so the values don’t clip out at one. For example, say you have 4 voices and you want each voice to have a spread from the other, but you’ll also be modulating that spread or perhaps the center value. Using an add wrap mixer can help keep the spread ratio while using fold wrap will potentially cluster the spread around the ends without them all clipping to -1 or 1.

Normalizing Mix

A normalizing mixer automatically scales down the inputs based on the input values. In the summing mixer, you can manually adjust the input scale down and it will adjust all the scales. If you don’t want to manually adjust those, we can create a quick formula to adjust the input based on the level. This may be useful in a performance setting where you may be making adjustments quickly but want to guard against clipping the signal.

There are two basic formulas, one for signals that are likely to be correlated and one for uncorrelated signals.

Correlated. Using a 4 input example:

1/ ((!Level_1 + !Level_2 + !Level_3 + !Level_4) vmax: 1)

Nice and easy. Basically we add the input levels together and if it is greater than one, we scale the mixer input by the sum total. If all 4 levels were 1, then the scale would be 1 / 4 or 0.25. We added the vmax capytalk so that the divisor never drops below 1.

Uncorrelated. Using a 4 input example:

1/ ((!Level_1 + !Level_2 + !Level_3 + !Level_4) sqrt vmax: 1)

Uncorrelated signals assume that it is unlikely that the signals will stack in a why so the peaks align to saturate the range beyond -1 to 1. Audio signals are uncorrelated. Modulation sources may be uncorrelated but it depends.

Auto-normalizing mix

Rather than adjust based on your fader values, you could auto adjust based on the signal. This requires you determine how you want the signal to adjust. In this case, you measure the input with the slew-rate or bidi follower and then mix multiple followers together in the same formula as above. Here, release value matters but if you are using this for modulation, you may want to adjust it a lot like you adjust compressors where the release fits within the overall tempo and rhythm of the piece. You can definitely run the risk of having the modulate swell in and out or be a bit unpredictable but perhaps that fits with your intent.

Product Mix

Not sure what this is called formally, but the idea here is that the input signals are fed into a product rather than summed.

Example capytalk

(!ModOn_1 true: (ModSource1) false: 1) → Product
(!ModOn_2 true: (ModSource2) false: 1) → Product

This passes a 1 to the product if the ModSource is disabled. As soon as you enable it by having the ModOn value go positive, it passes the mod source to the product.

The challenge here is that you find yourself quickly reducing the RMS down towards 0, especially as the input sources increase, but that could be just the desired effect you seek.

Matrix Mixer

Returning to the matrix mixer. There is a prototype for matrix mixers in Kyma. This takes a set of inputs with the ability to route the inputs to a given output. There are 4 and 8 channel versions. Then using the channel selector, we can route the output to our modulation destination.

Here is an example:

Screen Shot 2021-01-15 at 8.53.14 PM2044×1728 304 KB

Screen Shot 2021-01-15 at 8.51.52 PM1040×968 81.4 KB

In this example, we wanted an auto-normalizing matrix so we didn’t clip our modulating mix. Rather than repeat the pattern to define the normalizing behavior, we use a script to calculate the to divisor total and generate the control events.

Example files

Here is are two kym files. One is of the matrix mixer above and another is a capyrate version of a custom granular engine. With the capyrate version, I left places for you to insert your own jitter sources. See above for some ideas and examples.

KatainCore-CapyRate.kym (308.5 KB)
ModulationMatrix.kym (205.3 KB)

The matrix mixer creates a highly playable way to switch between different sources and create different mixes quickly but one thing that I discovered is that it isn’t the most efficient use of resources especially when replicated. In talking with the some others, the theory is that by using output routing, we forego some of the optimization benefits within Kyma complier.

In the screenshot above you can see how I am routing the sources to the duration length, sample start, filter, pan, etc.

Other

I highly recommend that you sign-up for Alan Jackson’s Patreon. He has been releasing a new set of modules each month. This month includes some extremely handy files including a number of modules for building a sample rate granular engines, a sample rate clock divider, ASR, DAC, and more. Also included is an implementation of a Blippoo Box by Ian Fenton.

Alan is also providing one-on-one coaching and has been an invaluable resource to creating modules, especially sample rate versions of complex things that may have only been easily accomplished at Capyrate before. He is responsible for talking my brute force approach to the matrix mixer and turning it into an easier to maintain script.

bphenix · 2021-01-17T00:22:03.036Z

This is always a tricky one to answer since I find which environments work highly dependent on your workflow, interests, and personal preference.

I am not a programmer by trade and you don’t need to script at all to be highly successful using Kyma. Over the years, I’ve picked up a snippets of things that I use where needed or I just work it out the long way and then perhaps someone shows me a short cut that makes reusability easier. I’d say the vast majority of users don’t script at all. Kyma does make use of text commands here and there for control signal and those are handy but it again, it is very easy to use selectively in spots. For many, many years I spent most of the time working with the higher layer flows of wiring together existing modules. Even now that is where I spent most of my time. That said, there is amazing power in Capytalk and I’ve been spending more and more time learning those over the past 5 or so years and that library of commands continues to grow in new and interesting ways. But I don’t consider that true programming and they are easy to use. They also are designed to be used a standalone statements and don’t require structured code.

For me, the limitations mostly are not knowing the best way to solve something and my own limited understanding of certain concepts.

I found Kyma easier to learn than CSound and PD for sure. I liked SuperCollider but I also found Kyma far more powerful and compete, though it has a been a long while since I picked up SuperCollider. It was the first of many tools I’ve tried that just synched with me and I haven’t found anything I prefer better after 20+ years. If I gave up Kyma, I’d spend a lot time inside of Bitwig Grid, return to SuperCollider, or see if Max is finally less frustrating to me.

If you decide you want to pursue that path further, feel free to reach out to me and I’d be happy to do a zoom call to answer questions and screen share Kyma in action more.

bphenix · 2021-02-09T06:36:17.120Z

I’ve been sick for the past month so not a lot of Kyma or music recently. I started back on an older project this past weekend and ended updating a little helper sound that I think may be useful to others.

Depending on the area of Kyma you are exploring, you may find yourself creating large arrays of controllers. A common example is anything dealing with additive or aggregate synthesis. Other semi-common use cases are sounds like spectral delays or filter banks. You can easily find yourself creating banks of 16-32 or more faders for multiple controls like frequency, bandwidth, or amplitudes. This is great for detailed fine control over the sound but it can be challenging to manage quickly or modulate the array while maintaining relationships between the other parameters in the array.

Perhaps this is my brain gravitating towards patterns but I often find that arrays end up as recognizable shapes or patterns. For example, arrays distributed in a ramp from high to low or triangle shaped. So rather than manually adjusting massive arrays by hand, I wanted to create a simple waveform to array sound.

There are several ways to do this, in the past I used offset triggered sample-and-holds and FFT approaches but I found the following process the most flexible and easiest to modify and troubleshoot, though with some drawbacks depending.

Our signal flow:

wavetoarray1492×412 75.3 KB

wavetoarray-vcs2386×1398 155 KB

Here is the .kym for the above sound:
WavetoArray.kym (66.1 KB)

The core is a replicated sound with an oscillator that is phase offset by the number of values you have in the array. From there you can set the modulation running, freeze the sound, add an offset or reset the wave back to the starting point.

If you have ever created a large bank of faders and wanted to experiment with different settings quickly, I suspect that you can imagine how handy this approach could be. One obvious use case is scanning through a filter or an oscillator bank. Recently, I’ve been using it to control probability values within the nextRandomIndexFromDistribution that then selects notes within a scale. With narrow width but setting the curve to extreme values you can create highlight small areas within the array and then scan through those as well or create notch effect.

Note:
I sometimes find that using large banks Sound to Global Controls quickly leads to DSP overloads, especially when modulated. I don’t recommend using STGCs in this way typically. Rather, I recommend hardwiring this directly into your modulation destination where possible.

bphenix · 2022-04-11T00:18:35.679Z

K_Field Lab

I’ve always heard great things about Fairfield Circuitry and, in particular, the Shallow Water pedal. Happily, the designer includes the signal flow in the spec / manual which makes it a heck of a lot clearer what is going on compared to the general description.

shallow_waters1678×820 72.9 KB

I love using stuff like this as a jumping off point for creating Kyma patches. It sparks ideas but not having the reference example often means I can explore and learn without trying to recreate the canonical version initially.

Let’s start with the modulation circuit. This is basically a filtered noise design that is very similar to the Buchla 265 Fluctuating Random Voltages circuit described above. Alan Jackson recently outlined a correlation script in CapyTalk, reproduced here:

| lastValue currentValue |

lastValue := EventVariable new
initialValue: 0.
currentValue := EventVariable new
initialValue: 0.

(!Rate hz s tick evaluate: (
     (lastValue <+ currentValue),
     (currentValue <+ (!Correlation interpolateFrom:  Noise L to: lastValue))
)), currentValue

Noise L is a white noise generator though you could insert a CapyTalk expression in its place.

By doing in a script, we save adding a feedback loop and the attendant dsp overhead though we give up audio rate resolution. That doesn’t matter in this design since our rate control won’t exceed control rate.

To complete the delay modulation section, Shallow Water has a “damp” control which in the original design appears to independently set the noise filter from the s&h rate and as such results in sharper edges to the modulation. I use a simple filter based on a delay line as the built in Kyma filter doesn’t seem work properly below about 4 hz and as such is ill suited for this use case.

For the post delay filter, the envelope response isn’t specified so I do not know if it is fixed or dynamic based on other controls or input. I prefer having direct control over the env follower anyhow since this allows you to better tune the responsiveness for various source materials. At small values, you can get fuzz-like sounds and is useful for plunky or drums. If you want a dynamic system, I recommend tying the rate to the attack / release so that the rate scales with higher rate resulting in faster attack / release times.

I added a number of minor additions to improve the response of the envelope follower, along with added filters and transfer functions. This is an area the Fairfield team likely spent some time fine tuning to get the responses they sought for their vision and potential source materials they were tilting towards since as a dynamic and interactive network, it can go in many different directions especially as you add additional response points within the network.

This core design is quite a lot of fun and I want a Shallow Water all the more now as I could see it being a great addition to my computer free setup. I’ve also read the pedal has a fantastic boost circuit which is always a big plus.

One delay is nice but we know many of the classic chorus circuits use 3 delay lines modulated by different phases of an LFO. Let’s see if more is better here.

The replicator makes this clean and easy. Instead of different phases of an LFO, we use uncorrelated noise (in kyma case, white noise with a different seed per voice). We add a spread control to create a stereo image and a set of independent controls for each delay line including a rate ratio, level, and invert. At this point we have departed quite a bit from the original design and we go even further and potentially collapse the field by wrapping the whole thing in a feedback loop. That said, three delays, especially with stereo panning is lovely. I played with more than three and it just is a mess after a while so three seems to be sweet spot.

kfied_signal_flow1920×751 55.2 KB

Attached is an example kym files as a starting point. The implementation is a bit rough around the edges and needs a bit of clean up and fine tuning before encapsulation but should get you started.

K_Field_Lab.kym (646.8 KB)

bphenix · 2022-12-05T05:16:56.191Z

I was working with a multi-tap delay and I wanted to create different tap spacing strategies, one of which would be a sequence of prime numbers.

There is a Smalltalk message called nextPrime that returns the next nearest prime number but if you want to use ?VoiceNumber or ?CascadeNumber to fetch the next prime in the sequence, nextPrime will return doubles of primes at various points in the sequence as the ?VoiceNumber. The alternative is to script it to capture the prime number and use that to fetch the next one.

An example is copied from a version of Ian’s Dattorro reverb implementation:

| primes x|
x := 1.
primes:=
1 to: 205 collect: [:I |
x:= x nextPrime.
x.
].

It occurred to me that what I really wanted was different subsets of prime number sequences. We all are familiar with the ‘regular’ sequence of prime numbers but mathematicians do love to a clever game or exploring various formulas to create different prime number subsets.

To implement these completely in code is beyond my needs, desire, or skill for a ‘quick’ afternoon project and since I rarely need more than the first 32 of any subset, it was easier to copy them out by hand into lookup tables which are used to populate a Smalltalk dictionary object.

|  primePresets primeArray  |

primePresets := Dictionary new.

primePresets
add: #regular ->  #(2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131);
add: #chen -> #(2 3 5 7 11 13 17 19 23 29 31 37 41 47 53 59 67 71 83 89 101 107 109 113 127 131 137 139 149 157 167 179);
add: #higgs ->  #(2 3 5 7 11 13 19 23 29 31 37 43 47 53 59 61 67 71 79 101 107 127 131 139 149 151 157 173 181 191 197 199);
add: #eisenstein -> #(2 5 11 17 23 29 41 47 53 59 71 83 89 101 107 113 131 137 149 167 173 179 191 197 227 233 239 251 257 263 269 281) ;
add: #gaussian ->  #(3 7 11 19 23 31 43 47 59 67 71 79 83 103 107 127 131 139 151 163 167 179 191 199 211 223 227 239 251 263 271 283);
add: #pythagorean ->  #(5 13 17 29 37 41 53 61 73 89 97 101 109 113 137 149 157 173 181 193 197 229 233 241 257 269 277 281 293 313 317 337);
add: #isolated ->  #(2 23 37 47 53 67 79 83 89 97 113 127 131 157 163 167 173 211 223 233 251 257 263 277 293 307 317 331 337 353 359 367);
add: #ramanujan ->  #(2 11 17 29 41 47 59 67 71 97 101 107 127 149 151 167 179 181 227 229 233 239 241 263 269 281 307 311 347 349 367 373);
add: #harmonic ->  #(5 13 17 23 41 67 73 79 107 113 139 149 157 179 191 193 223 239 241 251 263 277 281 293 307 311 317 331 337 349 431 443);
add: #long ->  #(7 17 19 23 29 47 59 61 97 109 113 131 149 167 179 181 193 223 229 233 257 263 269 313 337 367 379 383 389 419 433 461);
add: #euler ->  #(19 31 43 47 61 67 71 79 101 137 139 149 193 223 241 251 263 277 307 311 349 353 359 373 379 419 433 461 463 491 509 541);
add: #irregular ->  #(37 59 67 101 103 131 149 157 233 257 263 271 283 293 307 311 347 353 379 389 401 409 421 433 461 463 467 491 523 541 547 557);
add: #good ->  #(5 11 17 29 37 41 53 59 67 71 97 101 127 149 179 191 223 227 251 257 269 307 311 331 347 419 431 541 557 563 569 587);
add: #lucky ->  #(3 7 13 31 37 43 67 73 79 127 151 163 193 211 223 241 283 307 331 349 367 409 421 433 463 487 541 577 601 613 619 631);
add: #super ->  #(3 5 11 17 31 41 59 67 83 109 127 157 179 191 211 241 277 283 331 353 367 401 431 461 509 547 563 587 599 617 709 739);
add: #happy ->  #(7 13 19 23 31 79 97 103 109 139 167 193 239 263 293 313 331 367 379 383 397 409 487 563 617 653 673 683 709 739 761 863);
add: #emirps ->  #(13 17 31 37 71 73 79 97 107 113 149 157 167 179 199 311 337 347 359 389 701 709 733 739 743 751 761 769 907 937 941 953);
add: #safe ->  #(5 7 11 23 47 59 83 107 167 179 227 263 347 359 383 467 479 503 563 587 719 839 863 887 983 1019 1187 1283 1307 1319 1367 1439);
add: #balanced ->	#(5 53 157 173 211 257 263 373 563 593 607 653 733 947 977 1103 1123 1187 1223 1367 1511 1747 1753 1907 2287 2417 2677 2903 2963 3307 3313 3637);
add: #circular ->  #(2 3 5 7 11 13 17 31 37 71 73 79 97 113 131 197 199 311 337 373 719 733 919 971 991 1193 1931 3119 3779 7793 7937 9311).

I restricted my list to sequences where the 32nd digit was less than 10,000 with most being less than 1000. This gives us 20 options.

Now that they are in the dictionary, we can collect and unroll the array back out of the dictionary named primePresets.

"Build a collection of arrays based on Dictionary of Primes"
primeArray := (1 to: 32) collect: [:i | 
	Array 
	with: (0@ ((primePresets at: #regular) at: i)) 
	with: (1@ ((primePresets at: #chen) at: i))
	with: (2@ ((primePresets at: #higgs) at: i))
	with: (3@ ((primePresets at: #eisenstein) at: i))
	with: (4@ ((primePresets at: #gaussian) at: i))
	with: (5@ ((primePresets at: #pythagorean) at: i))
	with: (6@ ((primePresets at: #isolated) at: i))
	with: (7@ ((primePresets at: #ramanujan) at: i))
	with: (8@ ((primePresets at: #harmonic) at: i))
	with: (9@ ((primePresets at: #long) at: i))
	with: (10@((primePresets at: #euler) at: i))
	with: (11@((primePresets at: #irregular) at: i))
	with: (12@((primePresets at: #good) at: i))
	with: (13@((primePresets at: #lucky) at: i))
	with: (14@((primePresets at: #super) at: i))
	with: (15@((primePresets at: #happy) at: i))
	with: (16@((primePresets at: #emirps) at: i))
	with: (17@((primePresets at: #safe) at: i))
	with: (18@((primePresets at: #balanced) at: i))
	with: (19@((primePresets at: #circular) at: i))
].

Now within the replicated sound, I can use the ?VoiceNumber or ?CascadeNumber to fetch the value at the position within the array and use it to set the tap time.

Example:
(!PrimeType into: (?primeArray at: ?VoiceNumber))

Make your !PrimeType control in the VCS size 0 to 19 to cycle through the dictionary list. Add the list as VCS tick markers to show the names.

It is worth noting that a you could also do this entirely within the CapyTalk expression select: of : as what is created above is a 2d nested array. The advantage of the dictionary approach is for long lists, it can be easier to read and remember which row within the array belongs to which named entry and that can be useful during troubleshooting. The expression select: select: of: creates a 3d array.

Next post will insert the above example into a multi-tap delay.

Cristian_Vogel · 2022-12-05T23:11:03.414Z

Hi, not sure if anyone reading this thread is aware of it, but the NeverEngineLabs Wireframes library for Kyma has been on GitHub for a while now.

GitHub

GitHub - cristianvogel/wireframes: Library for Symbolic Sound Kyma

Library for Symbolic Sound Kyma. Contribute to cristianvogel/wireframes development by creating an account on GitHub.

bphenix · 2023-04-01T18:06:09.735Z

Pedals are always a fun source of inspiration. They tend to be focused, have all sorts of design constraints, and focus on real-time playability. This creates a vibrant and diverse set of outcomes from a few basic building blocks.

A few years ago I was looking at Pladask Elektrisk pedals, likely because I was considering the FABRIKAT in my currently unsatisfied search for a granular pedal. I noticed the FEBER pedal which contains the following description:

An exploration of the intersection of single sideband modulation, ring modulation, phasing and tremolo. FEBER combines a ring modulator pair, a Hilbert transform approximation, feedback and a random value sample/hold generator into a feature rich tool for exploring amplitude- and phase-based modulation at both high and low frequencies.

That sounds awesome and definitely a fun realm for all sorts of sounds both lovely gentle warbles and clangly, feedback mayhem. I set it aside to come back to create a prototype based on this and keep an eye out for purchase.

A few months ago, a similar topic came up during a weekly Kata call and that led to the creation of a bidirectional pitch shifter.

One of the issues with digital pitch shifters is that they ‘reflect’ the waveform as the signal hits the boundary at the top (half sample-rate ) and bottom (negative frequencies). Aliasing.

Alan & Pete, along with some others I forget (Jim, Andres, Simon,…?), worked through how to compensate for that. Here is the signal flow:

bidi-shifter3270×1392 155 KB

A couple notes, especially for those who may not be familiar with Kyma concepts:

Kyma Hilbert provides the 90 degrees signal on the left signal output and the orginal on the right.
The Hilbert has latency, defined by the NumberTaps setting. The default of 1051 is recommended. If you need greater accuracy especially at sub-audio rates, you can increase the value and the expense of increased latency. The default works great for our needs.

So that is the core bidi-shifter. I created an encapsulated version to reduce clutter for the next step. The encapsulated version is included in the link below. It has a couple tweaks with sample rate controls for band mix, frequency, and dry signal mix. The dry signal is latency compensated.

From the bidi shifter, the rest of the main signal path for the FEBER is easy: signal > shifter > filter and wrap that in a feedback loop. The modulation is then sent to the frequency.

Modulation is the first area where the designer choices really start to appear and there is no ‘right’ choice, just opinions and preferences, though admittedly those opinions tend to cluster in patterns.

The FEBER description is noise into a sample-and-hold with an interpolate option and cycle rate between 0 and 30 hz. I’d guess the noise in the original is not pure white but pink or is white but then transformed so that the modulation is distributed equally across each octave when at max. But white noise could be fun too, especially at lower settings. So let’s have both. Our control rate is low enough we could do this all in Capytalk easily but I am doing them here in signal flow because I find it easier to understand a glance and because I tend to want to try different processes to control signals and it faster for me to test ideas out in the signal editor and then go back and tidy up with Capytalk if desired.

The interpolation method isn’t defined in the docs, but it makes sense that it is not a straight line and is synched to the rate. I am using a control filter that works below 4 hz (the native filters don’t work properly if their cutoff is below 4 hz or so). Because controls are cheap in Kyma (unlike the limited surface of a pedal), we can add a variable smoothing rather than an on/off switch. At full smoothing, the cutoff frequency, and hence the interpolation curve between values, is synched to the sample-and-hold rate.

So we have a modulation source in the form of a fluctuating random voltages circuit but with some extra bits. In the future, I will likely add a feedback loop (more likely a Capytalk equivalent) here to create a correlated signal which could be handy for creating a brownian walk to the sound.

So at this point, we have already gone afield of the FEBER through our choices within the modulation section (and our ignorance of what choices Pladask made here outside the some guesses and what is documented in the manual), but we have the core FEBER design and it can be tweaked and shaped in many different directions. It is capable of so much from gentle tremolo sounds and glitchy feedback squeaks and squalls. The pedal must be a ton of fun, especially when paired with other effects and feedback. It is easy to see why they are popular on the secondhand market and sell out quickly when available new.

From here, we can leverage the fact that we have DSP to burn and few limitations on the control interface other than those we self-impose.

Add a high-pass filter and saturation to the tone. At this point, I started inserting envelope followers to modulate the filter and side-band mix. The envelope followers really add a nice lively dimension to the sound. I added a control to change the response rate in real-time.

Next was to add a delay to the feedback path. I played with a normal fixed delay and that was nice but I wanted something ‘integrated’ with the rest of the overall design. I pulled in the delay Pete built that has tapehead like qualities and synced its delay time to the frequency of the pitch shifter. This means at lower frequency values the delay time can get long (this one has a fixed maximum of 120 seconds). I’ve been meaning to do more with this delay. It is so nice. I know there is an immense gravity pull to go down a certain paths with a tapehead core, I feel them myself regularly, but they are useful in many additional contexts.

But synching the delay to the frequency is not the only choice. Another option is the sample-and-hold rate. The goal was to constrain the available controls and these are the two most natural as they both share a time based component with the delay. A switch could easily be added as well as a clock divider or a probability chance so the sample hold skips around out of step. But that is getting ahead of ourselves.

feber1920×829 46.5 KB

And a VCS that looks like this:

vcs2918×1848 178 KB

I arranged it so that it was readable and to hopefully be functional to interact on screen but also auto-mapped to my Motormix in a useful way for live playing (the first 8 of the top row, hence the filter section dropped a bit lower). I think another live control to add would be an ‘external’ audio sidechain path into the envelope follower.

This shift > filter > feedback delay combo is as good a place as any to wrap up here. The sound is linked below. No presets to start with. There are many ways to continue to expand and explore. Lots of modulation options, especially with shift registers and other stepped noise. Add multiple delay heads to the feedback loop or a granular delay. Wavefolders are always a good time but can be difficult to tame. Or a scattering of particles. And it should be stereo.

Enfebre.zip (793.8 KB)

bphenix · 2023-06-19T18:51:05.432Z

In case you have not built your own versions, here are two handy bit operators:

LFSR

The 8-bit LFSR has a few extras and options:

Audiorate clocks accepted
Clock conditioning. Can be used with any input, including a sample file as long as the input crosses zero at some point.
8 Total outputs
- Output 1&2: Tap 1
- Output 3: 4-bit DAC based on the first 4 taps
- Output 4: 8-bit DAC based on all taps
- Output 5-8: Taps 5-8
Toggles to enable / disable XOR operations at Tap2-4
Add / Injection to start the LFSR. Holding for 8 clock cycles will fill all the slots with a 1 and then releasing will start the LFSR cycle. This can also be used to inject a new value into the sequence and changing the loop.

Knot Register

The core of the Lorre Mill sequencer, itself built on the CD4105. I have not modeled or built out the entire Double Knot device. The Lorre Mill was built during a Kata session. That is for your fun

Knot+LFSRv2.kym.zip (199.5 KB)

Update:
Discovered an interesting bug in my sound due to a kyma nuance that I never knew before today, but I think I ran across before and didn’t understand then.

The channel selector optimizes to reduce compiling parts of the branch that appear unnecessary in an effort to reduce DSP load. That is handy and useful in many cases. However, in this case, for some of the channels, I was taking taps out to the individual channels prior to the final tap. That had the side effect of eliminating the feedback loop after the last tap. The fix is to make sure the feedback input is added to each channel (muted into a mixer).

The corrected sound has been added here as a v2.

bphenix · 2024-08-05T22:27:59.269Z

On a recent Kata, a question was asked about different modulation approaches for replicated sounds with a focus on reducing the overall number of controls to improve playability.

Here are some notes and examples from that session. Contributions from a number of people including Rio, Alan, Pete, and Vlad.

If you want to build along with these notes, I’ll list these in one order from “right to left” but that doesn’t necessarily mean that would be how I’d build in practice. That often depends on the flow of working through an idea. Also included at the bottom is the kym file with all of this built out with several variations.

Build notes
Open a new sound file or add a replicator to your existing sound and set that up for 16 voices. For this example, that is enough voices to see some of the more complex behavior in action.

The nice thing about using the replicator rather than a script here is that it will be easy to modify the number of replicators to use your use case. I personally default to enabling RenameSpecialEvents and then add which event values you want to generate multiples of. I find that usually there are only a handful which I want replicated and especially in the case where we are trying to reduce the number of real time controls.

Put a SoundtoGlobalController (STGC) into the Replicator. In this example, we are using it mostly for visualization. Name the Generated event to something like !ModOut or something generic. Add that name to your RenameSpecialEvents in the Replicator.

Into the STGC, add AddWrap. An AddWrap is a mixer where if the sum of the inputs is greater than -1 or 1, instead of clipping, the values wrap around. This is particularly useful when doing index or phase manipulation.

Into the AddWrap, add a TimeIndex and a STGC. Copy that STGC into the AddWrap so it is in there twice. A constant is typically used but in this case I am using another SoundToGlobalController so we can monitor how the phase offset is being manipulated. Name the STGC generated !Phase and add that to the Replicated sound.

We put the Spread STGC twice because we want to create a range of 2 so that when the index offset value is -1, we can spread across the full range. Keep this in mind if you replace the Ramp with another source or remove it altogether. You may need to scale the source or if using fixed values, add an offset, or remove one of the Spread STGC depending on your use case.

A scaled, equal weight distribution Spread would have the value: (?VoiceNumber-1)/(?NumberVoices-1) * !Spread

But we may not want equal weight distribution so let’s add distribution curves to the spread. Somewhat new to Kyma is the Capytalk function warpBy that provides an adjustable nonlinear warping function that can vary from logarithmic, to linear, to exponential. Adding that gives us: ((?VoiceNumber-1)/(?NumberVoices-1) warpBy: !Distribution) * !Spread

Note, that the !Distribution control will go from -1 to 1 in the VCS.

Other distribution strategies are also possible. One method is creating arrays and then using the ?VoiceNumber to index into that array. This could be in addition to or in place of the above method.

If we want to add repeating ‘horizontal’ patterns, we can use the GainWrap feature. I recommend using 1 + (!Wrap * (?NumberVoices-1)) here as it will automatically scale based on the number of voices but it is just as valid to hard use 1 + !Wrap or even just !Wrap and scale the fader from 1 to N max wraps in the VCS. There are pros and cons to each approach.

For the TimeIndex, create a hot control for the cycle time at minimum. I also recommend adding a reset button and a freeze function. The freeze function is by adding a toggle that sets the frequency to zero. Within a sound you may want to map reset to !KeyDown and the !Freeze function could be triggered. This is perhaps more interesting when using the modulator in sample playback or time index (granulator, spectral, sample, etc).

So now we have a fairly full featured basic spread. I recommend spending some time with this basic version to get a feel for how the controls interact. We only have a few at this point: Frequency, Spread, Distribution, and Wrap plus the optional freeze and rest to drive modulation across how many replications we desire (example 1).

basicspread2426×1434 118 KB

I’d also spend a bit of time tidying up the VCS so that it is easy to monitor and visualize how the replicas are behaving. I prefer making the replicated controls into an array to make it easier to clean-up and move things around.

As mentioned at the start, we used an index instead of a traditional LFO because it provides a bit more flexibility to drive more complex shapes.

The next step is to add a wavetable reader in the form of the Morph1DWaveshaper after the GainWrap (example 2). Add in a set of wavetables. In these example, we are using bipolar wavetables but that isn’t required.

We can also add a form of PulseWidth or Tilt control. We do this by using the InputOutputCharacteristic prototype to remap input and output values (example 3) to change the zero crossing center point. By using positive only waves like Gaussian or TrianglePos, we can change the length of the rise and fall portions of the wave. An example of this technique is found in Chase Bliss Warped Vinyl and Gravitas pedals.

tilt3248×1470 147 KB

Next let’s add some random variation. There are a few approaches which can be loosely grouped into correlated and uncorrelated. If you want each voice to be completely uncorrelated then take a noise source, each having unique seed values based on ?VoiceNumber, and run it through a sample and hold.

An example of a correlated approach would be to use a shift register so that each voice is a step along the register and a value is passed to the next voice once it receives a new value. Depending on how this is set up, all the voices will start at the same place and then drift as the ASR fills up or we can seed all the voices with a starting point.

There are additional variations and additions here, for example, using an LFSR, concepts from the Buchla 266, random walk, smoothing, etc.

asr3248×1470 149 KB

These examples focus on direct randomization of modulation output but I do also recommend experimenting with randomization elsewhere within the modulation chain.

Spread Examples

SpreadExamples.kym (294.8 KB)

Additional comments
A quicker method than the set up above would to just use an oscillator or the Morph1D oscillator and insert the spread offset into the phase modulation section. Especially, if you don’t need tilt or want to do other processing of the ramp before it hits the wave shaper.

Smuff · 2024-08-06T07:31:13.114Z

Wow some valuable info. Thanks!!