78 – Creating Better Patches (Part 5)

In this fifth installment of my series on better patch design, I thought I would take a much-needed break from all the theory and synth jargon, and instead focus on some creative Thor synth ideas. I can almost hear the collective yawn after reading the last few articles. So let’s spice it up with a few videos that showcase some of the concepts we’ve talked about, but more importantly, let’s just have some fun fiddling around in Thor.

In this fifth installment of my series on better patch design, I thought I would take a much-needed break from all the theory and synth jargon, and instead focus on some creative Thor synth ideas. I can almost hear the collective yawn after reading the last few articles. So let’s spice it up with a few videos that showcase some of the concepts we’ve talked about, but more importantly, let’s just have some fun fiddling around in Thor.

You can download the project files here: better-patches-part5. This zip consists of a few Thor patches and demo .reason files that outline the ideas below. You can use any version of Reason above 4.0 (when the Thor synth was introduced to the world of Reason). Enjoy! Read on for more about these ideas.

The Hoover Sound (Redux)

Chris Petti did a great video on how to create a Hoover Sound in Reason using some Analog Oscillators and a Multi-Oscillator to fatten everything up. If you haven’t seen his video, I’m going to showcase it here. Have a look and build the patch first. We’ll use this as the base building block and figure out a few modifications you can add to enhance it’s flexibility. Here’s his video:

This patch is a really great sound as it is, and Mr. Petti does a bang up job of presenting it to us (not to mention his videos are way cooler than my own DIY camera work). Nonetheless, there’s lots you can do to add to his patch. So I’m going to start where Chris left off and see what we can do to make his patch more flexible, taking it to the next level of patch design. Check out the video below:

Button Trigger Madness

In my never-ending quest to solve interesting problems in Reason, I came across this dilemma. How can I use the button in Thor as a toggle switch to step through the Thor Sequencer? I wasn’t happy with the “it’s not possible” answer. So here’s what I devised. It’s actually a nice simple solution which allows you to use the Thor button as a cycler. The power in this trick is that when the Sequencer is set to “Step” mode, the button can be used to cycle through all 16 steps. If you watch the video below, you’ll see how this can help you devise Thor patches that contain 16 distinct sounds within a single Thor patch.

Here’s the short version of how you set it up (see the Chiptune video below for a practical application):

  1. Open a new Reason document. Go into Edit > Preferences, and on the “Audio Tab,” ensure the Sample Rate is set to 44,100 (should be the default). Then close out of this dialog.
  2. Create an initialized Thor device.
  3. Turn off the “Step Sequencer” green light in the Global section’s “Trigger” area. While we’re doing that, label Button 1 the “Stepper.”
  4. Turn off the Global Envelope’s “Gate Trig” green light.
  5. Turn up the Global Envelope’s Sustain to full (0.0 dB), and turn down all other Global Envelope parameters to zero.
  6. In the Modulation Bus Routing Section (MBRS), create the following two lines on the left side:

    Button1 : 100 > G.Env Gate

    Global Env : -100 > S. Trig

  7. Now, enter the following in the MBRS on the first line on the right side

    Button1 : 100 > S. Trig : 100 > S. Trig

  8. In the Step Sequencer section, change the Run Mode to “Step.”
The Thor Button Cycler, showing all the changes that need to be made to the Thor init patch
The Thor Button Cycler, showing all the changes that need to be made to the Thor init patch

Now when you press button 1, you’ll notice that the Step sequencer moves forward one step when turned on, and another step when turned off. In essence, we’ve tricked Thor into thinking that both button “on” and button “off” should trigger the Step Sequencer to “Run.” The Global Envelope was required because it is always left on, and so can be manipulated without requiring a Midi Note to “gate” the envelope.

You can now use the Step Sequencer’s Note, Curve 1, Curve 2, Gate Length, etc. to control any aspect of the Thor patch that you like, and build up different sounds at each step of the Step Sequencer. Think of generating 16 different Bass tones or 16 different Pads, Strings, Drum sounds, or any interesting sounds you can dream up. The only limitation is that you won’t have access to the Global Envelope — a minor limitation given the fact that you can get Thor to generate 16 different sounds from a single patch.

Chiptune Sounds (Redux)

As I was experimenting one day, I stumbled upon. . .

. . . a wonderful way to create some Chiptune sounds using the Wavetable Oscillator in Thor and affect it’s “Frequency (FM)” parameter with a stepped LFO. Sometimes it’s not how crazy you can make things. Instead, it’s about keeping things ultra simple. Have a look at the video to see how I paired this Chiptune idea with the above “Button Trigger Madness” idea to create 4 different Chiptune sounds within a single Thor patch.

Here’s the video:

Creating a Sweep

This is an interesting patch that will show you an alternate use for the Velocity performance of the Patch. Since the sweep changes the Volume (along with a few other parameters) over time to sweep the sound upward to full volume, you probably don’t want to have Volume modulated by Velocity. Instead, you can use the Velocity information from the musician’s performance to adjust the speed or rate of the sweep, making it rise slowly when the keys are played softly, and faster when the keys are played harder. You could also set up a button to reverse the Velocity behavior, if you like (see my previous tutorials in this series for explanations on how this is done).

Here’s the video:

Using the FSB for Practice

Another idea I had was to take patches from one synth and transfer them over to another synth within Reason. In this video, I’ll show you how you can take one of my favorite Subtractor patches and recreate the sounds inside Thor. While not every sound from the Subtractor (or Malstrom, for that matter) can be accurately reflected in Thor — they are, for the most part, different synthesis algorithms and techniques underlying each synth — you can still get pretty close, depending on the patch you start out with. It’s good mental exercise. It will help you get to know all the synth parameters and how they work. And you have an endless array of sounds at your fingertips in the FSB.

So why not give this a try with your favorite sounds? And there’s also another reason to transfer patches from the Subtractor into Thor: At the end of the transfer, you’ll still have the Rotaries, Buttons, and step sequencer to enhance or expand on the patches — something the Subtractor lacks. So here’s the video to show you the method I used:


So that’s part five in the series. As always if you have any questions or want to contribute your thoughts and ideas, I encourage you to do so. I’m always interested in hearing new ways you’ve found to work with Reason. All my best until next time.

75 – Creating Better Patches (Part 2)

In this second installment of Reason 101’s Guide to creating better patches, I’m going to focus on Performance, Velocity, and how the MBRS (Modulation Bus Routing Section) in Thor relates to both. The focus is to look at new creative ways you can improve how Thor reacts to your playing style and explain some of the reasons why Thor is such a powerhouse of flexibility in this area. Again, I’m not going to be approaching this as a complete guide to every possible performance technique you can accomplish inside Thor, but rather try to outline its flexibility and show you a few key aspects of performance that you should think about as you develop your own patches.

In this second installment of Reason 101’s Guide to creating better patches, I’m going to focus on Performance, Velocity, and how the MBRS (Modulation Bus Routing Section) in Thor relates to both. The focus is to look at new creative ways you can improve how Thor reacts to your playing style and explain some of the reasons why Thor is such a powerhouse of flexibility in this area. Again, I’m not going to be approaching this as a complete guide to every possible performance technique you can accomplish inside Thor, but rather try to outline its flexibility and show you a few key aspects of performance that you should think about as you develop your own patches.

What is Performance?

Performance has less to do with the actual sound than it does with how the sound is played. If sound is the Motor that moves the car, Performance is the route it takes. It adds dynamism, movement, and modulation. And it is just as important as the actual sound you are hearing, or in our case, “creating” inside Thor. Both the sound and the performance of the sound are intrinsically interconnected. Without performance, sound would be very lifeless and dull, devoid of any movement or humanity. In terms of creating a patch in Thor, there are several performance parameters that you can use to determine how the sound is affected (changed or modulated) based on the way the patch is played by the musician. It is up to you, as a sound designer, to select what changes are made to the sound when a key is struck softly versus when the key is struck hard. It is up to you to determine what happens to the sound when the patch is played at different pitches along the keyboard, or when the Mod Wheel is used. And Thor offers an endless variety of ways you can harness the power of performance.

Performance Parameters

Performance parameters fall into the following categories (note the names in parentheses refer to the different names these performance parameters are given on the front panel of the Thor synth):

  • Velocity (or Vel): How soft/slow or hard/fast the keys on your keyboard are initially pressed.
  • Keyboard Scale (or “KBD,” or “Key Sync” or “KBD Follow”): The Keyboard register/pitch, or, where you play on the length of the keyboard (from -C2 to G8)
  • Aftertouch: Also called “Pressure Sensitivity,” Aftertouch responds to the pressure you place on the keys after they have initially been pressed down.
  • Mod (Modulation) Wheel: A unipolar (0 – 127) wheel that is generally used to (but not limited to) control vibrato (pitch wobble), tremolo (amp wobble), or both.
  • Pitch Bend: A bipolar (-8,192 – 8,191) wheel that is generally used to (but not limited to) control the pitch of the sound upward or downward.
  • Breath: Used with a breath or wind controller. Breathing into the controller will usually cause the sound to be modulated in some way. And if you’re interested in how a breath controller can be used, check out http://www.ewireasonsounds.com/ and http://www.berniekenerson.com/
  • Expression: Usually this parameter is tied to an Expression Pedal, usually found on an organ or piano.
  • Sustain Pedal: Usually this parameter is tied to a Sustain Pedal, usually found on an organ or piano.

Note: While performance relates to how the physical instrument / MIDI Controller is played by the musician, any performance parameter can also be programmed or automated in the Main Sequencer in Reason.

The various Performance parameters that can be assigned in Thor's MBRS.
The various Performance parameters that can be assigned in Thor's MBRS. Note the Sustain Pedal is located in the root folder, not within the Performance subfolder. Velocity is under the "MIDI Key" subfolder, and Keyboard Scale is found at the top of the root menu under the "Voice Key" subfolder.

While all these parameters can be “turned on” or “turned off” (“implemented” or “not implemented”) in a patch, generally you want to make use of most of these parameters in order to make your patches highly flexible and dynamic. However, I don’t use the Breath, Expression, or Sustain Pedal controls. To my mind, these three controls are very specific, and unless the Musician has a pedal or a wind controller (like a MIDI Flute), they won’t be able to make much use of them. If I were designing a ReFill specifically for a Wind Controller, however, then the Breath parameter would be extremely important and you would probably design most of your patches with this type of control in mind. But for the majority, these controls probably won’t need your attention. And I won’t be discussing them here.

Out of the remaining controls, you can break them down into two groups:

A: Keyboard controls: Velocity, Keyboard Scale, and Aftertouch. These are the Performance parameters that rely on how you play the keys on your MIDI keyboard. Velocity and Keyboard Scale are vital in my opinion. Aftertouch is not as vital, since not every MIDI Keyboard controller can utilize Aftertouch. But many CAN utilize it, and as a designer trying to make your patches stand out, this is one area that can separate your patches from others; making them shine. Note: If your keyboard is not equipped with Aftertouch, you can still test your patches by creating an aftertouch automation lane in the Main Sequencer in Reason, and drawing in your automation. This is true of any of the above Performance parameters. However, this kind of testing can be rather tedious. Better to try and purchase a controller that comes equipped with Aftertouch capability if you can spare the money.

B: Wheel controls: Pitch Bend and Mod Wheel. These are the Performance parameters that rely on how you play the two wheels on your MIDI controller. It’s rare you will find a MIDI keyboard that doesn’t have these two control wheels as commonplace controls, so it’s always a good idea to design your patch with these two controls assigned to modulate something in your patch. Furthermore, even if you don’t have a keyboard controller that has these wheels, you can still test the controls by turning the Thor wheels up or down on-screen with your mouse.

Let’s start with the Keyboard controls:

Velocity

Think of a sound that has no velocity sensitivity. You actually don’t need to travel too far to think about it. Load up a Redrum, set the Velocity switch to Medium, and enter a Kick drum that beats on every fourth step (typical four to the floor programming). Now play the pattern back. Sure, the drum sounds great, and it has a beat. But it has no change in level. It’s as lifeless as a bag of hammers.

Now put a high velocity on the second and low velocity on the third drum beats. Listen to the difference. Obviously this is still pretty lifeless, but by introducing Velocity, you’ve introduced a small degree of movement to the pattern. It’s more dynamic “with” velocity than “without” velocity. It doesn’t sound stilted or robotic. It starts to take a better shape. You’ve just added a performance characteristic by changing how the sound is played, albeit, you’re programming the velocity instead of playing it on a keyboard.

Now instead of putting the Kick drum through Redrum, what if you built your own Kick drum in Thor, and played it from your MIDI controller, Your keyboard is capable of a range which goes from 0-127, so you can have 127 different degrees of Velocity (or put another way, you have 127 different velocity levels). When you strike the keyboard to play your Kick drum, the “Velocity” at which you strike the keys can be used to determine the amplitude of your Kick Drum sound.

Velocity in Thor’s MBRS

Now here’s where things get interesting, and Modular / Semi-modular, in Thor terms. Thor offers both hard-wired (fixed) routings, and programmable (adjustable) routings. What you see on the front panel of Thor is what I would term as “Fixed,” while the Modulation Bus Routing Section (the green area below the front panel) offers you the ability to create your own custom routings; not just audio routings, but also performance routings. Using the MBRS, you can adjust what these performance characteristics will affect in an incredibly open-ended way. In other words, you can use any of these performance parameters to change any other Thor parameters you wish (within a few limitations).

Now let’s look at a fundamental use of Velocity in Thor.

Velocity = How soft or hard you play your keyboard. How the note is performed.
Amplitude = The amplitude or volume of a note. How soft or loud the note sounds.

By combining these two parameters together, you end up with the following:

Velocity Amplitude = A change in amplitude when you play your keyboard soft versus hard. Put another way, the “Velocity” is what is “performing the change” while the “amp” is “being changed.” Velocity is the “How” and Amplitude is the “What.” Velocity is the “Verb” and Amplitude is the “Subject.” Or put in Thor terms, Velocity is the “Source” and Amplitude Gain is the “Destination.”

I’m stressing this concept for a very good reason, because it’s the basis of all modulation concepts inside Thor (and any other really good modular synth for that matter). The main reason why people go kookoo for cocoa puffs over the MBRS in Thor is because you can change the “Verbs” and “Subjects” around in any wacky way you like. So any of these “Performance Parameters” can be used to change any other “Thor Parameters.” And not just that, but you can have as many “Verbs” affecting as many “Subjects” as you like. Or have one “Verb” affecting many “Subjects” or have many “Verbs” affecting one “Subject.” The only limitation to how many routings you can create is the number of MBRS rows provided in Thor.

At this point, you might want to know the complete list of Verbs and Subjects right? No problem. In the MBRS, click on the first “Source” field. Those are your “Verbs.” Now click on the first “Destination” field. Those are your “Subjects.”

Typically, you want your Velocity to affect the amplitude in such a way that the softer you press the key, the lower the amplitude is, while the harder you press the key, the higher the amplitude is. But what if we want to reverse this relationship. What if we want softer key strikes to result in louder sounds, and harder key strikes to result in softer sounds. We can very easily accomplish this in Thor using the “Amount” field in the MBRS. Since you can set up the amount to go from -100 to +100, you can make the Velocity affect the Amplitude by a “positive amount” or a “negative amount.” Here’s how both Velocities would look inside the Thor MBRS:

First, turn down the Velocity and Amp Gain knobs on Thor’s front panel, so they are fully left. Then Add the following routing in the first line of Thor’s MBRS:

Positive Velocity Amplitude = MIDI Velocity (Source) modulates by +100 (Amount) to affect Amp Gain (Destination)

The Source (MIDI Key > Velocity) and Destination (Amp > Gain) settings in the MBRS row
The Source (MIDI Key > Velocity) and Destination (Amp > Gain) settings in the MBRS row

Next, turn the Amp Gain knob up, fully right. Then change the amount in the MBRS line you previously created, as follows:

Negative Velocity Amplitude = MIDI Velocity (Source) modulates by –100 (Amount) to affect Amp Gain (Destination)

I’m sure by now you’ve noticed that the amount does not necessarily need to be exactly 100 in either direction. You can, of course, enter any amount between -100 and +100 as well. What happens if you lower the Positive Velocity Amplitude? You end up with Velocity affecting the Amp Gain to a lesser degree. In this respect, Amount is actually a way to “Scale” back on the Amp Gain when Velocity is used.

Now what if you want Velocity to affect Amp Gain some of the time, but not all the time? For example, I want to create a patch where the performer can use Velocity some of the time, but not all the time. You can create an on/off switch for this very easily using the “Scale” parameter in the MBRS. Just add the following:

Positive Velocity Amplitude = MIDI Velocity (Source) modulates by +100 (Amount) to affect Amp Gain (Destination)

and this Positive Velocity Amplitude modulation is scaled by +100 (amount) from the Button 1 (Scale) control.

Put another way:

PVA = [MIDI Vel (Source) modulates +100 (Amount) to affect Amp Gain (Destination)] scaled by +100 (Amount) from the Button 1 (Scale) control.

In the grand scheme of things, Sources and Scales are the same. Anything that can be used as a source can also be used to Scale a modulation. The only limitation is that you can’t have a “per voice” parameter scale a “global” modulation. For example, you can’t have the Modulation Envelope Scale the LFO2 Source changing the Global Envelope Attack. Anything that is “per voice” is considered anything in the “black area” on Thor’s front panel, while anything “global” is located in the “brown area” on Thor’s front panel. There’s also a line that separates the “Per Voice” parameters from the “global” parameters in the menu that opens when you click on “Source,” “Destination,” and “Scale” fields in Thor. “Per voice” parameters are located above the separator, while “global” parameters are located below the separator. If you choose a global modulation to scale a per voice modulation, a strikethrough line will appear over the text in the MBRS row.

Now, when Button 1 is turned on (lit up), the Positive Velocity Amplitude is active for the performer. When the Button 1 is turned off, the Positive Velocity Amplitude is inactive. By now, I’m sure you have figured out that you can reverse this “Button 1 on/off behavior” by reversing the Scale amount to -100. This would mean the PVA is active when Button 1 is off, and inactive when Button 1 is on.

You might also want to provide “degrees” or “gradations” of changes in the way the PVA is modulated. If this is the case, change “Button 1” to “Rotary 1” and then use the Rotary to provide 127 shades to how “active” the PVA modulation is. The more the Rotary is turned right, the stronger the effect of the PVA becomes. The lower you turn the Rotary, the less impact PVA will have on the performance. How you set this up is totally up to you, the sound designer.

Important Point: Your setting in the MBRS works “in conjunction with” the fixed parameters in the Thor synth. This means that the amount of your Amp Gain knob is going to determine how the routing you’ve set up for it in the MBRS operates. If the Amp Gain knob is set to zero (0) on the front panel, and you’ve set up a Positive Velocity Amplitude as shown above, the knob has no effect, and the MBRS settings are doing all the work to control the Amp Gain. If, on the other hand, you turn up the Amp Gain knob, the sum of the knob’s gain position is added “on top of” the amplitude increase you’ve set up in the MBRS. It is cumulative. This is why you need to adjust the “Amp Gain” knob in the above examples, even when you enter the MBRS settings. The fixed “Amp Gain” knob setting works in conjunction with the adjustable MBRS “Amp Gain” routing assignment.

In this setup, the Amp Gain is completely controlled via the MBRS routing, since both the Amp Gain and Velocity knobs are turned all the way down (fully left).
In this setup, the Amp Gain is completely controlled via the MBRS routing, since both the Amp Gain and Velocity knobs are turned all the way down (fully left).

Now that you know a little bit about how the MBRS works, I’m going to completely throw all of the above away, because you don’t have to set any of this up in the MBRS at all. Notice the little “Vel” knob next to the Amp Gain knob? This is an example of one of those “fixed” elements of Thor. And since a “Positive Velocity Amplitude” is such a basic principle in most sounds or patches, The Propellerheads gave it a “fixed” position in Thor, next to the Amp Gain knob. By default, it is turned down or off, but you can raise it (turn it right) to achieve the same effect as if you created a line for it in the MBRS.

In this setup, the Amp Gain knob and Velocity knob are controlling the Velocity, not the MBRS. The velocity control result is exactly the same as in the previous image. It's just a different way to set it up within your patch.
In this setup, the Amp Gain knob and Velocity knob are controlling the Velocity, not the MBRS. The velocity control result is exactly the same as in the previous image. It's just a different way to set it up within your patch.

Also keep in mind that since both the “fixed” parameter (the Velocity knob) and routing (the MBRS) work in tandem, if you have the Velocity knob set to 127 (fully right), and have a line in the MBRS set up for Positive Velocity Amplitude as outlined above, you are essentially doubling the degree to which your Velocity is affecting the Amp Gain (+200). Same goes if your Velocity knob is set to zero (0), and you create two lines in the MBRS that both have Velocity affecting the Amp Gain by +100. If you duplicate lines in the MBRS, you ARE going beyond a value of 100, and this is true if you go in a positive or a negative direction. Lastly, if you have the Velocity knob set to +127 and the MBRS is set to -100, then they cancel each other out, and Velocity DOES NOT affect Amp Gain at all.

It should be noted that there are actually three different Velocities that can be used as a Source or a Scale in Thor. Here’s how they differ:

  • Voice Key > Velocity: This setting sources velocity on a “per note” basis. In this respect, it’s the most granular of the Velocity settings in Thor. Each note polyphonically will receive a different Velocity setting based on how soft or hard you play each key. Of course, if you use this setting, you probably also want to be using a polyphonic patch that has more than one voice. Otherwise, it will react the same way as the MIDI Key > Velocity setting.
  • Last Key > Velocity: This allows you to use the Step Sequencer or incoming MIDI key signal to source Velocity. This is also global, so it is also “monophonic” by nature. The idea is that the last key played (from either the Step Sequencer or the MIDI Key) determines how the velocity is sourced.
  • MIDI Key > Velocity: This sources the Velocity globally via the incoming MIDI key signal. It is different from the Voice Key Velocity setting because it is monophonic, and it is different from the Last Key Velocity because it does not react to incoming signals from the Step Sequencer; only incoming MIDI signals (ie: a keyboard controller).

So before you start assigning Velocity settings, think about how your patch will be played by the musician. If your patch is programmed via Thor’s step sequencer, then you will need to use “Last Key Velocity.” If you want Velocity to be accessed via the MIDI Keyboard, all three settings will work, but you have the option to set up velocity on a per-note basis using “Voice Key Velocity” or on a global basis using “Last Key Velocity” or “MIDI Key Velocity.”

Beyond Typical Velocity Settings

Up to this point, all we’ve accomplished is how to create one simple performance parameter in the MBRS which is used the majority of the time in most patches in one way or another: Positive Velocity Amplitude. And yet I can’t tell you how many times I’ve seen patches that don’t even go this far. No, I’m not going to name names. But my point is that if you do anything at all in your patches, at the very least turn up the “Vel” knob next to the Amp Gain at least a little bit. Or keep the Filter envelope and velocity settings at their default in order to create a little movement in your patches that are tied to Velocity. Sure, there are cases where Velocity does not effect Amp Gain, and even cases were Velocity is not used at all. There will always be exceptions. But if you do anything at all, use the velocity knobs that Thor is giving you in the main panel. This will bring your patch designs from Noob to “Beginner” or “Good” as far as Velocity goes. Don’t forget to think about Velocity! It can be of the most expressive of qualities of your patch, and it adds yet another dimension to your patch that shouldn’t be overlooked.

Now if you want to make your patches go from “Good” to “Great” might I suggest getting your feet wet in the MBRS and experimenting with the following ideas:

  1. Change the destination around. What if we have Velocity affect the Filter Cutoff, or the FM Frequency, or the Mix between Oscillator 1 and 2? The point is, try it out for yourself and see what creativity you can come up with. See if it enhances your sound or detracts from it.  Remember that you are not limited to tying volume to velocity.
  2. Test out the “Amount” setting when you are creating an MBRS routing. Sometimes a negative value will produce a better result than a positive one. If a velocity setting produces a very harsh jump in modulation from soft to hard key presses (or vice versa), you might need to scale back the amount to a more comfortable setting.
  3. Try having the Velocity affect more than just a single parameter. Have Velocity affecting both the Filter Cutoff and the Filter Resonance at the same time. Or perhaps, if two filters are used, have the Velocity setting open up one filter (positive amount) and close the other filter (negative amount). This creates something akin to a Filter Crossover.
  4. Try assigning different destinations to the “Voice Key > Velocity” and “MIDI Key > Velocity” sources. I haven’t tried doing this yet, but I would imagine it can create some very interesting Velocity-sensitive sounds, since one is “per voice” and the other is “global.”
  5. Something I’ve been experimenting with lately is having the Velocity affect the Rate of an LFO, and then having the LFO affecting another parameter in Thor. This has the effect of creating a slow modulation on one end of the velocity spectrum and a faster modulation on the other end of the spectrum. Using positive amounts, when you press the key softly, the LFO is slow, and when you press the key hard, the LFO speeds up. Using negative amounts will reverse the process.
  6. Velocity is independent of the Amp Envelope. Whereas the Velocity is a measurement of how soft or hard you press the key (a function of Weight+Speed on the keys), the Amp Envelope is a measurement of loudness over time. That being said, Velocity occurs before the Attack portion of the Amp Envelope, and therefore, it can be used as a source to control the Attack, Decay, or Release portion of the Amp Envelope (or any other envelope) in Thor. Try using Velocity to change these aspects of your patch. It can produce interesting results as well.

So go make some killer patches and practice changing the destinations and the amounts, so that you hone in on just the performance quality you want out of your patch. And ensure that you keep testing using your Keyboard Controller. Play your patches at low velocities and high velocities as you create modulation routings so that you can hear the effect Velocity has on your sound.

Note: Most Keyboard Controllers have built-in velocity sensitivity and even come with specialized settings that allow you to select from different Velocity scales, depending on your playing style. But before you begin, ensure your keyboard IS velocity sensitive. In the rare case that it is not, you can press F4 (in Reason 6) to access the on-screen keyboard. Using the keyboard, you can switch between velocities. It’s time-consuming to test this way, but I would be remiss if I didn’t mention it as an option.

Fixed Velocities in Thor

In Thor, there are essentially two types of “Fixed” Velocities. I’ve already discussed the first fixed velocity as the “Positive Velocity Amplitude” which is otherwise known as the “Vel” knob in the Amp section of Thor. So I won’t go into detail about that. But there’s also another kind of Velocity which is located as a knob on all Filters in Thor. This is what I like to call the “Positive Filter Envelope Velocity” knob. This sets how much the velocity you play on your keyboard affects the envelope of the Filter. Think of it as having Velocity affecting the Envelope. If the envelope is set to zero, the Velocity knob has no effect on the envelope. Nothing happens. If your envelope is turned higher, and Velocity is turned up to 100, for example, the Velocity you play will have a pretty significant effect on whether or not you hear the envelope affecting the filter. Sounds complicated, but test it out by creating a very noticeable Filter envelope, and then turning up both the envelope and velocity knobs, then play your key controller softly and very hard. Notice the difference?

The Fixed Velocity settings in Thor.
The Fixed Velocity settings in Thor. Note that you can turn off these fixed Velocities very easily by turning all the Velocity knobs fully left. This frees you up to set up your own velocity routings in the MBRS, as you see fit.

So that does it for the second part of the series. I’ll continue with the other Performance parameters in part 3. As always, if you have any questions or want to contribute your thoughts and ideas, I encourage you to do so. I’m always interested in hearing new ways you’ve found to work with Reason. All my best until next time.

64 – Creative Thor Synth Tricks

This tutorial is one that might show you a few new tricks with Thor. Recently I’ve been doing a lot of new sounds in the Reason rack, and I wanted to show off a few new things I’ve found out as I was creating inside Thor. This will also take you on a journey showing how I would come up with a simple synth lead in Thor.

This tutorial is one that might show you a few new tricks with Thor. Recently I’ve been doing a lot of new sounds in the Reason rack, and I wanted to show off a few new things I’ve found out as I was creating inside Thor. This will also take you on a journey showing how I would come up with a simple synth lead in Thor.

Trick #1: Creating a Dry / Wet control for the Kong effects using Thor’s Mod Wheel

This trick was one I stumbled upon when I was trying to figure out how to create a control which allows you to crossfade between the dry and wet control in the Kong effects device (since some of the Kong effects don’t allow you to automate the dry/wet knob directly. This method uses Thor as a pass-through for both the dry and wet signals, and then assigns them to the Mod Wheel. Once this is done, you can use the Combinator mod wheel to effectively switch between a fully dry signal (when the mod wheel is lowered), and a wet signal (when the mod wheel is raised).

This little strategy also has one other benefit: It doesn’t require you to utilize any modulation lines inside the Combinator programmer. This means that if you have a Crowded set of modulations for a particular device which uses all the Combinator modulation lines, you can still add this to the Mod Wheel of the Combinator without having to sacrifice any of those crafty modulations you’ve set up.

The general idea is that you use a Spider Audio splitter to send one split into the Kong effect, and the other split directly into 2 Thor inputs (input 1 & 2). Then you send the Main outputs of Kong into another 2 inputs on Thor (input 3 and 4). The 2 main audio outputs of Thor are then sent to a Mixer or to the final output.

Inside the Kong, you would add your effects devices in the Bus FX and Main FX slots. Set up the effects to your liking.

Then in the Thor pass-through, ensure that all the parameters are turned off or turned down (remove Osc 1, bypass filter 1, etc.). In the Modulation Bus Routing Section (MBRS), you would create 4 lines as follows:

Audio In 1 : 100 > Audio Out 1 : -100 > Mod Wheel

Audio In 2 : 100 > Audio Out 2 : -100 > Mod Wheel

Audio In 3 : 100 > Audio Out 1 : 100 > Mod Wheel

Audio In 4 : 100 > Audio Out 2 : 100 > Mod Wheel

Now when you raise the Mod wheel in the Combinator, the affected split (going into Audio in 3 and 4) on Thor, is going to be heard. When you lower the Mod Wheel, you have a dry signal.

Bear in mind in the video below, I had these splits switched around in the back of the rack (Audio in 1 and 2 were the wet splits and Audio in 3 and 4 were the dry splits). Since this was the case, I had to switch the scaling on all four Mod Wheel lines in the MBRS. So Audio in 1 and 2 had a scaling of “100” and Audio in 3 and 4 had a scaling of “-100” — it’s really the same idea, just in reverse.

Here’s the video which outlines how to use Thor as a dry/wet control for your Kong effects:

Trick #2: Creating some Movement for your Thor Sounds

This isn’t so much a trick, as it is a way to add some modulations and movement to your sound. So here’s a quick way to introduce some LFOs and Looped Mod/Global envelopes to affect the various Oscillators, Delay and Pan in Thor. Let me tell you, there’s hours, days, and months of fun to be had in Thor just by adjusting various parameters such as these.

Here’s the video outlining how to get a bit more movement from some of the parameters in Thor:

Trick #3: Gating and Transposing your Thor Sequences along the Keyboard

I have to give a big round of thanks to James Bernard for stearing me in the right direction with this. And when I found out how to do this, it was a “D’OH!” moment. As soon as he showed it to me, I felt completely stupid for not realizing how to do this in the first place.

In this method, you create a wonderful sequence to play your Thor patch, but instead of having to hit the “Run” button each time you want to hear the sequence, you trigger it from the “MIDI Key Gate,” which is a fancy way of saying, turn on the “Run” button in Thor’s step sequencer whenever you press a key on the keyboard.

Next, you set up Sequence to follow the “MIDI Note value” that is input, which again, is a fancy way to say that where you play the keyboard will determine the notes that are played in the Thor sequence.

So putting this together is a piece of cake. Assuming you have a sequence set up in Thor’s Step Sequencer, and your sequence in, set the Run Mode to “Repeat” and direction to “Forward” (or any other direction you wish). Turn off the “MIDI” light on Thor’s global panel, otherwise you get duplicated notes playing the same instrument (probably not what you intended). Finally, enter the following in the MBRS:

MIDI Gate : 100 > S. Trig

MIDI Note : 100 > S. Transp

Now when you play the sequence, it will be tracked along the keyboard and will only run when a key is pressed down.

Here’s the video that shows how this is done (building on the Thor patch I was building in the video above).

Note, if you want, you can also add Velocity information into the mix. Just add a new line in the MBRS as follows: “MIDI Vel : 100 > S. Vel.” If you do this, be sure to change the sequence edit knob to “Velocity” and ensure that all the steps for velocity are set to zero (0). You “can” set them to values higher than zero if you want, but then this will affect the velocity in tandem with the MIDI velocity from your keyboard. It’s these two values “combined together” that merge to form the final velocity value of the notes that are played.

Trick #4: Using Frequency Modulation between Oscillators

This isn’t so much a trick really, but something I like to try out once in a while. When the patch you’ve created is pretty much finished and you like the way it sounds, it never hurts to try this out. Set one Oscillator to modify the FM Frequency (in Thor’s menu list, this is shown as “Frequency (FM)”). You can often get some weird and wonderful new sounds that you didn’t know were hidden behind the scenes. Add to that a few effects like a Vocoder and some Scream “Tape” compression, package it up in a Combinator, and you just found your new lead sound. Here’s a video that shows how to do just that:

So there you go. A few interesting ways to utilize Thor and create a nice little synth lead. Let me know what you think, and also let me know if you have any other tricks along the same lines. Perhaps I can keep going with this whole Thor idea and show off a few other things you can do in an upcoming tutorial. For now, thanks for stopping by, and good luck in all your creative Reason productions.

60 – Generative Ideas (pt. 1)

Enough about Kong already. Let’s try something a little more interesting. Let’s start with a concept: Generative Music. And let’s see what we can do with it in a Reason environment. For starters, let’s see how we can extend the Thor step sequencer a little bit. Well, okay, let’s make it go absolutely NUTS!

Enough about Kong already. Let’s try something a little more interesting. Let’s start with a concept: Generative Music. And let’s see what we can do with it in a Reason environment. For starters, let’s see how we can extend the Thor step sequencer a little bit. Well, okay, let’s make it go absolutely NUTS!

You can download the project files here: thor-extended-step-sequencer-ideas. This contains a lot of different ideas from EditEd4TV, Sterioevo, and myself. All of us had a hand in working out my little idea. And I just want you guys to know that you’re the best! Without your ideas, I never would have been able to make this thing work. So anyway, there are 5 Reason (.rns) files and 5 Combinator (.cmb) files. Read below to see what kind of mayhem you’ll find inside. Note: to “Run” any of the patches in the file, just press Button 1 on the Combinator. This will start the sequence/system going. To stop the sequence/system, press Button 1 again. There’s a “Sound Source” setup in each Combinator to test the sound. There’s also 2 DDL-1 devices in each Combinator which is used to visually see the CV Note / Gate values.

Defining Generative Music

There’s many definitions for what Generative music is. Put simply, it can be defined as music that meets the following requirements:

  1. It must be created by a “system,” which is to say that it requires an algorithm to generate the “structure” (such as algorithms, mathematical equations, number sequences, etc). There must be logic behind it, whether this logic is set up by the composer or the listener.
  2. It is ever-different and changing over time; non-repeatable and “emergent,” as wind chimes are.

Brian Eno provided a really great Generative Music lecture at In Motion Magazine. I would highly recommend giving it some time if you also enjoy this sort of thing.

Starting off with a Problem

First I’ll give you the problem: How do we create a step sequencer pattern that is 128 steps long and randomly selects values between 0 – 127 in real-time? Can this be done in Reason using Thor’s Step Sequencer?

When I was building my “Key Flux FX Processor” behemoth, I wanted a way to randomly select the MIDI note values from 0-127 (C-2 to G8). Using the Matrix was a workaround, however, you have to jump through some serious hoops in order to get it to use note values outside the typical 5-octave range of the device. And even then, the randomizations aren’t really random. You’re selecting from a set of pre-defined patterns that never change. You can click the “Randomize” function in the Matrix, but once the notes are assigned to the Matrix, they’re permanent. Thor, on the other hand, provided a way to assign a “Random” run mode that is random during “Live play” — and this is the crux of the biscuit. This is what can open you up to one area of Reason which is truly “Generative.” It’s like the Holy Grail of building a “Generative System” in Reason. However, like the Holy Grail, it’s elusive. You’ll soon see why.

As for the “Key Flux FX Processor” patch, I settled on the Matrix because I couldn’t solve a simple problem at the time: How to Merge the Note values coming out of Thor, so that you could create patterns longer than 16 steps (the total length of a Thor Step Sequencer). The idea was to set up a series of Thor Sequencers and increase each step by 1, and then randomize the whole lot, so that you can get something truly random going from 1 – 127 MIDI value. Of course, I soon realized that you can’t get something truly random like that with the Thor Step Sequencer because the way it would work is it would go from Thor 1 (randomized between 1-16 MIDI value), then to Thor 2 (randomized between 17-32 MIDI value) and so on. Not “truly” random, but still better than nothing.

However, there are two main issues with Thor’s Step Sequencer:

  1. The Thor step sequencer leaves the gate open from one step to the next and never fully returns to zero between steps. This means that merging the note/gate values sums the previous note value with the next note value. And using the “End Trig” CV to trigger the “Start Trig” of the next Thor sequencer sums the two values together. This could be seen as a bug or a feature, depending on what it is you want to do with the CV values given off by Thor. Sometimes keeping the gate and CV open is a good thing. However, not in this case.
  2. The second issue is that the Note CV values from Thor’s Step Sequencer are bipolar (-64 to +63). Not a really big deal if you understand that. But something that will leave you scratching your head if you’re trying to visualize your CV with a DDL-1 device.

These two seemingly harmless facts about the Thor Step Sequencer ended up in hours upon hours of frustration when I was trying to do something as simple as connect multiple Thors together and have them generate the exact note/gate values to apply to a single sound device.

To recap, here are the three limitations/hurdles we need to overcome in order to tackle the issue:

  1. We need to use Thor, because it’s the only device that can generate a real-time “Randomized” sequence. Using the Matrix is a non-starter because the notes cannot be changed or randomized in real-time (not to mention it uses only a 5-octave range out of the box).
  2. We need to be able to create a Step Sequencer that is 128-steps long, so that each MIDI value has a chance to be selected. Since Thor is 16 Steps long, we need 8 Thors to generate a step sequence from one end of the MIDI spectrum to the other.
  3. We need to build a method to Randomly “play” the entire sequence so that only one MIDI value is selected and played at any one time, and this value can freely jump from any value between 0-127 to any other value between 0-127.

The solution(s)

Hurdle #1:

Tackling the first issue is simple. We use Thor and forget about the Matrix. Check!

Hurdle #2:

The second issue was beautifully tackled by both Sterioevo and EditEd4TV, with two different solutions:

First, Steve (Sterioevo) came up with the brilliant idea of using the Global Sustain on Thor to shut the gate off between notes. This was perfect. You simply connect all your Thors together, send the CV from the Note / Gate outputs through Rotaries in Thor and then use the Global Envelope Sustain to scale the note and gate CV in the Modulation Bus Routing Section (MBRS) in the Thors. This allows the Global Envelope Sustain to “shut off” the gate between the steps, and you can freely merge as many note CV and gate CVs as you like. In essence, you can string as many Thors together as you like and merge them properly. See the project files for his patch.

Next, EditEd4TV provided a more compact solution. His solution sends both the note / gate CV outputs into the CV1 and 2 CV inputs on the same Thor, and then outputs them to CV 1 & 2 outputs to the Spider Note / Gate CV mergers. This step is done to convert the note values from bipolar to unipolar (that so-called benign problem #2 was solved). Then in the MBRS, he programmed the following:

CV in1 : 100 > CV out1 : 100 > Last Gate

CV in2 : 100 > CV out2 : 100 > Last Gate

The Modulation Bus Routing Section (MBRS) of Thor showing the assignments and Steps
The back of the first Thor device showing the CV routings to set up the first set of 16 steps in the 128-step Forward-running sequencer where the Thors are strung together and play end to end.
The back of the first Thor device showing the CV routings to set up the first set of 16 steps in the 128-step Forward-running sequencer where the Thors are strung together and play end to end.

Brilliant. The “Last Key > Gate” (ie: Last Gate) is what shuts off the gate after each step, and allows you to merge the note / gate CV successfully. Now you are free to string up as many Thors as you like, without a hassle. See EditEd4TV’s patch which is also included in the project files. Hurdle #2 has been jumped and solved. Check!

Note: Due to EditEd4TV’s solution being easier to build, and more self-contained, I’m going to build on his patch to solve hurdle #3. Not that Sterioevo’s solution isn’t any less brilliant or usable by the way.

Hurdle #3:

Solving the third problem hit me in the head like a ton of bricks. What was needed was a set of recursive on/off triggers. One Thor needs to be set up to control the on/off state for every two Thor sequences beneath it. Once this is set up, you can then work backwards, building a pyramid of Thor controllers to turn things on and off. Visually, it looks something like this:

Master Controller > > Controller A > > Controller A1 > > Sequence 1 (Steps 1-16)
> Sequence 2 (Steps 17-32)
> Controller A2 > > Sequence 3 (Steps 33-48)
> Sequence 4 (Steps 49-64)
> Controller B > > Controller B1 > > Sequence 5 (Steps 65-80)
> Sequence 6 (Steps 81-96)
> Controller B2 > > Sequence 7 (Steps 97-112)
> Sequence 8 (Steps 113-127)

 

So I started to work from the bottom of the pyramid upward. It worked out well for Controller A1 controlling two sequences underneath. To see how this was set up, you can look at the “Thor 32-step random sequencer” rns or Combinator file in the Project files at the top of this article. Incidentally, it uses the “double-scaling” lines in the Modulation Bus Routing Section of the Pattern Sequence Thors (so that’s a little nod to Hydlide’s next tutorial all about the MBRS — See his latest on the Mod Matrix Filters and Amps — a great read).

The idea is to create another Thor (Controller A1 in the diagram above) which switches Sequence Thor 1 and Sequence Thor 2 on or off. I used the 2 Curves inside Controller A1, and set them so that they are both 16 steps which are set to “Random” mode, as follows:

Curve 1: Step 1 – 0; Step 2 – 100; Step 4 – 0; Step 5 – 100, and so on. . .

Curve 2: Step 1 – 100; Step 2 – 0; Step 4 – 100; Step 5 – 0, and so on. . .

Then I sent Curve 1 into CV 3 input on the first Thor Sequence, and Curve 2 into CV3 on the second Thor Sequence. In these Thor sequencers (1 and 2), set the following lines into the last 2 lines on the MBRS (the ones with 2 scalers):

The MBRS for the first Thor Step Sequencer
The MBRS for the first Thor Step Sequencer
The step sequencer on the "Controller A1" Thor, which uses both curves set in opposition to each other to control the 2 Thor step sequencers underneath it.
The step sequencer on the "Controller A1" Thor, which uses both curves set in opposition to each other to control the 2 Thor step sequencers underneath it.

So this creates the “Thor 32-step Random Sequencer” patch found in the project files at the top of this article. If you duplicate this same setup for the next two sequences (Sequence 3 & 4), controlled by “Controller A2,” you end up with one level tackled. Our next step is to figure out how to extend this to 64 steps. So let’s try doing that now.

You would think that using this same idea one level higher would yield the same results. What you find out instead is that this trick can only be used once. As soon as you use the double Curve trick one level higher (“Controller A”) to control the level below (“Controller A1” and “Controller A2”), you end up with completely messed up CV values coming out of the system. Trust me: I tried. So what we need to do is find a new trick to select between the two “A1” and “A2” Controllers.

Enter the Mod Bus switcheroo! This time, we need to separate the merged note/gate outputs from Thor Sequence 1 & 2 and Thor Sequence 3 & 4 so that they both are on separate Spider Merger/Splitters. Then send the merged outputs from all 4 of those Spiders into the “Controller A” CV inputs 1-4. Be sure to keep track of what is going where, as shown below:

Note Merge 1 & 2 > into CV 1 input

Note Merge 3 & 4 > into CV 2 input

Gate Merge 1 & 2 > into CV 3 input

Gate Merge 3 & 4 > into CV 4 input

The routings to split the 2 sets of Thor sequencers into their own Spiders, and send the merge outputs into the "Controller A" CV inputs. The CV 1 & 2 outputs are sent to the Combinator Rotaries.
The routings to split the 2 sets of Thor sequencers into their own Spiders, and send the merge outputs into the "Controller A" CV inputs. The CV 1 & 2 outputs are sent to the Combinator Rotaries.

Then you setup the Thor “Controller A” MBRS as follows:

CV In1 : 0 > CV Out1

CV In2 : 0 > CV Out1

CV In3 : 0 > CV Out2

CV In4 : 0 > CV Out2

While you’re there, set up the steps on the Thor “Controller A” the same way you did with “Controller A1” and “Controller A2”:

Curve 1: Step 1 – 0; Step 2 – 100; Step 4 – 0; Step 5 – 100, and so on. . .

Curve 2: Step 1 – 100; Step 2 – 0; Step 4 – 100; Step 5 – 0, and so on. . .

The MBRS and Step Sequencer of the Thor "Controller A"
The MBRS and Step Sequencer of the Thor "Controller A"

In the Combinator Modulation Routing section, select “Controller A” and enter the following:

Rotary 3 > Mod 1 Dest Amount : 0 / 100

Rotary 4 > Mod 2 Dest Amount : 0 / 100

Rotary 3 > Mod 3 Dest Amount : 0 / 100

Rotary 4 > Mod 4 Dest Amount : 0 / 100

The Combinator Modulation Routing for "Controller A"
The Combinator Modulation Routing for "Controller A"

On the back of the rack, send the CV Output 1 & 2 from the Thor “Controller A” into the Combinator’s Rotary 1 & 2, respectively. Note: in the setup shown above, these CV outputs are split with a Spider “Note/Gate” splitter so that I could send the signal to two additional rotaries to visualize the CV values in the two DDL-1 devices, but you don’t need to do this. This is so that I could test out the CV and make sure the values output are indeed random and working properly.

Turn up the CV trim knobs to 127, and on the front of the Combinator, turn the rotaries to zero (0). And there we have it. a 64-step random sequencer. Of course, you have to use 2 Rotary CV sources on the Combinator, but if you have version 5, you can set this up on the new CV inputs, without giving up any rotaries. Take a look at the “Thor 64-step Random Sequencer” patch included in the project files at the top of this tutorial to see it in action.

Finally, to gain access to the next level (Master Controller), I have to concede that I cheated a bit. I used a Thor and called it “Doubler” which essentially doubles the CV values of all the Thor Step sequencers. Then I used a curve value to send a series of random steps set to either a value of zero (0) or 100. This was sent into the final CV input on all the step sequencers, and the following was entered into the MBRS of each Thor Step Sequencer (Sequencers 1-4):

CV In4 : 99 > S. Transp (Step Sequencer > Transpose)

This has the effect of extending the range of the four Thor Sequences from 0-64 to 0-127. Of course there may be a limitation when it comes to changing other parameters of the step sequencers, like Gate Length and Gate Duration, because you essentially have 1 step which acts for 2 outputs. For example, the Gate Length for step value “1” will also double for value “66.” So this system is not exactly perfect. But it’s the best I could come up with at the moment. Perhaps someone smarter than I could come up with a better solution. If so, I’m all ears and would love to hear it. Check out the “Thor 128-step Random Sequencer” patch in the project files at the top of this tutorial and you can see the finished version.

So there you have it. This solves the third and final hurdle. Checkmate and your move!

Moving Forward

In the next part of this series, I’ll try to explore a little more about how you could potentially use this type of setup. For right now, just have a look and see if you can improve upon this or create a better way to create a fully functional 128-step random sequencer.

As for the “Generative Music” concept, I think this could have some interesting potential. For right now, I’ll just leave off with another interesting “Generative” site that I found online which takes mathematical number sequences and converts them into music. You can listen to thousands of sequences all based on these math sequences. I thought it was interesting. Check it out here if you have a minute: http://oeis.org/play.html. The site is a little cludgy, as you have to copy the database integer sequence number into the “Play” page, but once you do, you can hear that database record as a MIDI file and choose the instrument that plays the sequence.

And here’s another site which generates music (MIDI files) from paintings: http://www.synestesia.fi/ Now there’s something original.


In conclusion, you can indeed insert some “Generative” elements into your Reason projects. Hopefully you won’t have to spend hours upon hours figuring out how to do it like the three of us did, and instead spend hours and hours coming up with your own “Generative” systems a la Brian Eno. More to come on this later. . .

In the meantime, send me your best “Generative” music ideas and let’s see where this concept will take us in Reason and Record. Peace out!