GlobSeq:

Global Sequencers and Kyma Scripting

by Cristian Vogel

Credits and Copyright

GlobSeq for Kyma 7: A Sequencer Specification Tool

Design and Programming by Cristian Vogel

All rights reserved
© Cristian Vogel 2018
Ⓟ NeverEngineLabs Plus 2018

GlobSeq is licensed under the following conditions:
You may not distribute, sell or re-use GlobSeq or any part of its documentation or source code in any software, hardware or other form of distribution that contains it or is a derivative of it without prior consultation and written consent.

GlobSeq: Global Sequencers and Kyma Scripting

Written by Cristian Vogel
All rights reserved
© Cristian Vogel 2018
Ⓟ Version 1.1 published 27th September 2018 NeverEngineLabs Plus

Kyma is a registered trademark of Symbolic Sound Corporation.
The GlobSeq name is protected under copyright.
Web: www.neverenginelabs.com
Twitter: @neverenginelabs
Email: support@neverenginelabs.com

What is GlobSeq?

GlobSeq is an encapsulated Class for use in Kyma Signal graphs, Timelines and MultiGrids. It was designed and programmed by Cristian Vogel entirely in the Kyma environment using Smalltalk and Capytalk. Its main function is to sequence through pre-defined collections when triggered and emit the value of the element at the current step. By that general definition we could say that GlobSeq is a step sequencer. But actually it is much more than just one type of step sequencer.

GlobSeq is a tool that enables you to specify the feature set and interface for sequencers of your own design in Kyma.

By default, GlobSeq does not create any audio signals of its own, but instead focusses on scripting as a means to rapidly prototype different types of step sequencers with which you can create audio by modulating the parameters of audio generators in Kyma or — as we shall see — possibly beyond Kyma.

This book is intended to be a user guide for the Global Sequencer tool, but can also serve as a valuable introduction to Kyma scripting and it’s two integrated languages — Capytalk and Smalltalk.

Even if you are just curious about GlobSeq and Kyma, we hope that reading through this book may help you step forward with your understanding of how scripting can be used in the Kyma system or simply inspire you in your creative pursuit whatever that may be.

Global Sequencer

The main differences between a GlobSeq sequencer and the standard Kyma step sequencer is that a GlobSeq sequencer broadcasts its output mainly as Kyma specific global controller events and/or as MIDI Events and/or as audio control signals. What this means, is that the current value of each pattern is broadcast to the rest of the Kyma signal graph or to external devices from a global controller with a unique !hotValue name which you define. As you might know from elsewhere in Kyma, the hot value generated by a global controller can be used in any parameter field in the signal graph by simply typing it's name. It can be used on its own or nestled in a Capytalk expression like in this example:

(!glob_cutoff * 1000) + 80 hz

In this way GlobSeq can be used to automate parameters anywhere in the signal graph, not just in Sounds that are connected to the left of it, like the standard Kyma step sequencer does. In fact, by default you don’t even need to connect a GlobSeq instance to anything in particular in the signal graph. GlobSeq doesn’t use the symbolic “wire” metaphor as an output, like other Kyma Sounds do. The globals which GlobSeq generates usually appear in the VCS as widgets which change value according to their sequenced rows. You don’t interact with one of these generated widgets in the VCS. You should think of it as a way to see the value of an automated variable modulating some aspect of the Sound Program running on the Pacarana. Furthermore, as we shall soon see, you could also start modulating systems that exist outside the Paca(rana) with these globals when you start using the external routing options of a GlobSeq sequencer.

What the Global part means

To use any global generated by your GlobSeq sequencer, you just have to type its unique !generatedEventName in the parameter field or Capytalk expression you wish it to modulate. As mentioned earlier, GlobSeq events could also be used as signals that control external hardware or software outside of Kyma using MIDI, OSC and Control Voltage.

The Control Voltage option is a special scenario which enables GlobSeq to output audio rate control signals through Kyma's audio outputs. If you have a DC coupled interface or an ADAT-to-CV module such as the ExpertSleepers ES-3 you will be able to sequence your Eurorack modular synth from GlobSeq.

Vintage and modern MIDI gear can also be sequenced with note, velocity and CC numbers by simply setting the MidiChannel to any value higher than 0 and connecting a MIDI cable from your Kyma system's MIDI output to the hardware. If you own Delora Software's KymaConnect then you can send MIDI control data from GlobSeq via the VirtualPacarana MIDI output to other software and control VST instruments running in your DAW.

And for further advanced applications you can use Kyma's built in OSC support. With OSC you can send high resolution OSC control messages to sequence software controlled lighting systems, spatial sound parameters, virtual object, dancing robots or anything you can think of using GlobSeq sequencers and Kyma.

External Control of GlobSeq

This goes the other way too. When you want to step a GlobSeq from an external clock source such as a modular synth pulse output, or some other kind of trigger generators you can do that as MIDI, audio or voltage signal. GlobSeq can even extract triggers from a continuous audio signal, such as an LFO or waveform allowing for some interesting groove warping and groove morphing ideas, that will go way beyond the ‘shuffle’ feature of conventional sequencers.

If you want to program steps realtime into sequencer patterns using hardware controllers, your touch tablet or other controllers, this is possible too, using Kyma’s built-in method for mapping widgets in the VCS to external controllers, which of course is all fully compatible with GlobSeq.

Possibilities are quite far ranging, as you can probably sense by now. If you have purchased the GlobSeq Examples Pack, you will find some examples of how to program GlobSeq to do all of the above and more, which you can use as starting points to successfully integrate sequencers with your own setups and workflows.

Brave New Hello World

Kyma has always been a little unconventional in some things and this is exactly what we love about it at NeverEngine Labs. For example, most scripting languages out there are introduced to a new user through the convention of a ‘Hello World’ program which simply prints ‘Hello World’ to the screen. In Capytalk, you would never need to write such a pointless script, so there isn’t any obvious way to do a ‘Hello World’ program. You could load a text file containing the words ‘Hello World’ and turn each character into a sound quite easily though.

The point is, that Kyma scripting is not an essential part of using Kyma, but learning more about it can be very rewarding and actually quite straightforward. Scripting in Kyma feels elegant, lean and efficient and does not demand that you know anything about Asynchronous Functions and Pointers and Types and stuff which will send you deep into forums and tutorials and far from the goal of making expressive electronic music — which is what the Kyma system is almost entirely dedicated to.

Why Script?

Learning how to script with confidence is the key to opening up amazing next level stuff because — at its heart — Kyma is a powerful and elegant computational music and sound design environment. You program little programs here and there to compute variation or nuance or just to keep things varied in the music you are creating. Whats more the sound altering and music generating scripts you write will always sound amazing thanks to the precision and power of the Paca(rana) sound computer.

Capytalk and Smalltalk.

Capytalk and Smalltalk are two scripting languages that co-exist and can be used together in Kyma scripting. Capytalk syntax is pretty much the same as Smalltalk syntax. In fact, they integrate so well together that Kyma users sometimes get confused about which is which. It is important to understand what makes them different and to know where to use one and not the other.

Capytalk is used to CONTROL things.

Capytalk is a high level event-driven language for realtime computation. Capytalk is an elegant and streamlined approach to realtime programming developed by Carla Scaletti at Symbolic Sound since the start of Kyma back in the early 90s. It has exceptionally tight scheduling and precise timing which you can really rely on, no matter how complex your program might be. Capytalk is characterised by event driven expressions and !HotValues which usually appear as graphical widgets in the VCS. Capytalk is a way to interact with the variables of a program that has been designed in the programming environment - Kyma on your host machine - but will execute in an audio specialised runtime environment - the Paca(rana) sound computation engine. For those of you who might be reading this and don't know what a Paca(rana) is, it is literally the other half of the Kyma system, a masterpiece of DSP hardware designed by Kurt Hebel to work hand in hand with the Kyma software programming environment.

This is what Capytalk looks like:

(!run bpm: bpm) nextChaotic * (!range smoothBy: (!sloGroTime * 10))

At runtime, all Capytalk expressions are evaluated every millisecond. Sometimes they are evaluated only when a user specified event happens. When Capytalk is executing on the Paca(rana) at runtime, it no longer exists in any form of human readable script. Instead, it has been compiled into a low level machine code program which runs perfectly alongside precision high speed audio processing on the Paca(rana). OK. And Smalltalk?

Smalltalk is used to BUILD things.

“More than four decades later, no programming language has yet to catch up to Smalltalk in terms of simplicity and elegance, minimal cognitive friction, object-oriented purity, elegant live coding and debugging, enormous programmer productivity, and professional respect.” — https://hackernoon.com/@richardeng

Smalltalk is a revered “Object-Oriented” language that has its roots in a golden age of computer science. In Kyma, Smalltalk only works in the programming environment. In fact, Smalltalk seems to be the language that the programming environment is mostly written in, but I may be wrong about that.

This is what a little Smalltalk program looks like:

| x y |  "define some variable names"

y := #( 1 2 3 4 ). "create a Collection and assign it to y"

"Smalltalk block transforms each element of y and collects a new collection"
x := y collect: [:a | a * 10]. 

"yield the new collection in reverse order #(40 30 20 10)"
x reverse

The main thing to understand in the context of Kyma is that any purely Smalltalk code is interpreted before the program is sent to the Pacarana. It is often written in Kyma’s Script Prototype which passes results into the Signal graph using the special ?GreenVariable construct. But you don't have to work that way, in fact Smalltalk programs can be written directly into any parameter field, which is fine as long as they yield the right type of result for that field. The Smalltalk language interpreter is one stage in the automated process of building the machine code program that will be sent to the Paca(rana). It therefore serves no more purpose once the program is running on the hardware, and this is important point to understand. You don't use Smalltalk to change things in a Sound program that is running, you only use Capytalk to do that. So when do we use Smalltalk?

You can use Smalltalk to build more complicated scripts in just a few lines of code, keeping things graceful and elegant.

In more advanced Kyma programming, such as we do at NeverEngine Labs, Smalltalk can be used to construct different configurations of programs according to some user options, or to construct Sound programs algorithmically using iterative Sound building scripts. That’s how the amazing Replicator prototype works in Kyma and how GlobSeq builds the sequencers of your dreams .

Smalltalk is especially useful for collecting numbers or Capytalk expressions together as elements into a Collection, which is the data structure at the heart of the GlobSeq concept. Here’s a very simple example of a shortcut in Smalltalk to create a Collection of faders in the VCS — widgets in the VCS are visible and grabbable Capytalk:

{!Fader copies: 16}

Type the above anywhere in Kyma, highlight it with your mouse and press ctrl-Y to evaluate the expression. Kyma will print the result directly inline. You will see that a little Smalltalk goes a long way. Here’s a slightly more flexible version which mixes Smalltalk and Capytalk. Can you guess what it does?

(1 to: 16) collect: [:i | (!Fader suffix: i) smoothBy: !faderSmooth s]

One final example here. This script could be written directly in the OnDuration field of a FunctionGenerator prototype, or anywhere that might expect a duration.

| x y |	

x := #( 1 2 3 4).

y := x collect: [ :a | 
					(a odd) ifTrue: [ a * 10 ]
							ifFalse: [ a * 100]
					].

(!Selector of:  y ) ms

Almost all of this script is classical Smalltalk. It transforms a Collection of numbers initially assigned to the variable x . The transformation happens to each element by the code inside the block. Each element from x is passed into the block using a temporary block variable [ :a | ... ] - this block structure exists in Smalltalk only. The block does some kind of conditional transform on each element as it comes through, and collects the result into a new Collection called y .

Smalltalk is great for building and transforming data Collections and lists of data objects, such as numbers, filenames in a folder or Capytalk objects as I mentioned earlier on.

Take a look at the last line of the example though. The last line is pure Capytalk coming into play at runtime. It allows you to index into the Collection constructed by the Smalltalk code according to an event called !Selector - which may possibly be coming from a GlobSeq sequencer, or manually with a widget in the VCS.

Carla Scaletti’s essential book Kyma X Revealed is the best place for further reference, and it is directly available from the Help menu in Kyma 7.

GlobSeq Scripting

Scripting with Kyma in the context of GlobSeq affords many new possibilities for innovative step sequencer designs for controlling Kyma Sounds and beyond. Remember, everything you learn about scripting when using GlobSeq will benefit you throughout Kyma. It’s really worth rolling up your sleeves and learning the concepts and syntax.

First Steps

1. Set some master parameters such as BPM and RUN in separate parameter fields of the GlobSeq prototype, just like in all other Kyma prototypes.
2. Decide which parameters you want to automate as GlobSeq globals.
3. Define the rows which will form the sequencer patterns by scripting in the fields called the MasterGatesPattern, MasterPitchesPattern and GlobalEventPatterns.
4. If the interpreter is happy with your scripting it will send the program to the compiler and the compiled code will be loaded to the Paca(rana).
5. Each GlobSeq instance you have in your signal graph will build the sequencer you have specified from it, with the kind of controls you have requested in the VCS will appear.
6. When you start things running using the RUN and BPM parameter fields, a GlobSeq sequencer will begin counting and stepping through all the Collections that you have defined in that particular GlobSeq instance generating globals from the rows you defined.
7. If you have specified MIDI or CV — it will also begin to output those events as audio and MIDI to external hardware or software.

Collection Row Sequence Pattern

Let’s look at a GlobSeq Collection the main data of the row definition. It could be just a sequence of fixed values that represent a pattern for example:

( 1 0 0 1 0 0 )

It could also be a sequence of fixed values and Capytalk expressions and !hotValues . A !HotValue element may well relate to a widget in the VCS because widgets are Capytalk !hotValues made visible. Here is an example of a six element Collection which contains different types of elements:

( {1 brownianGate: 3 s} 0 0 { !upBeat } 0 { 1 - !upBeat} )

You can also use the Smalltalk language as a way to fill and structure sequenceable Collections. Here are a couple of examples that create patterns of values using pure Smalltalk:

"32 values equally spaced between 0 and 1"
{ (0 to: 1 by: (1/31)) asArray } 

"A fixed Collection of positive growing Random Numbers using Smalltalk"
{ (1 to: 32) collect: [:i | Random new next abs * i ] }

And here is an example that uses Smalltalk to build a Collection made of 16 different variants of a Capytalk expression which also involves some widgets:

{ 
(1 to: 16) collect: [:i |
	(!baseNote suffix: i) +
	((!walk swarmFollowFromPosition: 0 stepSize: (i/16) reset: !reset) * 12) 
	] 
}

In the above example the script is spaced out a bit so it’s easier to read — which is best practice when you are programming. You can do that using ALT-Tab in Kyma. The example builds a collection whose elements start to wander from the base pitches set using a row of 16 faders in the VCS, whenever you toggle the !walk button. Some kind of wandering bassline perhaps?

At this point you could say that what we are describing here, is not much different to what the standard Kyma StepSequencer prototype already does. So what does GlobSeq bring to the party? GlobSeq brings its own custom set of scriptable options which you use to specify the features of a sequencer you want it to construct for you. As far as we know, this is a first in Kyma.

Let’s take a look at the GlobSeq options.

GlobSeq Options

The GlobSeq options have been carefully chosen to let you quickly specify what kind of things a sequencer will be able to do, how it will behave and how many interactive controls you want it to have. You use them inline with Capytalk and Smalltalk in a GlobSeq definition row.

Before you start programming your own sequencers you may wish to study some examples at first. You will find quite a few in the GlobSeq Examples Pack available at the website. Mixing the GlobSeq options with Capytalk and Smalltalk does need to obey some rules regarding unique names, correct use of curly parentheses, block structures and so on. But it won’t take long to master and once you are flowing, you will appreciate that you can use none, all or some GlobSeq options and it doesn’t matter how you arrange them. GlobSeq is pretty easygoing in that respect. As mentioned in the previous chapter it is advisable to use ALT-TAB to indent lines and use RETURN to space things out. It will be much easier to debug when problems arise.

GlobSeq options start with a # and you add them after the main data of the row definition. Detailed descriptions of all the options, how to use them and what they do, can be found in Appendix A of this guide and you will also find detailed in-line help for each parameter of GlobSeq when you are working with it in Kyma. Just hover your mouse over a parameter field and a short description will pop up.

Following now is an overview of the syntax for GlobSeq rows and the options for different types of rows. We start with how to correctly specify the name of the Global that will be generated and then go onto the GlobSeq options.

Generated Global Event Name

The first element in a GlobSeq row must be a name for the Global which will broadcast the value of the element at the current step in the row definition. The name declaration should begin with an exclamation mark and must be totally unique. If a global name conflicts with another name, things might not work as you expect and sequencers may malfunction. In the worst case, the Paca(rana) could crash. You can name a global anything you want but try to avoid number suffixes. Use letters instead.

Some examples

!UniqueGeneratedEventName
		!Glob_UniqueGeneratedEventName
		!DrumVoice_1 <--- (will work but not advised) 
		!DrumVoice_A <--- (preferred)

As is being emphasised here, you should not define a global which has the same name as another in the same instance of GlobSeq or another instance of GlobSeq that might be also running. Neither must it clash with any event names being generated by other SoundToGlobalController Classes somewhere else. If you want to work with the Replicator and GlobSeq - which can be really fun - a little extra care needs to be taken about keeping names unique. You will find good examples of how to do this safely in the GlobSeq Examples Pack .

Do not add extra Capytalk or anything else to a Global Name definition

The first element in a GlobSeq row definition is only a name for the global created by that row. You don’t add any Capytalk there or anything else. There are also some GlobSeq options which create globals, such as #counter and #gatesTick and the same rules apply to those.

Totally Wrong:

!Glob_CutOff * 10 hz smoothed 100 300 500 800

Correct:

!Glob_CutOff 100 300 500 800

Remember you can always add extra Capytalk to a global in the field where you actually refer to it. In other words, the correct place to put the scaling and smoothing in the above example could be in the frequency parameter field of some filter prototypes. Just put !Glob_CutOff * 10 hz smoothed in the frequency of a filter and it will be sequenced with initial values from the !glob_cutoff row but scaled smoothly inside the filter prototype. This is the correct workflow method in every case throughout Kyma when using SoundToGlobalController Classes.

SoundToGlobalController

GlobSeq is a member of the special SoundToGlobalController Classes in Kyma, which don’t directly create audio themselves.

STGCs and Triggered STGCs are a powerful set of Classes in Kyma, and form the basis for important design patterns in Capytalk programming. They generate global controllers from scripts or pasted sounds which appear as widgets in the VCS. They can track and then emit as global controllers all manner of triggered or time varying signals and scripted programs. They can be gated or continuously updated every millisecond.

Its important that you understand how they work, especially when it comes to avoiding naming conflicts with GlobSeq globals.

You can learn more about more about how to work with STGCs in Kyma by looking them up in the standard Kyma prototypes and reading about them in Kyma X Revealed.

GlobSeq General Usage

Detailed definitions can be found in Appendix A of this guide.

Valid Elements

1. A Fixed number 
2. A !HotValue
3. A Capytalk expression in curlies
4. A Pasted Sound in curlies
5. A SubCollection (in main data row and #fills option)

Arbitrary Global Generated Events

#( !generatedName <value> <value> <value>.... 
		#div <value> 
		#loop <value> 
		#glide <value> 
		#cc <value> 
		#freeze <value>
		#euclid <value>
		#gateType <value>
	)

Arbitrary Global Generated Events — Drum Machine Mode

#( !generatedName <value> <value> <value>.... 
		#gatesNN <value> 
		#gatesVel !VelEventName
		#gatesTick !TickEventName
		#fills <value> <value> <value>...  
		#gateType <value>
		#div <value> 
		#loop <value> 
		#freeze <value>
		#euclid <value>
	)

Master Pitch Pattern

!generatedName <value> <value> <value>.... 
		#div <value> 
		#loop <value> 
		#glide <value>
		#euclid <value>
		#freeze <value>
		#gateType <value>

Master Gate Pattern

!generatedName <value> <value> <value>.... 
		#div <value> 
		#loop <value> 
		#fills <value> <value> <value>...

You will find that the Master Gate Pattern has individual parameter fields in the GlobSeq prototype for defining Length, LoopMode, Shift, Euclid, Freeze, VelocityGlide, TickEvent and GateType. These act as masters when you don’t specify options for each row individually.


Let’s now take a look at the Master Gate Pattern to see why it is called Master.

Master Gate Pattern

The Master Gate Pattern in GlobSeq behaves and affects the behaviour of all the other rows in a GlobSeq sequencer in quite an idiosyncratic way. It is inspired by the many different approaches to monophonic step sequencers that have been tried over the years.

The idea in GlobSeq is that the length of the Master Gate Pattern, as defined by the number of elements it contains and the MasterLength parameter, defines an overall cycle period for one GlobSeq instance. All patterns reset when the master gate pattern resets. If sub patterns contain less elements than the Master Gate Pattern, then they loop around themselves according to the master loop mode, or the optional loop mode per row. This behaviour is different when a GlobSeq sequencer is in PolyMetric mode, but more about that later.

Each element in the Master Gate Pattern is interpreted as a gate stage, meaning in principle it is either on or off — a boolean Logic Value. When the value of a gate stage is positive, then it is considered on and will generate a gate of the type specified in the MasterGateType parameter. This gates a MIDI event and an audio CV event (if those features are active) and all the global event patterns will output their current step values.

What is special in GlobSeq is the behaviour when a gate stage is zero.

This is interpreted as the gate stage being off. When a gate stage is off, rows step and count but do not output a new value. Instead, they hold the last value that was gated and if there is a glide time they will glide away from the last value.

In practice, its a bit like the “Step Tie” feature found in some step sequencers but more unique. The behaviour means you step the sequencer with a regular clock without outputting values on every clock pulse from every row. Its more like a conditional mask than a tie, and the polyrhythmic output can quickly become interesting with this conditional holding.

As mentioned earlier, there is the polymetric option in GlobSeq. If you set this to true, the same gate logic conditional output occurs, but if pattern rows have different lengths to the Master Gate Pattern, they will cycle according to their own length — this is true polymetric sequencer behaviour.

You do know the difference between polyrhythm and polymeter right?

;)

Gate Velocity

Gate logic is all good and well, but the days of just On and Off are over. We can get more information than the 1-bit state of a stage by treating it’s positive value as the 32-bit signal that it is. With respect to this, a GlobSeq sequencer can also broadcast the value of each master gate stage using the optional GlobalGateVelocity global that you give a unique name to. The idea here is that the gate stages are not on and off, but are more like an on signal with an amplitude, much like in the modular synthesiser. And if a gate stage is on, then followed by some stages are zero (off) then the GlobalGateVelocity will exhibit the same 'holding' behaviour described above, which is useful for holding a sample or mono synth note between gate stages. A really special feature is the possibility of gliding between held velocities smoothly using the VelocityGlide parameter.

Modulating Gate Stages

In more advanced sequencer applications, the gate stages could be fast changing signals that may be updating much faster than the step rate. For example it may be a collection of Capytalk LFOs at different rates per step. GlobSeq reads the elements of the Master Gate Patterns at maximum rate (every millisecond) so when it encounters an element that is a fast signal changing signal this signal will be expressed both as the gate logic AND a fast modulation of the GlobalGateVelocity. It is kind of a Kyma / GlobSeq concept and will take some experimentation, but if you are already working with CV signals, VCAs and so on in your modular synth, it hopefully makes sense. Oh, and if that is you, of course these hybrid gate / modulation signals provide a good solution for making the most of Kyma’s most scarce resource — the 8 channel output limitation — as you can mult patch the one signal to both a VCA and a Gate input on the modular side.

A Collection of Fast Scaled Modulators as Master Gate

!glob_gate 
	{1 to: 8 collect: [:i | 
		(1 repeatingTriangle: (i * 100 ms)) * (!gates suffix: i)
	]}

You should use GateType 3 and a VelocityGlide widget to hear how the modulator/gates interpolate into each other when you turn some stages off. It’s pretty cool. You could use this fast update feature to trigger little fades on fills or whatever you can come up with.

More examples are available in the GlobSeq Examples Pack on the NeverEngine Labs website.

Advanced Scripting Tutorial

To define the elements that constitute a sequenceable collection, it could be as straight-forward as typing in a unique name for the global then a row of fixed numeric values and nothing else.

!Glob_Note 61 64 68 51 54 57 59 65

Alternatively, the row might consist of a unique name for the global then a collection of dynamic values that will be set by faders or other widget types in the VCS (Virtual Control Surface).

"generate 8 faders in the VCS called !pitch01 !pitch02 etc"
!Glob_Note { 1 to: 8 collect: [:i | !pitch suffix2: i ] }

As you can already see, programming GlobSeq will get you even more familiar with Capytalk and Smalltalk scripting in general. Once you get a hang of scripting in Kyma — which is really not as complicated as other systems — you will find that scripting is a particularly fast and efficient way to define collections of values, or collections of event expressions which you can then sequence through using GlobSeq. Additionally, GlobSeq features those extra scripting options of its own which help you configure different types of sequencing behaviour and characteristics.

"Smalltalk/Capytalk combo creates 16 faders in the VCS which will move smoothly when you change them. This row broadcasts its value as a global called !Glob_cutoff. Options will generate a step counter called !brightnessCounter and set the looping mode to be fixed as ping-pong"

#( !Glob_cutoff 
	{1 to: 16 collect: [:i | 
		(!brightness suffix: i) smooth: !SmoothingTime ] 
	} #counter !brightnessCounter #loop 2
)

When you get tired of so many parameters to manually control in a sequencer, you may start thinking about setting up probabilistic events or other algorithmic features. GlobSeq is written in Kyma and Kyma can be one of the most powerful algorithmic music systems if you want it to be. With GlobSeq you can easily design and explore advanced generative sequencers. This is because you can use all of Kyma’s Capytalk runtime expressions and pre-runtime Smalltalk language to define elements and patterns and you can use Capytalk to control many of the GlobSeq options too.

"Smalltalk/Capytalk combo fills pattern of 32 gates with a Euclidean distribution. Notice that only two widgets will be needed to change the Euclidean algorithm during runtime. A four element array of retrig fills will cycle within the 32, doing fills on every 3rd and 5th gate if that stage is on according to the Euclidean algorithm"
!Glob_gate
	{1 to: 32 collect: [:i | 
		i isOnForEuclideanBeats: !masterLength 
		pulses: !pulses 
		offset: 0 ] 
	} 
	#loop !GateLoopMode
	#fills ( 0 0 1 0 2 )

Mind-bending rhythmic complexity can quickly emerge when you discover that elements in patterns can control parameters from the same instance they are being sequenced by. You need to do this properly to avoid feedback loops which might crash the Pacarana. Use a special GlobSeq option called #gatesTick or the master GeneratedEventTick to do this type of thing safely. They broadcast a 1ms trigger global with the name you give it, whenever an element in the Master Gate ( using the GeneratedEventTick ) or a Drum Machine Mode Extra Pattern ( using #gatesTick) has a positive logic value. You can use these to trigger any type of triggered Capytalk expression, such nextChaotic or nextRandom. You could even count it to build nested mini-sequencers, such as !snareTick in the following example.

"#gatesTick of one `drum machine` type row affects the loopMode of the other which in turn is sequencing the MIDI note number of the first one"

#(!glob_kickGate 
	{!kickStage copies: 8} 
	#gatesNN {70+(!snareTick countTriggersMod: 8)} 
	#gatesTick !kickTick #counter !kickCounter
)
#(!glob_snareGate
	{!snareStage copies: 8}
	#gatesNN 60 
	#loop {!kickTick nextRandomElementOf: #(0 0 1 1 2)}
	#gatesTick !snareTick
)

Read more about Drum Machine Mode rows on page 39 “Global Event Patterns: Drum Machine Mode”

Appendix A

GlobSeq Optional Definitions

Inside the following code blocks you will find an example defining a fixed value element, then a widget controllable one, then some examples which set values algorithmically. Many more examples are available in the GlobSeq Examples Pack on the NeverEngine Labs website.

Clock Divider

#div <value>

1 = step every pulse

2 = step every other pulse

3 = step every third pulse

etc

Examples:

"fixed value"
#div 4

"manual control"
#div !clockDivider

"algorithmic"
#div { !stepCounter * 2 }
#div { (!stepCounter eq: 1) nextRandomElementOf: #( 1 1 4 8 16 ) }

Loop Mode

#loop <value>

Defines the way the iterator loops when it reachs the end of the row

0 = cycle forwards

1 = cycle forwards and backwards

2 = jump chaotically

Examples:

#loop 2

#loop !loopMode

#loop { (!loopMode * 2) rounded }

#loop { (!stepCounter gt: 4) true: 2 false: 0}

Row Length

#len <value>

Shorten the end of a row using a percentage value.

0 = one element

0.5 = half of the row

1 = all of the row

Not used in a Master Gate Pattern definition.

Examples:

#len (5/8)

#len !rowLength

#len { !glob_tick nextRandom closestPowerOfTwo abs }

#len { !growLength smooth: 60 s }

Row Shift

#shift <value>

Offset the row iterator to the right.

0 = no shift

1 = one place

2 = two places etc

Not used in a Master Gate Pattern definition

Examples:

#shift ?voiceNumber

#shift !rowShift

#shift { !glob_tick nextRandom abs * 8 }

Freeze Row

#freeze <value>

When <value> is non-zero, output of this row is muted, but the iterator continues to remember its progress. This is an easy way to do Elektron or Cirklon style step muting. When option is not used, the row will get frozen by the master freeze.

Not used in MasterGatesPattern

Examples:

#freeze !freezeRow

#freeze { !crashTick stayOnFor: 10 s } 

"50% probabilistic freeze"
#freeze { !snare_tick nextRandom sign }

"freeze on !freezeStage of the master counter"
#freeze { (!masterGateCounter eq: !FreezeStage) }

Glide

#glide <value>

Sets a glide time in seconds. This is not the same as normal Capytalk smoothing. It is an exponential glide between the previous value that was output towards the current one. Its behaviour definitely depends on #div and the [[Master Gate Pattern]] logic which defines when a new element is read from the row, especially when you are requesting longer glide times.

Not used in a Master Gate Pattern definition, use velocityGlide to glide gate velocities

Examples:

#glide 0.05

#glide !glideTime

#glide {!glideTime roundTo: !bpm bpm s}

#glide {0.01 * !stepCounter}

Gate Retrigger Pattern

#fills <value><value><value>…

Only used in a Master Gate Pattern definition or Drum Machine Mode extra patterns (see below)

A Collection of fast gate reTrigs for each step.

0 = no retrig

2 = 2xRetrig

3 = 4xRetrig

4 = 8xReTrig etc

Each element in the fills collection can be a number or a !hotValue or even a Capytalk expression. If there are less elements in a #fills collection than there are in the pattern row it is retriggering, it will cycle around its own length.

Examples:

"fill on every third step"
#fills ( 0 0 2 ) 

"a one element Array"
#fills ( !fills ) 

"build collection of widgets to manually set the fills"
#fills {1 to: 8 collect: [:i | !fills suffix: i ] } 

"fills on every odd step of a counter"
#fills ( {(!stepCounter mod: 2) * !fills} ) 

"random fills every fourth step"
#fills ( 0 0 0 {!fills * (!glob_tick nextRandom abs * 4)} )

MIDI Controller Number

#cc <value>

Specifies the controller number to output the row’s Global events to. The MIDI CC value can be fixed or it can be a hotValue, so you could re-route the MIDI CC destination dynamically in realtime.

Only used in GlobalEventPatterns which are not in Drum Machine mode

Examples:

#cc 7 

#cc !ccDestination

#cc {60 + (!glob_tick countTriggersMod: 2)}

Generate a Counter

#counter <generatedCounterName>

Generates a global that appears as a step counter widget in the VCS. You can also use its value in different places when you want to do things according to what step a particular row is on.

Remember, you cannot add any Capytalk to the name here and it must be completely unique.

Not used in MasterGatesPattern

Examples:

#counter !pitchesStepCounter

Global Event Patterns: Drum Machine Mode

#gatesNN <value>

Normal GlobalEventPattern rows have arbitrary values and interact with the Master Gate Pattern. The idea is that they are used more like controller automation for events generated with the master rows. But perhaps you want to have more rows that emit gate like events, without having to create another instance of GlobSeq and fill in all the parameter fields again.

Drum machine mode is the solution to this. It basically lets you build a hybrid drum machine and control sequencer with multiple voices in the GlobalEventPattern rows. This drum machine could exist alongside some bass line notes controlled by the master gate and master pitch rows — all in the same instance of one globSeq — this is a very useful and efficient feature, and although it might not make sense as you read this now, it will when you need it (hopefully).

If you define your row as usual !aPercEvent 1 0 0 1 0 0 0.9 0 but add the #gatesNN option followed by a number, then the pattern gets interpreted as a row of gates. The gates will ignore the MasterGatePattern logic, and emit their gate velocity to the global you have defined for use in the Kyma signal graph, and also to one fixed note number via MIDI for hitting external systems. The appearance of #gatesNN in a row definition also means you can work with the #gates family of options listed below.

The idea is that you might want to create a type of drum machine style step sequencer, with many different rows of gates, all firing on different globals , and different MIDI notes but on the same MIDI channel. When MIDI output is active, each row will send to the note number that accompanies its #gatesNN and it will send the gate logic (gate on, gate held) as gate velocity via that note and via its !globalEventName of course.

MIDI from Drum Machine rows is sent to the next channel up from the current global MIDIChannel you have specified in this GlobSeq instance. That is so you can define Drum Machine type rows within the same GlobSeq instance which is also broadcasting master gates and pitches (using the master rows) and perhaps other types of arbitrary global rows, on a different MIDI Channel.

Drum machine mode will ignore the gate logic of the Master Gate Pattern because they have their own gates, but they do still obey MasterLength and MasterLoopMode unless you give them individual globSeq options (#len #loop or #shift). They will also cycle as polymetric rows or not, depending on the master setting of the Polymetric flag.

Only used in GlobalEventPatterns

Examples:

!kickGate 1 0 0 0 1 0 0 0 #gatesNN 60 #counter !kickCounter
!snareGate 0 0 1 0 #gatesNN 61 #counter !snareCounter 

"The NN could be a hotValue"
!kickGate 1 0 0 0 1 0 0 0 #gatesNN !KickNN  

"shortcut that automatically maps each row you define starting from 60nn" 
#gatesNN 0 

"sequence the gatesNN number using the master pitches row and trig the same gate pattern over different samples of your MPC" 
!mpc_hits 0 0 0 1 0.5 0.2 0.1 0 #gatesNN {!Gen_Pitch rounded}

Gate Velocity

#gatesVel <GeneratedEventName>

Choose a unique event name that will broadcast the current value of the gate in a drum machine type row. Remember, you cannot add any Capytalk here and it must be completely unique.

Only used in GlobalEventPatterns in Drum Machine Mode

Examples:

#gatesVel !glob_kickVelocity

Gate Tick Event

#gatesTick <GeneratedEventName>

Choose a unique event name that will emit a 1ms tick whenever a gate in a drum machine type row has a non-zero value. Unlike the master GeneratedTick parameter this row specific one is always in #pre mode meaning it is emitted even when the row is frozen.

Remember, you cannot add any Capytalk here and it must be completely unique.

Only used in GlobalEventPatterns

Examples:

#gatesTick !kickTick

Gate Fills

#fills <value><value><value>…

A Collection of fast gate reTrigs for each step of a drum machine type row. Each element in the fills collection can be a number or a !hotValue or even a Capytalk expression. If there are less elements in a #fills collection than there are in the pattern row it is retriggering, it will cycle around its own length.

Examples:

"fill on every third step"
#fills ( 0 0 2 ) 

"a one element Array"
#fills ( !snareFills ) 

"build collection of widgets to manually set the fills"
#fills {1 to: 8 collect: [:i | !snarefills suffix: i ] } 

"fills triggered by the tick of another row"
#fills ( {!kickTick * 4} ) 

"bpm syncd decaying ramp of retrigs triggered by other row"
#fills ( {!crashTick ramp00: !bpm bpm s} * 4 )

Row Gate Type

#gateType <value>

Assign a row to have a gate output type independently of the master gate type.

_Type 1:_ 
10 ms positive pulse with no voice stealing reads from drum machine row whenever its gate stage is non-zero
_Type 2:_ 
Short Kyma voice stealing gate reads from row drum machine row whenever its gate stage is non-zero
_Type 3:_ 
Voice stealing holding gate. Remains positive and does not output its row values until the next non-zero stage occurs in the row gate sequence. 
_Type 4:_ 
Outputs every step regardless of the row gate stage logic.

Not used in MasterGatesPattern row, use the MasterGateType parameter field instead

Examples:

#gateType 4

#gateType !hiHatGatetype

"kind of choke effect by alternating between gate type 2 and 3 on every other step"
#gateType { (!hihatCounter mod: 2) + 2 }

CV Options

Only used in the CVOptions parameter field, and only working when OutputCV is set to true.

#outV <value>

<value> should be an integer from 1–8 corresponding to a Kyma output.

Selects the audio output channel you want the voltage relating to the Master Gate row and its the current velocity of the stage if it is more than 0. You can smooth it using the VelocityGlide function.

As well as a Gate Velocity value, you may want to use it to modulate any CV input. If you want to use it as both an voltage amplitude and a gate, then Mult it and send it to a gate input and a VCA at the same time.

Examples:

#outV 7 
#outV !VoltageOutput
"route the gates vel signal to a different Module every master tick"
#outV { (!MasterTick nextIndexMod: 3) of: #(1 3 5 7) }

#outP <value>

<value> should be an integer from 1–8 corresponding to a Kyma output.

Selects the audio output channel you want the voltage relating to the Master Pitch row. Changes character according to #pitch and #range options listed below.

Examples:

#outP 7 
#outP !VtoOctOutput
"route the pitches signal to a different oscillator every master tick"
#outP { (!MasterTick nextIndexMod: 3) of: #( 2 4 6 8) }

#pitch #range <value>

If you do not put #pitch anywhere in the CVOptions field, then #outP sends a clock signal.

But if you do use #pitch then you can use #range to create a Volt to Octave mapping that may match oscillator modules that have V/Oct inputs in your Eurorack. A value of 10 seems to fit some well but others not so well. You can explore weird scales and tunings by altering or changing this value with a widget or some Capytalk.

Examples:

#pitch #range 10 #outP 7 #outV 8 

#outP 7 #outV 8 #pitch #range !VtoOctRange

#outP 7 #outV 8 #pitch #range {(1 repeatingTriangle: 30 s) * 10}

Appendix B

Debugging Tips

Most of the problems you might encounter will be down to syntax errors in your scripting. So don’t panic. Kyma is not the kindest development environment when it comes to syntax errors — probably because its not really supposed to be used as a hardcore development environment for building apps and things.

One of the rather unpleasant things the interpreter does if you have forgotten to match parenthesis, or put in too many or too little or pressed enter too soon, is insert error messages directly into your nice script. This is quite a crude way for the interpreter to inform you that you have made a mistake because it will make your program even more prone to syntax errors, when you have to delete the error output carefully from your script which this can be tricky and messy. So watch our for that.

Best practice is to use ALT-TAB to indent your code, and return to make new lines. Your script will be much easier to debug. Kyma doesn’t mind if there’s lots of space and carriage returns and ignores comments enclosed in double quotation marks. GlobSeq doesn’t mind in what order it’s options appear but they MUST be added after the row of elements like this:

!root_note "it is ok to add comments here"
	60 62 59 58 66
	#div 16 #loop 2 #glide 10 
	#counter !rootNoteCounter

GlobSeq does have a basic error catching system programmed into it too which could catch some syntax errors related to its own options syntax. This could help if you forget to add a value it was expecting, or you are not doing something right with a Collection declaration. If it catches an exception, GlobSeq will actually try to give you some clues about where the problem might be. In some cases the Sequencer is compiling and running but things are not happening as you expected — welcome to the world of debugging!

PS. If you are desperate you can always come by the NeverEngine Labs Slack Channels and we will try to help. neverenginelabs.slack.com

PPS. If you don’t want to do any debugging at all, get the GlobSeq Examples Pack from the NeverEngine Labs website and just tweak whats there.

Golden rules in GlobSeq

First element MUST be the generated name that row will generate.

The generated name MUST be unique

GlobSeq contains many SoundToGlobalController Classes so it inherits the same principles. Read up on them in Kyma X Revealed p.255 onwards or study the SoundToGlobalController Classes in the Kyma 7 prototypes library.

Declaring Collections

In the GlobalExtraPatterns field which is actually a Collection of Collections, you need to enclose each row definition in a #( ) or GlobSeq doesn't know when a row begins or ends.

Correct:

#( !glob_cutoff 
		800 900 1000 300 200 100 
		#glide 0.1 
		#counter !cutoffCounter
		#cc 68 #len !cutoffLen
)
#( !cutoffLen 1 0.75 0.5 0.25 #div 8)

Wrong:

!glob_cutoff 800 900 1000 300 200 100 
		#glide 0.1 
		#counter !cutoffCounter
		#cc 68
!cutoffLen 1 0.75 0.5 0.25 #div 8

In the Master Gate and Pitches fields you don’t need any extra curly brackets or hashes, because they represent only one Collection.

But do get the order right.

Global name first, then the row, then the options.

Correct:

!glob_gate 1 0 0 0 1 0 0 0 #div !gatesDiv

Totally Wrong:

1 0 0 0 1 0 0 0 div !gatesDiv

Like everywhere else in Kyma , when you want to use Capytalk inside a Collection you have to enclose expressions in curlies.

Correct:

#( !glob_cutoff 
		800 900 {3000 * (1 repeatingTriangle: 20 s)} 
		#glide 0.1 
		#counter !cutoffCounter
		#cc 68 #len !cutoffLen 
		#shift {8 - (!cutOffLen * 8)}
)
#( !cutoffLen 1 0.75 0.5 0.25 #div 8)

Smalltalk Syntax

Correct:

!glob_pitch 
{
1 to: 64 collect: [:p | 
		p ofEuclideanScaleSteps: 8 
		octaves: 2 mode: 0 stepsPerOctave: 12
		]
}  
#div !pitchDiv #loop !pitchLoopMode 
#counter !pitchRowCounter

Ok, I’ve exaggerated the spacing out a bit, but….

Notice how the entire Smalltalk Collection building block is in Curly brackets and /after/ the Global Event Name.

See how the block variable ( ‘p’ in this example ) has a colon BEFORE it and a PIPE after it.

See how you need to match your parentheses carefully.
Check out how the GlobSeq options come after the Smalltalk code.

Here’s a cool pure Smalltalk example:

#( !glob_panpos 
	{ (0 to: 1 by: (1/31)) asArray } 
	#counter !panPosCounter 
)

Generates 32 pan positions between 0 and 1 which you could then sequence through in different ways.

I learned that trick from a Smalltalk cheat sheet that someone made once. Here it is http://www.angelfire.com/tx4/cus/notes/Smalltalk.html

Good luck and enjoy the ride!

Appendix C

Class Parameter Descriptions

Here is a copy of the parameter descriptions in alphabetical order. The descriptions are the same that you will find as inline help when you hover your mouse over any parameter field in the GlobSeq Class inside Kyma.

BPM

Master beats per minute frequency for the internal pulse train clock.

If UseExternalStepInput is set to true then this parameter is ignored. !BPM will be defined in your external step clock in that case.

Cost

This choice downsamples the master clock data internally.

1 = best timing and accuracy. Most DSP heavy.

2 = default

3 = more efficient maybe a little loose on the timing

4 = most efficient but quite sloppy timing

Cost of 3 or 4 might save the day when asking for lots of replications.

CVoptions

When OutputCV is active, here is a list of options you can specify.

Example: #pitch #range 9 #outV 7 #outP 8

#outV <value>: 
Range from 1 to 8, fixed or hot. 
The output to send gates with velocity as an audiorate signal to control analogue gear

#outP <value>: 
Range from 1 to 8, fixed or hot. 
The output to send audiorate pitch information as a voltage signal.
 
#pitch : 
Will send audiorate pitch information to the #outP route. If you omit this option, a step clock will be sent instead to #outP

#range <value> 
By default ( if you omit this option) the V/Oct range is set to 10. You can put a !HotValue or other values here higher than 1 to explore microtuning or try to find a better setting for your oscillator.

Enable

Leave this set to true in normal use. For debugging purposes.

ExternalStepInput

You can use an external audio signal to step through the patterns. It can be a pulse generator type clock, or any cycling oscillator, phase generator or audio input.

With a low frequency oscillator or (warped) ramp as step input, you can experiment with groove patterns in an interesting way. Important: See info about ‘ExternalStepType’ below.

ExternalStepType

If you are using a Pulse Train or sync signal from other hardware, the width of the pulse should be more than 2 ms to trigger steps correctly. Set ExternalStepType to be 0.

ExternalStepType set to any number other than 0, will implement a trigger extraction algorithm that will allow you to work with audio signals other than pulses, such as linear ramps cycling at !BPM rate. With a low frequency oscillator or (warped) ramp as step input, you can experiment with morphing groove patterns as the algorithm extracts triggers for the sequencer in different ways.

GeneratedMasterCounter

The name of a step counter event which yields the number of the current master gate stage.

If you don’t want to generate a global counter for the Gates then you can just leave this field blank.

As with all Global Event generators, this is name of a widget will will be algorithmically generated. It is declared like this — !GeneratedName

Do not put any extra Capytalk

Remember — the Global Event Name must be unique. Be very careful not to be generating more than one generated event with the same name anywhere else in your Kyma signal graph.

GeneratedMasterGateVelocity

The name of the GlobalEvent that will hold the gate velocity value when the gates stage is not zero. You can use it globally as a velocity or level or anything else really. It is full resolution, so it can track signals that change faster than the clock is stepping, like an LFO.

Remember! No extra Capytalk here — only the name for the GlobalEvent

The name MUST be unique, be very careful not to be generating more than one generated event with the same name in your Kyma signal graph.

TIP: If you don’t need to generate a gateVelocity global then leave this field blank

GeneratedTick

The name of a GlobalEvent that will generate a 1ms tick derived from the On/Off state of the Master Gate row with a couple of options. Remember a gate element that has any value above zero is treated as being On.

You need EventTick when you want to get complex and trigger things like random conditions or your own counters inside the same GlobSeq instance. It is advisable to use this event instead of the generated !Gate from the GlobalGatePattern. This is because, that is a gate with voice stealing and fills, and will confuse something that needs a trigger.

Use this global within other definitions of the same GlobSeq instance and/or any where else in your sound. Its a kind of ‘call back’ event which is useful and has some options too. By default, with no options, it ticks when ever the gate stage logic is true ( not zero ) and is muted by !Freeze.

GeneratedTick Options: 
!GeneratedEventTick #pre 
* ignore !Freeze so, you can mute gates without muting other tick events.

!GeneratedEventTick #clock
* tick on every step regardless of gates stage logic

TIP #1: You can rely on this GenereratedEventTick not to crash the Pacarana when you try to wire GlobSeq gate events into their own row definitions (which can cause internal feedback loops).

TIP #2: If you don’t want to generate an EventTick global then leave this field blank.

Remember! No extra Capytalk here — only the name for the GlobalEvent

The name MUST be unique, be very careful not to be generating more than one generated event with the same name in your Kyma signal graph.

GlobalEventPatterns

Use this field to specify sequence patterns for arbitrary generated global EventValues.

Each pattern row will have its own independent cycle length according to its number of elements (be sure to look at the PolyMetric check box too)

If you don’t need to generate any Extra Global Events you can leave this field blank.

The basic syntax:
	#( !globalEventName 
		<value> <value> <value>.... 
		#div <value> 
		#loop <value> 
		#euclid <value>
		#glide <value> 
		#cc <value> 
		#len <value>
		#shift <value>   
		#counter !GeneratedCounterName
		#gatesNN <MIDInn> 
		#gatesVel !GeneratedVelName #fills <value> <value> <value>....  
		#gatesTick !GeneratedTickName 
		#freeze <value>
		#gateTye <value>
	)

The first element must ALWAYS be a UNIQUE name of the global event that will be generated. No extra maths or Capyytalk messages can be sent to it.

It must be on its own. Everything after it is the data to be sequenced followed by any optional grammar.

In this field as in all Capytalk Arrays parameter fields, you must enclose expressions within curly braces.

GlobalEventPatterns : Drum Machine Mode

Adding a #gatesNN option turns a normal GlobalEventPatterns row into a row that will be interpreted as gate. Now you can specify a #fills array, a MIDI note destination, a gate type, a tick event (fixed to #pre) and a generated gate velocity event for each separate row you define.

TIP: #gatesNN mode sends to the current MIDIChannel + 1 , so you can mix bass-line and drums on the same synth for example.

Some Examples:

#(!Pan 
	{0.5 - !PanSpread} {0.5 + !PanSpread} 
	#div 4
	#glide { !panGlide smooth: 3 s }
)

Four fixed values updating every four clock steps with glide and a counter.

#(!Morph 
		0 0.25 1 0.125 
		#div 4 
		#glide 0.2
		#counter !MorphStep
)

A Smalltalk expression expands into 8 independent hotValues with a fixed glide value hot divider and counter that also sends to midi CC pan and outputs every step regardless of Master Gate logic

#(!CutOff 
	{1 to: 8 collect: [:p | !CutOff suffix: p] } 
	#glide 0.2 
	#div !CutOffClockDiv
	#counter !CutOffStep 
	#cc 10 #gateType 4
)

Euclid Drum Machine Mode with its own freeze

#( !PercGates 1 0 0 1 0.5 0 0.75 0 1 0 1 1 0.2 0.5 0 0  
	#gatesNN 60 #gatesVel !PercVel #gatesTick !PercTick #euclid !PercEuclid #div !PercDiv #freeze !PercFreeze
 )

TIP: Read the user guide for more examples!

MasterEuclideanSteps

Any integer value above 0 will start to hold then skip steps in the Master Gate row, according to an integrated Euclidean dsitribution algorithm. Great for sequence step variations that are neither random nor masked.

MasterFreeze

Freeze will freeze the output of all counting sequencers, whilst continuing to count them internally. This is a cool performance feature, as when you unfreeze with any value above 0, the sequencers will drop back in perfectly in time.

TIP: Each row can have its own independent freeze using the #freeze option

MasterGatePattern

A collection of hot values or numbers that will be interpreted as the main Gate stages of the sequencer. Think of it as the master pattern which controls when all the other patterns update their state or will hold their state.

When the value of a Gate stage is 0 (off) then new values will NOT be output from the other pattern sequences, instead they will be held. Any value greater than zero will be interpreted as the Gate stage being active. It will transmit its non-zero value as a !gateVelocity global event using the GeneratedNameGateVelocity name you specify.

This behaviour means that a gate can be held between active stages, through some off stages which means patterns update their states internally as the step changes, but do not output their values. This can be great for triggering phrases that need some time to be heard or looped samples with sustain and more. It is also what gives all the complex ‘masking’ interactions between patterns of different lengths, characteristic of the NEL GlobSeq. See ‘GateType’ below to for more options.

SYNTAX:

The first entry MUST be a UNIQUE hotValue ( do not try to perform any Capytalk on it here ).

It will be used as the name for the global event generated by the gate.

Everything after that first entry, is the pattern data followed by any GlobSeq options.

The Gates field ONLY accepts #div #loop and #fills — its length and shift are controlled by the !MasterLength and !MasterShift parameters.

EXAMPLES:

!Gate {1 to: 8 collect: [:i | !Gates suffix2: i]} #div !GatesDiv #loop !GatesLoopMode

As in all Kyma arrays Smalltalk/Capytalk expressions must be in curlies.

!Gate 1 0 { !bpm bpm tick nextRandom abs closestIntegerWithHysteresis: 0.2} 0 1

FILLS: You can add a #fills retrig array

!Gate	{1 to: 8 collect: [:i | !Gates suffix2: i]} 
		#fills {1 to: 8 collect: [:i | !Fill suffix2: i]}
		#div !GateClockDiv

Use ALT-Tab for indents to make your code more readable.

!Gate 
		1 0 1 0 1 1 0 1 
		#div !gatesDiv 
		#loop !GatesLoopMode 
		#fills (4 3 2 {!Glob_tick nextChaotic7 * 4} )

MasterGateType

Defines three different flavours of generated events.

Type 1: 
10 ms positive pulse with no voice stealing reads from row whenever Master Gate stage is non-zero
Type 2: 
Short Kyma voice stealing gate reads from row when Master Gate stage is non-zero
Type 3: 
Voice stealing holding gate. Remains positive and does not output its row values until the next non-zero stage occurs in the Master Gate sequence. 
Type 4: 
Outputs every step regardless of the Master Gate stage logic.

"##### Kyma Voice Stealing Gates drop to -1 for 5 ms to allow currently active envelopes to rapidly fade out without click ########"

TIP: Type 3 is great for holding a loop on a sample, or ‘tie’ events where sustaining a long gate time over empty stages is preferred.

TIP: Each GlobalEventType can have an independent gate type from the master gate type using #gateType option

MasterLength

An integer number which defines the loop length of the Master Gate pattern. If internal patterns are shorter than this value, they loop according to their loop mode and #len value until patternLength is reached, where they will reset their counting.

TIP: To get full polymetric behaviour set polyMetric to True — in that case, the master loop length will only limit the Gates pattern row, but other rows loop independently according to their own lengths.

MasterPitchPattern

The collection that represents Pitch information that is sent via MIDI and broadcast globally using the global event name you choose. Usually the values are note number if you are outputting MIDI, but really the pattern row could contain any kinds of values, like a !Rate for example.

The first element must ALWAYS be a UNIQUE name of the global event that will be generated.

No extra maths or Capytalk messages can be sent to it. It must be on its own.

Everything after it is the data to be sequenced with any GlobSeq options.

MasterPitchPattern options: 
	#div <value>
	#loop <value>
	#glide <value>
	#counter <!GeneratedCounterName>
	#euclid <value>

In this field as in all Capytalk Arrays parameter fields, you must enclose expressions within curly braces.

Example 1 - rate sequencer for sample players with counter and Euclidean step
!Rate 
	{ 1 to: 8 collect: [:i | !Rates suffix2: i]} 
	#div !ratesDiv  #euclid !rateEucStep
	#loop !RatesLoopMode 
	#glide !ratesGlide
	#counter !ratesStepCounter

Example 2 - upwards arpeggiator with counter: 
!GenPitch 
	{ (40 to: 56) asArray } 
	#div !pitchDiv 
	#loop !pitchLoopMode 
	#glide !pitchGlide
	#len !pitchRowLength
	#shift !pitchRowShift
	#counter !pitchStepCounter

TIP: @CharlieNorton noticed that when using GlobSeq in Timeline or Multigrid, you’ll have to manually make sure that the generated name is completely different to any other instance of GlobSeq in the Grid or Timeline. So call it a different name in a new instance , such as !GenPitchA !GenPitchB

TIP: If you don’t need to create Pitch data you can leave this field blank.

MasterShift

Shift the Gates pattern row by integer number of steps

MasterVelocityGlide

Like glide for pitch, except it will smooth and interpolate the values between each active master gate stage over this timeConstant. It can make the velocity information be very smooth, great for CV. See manual for examples.

MIDIChannel

This is the MIDI channel that note and CC event information will be sent on.

Leave it empty if you do not need to output MIDI.

TIP: This field can be a !hotValue too, for dynamic MIDI channel routing

OutputCV

If true, the you activate the Control Voltage audio features of this GlobSeq instance, allowing you to send gates, gate Velocity, pitch or clock as voltage control signals through two channels of a DC coupled audio interface or on an ExpertSleepers ADAT Eurorack module.

See CVOptions to find out more about how to configure further options.

Be aware that switching this to true will send raw control voltage from the audio outputs — watch your speakers!

PolyMetric

When PolyMetric is checked, all rows have independent loop lengths defined by their number of elements and #len value. This means they loop regardless of the !MasterLength gates value.

When PolyMetric is unchecked, all rows restart when the !MasterLength is reached regardless of their length.

RateScale

When running on internal step clock, this value scales the master BPM rate.

So when set to 1, the sequencer runs at !BPM rate, and when set to 2, twice as fast.

When using external step input, and you are extracting clock pulses from a waveform, this parameter doubles to be a variable threshold on that extraction process. Experiment with this!

Reset

Resets counting and clocks when not zero

Reverse

Reverses the step index.

Run

Runs and restarts the internal master clock — use Freeze to pause.

Seed

A seed between 0 and 1 for the chaotic step generators

SlowMidi

Slows down MIDI information to 31.25baud the original MIDI speed for possibly better response from older gear

StealthMode

When in stealthMode, all generated events are still generated, but they do not appear in the VCS.

TIP: Any generated counters will not be hidden in Stealth mode, you can hide any you don’t need manually in the VCS

UseExternalStepInput

Use external step input. Will bypass BPM, RUN and RESET which relate to the internal pulse generator. I suggest moving these parameters to be expressed somehow in the external step generator.

!RateScale DOES remain active and will affect the threshold sensitivity to external input signals when ExternalStepType is set to 1, which implements the trigger extraction algorithm.

Additionally !Run lets the external clock through or mutes it when in external clock mode.