In this tutorial, I’ll cover the topic of using Event Smoothers to eliminate audio glitches and bugs from your Reaktor ensembles. There are several modules in Reaktor that will respond poorly if the knobs attached to them are not properly set up. I’ll identify some of the most common problems and show how to fix them.

AMP/MIXER MODULE

Here’s one of the most common examples of a problem that can be solved with the use of an Event Smoother:

If you create this structure and quickly turn the Level knob while playing a note, chances are you’ll hear some pretty bad audio glitches in the form of cracks and pops. It is useful to think about why this happens, when determining how to fix the problem. In this case, the Level of the Mixer module is being translated into an amplitude value, which is multiplied against the incoming audio. When the multiplier drops (or rises) very quickly, it creates a discontinuity in the waveform, typically referred to as aliasing. Check out our series on aliasing here.

Here, the solution is simple – just add an Event Smoother between the Level knob and the Lvl input of the mixer:

The Event Smoother module has a value in the FUNCTION tab of the properties called transition time. This value is the amount of time in milliseconds it will take to transition to a new value received at the input.

The Event smoother is one of the few modules in Reaktor that outputs a continuous stream of events, the speed of these events is determined by the Control Rate (in the Settings Menu). By default, the Control Rate is set to 400 Hz, which comes out to one event every 2.5 milliseconds (1000 ms / 400 Hz = 2.5). The transition time defaults to 100 milliseconds, which means that a new value received at the input of the Event smoother will take 40 events (100 ms/2.5 ms = 40) to fully transition to that value.

If you choose to change the transition time, it makes sense to keep it as a multiple of the Control Rate. As shown above, you can translate the Control Rate into milliseconds by calculating 1000/x, where x is the Control Rate.

LFO SMOOTHER

Recently, while working on a project that contained an LFO modulating various parameters, I determined that the LFO was causing pops and cracks if I set it to restart on a new MIDI gate. After some thought, I wondered if an Event Smoother would help the situation.

I built the following structure to take a look at what the LFO was doing:

The top Event Table is recording all the events from the Event Smoother, and the bottom Event Table is recording the events straight from the LFO. I set the transition time to 20 ms (8 Events), and grabbed the following screeshot:

I retriggered the LFO in the middle of the section of the graph shown. The two signals look very similar, but if you look closely, the top one has a smoother transition when the LFO restarts. This might matter, it might not, depending on what you are using the LFO for, but it’s something to keep in mind with any event stream that interacts with the audio engine.

Unfortunately, adding the Event Smoother in this case is not without it’s downsides – at higher frequencies, the LFO will lose amplitude. The amplitude loss can be lessened by using smaller transition times. Fortunately, LFOs are usually not going very fast (hence the name), so this is not so bad.

CONCLUSION

Event Smoothers can take a little while to learn, but they are very useful. If you have any questions, comments or suggestions, please post them in the comment section below. Thanks for reading!

The post Using Event Smoothers in Reaktor appeared first on NI Reaktor Tutorials.

In this tutorial, I expand upon a previously made drum machine, adding the ability to save and recall sequences, and change the length of the sequences.

Part II of a series, check out part I here.

For a new Reaktor tutorial every week, please subscribe to our YouTube channel.

Click here to view the video on YouTube.

The post Create a Simple Drum Machine in Reaktor, Part II appeared first on NI Reaktor Tutorials.

This week, I’d like to share with you all a simple ensemble I built recently, called MIDI Hero (drawing an obvious inspiration from Guitar Hero, despite the fact that I have never played Guitar Hero). The ensemble is made for owners of Maschine hardware, and builds off some other recent tutorials of mine, namely the Create a Simple Drum Machine series (1 + 2), and a tutorial on controlling Maschine LEDs with Reaktor.

OVERVIEW

The reason I created MIDI Hero is I was looking for a way to improve my finger drumming skills (which are quite terrible). Watching old South Park reruns late one night, I came up with the using an interface like Guitar Hero has to signify when certain notes should be played. The bottom row of pads on the Maschine grid are for playing back the samples, each column has MIDI notes “falling” towards the bottom row. When they hit the bottom, it’s your job to press the note!

Unfortunately, this setup reduces you to playing 4 sounds at a time, but if you’re as bad at finger drumming as I am, it’s probably enough to overwhelm you at faster BPMs anyway, even with relatively simple sequences.

The controls for MIDI Hero are simple. You can program in up to 128 sequences, each sequence can be up to 8 bars long. Simply draw the sequence into the Event Table with your mouse. MIDI Hero has the ‘Set BPM by Snapshot’ option checked in the Settings menu, which means the BPM will be stored along with the sequence when you save a snapshot. There is an option to have Reaktor trigger the notes for you (the Autoplay button), which allows you to hear the sequence if played back perfectly. Finally, the Velocity switch determines whether notes will be played back at maximum velocity or controlled by the incoming MIDI data.

SETUP

The tutorial on controlling Maschine LEDs that I linked above explains how to set up the Maschine pads to receive MIDI data. The LEDs are presumed to be receiving MIDI in HSB mode for use with MIDI Hero. The default template of the Maschine in MIDI mode has 8 pages for the pads – page 1 has the pads sending MIDI notes starting at C-1 (or 12). MIDI Hero uses the same notes to control the LEDs, so just make sure to set them to HSB mode and you’ll be all set.

Once you have your template made, press Shift+F1 on your Maschine hardware to enter MIDI mode, open MIDI Hero, choose a sequence, and press play on the Reaktor transport. The LEDs will begin flashing to let you know which notes to press. Finally, you need to load in some samples.

Here’s how I set up the sample map in the Sample Map Editor, which you can open by pressing F9 (or the icon that looks like a sample on the top row of the Reaktor interface). The top row of the Event Table controls the kick drum, the second row controls the snare, etc.

DOWNLOAD MIDI HERO

CONCLCUSION

I am currently contemplating ways to expand this idea to somehow use the full 16 pads for playback for more dynamic and useful sequences. If anybody has any ideas towards that end please feel free to leave them in the comments.

This year I am going to try hard to create more content that is easily usable for people who do not build in Reaktor. To that end, I’ll be creating more simple ensembles and projects that can easily be used for music production or teaching. If there are any specific projects that you would like to see me tackle, please be in touch.

The post MIDI Hero – Free Reaktor Ensemble appeared first on NI Reaktor Tutorials.

In this video, I show how to create polyrhythmic sequencers in Reaktor. This is a great technique for creating generative sequences! I also show how we can get per-drum control of any parameter we want, to create more expressive and dynamic instruments!

This tutorial builds off of two previous tutorials:

Simple Drum Machine 1

Simple Drum Machine 2

For more Reaktor tutorials, please subscribe to our YouTube channel!

Click here to view the video on YouTube.

The post How to Create Polyrhythmic Sequencers in Reaktor appeared first on NI Reaktor Tutorials.

Twisted Tools Ultraloop,  their most recent ensemble, is a very powerful and well designed ensemble. Each element has been meticulously planned and executed, there is a substantial amount of depth to the GUI. In this video, I give my thoughts and a quick overview of features and use.

For more, please subscribe to our YouTube channel!

Click here to view the video on YouTube.

The post Twisted Tools Ultraloop Review and Overview appeared first on NI Reaktor Tutorials.

ULTRALOOP from Twisted Tools is yet another awesome addition to their Reaktor ensemble lineup. This tutorial shares how you can use it with NI Maschine!

Click here to view the video on YouTube.

ULTRALOOP from Twisted Tools is something they are calling the ultimate loop remixing sampler and it’s a perfect match for NI Maschine. It combines advanced loop layering, comping, effect processing and automation techniques to generate new grooves, riffs and is a brilliant tool for discovering new song ideas. It comes with a ton of great samples already loaded, but you can easily load your own, so you are not tethered to just factory sounds.

The heart of ULTRALOOP from Twisted Tools is the loop layering engine and sequencer, allowing you to flip back-and-forth between simultaneously playing layered tracks. Think about that for a moment. It also features the Gestural FX engine, which automatically generates dynamic effect movements that ramp and modulate over time, using a suite of creative effects designed to produce endless fills, articulations and variations. In other words, it automagically creates wicked twists and turns in your music for you!

The proprietary Preset Grid system in ULTRALOOP from Twisted Tools provides you with endless potential for new loops and grooves, allowing you to save, recall and automate settings on-the-fly. There is an insane amount of flexibility here! Add to all of this the fact that you can manage eight different Global Scenes to store and recall every setting in an instrument and you quickly find your mind blown by the endlessness of it all.

ULTRALOOP from Twisted Tools proves, yet again, that these guys know what’s up. Their unique approach to sound manipulation is always at the forefront of the music industry and provides us with intuitive tools that help in the studio as well as live performances. If you are unfamiliar with them, definitely check them out! They have a lot of other awesome toys to play with.

Cheers,
OhmLab

The post Using ULTRALOOP from Twisted Tools with NI Maschine appeared first on NI Reaktor Tutorials.

In this tutorial, I’ll cover the basic usage of the Modal Bank module, and use it to create a simple modal synthesizer for physical modelling. The Modal bank is perfect for making sounds based upon resonant objects, such as strings, and bells. At the end, an ensemble is provided for download.

USING THE MODAL BANK MODULE

The Modal Bank is very similar in form and function to the Sine Bank module. Interested readers may wish to check out our series on additive synthesis for information on the Sine Bank. The difference between the two, essentially, is that a Modal Bank is a series of resonant filters that act on an incoming waveform, while a Sine Bank is a series of sine waves. As such, programming the two is nearly identical.

A Modal Bank can have hundreds of filters (referred to as ‘partials’ or ‘modes’). Each mode has several parameters, such as amplitude, frequency ratio, and decay time. Therefore, it is impractical for the Modal Bank object to have an input for each parameter. Instead, to change a single parameter, you must send three events, in proper order, to the Modal Bank module – first you must tell the Modal Bank which partial to operate on; next send the values to the appropriate inputs; finally you must tell the Modal Bank to apply the changes by sending an event to the App input. This process is explained in more detail in the tutorials on additive synthesis.

The next problem is that it is also impractical to have a knob for each parameter of each partial – you’d end up with hundreds of knobs, and each one would have only a very small effect on the final sound. To work around this problem, I find it is useful to use Iteration modules, and to create knobs that affect every partial.

For this project (which is a very simple example, and can be expanded in many ways), I created three such knobs – one that controls the decay of the partials, another that controls the frequency distribution (from linear to random) and a third that controls the amplitude distribution (again from linear to random). When the distributions are set to linear, each partial has a frequency that is equal to it’s index number times the incoming MIDI frequency, and each partial has the same amplitude. Regardless of the setting of the decay knob, the higher frequency partials decay faster.

The distribution knobs basically add an amount of randomness to each partial. The macros look something like this (they are slightly different):

Basically, this structure leaves the first partial (the ‘fundamental frequency’) alone, and adds a level of randomness chosen by the ‘Range’ value, which is controlled by one of the distribution knobs.

PHYSICAL MODELS

As I mentioned above, one of the key differences between the Sine Bank and the Modal Bank is that the Modal Bank requires an audio input to work properly. There are, in fact, two audio inputs – one for percussive sounds (such as plucking a guitar) and another for continuous vibration of an object, such as using a bow to play back a violin. In this example, I am only using a ‘pluck’ sound, and am supplying the input with an AD envelope with both attack and decay times set to zero. Essentially, this simulates an immediate strike and release of our physical model.

With the frequency distribution set to linear, the final product of the output should sound something like a plucked string. With the amp distribution also set to zero, this should resemble a guitar. As the amp distribution goes up, the string begins to take on a different tone , a little more natural feeling (of course, in real life, the modes of a string are not precisely what mathematical models would like them to be due to minor imperfections in reality!).

Turning up the frequency distribution morphs from a guitar-type sound to more of a bell or other metallic sound, depending on the decay and amplitude distribution.

CONCLUSION

There’s a lot that could be done to expand this model. Using the continuous audio input to expand our range of instruments would be a good start. Adding in the resonance of instrument bodies would allow for more realistic string sounds, as the body of a guitar or violin will add to the character of the sound. If there is interest, I will expand to include these features.

For now,

DOWNLOAD HERE.

As always, thanks for reading, and feel free to leave any questions or comments in the section below.

The post How to Create a Simple Modal Synthesizer appeared first on NI Reaktor Tutorials.

In this tutorial, I’ll focus on creating custom envelopes in Reaktor, using only Primary modules. Specifically, I’ll create a standard ADSR envelope with an exponential attack phase, and provide a sample macro for download.

LINEAR VS. EXPONENTIAL ENVELOPES IN REAKTOR

Broadly speaking, envelopes are a collection of sections, where each section has a start point, an end point, and a length of time it takes to travel from the start to the finish. How the envelope is interpolated between the start and end point determines the shape of the envelope. For example, here’s a diagram of a Primary ADSR envelope:

In this picture the attack phase (starting at the leftmost point) is linear – it travels in a straight line from point A to point B. The decay and release sections, however, are exponential.

So, why use an exponential rather than linear shape for an envelope section? The answer is a little complicated, but the basic idea is that our ears do not hear in a linear fashion. Somebody mentioned to me one time that this is fairly obvious if you think about it – one person clapping can be pretty loud, but we aren’t deafened by 40,000 people cheering at a huge concert. We simply don’t perceive amplitude in a linear fashion (the same is also true with pitch).

An exponential decay and release more closely models the types of sounds we hear around us naturally, so it makes sense to utilize this same scale in a musical sense. What then, is up with the linear attack phase? To be honest, I’m not sure, but I’d wager that it has something to do with analog synthesizers using a linear attack section (probably for simplicity’s sake, but again, I’m really not sure).

In order to make volume knobs that appear to change amplitude linearly, the decibel scale is often used. In real world terms, reducing the amplitude of a signal by 6dB reduces it’s amplitude by half (though again, our ears hear things differently).

Something that I find frustrating about the way these Primary ADSR envelopes are designed is that the decay and release times are deceptive – they actually take about 3 times longer than they say they will. In the picture above, the attack, decay, and release times are all set to the same value, but you can see that the decay and release sections are substantially longer in reality.

MAKING OUR ENVELOPES IN REAKTOR

For the rest of this tutorial, I’ll focus on creating ADSR envelopes in Reaktor where the attack, decay, and release are all exponential. A happy side effect of this design is that all the sections will also be exactly as long as specified by the user.

At the heart of our structure is a 4-Ramp Envelope module. The 4-Ramp has 4 linear envelope sections that are very flexible and can be configured in many different ways. The first phase can easily be turned into an attack, the second can be a decay, the third can be ignored altogether, and there is a sustain and release section built in that can be used for those purposes.

Here’s how I set up the 4-Ramp module:

Okay, so the Attack, Decay, Sustain and Release knobs are exactly the same as they would be if you used the ‘Create Control’ command on the respective inputs of the Primary ADSR module, with one small exception: the minimum value of the sustain has been set to a very low value, but still above zero. When translated using the Log function, the output of the sustain knob has a range from -96 to 0 – this is the range of the envelope measured in decibels, where 0 is equal to unity gain, or an amplitude of 1. Adding 96 to the value lets the sustain knob be in the same range as the rest of the envelope, from 0 to 96.

The output of the envelope is then translated to the decibel scale, and from the decibel scale to amplitude using the Exp module.

For comparison, here’s the output of our new envelope with the exact same parameters as the ADSR pictured above:

As you can see, the attack is exponential, and the decay and release sections are the same length as the attack section.

CONCLUSION

The 4-Ramp module has a lot of flexibility and can be made into many different types of envelopes in Reaktor. If there is a specific envelope function you’d like to see in Reaktor, let me know in the comments.

You can download a macro of the envelope made today here.

Thanks for reading, and as always, feel free to contact me with questions or ideas.

The post Creating Custom Envelopes in Reaktor appeared first on NI Reaktor Tutorials.

In this video, I show a simple method that can be used to draw your own LFO shapes in Reaktor. Utilizing an Event Table and just a few other modules, a simple interface can be built that gives you full control over your modulations.

In order to use the Event Table properly, a bit of setup is required. There are a lot of options available to us in the properties – some merely cosmetic, others quite important. Once the Event Table has been properly initialized, setting the Table Draw Mode to on allows you to draw your own LFO shapes in the Panel view.

From here, we need to read the values in the Table out, in succession. To achieve this, a Ramp Oscillator can be used to control the current index being read from the Event Table. The amplitude of the oscillator is set to the length of the Table, and it’s frequency is set to the chosen LFO speed.

The last thing to finish the LFO is to trigger the Table to be read at the Control Rate. A System Info module is used for this purpose.

To expand upon this concept, check out the following tutorial. This will show you how to create waveshapes that can be recalled by snapshot, greatly expanding the power of the system.

Click here to view the video on YouTube.

The post Draw Your Own LFO Shapes in Reaktor appeared first on NI Reaktor Tutorials.

In this video, I show how to create a basic Additive synth in Reaktor. The Sine Bank module  is one of the most complex available in Reaktor, and programming it requires that you pay attention to event order.

Click here to view the video on YouTube.

A Sine Bank module contains any number of sine oscillators – each with it’s own pitch, left amplitude, right amplitude, and phase. In order to program a sine wave within the Sine Bank, you must first set the index (the Idx input) to the proper value. This tells the Sine Bank which oscillator to make the changes to. Next, you can send events to the Rtio, AL, AR, and Ph inputs to change the parameters of the oscillator. Finally, you must send an event to the App input to apply the changes made.

The difficulty of event ordering deters many beginners from using the Sine Bank module at all. Worse yet, using a knob for every available parameter would make for terribly tedious programming for the end user. In this video, I show a simple way around this using an Event Table to hold the amplitudes for each sine oscillator.

I’m not overly fond of the visual interface for the Event Table but the fact that it can be programmed for some complex purposes in about a minute is quite useful. If you’d like to see a more visually appealing way to achieve the same task, check out our tutorial on the Multi Display module, which is similar to the Sine Bank in the way it’s programmed. You can also check out our series on Additive Synthesis here, which has a fuller description of the Sine Bank than I am able to give in this video.

Thanks for watching, and as always feel free to leave suggestions or questions in the comments.

The post How to Use the Sine Bank Module in Reaktor appeared first on NI Reaktor Tutorials.

Lately, we’ve done a few tutorials utilizing the Sine Bank and Modal Bank modules, which share many common characteristics. Today, I’d like to share Modal Generator, a simple ensemble inspired by my re-discovery of the Metalon ensemble from the User Library. Metalon generates a random sound and records it to a Tapedeck module. If you like the sound, you can save the data in the Tapedeck as a .wav file.

MODAL GENERATOR

DOWNLOAD HERE!

The engine for Modal Generator is simple – given a number of partials (read this if you don’t know what partials are!), and a maximum frequency for those partials, a new sound is generated for each new MIDI note received. Each partial is assigned a random frequency (within the chosen range), amplitude, and decay time. Further, the knobs controlling the parameters of the engine (Maximum frequency, etc) can be randomized on a new note as well. This way you can create sounds that are completely random, or set some chosen  parameters and generate within that range.

In order to turn randomization on or off for any knob, you can simply select the proper value in the ‘Mrph/Rnd Isolate’ checkbox in the FUNCTION tab of the knob properties.

When this box is selected, all randomization events are ignored by this knob. I have everything but the Level knob set to random by default. With a ton of partials, the sound coming out of Modal Generator can be a little bit clangorous  sometimes, so it’s good to keep the level at a safe amount.

POSSIBLE IMPROVEMENTS

As of right now, the engine for Modal Generator couldn’t be simpler:

The input of this macro is connected to an Iteration module that sends a number of events chosen by the Partials knob. For each partial, the Ratio (frequency) is set between 0 Hz and 1, where 1 represents the maximum frequency. An amplitude for the left and right sides is generated as well, along with a decay between 20 and 60 (which corresponds to decay times of between 10 ms and 1 second).

I’m currently in the middle of sketching out some ideas for a larger engine built around this idea. There are many more parameters that could be added to create more depth and possibility to the sounds generated. A simple example would be to include tuned sounds – the current atonal engine is great for certain sounds, but with a large numbers of partials, most of the sounds become too similar as a result of their random distribution. As a result, some of the most interesting sounds are actually ones with less partials.

Another thing that would be nice is to have the ability to create sounds with continuous inputs as opposed to the simple impact sounds generated by the current engine. Moving the partials frequency as the sound is playing is another option that could add a lot of depth – each partial could get it’s own trajectory and speed generated individually.

Obviously, some of these ideas are more easily implemented than others.

The post Free Ensemble – Modal Generator appeared first on NI Reaktor Tutorials.

In this video, I show how to create morphing Sine Banks in Reaktor. Since Sine Banks require a very specific order of events during programming, you must be careful with each aspect of a structure containing one.

Click here to view the video on YouTube.

This video builds off of a previous Sine Bank tutorial, which showed a very basic setup for the Sine Bank using an Event Table to hold partials. Using that tutorial as a starting point, much of our work is already done. We simply need to duplicate the Event Table containing the partial amplitudes, and  morph between the outputs of the two Event Tables using a crossfader module.

Of course, there is a little more to it than that, because now we need the partial information to be updated constantly, instead of a new gate press as the previous tutorial showed. This can be accomplished simply using the CR output of a System Info module to clock the Iteration module. This way, the Iteration triggers constantly at the Control Rate and updates the Sine Bank constantly.

Finally, an envelope is used to control the morph position, but it would be easy to use another signal type as well.

For more Reaktor tutorials, please subscribe to our YouTube channel!

The post Morphing Sine Banks in Reaktor appeared first on NI Reaktor Tutorials.

Every so often, I like to showcase free Reaktor ensembles from around the web or curated from the depths of the User Library. It is my hope to make building in Reaktor a more rewarding experience for those who take the time, so if you like something you find, please let it’s maker know! If there are any ensembles you feel like I’m missing, please mention it in the comments and I’ll make sure to include them in a future installment.

METALON

Let’s start with one from the Reaktor User Library. Although dead simple in both programming and interface (and despite being 10 years old!), Metalon is a great little tool. You can create an endless supply of random glitchy drum hits simply by pressing a MIDI note. If you like a specific sound, it gets written to a Tapedeck module, and can be exported to a .wav file. Really cool method for creating lots of glitchy sounds very quickly and easily.

I especially enjoy the simplicity combined with a very specific goal with this one – it makes for a very streamlined project.

DOWNLOAD HERE.

SY66

On the other end of the spectrum, SY66 is an FM synth with a fantastic sound bank and a ton of features. I’ve barely had time to scratch the surface with this one, but it is quite impressive indeed. Utilizing the Multi-BP envelope, this synth is capable of a wide variety of sounds and has a ton of versatility.

DOWNLOAD HERE.

JP-4C

An emulation of the Roland JP-8000 by producer Alex, Shore. This is a cool little synth, and it comes with a paper analyzing the famous ‘supersaw’ oscillator that made the original so popular. This detailed analysis leads to a different supersaw implementation than the simple linearly detuned versions I’ve shown on this site before.

DOWNLOAD HERE.

TWISTED FREEBIES

I assume everybody probably knows about these already, but maybe not – just checking now there was some new stuff up I wasn’t aware of. Simply click the ‘FREEBIES’ tab on the link, and you’ll be offered a world of free stuff, from sequencers to synths to sample packs!

Buffeater Lite (pictured above) is a particularly nice little toy from the early days of Twisted Tools.

DOWNLOAD HERE. (Click on the freebies tab).

SONIC DUST

Another forgotten User Library ensemble, Sonic Dust is a unique little synth with a lot of character that excels at making weird sound effects. Based on techniques describe in Curtis Roads’ Microsound. In the presets you’ll find sounds for everything from chirping birds to leaky faucets.

DOWNLOAD HERE.

NEED A NAME ENSEMBLES

There are three ensembles here. They are not terribly complex in terms of programming or deep with tons of modular routings. Instead, they are simple ensembles with easy-to learn controls, built for specific tasks. And they look nice! I enjoy tools like these – they show what can be done in Reaktor without going crazy into DSP and math, yet still create a nice end experience for the user.

DOWNLOAD HERE.

CONCLUSION

That’s all I’ve got for you this time. It’s impossible for me to keep up with everything current and past in Reaktor, so as always, let me know of any inspiring ensembles in the comments and I’ll make sure to post them next time. Thanks for reading.

The post Free Reaktor Ensemble Roundup appeared first on NI Reaktor Tutorials.

The Random and Morph features in Reaktor are often overlooked – they are slightly hidden within the interface, and builders (myself included) often forget about them entirely when making ensembles. In this tutorial, I’ll show where they are, how to use them, and how to edit ensembles to use them morph effectively.

Pro Tip

The Random and Morph functions can also be accessed from the Snapshot Module for automation!

THE SNAPSHOT PANE

The Random and Morph functions have a variety of purposes, all of which control panel elements (and sometimes hidden ones too!) in Reaktor such as knobs.  Depending on the ensemble, the results can be pretty nifty or completely worthless. I have found Monark works pretty well, in a conventional way, and that Lazer Bass can give some pretty good sounds too, although sometimes gives some very strange results.

The Snapshot view in the Side Pane  contains the Random and Morph functions. You can access it by pressing F6 or by pressing the tab that looks like a camera in the Side Pane:

As you can see, the Morph and Random area is tucked between the Bank Selector and the Snapshot Selector, and is closed by default, making it easy to forget about. Click on the arrow to open the interface:

The top half of the interface is for the Morph function. To select a snapshot to use, click one of the areas marked “default”. Then you may choose a snapshot from the list directly below. Once you have two snapshots chosen, you can morph between them using the horizontal slider. You should be able to see the knobs on the Reaktor interface moving. The number better the two snapshot areas (marked “1.00″ above) is the Morph Time, in seconds, controlling the amount of time the knobs will take to arrive at their new value.

As far as I can tell, Morphing appears not to work on buttons – therefore, you can can set which snapshot has it’s button values used with the little buttons on either side of the horizontal fader.

The Random functions are found directly below the Morph function. The Randomize function gives a random value to each control. How random that value really is depends on the number directly next to it. At 0,the controls will not change at all. At 100, the controls can be any value along their spectrum. In between, the number determines amount that the value can deviate from it’s original position.

On the other side, is the Random Merge function. First, this takes the average position of the controls over two snapshots – the ones chosen for morphing. For example, if a knob is set to 0 in one snapshot, and 1 in another, when Merged, it will equal 0.5. Once Merged, a Random function is applied, again depending on the number between the two Random buttons.

EDITING ENSEMBLES FOR RANDOM AND MORPH

Most ensembles are not set up with Random and Morph functions in mind. There is no guarantee that any given ensemble with work the way you might hope.

One thing you can do to improve the situation is to decide for yourself with controls are effected. In the FUNCTION tab of the properties for any module that stores itself by snapshot, you may select the “Mrph/Rnd Isolate” option to ignore Morph and Random functions for that module:

This gives you the option of choosing exactly which knobs will be affected, giving you a much fuller control over the final sound.

The post Random and Morph in Reaktor for Beginners appeared first on NI Reaktor Tutorials.

In this video, I demonstrate a method for automated snapshot morphing in Reaktor. The result is a macro that can be easily dropped into any existing ensemble with no extra programming whatsoever.

Click here to view the video on YouTube.

Snapshot morphing is a fast and easy way to greatly expand the sonic potential of a synth. Creating ever-changing soundscapes has never been easier!

The Snapshot Morph and Random features are somewhat hidden in the Reaktor interface, and often builders forget to account for them. This means that some ensembles will be better results than others for morphing, and some may not work at all, depending on their design.

Ensembles that mostly use knobs and sliders for controls are the most likely to work well. Ensembles that use many custom controls, Mouse Areas, and Buttons, are unlikely to give satisfying results. Reaktor Factory Synths, such as Lazer Bass, Steampipe 2, and Monark have all worked quite well so far.

Using Reverb or Delays with Snapshot Morphing can also give very interesting results – with reverb you can effectively change the shape and size of the space being simulated.

DOWNLOAD HERE.

The post Automated Snapshot Morphing in Reaktor appeared first on NI Reaktor Tutorials.

Bessel functions have a wide variety of uses, from making filters to calculating the modes of a drum. Currently, I’m interested in them for the purpose of anti-aliased FM.

Unfortunately, creating Bessel functions in Reaktor is somewhat complex, and one place the Reaktor community has fallen a little short in my opinion is that there are very few libraries of code for specific functions to be re-used (one notable exception being the partials framework).

THE FACTORIAL FUNCTION

Factorial explanation from mathisfun.com

The first macro to show you today is the factorial function (which we’ll need to implement the Bessel Function), commonly denoted as n!, where n is an integer. The factorial function is pretty simple to implement, but it is quite inefficient. Instead, I simply calculated the factorial of n, from n = 0 to n =32 and stored the answers in a table. This way, the entire function can be reduced to a single read from a Table:

I should note here that Bessel functions are also very expensive to implement and as such I will store them in tables to be read back as well (though they will look slightly more complicated than the above).

The factorial macro has been named !, and can take any input from 0-32. Though the range may seem prohibitive, the reality is, the output values get so large so quickly that you rarely need to go any higher.

BESSEL FUNCTIONS

Bessel functions are pretty annoying to implement, due to their iterative nature. Today, I’m interested in what are called Bessel Functions of the First Kind. Here’s what they look like, mathematically:

I assume you’re here to avoid implementing this sort of stuff for yourself, so I won’t bore you too much with the details of this equation, other than to note that the Σ symbol runs from 0 to infinity, which denotes an infinite iteration, which is obviously impossible to implement. Instead, I’ve done 24 iterations, which is generally enough. The other thing to mention is that the symbol α denotes the order of the function.

Bessel Functions are very expensive to implement, with division and exponents for each iteration. Calculating one at audio rate would be prohibitively expensive on the CPU. Instead, I designed an ensemble that stores a given Bessel Function in a table.

The table can then be loaded into into a Core macro called Table Reader. As long as the ‘Range’ input of the macro is equal to the ‘Range’ knob position during the creation of the Table, you can then give an ‘x’ input from 0 to Range and receive an output. ‘x’ values outside the range will return incorrect values.

This implementation is not as versatile as I would like, but since it is wasteful to calculate Bessel Functions in real time I think it is the best solution.

MATHLIB v0.01

DOWNLOAD HERE.

The download consists of two core macros (the factorial function and Table Reader) and one ensemble (BesselTables.ens). In the future, I hope to expand this library to include many math functions, using the Table Reader and variations as a way of implementing expensive calculations. The Table Reader will also be expanded to include various types of interpolation.

If you have any math functions you’d like to see covered, please ask!

The post Math in Reaktor – Bessel Functions appeared first on NI Reaktor Tutorials.

You can see part I of this series here.

Click here to view the video on YouTube.

As you can hear in the sound sample at the end of the video, the sound keeps morphing through the selected ‘A’ snapshot (the one selected in the user interface), while constantly choosing new, random snapshots to morph into. Since all the switch values are chosen by the ‘A’ snapshot, a certain level of congruity is maintained between the selected sounds.

The great thing about the macro created in this video is that it can easily be added to a plethora of Reaktor ensembles and create totally new sounds with ease. As a demonstration, Lazer Bass is used, which is particularly suited to the task as a monophonic ensemble.

For more Reaktor tutorials, please subscribe to our YouTube channel!

The post Automated Snapshot Morphing in Reaktor, Part II appeared first on NI Reaktor Tutorials.

In this video, I show the ins and outs of my newest Reaktor ensemble, Bassic. I’ve been developing Bassic on and off for the last few months, and I hope you like it as much as I do!

Click here to view the video on YouTube.

Designed specifically for bass sounds, Bassic contains a simple modulation network that allows any knob to be controlled by an envelope or an LFO with ease. In the video, I show how to use the Voicing controls to easily duplicate, and detune oscillators. Up to 4 copies of each oscillator can be made, and they can be spread across the stereo field just as easily.

Bassic also contains a unique filter, with three audio inputs (for high, band and low pass). Each of the oscillators can be sent to any of the inputs, allowing for some creative sound design. For those who are interested in it’s design, it is a  zero delay feedback filter, featuring embedded saturation, and self-oscillation.

Self-oscillation means if you turn the resonance all the way up, and the oscillators all the way down, you can use the filter as a sound source. The Freq knob can then be modulated to create some interesting sound effects.

Get BASSIC – click here to find out more

The post New Reaktor Synth Available – Bassic appeared first on NI Reaktor Tutorials.

In this video, I show how to build a physical model of a guitar in Reaktor using the Modal Bank module. While the Modal Bank is very complex to use, with a little bit of knowledge about an instrument it becomes possible to create very realistic models.

Click here to view the video on YouTube.

A Modal Bank contains a number of resonant bandpass filters, which can be used to shape an incoming signal into something similar to what you might get out of a vibrating object, such as a guitar string or a drum. Typically a vibrating object has several modes, also called partials, that combine to define the sound of the instrument.

Fortunately, an ideal string has properties that make it very easy to use with the Modal Bank. The ratios can be ignored, and the amplitudes are all the same. The only parameter that needs special attention is the decay times of the partials. The higher frequencies in a  vibrating string decay faster than the lower frequencies. As you can see from the video, this is easy to set up!

For more Reaktor tutorials, please subscribe to our YouTube channel!

The post Create a Physical Model of a Guitar in Reaktor appeared first on NI Reaktor Tutorials.

Native Instruments recently unveiled a public beta for the new Reaktor User Library. Many users (myself included) had been complaining about the state of the old system for some time, so this is a very welcome development!

NEW LOOK AND FEEL

Not only does the new User Library look much better, the new look actually provides better functionality than previously. For instance, now each upload listing contains a screenshot while browsing:

The level of thought put into the user interface of a Reaktor instrument is often (but certainly not always) indicative of the quality beneath the hood. Not only does the new look make it easier to search for ensembles, I think will also reward builders who design nice interfaces, as it will give them a way to stand out from the crowd – something that was very hard to do in the previous UL.

You can also see the number times an ensemble has been rated, which gives you an idea of how much the rating is worth (just because something has 5 stars after 1 rating doesn’t mean much!).

Most importantly, the new feel of the User Library makes it much more enjoyable to use, and browse.

IMPROVED SEARCH FUNCTION

One of the biggest improvements in the new User Library in in the search capabilities. The old ‘Hot 50′ and ‘Top 100′ lists are gone, replaced with 5 options for sorting ensembles (newest, highest rated of all time, highest rated in the last three months, most downloaded in the last three months).

These sorting options can of course be used to look at, for example, the highest ranked ensembles, but they can also be used in conjunction with the other search functions. This leads to more complex searches than were possible with the old system – you can search, for example, the highest rated ensembles in a certain category, by a specific user.

In addition, there is a new tagging system, that will hopefully be expanded upon to allow users to add tags to their uploads. Right now you can choose any number of pre-existing tags to make your project easier to find.

CHANGED VOTING SYSTEM

Probably the most common complaint about the old User Library was the rating system. Although ensembles could theoretically have a rating from 1-10, practically speaking, it was impossible to get a rating above a 6, even if every rating you received was a 10!

This was due to an overly complicated rating function that was determined more by number of downloads than the actual votes you received. This led to an unfair system where the ensembles that had been around longer were ranked higher simply by virtue of incumbency.

Thankfully, the system has been simplified, and the rating is now just an average of the votes received, which makes far more sense.

LARGER UPLOADS

In the last few years, many of the most impressive Reaktor ensembles released by the community had to be stored somewhere other than the User Library, due to size limitations. Reaktor ensembles with large sample maps can be upwards of 1GB or more!

The options for free hosting of files of this size are limited. Fortunately the size limit for uploads to the UL has been increased to 900 MB. I believe the previous maximum was something like 25 MB so this is a very substantial increase!

TROUBLES

The new library is still in beta, and of course there are a few bugs here and there.  NI has stated they are working on these and I am confident they won’t be around much longer. The worst inexplicably showed ensembles to be 44 years old, but it seems to be fixed.

Worse for folks like me, the new system broke every single external link to the User Library, as the URL of the uploads has changed. That means many links on this very site are now broken, and need to be fixed, one by one.

CONCLUSION

Whether you’re a builder or just a consummate collector of Reaktor ensembles, this update is great news. It makes the library easier and more enjoyable to browse, removes frustrating ratings problems, and generally increased the capacity of the User Library in every way.

I’ll be moving my own work from private hosting over to the User Library in the next few weeks.

In the meantime, provide some feedback to Native Instruments in this thread!

The post Reaktor User Library Updated appeared first on NI Reaktor Tutorials.