Need to set the quantization direction

BTW: where do I start if I want to get into the topic of Building in Core? In another thread you once wrote that Core is not necessarily more difficult than Primary, but different. In what respect? I am a software developer (retired) and think sequentially in if-then-else structures or for loops. I have the feeling that this is getting in my way as far as Core is concerned. Are there any recommended tutorials to get started with building in Core?

Core is more like programming than Primary, you can manipulate state much more easily, and it is more precisely defined, it doesn't try to 'help' or 'fix' things in hidden ways like Primary does. You also have access to integers including booleans for bit twiddling.

It's not a high level language though, more like some sort of visual assembly language. No code reuse (unless you count macros), no iteration or recursion, no functions, no objects. You have to build all that yourself if you want it. (for) loops must be unrolled, or an iteration event stream fed in from Primary.

Paradigm wise, it's is a 'dataflow' language

Stuff like dsp algorithms are often easier to build than they would be in c++. Stuff like data structures are (way) more challenging.

Compared with Primary, it is more expressive, and generally more capable for building anything non-trivial.

Primary is more about simple structures connecting more powerful monolithic components together. It is interpreted.

Core doesn't have powerful monolithic components, it has a library of powerful macros, but they are all just built in core from the basic modules. Core is compiled (optimising compiler). Each time you make an edit, the compiler recompiles your code into binary form. It is very efficient. Not quite up there with C++, but plenty good for pushing a lot of numbers around with fairly hefty DSP algorithms.

e.g.

A Primary oscillator is a black box with inputs and outputs, and some parameters in the dialog on the left of the screen.

A core oscillator is a macro, you can click into it and read all the code, modify it, extend it, try and understand how it works. It's all built out of simple basic fundamental modules. Arithmetic, memory handlers, dataflow (comparisons, routers etc.).

Even some of the math stuff is built from more fundamental components. So e.g. trig stuff. The Factory sine macro, a while back on the forum one of the resident math experts reverse engineered it, worked out the math and derived another version with higher precision, and marginally higher cpu requirements.

Best place to start learning wise is the Manuals. So in Reaktor menus help→online Reaktor Documentation, then look for 'Building in Core'

Further down the page, the older Reaktor 5 'core reference' is useful particularly tutorial wise, although some stuff has changed (Core was smaller, so fewer features meant more space in the manual for step by step tutoritals).

Read the other manuals too!, then re-read the building in core manual :)

There are some more advanced topics and some gotchas and workarounds that are not in the manuals, but you can just ask for help when you get stuck. Stuff like the compiler freezing up, or thread safety problems. That's more advanced stuff that rarely needs consideration.

I scratch build most of my stuff in core. Part of the reason is that if Reaktor gets shelved at some point, all those algorithms that took so many hours to develop and tune can be ported to c++ without too much hassle. It's just more fun building stuff in Reaktor. Everything is immediate, so its less like work.

The only downside is the GUI end, all the GUI stuff is on the Primary layer, and it is clunky and old, it's also not portable. Fortunately, that's not the part that makes the great noises! but it will require a fair bit of work to port anything with a complex GUI.

You can do a lot without any DSP.

Something like a quantizer is just basic arithmetic and some programming logic.

Here's an idea for an intermediate modding project (Blocks are intermediate IMO because all of the extra baggage that comes with the framework, worth learning though):

Take the Bento LFO, and modify it with three extra outputs. Then have a selector so the four outputs can be:

• different phases of the same waveform 0, 90, 180 and 270 degrees
• different divisions of the main frequency, 1, 2, 4, 8
• prime relationships between the 4 to minimise correlation.

Another mod for that module would be a trigger input that syncs the frequency with the trigger input, and replaces the frequency knob with a multiplier/divider.