Advertisement
  1. Music & Audio
  2. Logic Pro
Music

An Introduction to Scripting in Logic X

by
Difficulty:IntermediateLength:MediumLanguages:

One of the more unique and less understood of the new features within the Logic X upgrade from Logic 9 is the MIDI Scripter. Although it comes with a host of ready made scripts, one of its key features is the ability to write one's own plugin program from scratch. 

In this tutorial I’ll get into the nuts and bolts of what exactly the Scripter is and go on to create a fairly basic, yet personalized MIDI delay plugin.

The Scripter Explained

The Scripter is basically a plugin which runs on the JavaScript coding language. It is inserted pre-instrument in order to effect incoming MIDI and/or timing data. As such, it is unlike any other Logic plugin as it does not have an effect on audio at all. 

Incoming information goes through the Scripter and only after passing through it does the information reach an inserted instrument which then creates an audio event.

The MIDI effects comes pre-stocked with a number of editable—the Scripter option—and non-editable pre-sets which are great jumping off points in order to explore the new capabilities. It is accessed by clicking on the top-most insert in an instrument channel—the MIDI FX slot. 

 The menu which pops up contains the un-editable stock MIDI effects along with the editable Scripter option which, in turn, contains a good number of editable tutorial script presets.

The interfaces alone of the non-editable programs are enough evidence to understand they are pretty sophisticated programs, yet they are all achievable with the right amount of JavaScript knowledge within Scripter—minus the clean interface. 

 A good example of this is the Arpeggiator. The stock Arpeggiator interface is very clean with a number of options, while selecting the Simple Arpeggiator pre-set of the Scripter itself reveals a stocky interface with far fewer options.

The highly functional Arpeggiator
The highly functional Arpeggiator.
The less functional Simple Arpeggiator interface
The less functional Simple Arpeggiator interface.
This is just a portion of the code
Clicking on the 'Open Script in Editor' button reveals the script necessary to create the 'Simple Arpeggiator'. It's not quite as simple as the interface makes it seem.  This is just a portion of the code.

Under The Hood

The Scripter comes in two sections. The top portion, the Code Editor, is where I will be writing the code while the bottom section, Interactive Console, gives me information such as errors, output values, about the code written above. 

The Code Editor, once programmed, will look for incoming MIDI and/or timing data, from the Transport, manipulate it in some way and either output it as text to the Console or directly to the instantiated instrument's input.

In the upper left is the Run Script button which will evaluate the written code and is necessary to hit after any code updates in order for them to be integrated. 

Additionally, Scripter comes equipped with an auto syntax error checking feature which will automatically highlight error lines as well as a syntax highlighting feature which distinguishes relevant keywords with color.

Getting Started

Getting in-depth at a beginner level of JavaScript is really beyond the purview of a music tutorial, so I’ll jump into the delay I built/wrote and give a brief explanation as to what is going on with the particular lines or blocks of code. 

 For further information on JavaScript, Envato can—of course—be used as an invaluable tool. The Logic Effects Manual is also packed full of Scripter specific code and examples for further learning. 

The final code
The final code.  I have omitted the brackets in the below explanation for sake of formatting.  They do need to be present in order for the code to work.

The code line function HandleMIDI(event) is the first line in this particular example and is the line that tells Scripter to look for a MIDI event and pass that information through the Scripter code. 

 The next line event.send(); tells the Scripter to pass the MIDI event through Scripter untouched. This will serve as the dry signal while the first line will serve as the wet/delay.

if (event instanceof Note)                                         

event.sendAfterMilliseconds(delayTime);

This tells Scripter that an incoming note event needs to be sent after a specified delay time in milliseconds. The delayTime is a variable value determined by a slider that will be built later. This value can also be changed from delayTime to a specific numeric value if a non-variable delay time is desired (e.g. 100 in place of delayTime for a set 100 ms delay).

var delayTime;                                                                                                                      

var PluginParameters =                                                                                       

{name:'Delay Time', type:'lin', unit:'ms',                                                                  

minValue:0, maxValue:1200, defaultValue:1, numberOfSteps:120},

This block of code creates a fader for the Scripter interface and names its output delayTime for internal routing. In this instance the slider will be named Delay Time in the Scripter interface, it will be a linear fader, lin, and the output units will be milliseconds, ms. It will output a minimum of 0 ms, a maximum of 1200 and will have a resolution of 120 steps, or 10 milliseconds.

function ParameterChanged(param, value)                                                                         

var timeInMilliseconds = value;                                                                                               

if (param == 0) delayTime = timeInMilliseconds;

This block of code connects the slider ('0' indicates that it is the first fader of the plugin) and what it outputs internally to the initial delayTime value. 

Essentially, if the slider is moved it is outputting a time in milliseconds and that time is sent to sendAfterMilliseconds(delayTime);.

The final delay interface
The final delay interface

How It Sounds

I have set up the Scripter with the completed code, Logic's B3 Organ, a MIDI sequence and a Slate Compressor, just to make things sound a bit better. 

As you can hear below, this delay is much different than a traditional audio delay in that there is no amplitude decay or other variations throughout the delay. It is simply sending the same MIDI signal twice at whatever slider value is selected. The only reason the delays sound slightly different is that they are sent at different times to the B3 which has an internal modulation effect.

In the below sound example, I have started with a 750 millisecond value—that sounds best to me with this particular example—and then slid up and back down through all of the possible parameters, landing on zero to show the dry loop.

The channel
The channel

Outro

The Scripter and the above code opens up a realm of possibilities, both for coding and further processing. One could use this in front of a stale hi-hat pattern to intuitively and improvisationaly slide through a large number of unthought of patterns where certain hits are accented with automation. 

One could also expand on the coding and in front of a pitched instrument create delayed chord progressions or chords where the note events do not happen simultaneously and have timing irregularities according to slider positions.

The Scripter, to my thinking, is likely Logic's answer to Max for Live and a novel one as Live can already be integrated into Logic since some years past. The ability to code ones own programs within a standalone DAW is a unique one and one I hope you can learn from and be inspired by.

Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.