quartz composer + NI Massive from ape5 on Vimeo.

Note: We’re aware we have let this site go without updates, but that’s because Peter Kirn runs Create Digital Music and Create Digital Motion and Pete Dines continues to post at Modulations@noisepages. That said, we’ll certainly announce if we plan a new batch of feature content!

In the meantime, I find I’m coming across new materials nearly every day via Twitter (oddly enough, the new ground for such stuff), so I’ll begin selecting the best Native Instruments-themed inspirational clips and tips to share here. I have quite a backlog of material to share, so stay tuned here and on CDM.

First up – I’ve long been fascinated by the possibilities to use the computer screen for something other than just fake knobs. A simple oscilloscope can offer profound insight into sound, and that’s essentially analog technology. Imagine what’s possible in the real of digital visualization.

The first step is to simply get things up and running so you can begin experimenting. The wonderful electronic artist and audiovisualist ape5 has been posting some early experiments doing just that. Think of these as “Hello, World” work rather than finished projects – but I always enjoy watching that very process, and this looks promising.

The ingredients:

1. Quartz Composer, the graphical patching tool for visuals bundled with the Mac developer tools (if you’ve got a recent Mac OS, you already own it, in other words). See Create Digital Motion for more QC resources.

2. Native Instruments Massive, in this case transmitting audio to produce the lovely patterns at top. (To analyze the audio stream, ape5 uses Quartz Composer’s Audio Spectrum object.)

3. Native Instrument Reaktor. With Reaktor, you have some choices – you could use audio, or you could use OpenSoundControl (OSC) to transmit control data.

ape5 also works with MIDI using the Mac’s IAC MIDI bus.

If you’re on Windows and interested in working in similar directions, check out vvvv (Windows-only) or the open-source Processing. On Windows, you don’t have built-in methods for routing audio and MIDI between apps, but check out tools like LoopBe for MIDI and ReaRoute for audio (a special ASIO driver you can install with the excellent production tool Reaper).

I’m working with other interfaces for visualizing and controlling sound, so I’ll be sure to share; they’ll work with NI’s tools via either MIDI or (with Reaktor) OSC.

There’s something magical about watching visuals locked to sound, but then, I can stare at oscilloscopes, too.

This find comes from the delicious Twitter feed Richard Devine maintains every day, found via Tom Davenport. There are too many great posts to allow them to get buried in Twitter, so I like reading via RSS.

quartz composer + reaktor test from ape5 on Vimeo.

Today, I cover the Battery 3.05 (beta) and Kontakt 3.5 updates. For both tools, you get 64-bit support under Windows, which lets you get into terabytes of addressable memory (theoretically), plus a much-needed fix for compatibility with Pro Tools 8 on Mac. On Kontakt, you also get a range of improvements, including “zero-memory” functionality when streaming from disk, multicore and multi-processor improvements, improved library management, aftertouch KSP support, and more MIDI assignments. Kontakt also supports up to 32GB of memory even on the Mac – which doesn’t yet do true 64-bit memory addressing for audio apps – thanks to something called the Kontakt Memory Server.

Now, not all of the Kontakt improvements are relevant to Battery, but it’s worth stepping back and looking at the two apps. There’s a reason there’s both Battery and Kontakt, even though they share some core technologies.

NI explains to CDM how the engines differ – some subtle differences that can make Battery the right tool for certain jobs:

The core engine technology is the same in Battery 3.0.5 and Kontakt 3.5, but Battery uses a “lighter” version because of its typical use case as a drum sampler.

It doesn’t include the Memory Server and the multiprocessor/multicore support because these features really only become necessary with multitimbral operation, high polyphony and a huge number of instrument samples (and heavy effects usage) like in Kontakt.

More on the updates at CDM, but I thought this was the perfect place to make the comparison clear.

Kontakt, Battery: Enhanced, More Compatible, 64-bit Memory

Since we have some hard-core users of both these tools reading this minisite, I’m curious to hear your mileage!

Note that, yes, we will generally be posting a lot more of our NI-related content on CDM moving forward, and that community contributions we expect to start appearing on our community platform noisepages.com, now in early testing. I’ll make a full announcement about this soon.

Somewhere, people are wasting time, procrastinating, and having inane chats on Twitter. But don’t tell that to the hard-core synth geek, who has bent Twitter into becoming a useful tool for finding like-minded creators, solving problems, and sharing tips and techniques. In 140 characters, there’s not much you can do to describe the depth of, say, Reaktor. Think instead of these tools as a compact, real-time pointer to the information elsewhere.

One of my favorite reads – and, regardless of your tools of choice, a great use case for how to make Twitter productive – is Reaktor Lovers. On Twitter as reaktorlovers, you get tips, tricks, story links, and for my favorite feature, the Reaktor Ensemble of the Day.

http://twitter.com/reaktorlovers

Given the depth of the User Library, it doesn’t look like we’ll be running out of Ensemble of the Day posts any time soon. That includes gems like the fascinating grid interface for the pad synth Pataphysical, top, and the ridiculously knob-laden DotCom 44 Modular, bottom.

So, what happens when you’ve run out of 140 characters and the forum isn’t the right forum? If you’d like to try out forming your own social groups with other users and have free blogs on this site – with the same tools we’ve used for the Kore site – come beta-test noisepages with us.

noisepages.com

Let us know if there are features you’d like or some things aren’t working – we’re doing an open beta precisely to get that kind of feedback. The venue for that feedback is the Help & Development group, where we’ll also be chatting about making improvements.

But just as the CDM team will continue working to bring you information, we’d love to see what you and the community has to share, too. Your work is ceaselessly inspiring – and makes reading Twitter a meaningful distraction.

We’ve got more Kore and Reaktor updates in the hopper, so stay tuned here and on CDM.

Well, the new 8.5 beta of FL solves all that! I was initially excited to read that the new beta lets plugins running with fixed size buffers use multiple outputs – but then I discovered a new audio setting called “align tick lengths” that makes those large fixed buffers unnecessary. The mouse-over hint for the align tick lengths checkbox tells us “may increase CPU performance” and they aren’t kidding.

This is fantastic, because now I can load up Kore in FL and Reaktor in Kore and get one of my favorite DAWs, my favorite control surface and my favorite plugins working together smoothly with no hitches, glitches or handicaps.

Licensed FL producer edition users can download the beta through their account page.

Via our friends at Make Magazine, Captain Dan controls a custom-created Reaktor synth with an Xbox 360 game controller. The secret ingredient: GlovePIE, the powerful, free scripting tool for alternative controllers under Windows. GlovePIE can actually output both OpenSoundControl and MIDI, either of which Reaktor can use, but in this case, Dan chose MIDI and routed between applications via MIDI Yoke.

The results may not necessarily be a new musical high point, but they are good fun. If you’ve got a Mac instead, you have several exceptional options:

Osculator

STEIM’s junXion (which now has a Lite version, too)

There’s one other that I’m … forgetting, if anyone wants to chime in.

Tried this yourself? Let us know!

xbox Controller Makes Drum and Bass [Captain Dan's "What Would the Captain Do?"]

360 controller busts mad beats + synth [Make Magazine]

Confession: plug-in specs make me batty. Happily, there’s a nice blog post that explains how to adjust a Reaktor patch for easy envelope control in Ableton Live. Ableton Live 8 changes how parameters are controlled, and I think fixes this problem – I need to try it with Reaktor. (Anyone out there already ahead of me?) But in the meantime, here’s the fix:

How to make Reaktor Knobs Automatable in Ableton Live [Do My Eyes Look Scary?]

When it comes to Automation, the parameters are exposed by the standard VST mechanism, with each Reaktor parameter being the Base ID for the instrument, plus the ID of the control.

In the case of RE201, the base parameter was 500-something, so all controls were invisible to Ableton Live.

If you look in the Reaktor Instrument Properties, click on the control routing tab. (the two little boxes with an arrow between them).

At the bottom, there’s an ‘Automation’ section. Do two things:

Pull down the ‘IDS’ menu, and select ‘Instrument Up’ until the base ID is zero. Then pull down the ‘IDS’ menu again and select ‘Sort and Compress IDs’

This will make all of the controls in the RE201 visible in Live. Honest to God.

Previously:
Kore Host How-To: Combine Kore with Ableton Live

Clap on, clap off!

Guiliano Cantini sends this patch he’s put together with Kore Player and Pd. He uses transient detection in Pd to trigger randomized parameter changes in Kore Player. That rig is entirely free (as in beer), but the same ideas could apply to Kore, too – and if you’re not into the clap metaphor, you could find other audio-reactive or controller-reactive approaches. (You can also just slap the mic on your laptop.)

From the description:

Instantly tweak NI Kore Player’s sound controls with a clap. Pure Data detects your clap and uses it to randomize all 8 controls. Download pd patch @ jkant.altervista.org

If you want to try this yourself, you’ll need:

1. A copy of Pd. It’s free and open source and runs on every OS, so no reason not to give it a try. I recommend downloading the latest “Pd-extended” release for your operating system of choice.
http://puredata.info/downloads

(Pd-vanilla isn’t quite as friendly to new users; Pd-extended is stable and includes a complete selection of the documentation and additional stuff you’ll want.)

2. A way of routing MIDI between apps, so you can transmit MIDI to Kore or Kore Player. On the Mac, enable IAC. Open up Audio MIDI Setup, look for an icon called IAC, double-click it, and make sure “enabled” is checked. You’ll then see this bus as an input and output in your Mac apps, including Pd, so that you can route MIDI virtually between apps. On Windows, try installing a tool like MIDI-Yoke. I have heard some performance issues with MIDI Yoke for Pd for some reason; I’m testing LoopBe1 now. Both work under Vista. On Linux, if you’re running Kore under WINE (unsupported but an interesting route), you can use JACK.

We’re big fans of Reaktor, of course, but once you’re addicted to patching, you may want to try Pd, too, especially since it’s free. I often get asked which patching app I think is “better,” and it’s more about choosing the right tool for the job. One of the things that’s nice in Pd is that there are lovely objects for audio analysis. (In this case, as my colleague Peter Dines notes, Reaktor could do the job, too. I don’t think Reaktor has some of the pitch-tracking features Pd does, however, if you wanted to go that route – and I’ve found skills I’ve learned in one tool have at least helped me in others, too!)

If you’re new to Pd, you’ll want to do two things when opening up this patch. First, check out the Media menu, which holds all-critical audio and MIDI configuration options. Next, try right-clicking objects and choosing Help. With Pd-extended, this will open interactive documentation on what each of the objects does.

If you’re a fan of Max/MSP, of course, this patch could be easily ported. (There are just some subtle differences, like Pd’s use of “moses.”)

The important Kore-related stuff is at the bottom, and it illustrates how you can use MIDI control of Kore parameters to make it even more powerful in performance. “ctlout” is an object that sends controller data, so you can see that controllers 40-47 here are the ones in which we’re interested. (ctlout 40 1 sends MIDI Control Change 40 on MIDI channel 1; since the random object above is random 127, it will send a value from 0-127.)

This is a pretty wacky patch, but it gives me some ideas for different ways of using Kore as a performance host. And because it’s relatively simple, it should spark some other possibilities. Brilliant work, Guiliano!

I can imagine Pd and Kore being generally a powerful combination, with Pd for control and sequencing and Kore running instruments and effects (including, if you want to get really crazy, Reaktor patches).

The power of Reaktor is essentially the power to build any instrument or effect you can imagine. But what does that mean for hardware control – how can hardware be as open-ended as software? One solution is multi-touch interfaces.

Antonio Blanca writes to share the work he’s done (in collaboration with JazzMutant’s Bryant Davis Place) on “Lemurizing” popular Reaktor ensembles. These make the Lemur touchscreen a dynamic, interactive hardware controller for these Reaktor ensembles. In the collection from Antonio and other creators, and all downloadable via JazzMutant:

• Vectory sequenced sample destroyer
• The legendary Skrewell instrument
• Native Instruments’ Massive drum computer ensemble (the one in Reaktor)
• Lurker hybrid delay effect from Reaktor
• GoBox groove box in Reaktor – complete with multiball morphing
• Aerobic beat machine
• Native Instruments Massive Synth (the standalone synth, not the one in Reaktor)
• A two-deck Traktor Pro configuration, plus DJ Kabuki’s own Traktor setup
• FM8 synth tweaking layout

From sequencing to modulation, there’s quite a lot you can control in these ensembles with your fingers. That demonstrates not only the potential for Lemur, but many other alternative interfaces, as well. With the exception of the standalone Massive, you can see some of the power of OpenSoundControl support in Reaktor, as well.

Antonio is extending this idea with Reaktor and exploring more sequencing ideas. He writes:

Now I am working on new “Lemur Projects” — a new version of Lemurized Metaphysical Functions and a pseudo-random sequencer built on the Lemur itself using the multiline script (amazing feature, by the way). Here’s some info from my outdated blog:

http://abreaklemurities.blogspot.com/

I am working to release a series of videos using the lemur and [given an overview of] some of my interfaces.

It’s really nice to see Reaktor coupled with the Lemur in this way; I hope to bring you more.

Reaktor users, what are you using to control your ensembles? Any touch-based solutions (Lemur or otherwise)?

This site is back – and back to stay. We have a new server, and some new tools we’ll be able to share soon to help the CDM community share tools and techniques more easily.

And sometimes, wonderful things just happen when the time is right. Case in point: a whole new set of beginning Reaktor tutorials, covering all the basic tasks you might like to accomplish. For newcomers to Reaktor, these will be ideal, as they get you rolling on a specific tasks — like, build me a sampler or do something cool and granular and delicious — without assuming a lot of prior knowledge. But if you do have prior knowledge, these will fill in some gaps even for intermediate users.

Reaktor Tutorial

Topics so far:

• Programming and patching: intro and a simple synth
• Effects: envelope generator, ring mod, tape decay
• Grain Delay
• Sampler
• Granulation modules (similar to our own series on the topic)

Creator Mats Claesson of Norway is interesting himself, with a background in classical guitar, a resume that includes work with John Cage and Iannis Xenakis, and ballet composition. If you can read Norwegian, there’s a lot more.

I have some additional Reaktor tutorials that, at long last, I’ll be publishing within the next two weeks – in a new format that will allow others to build upon the same work.

We won’t be disappearing for two months again, but with these tutorials and Reaktor in hand, you may.

When I look back at the Kontakt features we’ve done here at Noisepages, I notice that one feature of the software that keeps coming up is scripting. We’ve used scripts to:

• sequence and re-tune music box samples
• create a constrain-to-scale MIDI insert effect for Kore and other hosts
• Latch incoming notes, and dynamically pan voices in stereo

As well, we’ve looked at the creative potential of the scripts that ship with Kontakt. I’ve also pointed readers towards some fine scripting resources for Kontakt users. With one exception – stereo panning – these have all been stock factory scripts, prewritten scripts from third parties, or very slightly modified versions. Now that everyone’s toes are wet it’s time to dive in and splash around with some scripting from scratch. The water’s warm and we won’t venture too deep. I guarantee there are no sharks.

First, a few words about what Kontakt scripting is and isn’t. It doesn’t work on an audio or DSP level. If you’re familiar with Reaktor, a good comparison is the event handling in that program. Kontakt scripts respond to events, like MIDI notes, MIDI CCs, button presses, GUI knob tweaks and (in the case of sequencer scripts) clock signals. The output of a script could be note on and off signals or automation for Kontakt’s internal parameters like panning. Speaking of panning, I’ll give you an example drawn from the first Kontakt feature at noisepages.

on init
     declare $PanPos := 700
end on

on note
     change_pan($EVENT_ID,$PanPos,0)
     $PanPos := ($PanPos * -1)
end on

I’ll go through it step by step for the benefit of readers with zero programming experience. Those of you who are old hands at scripting and programming, try not to scoff, and pay attention because there are some essential Kontakt ideas in here.

on init tells Kontakt to do something when the script is first loaded into an instrument, or when an instrument containing this script is loaded. This is used to set up required elements of the script – things that generally only happen once and absolutely must happen for everything else to proceed. end on tells Kontakt that this series of setup instructions has ended.

What this particular initialization sequence does is to declare – that is, create – a variable and assign it an initial value. What’s a variable? It’s a container that can hold various values. Variable names in Kontakt scripts start with a $ symbol, so they’re easy to recognize. The := symbol assigns a value to the variable.

The next chunk of the script is called a callback. It’s a chunk of code that responds to some event – in this case, a note. It’s also bracketed by on and end on statements to show where the callback begins and ends.

The callback is where the action happens. change_pan() is a built in function that changes the position of a note in the stereo mix. There are three parameters, or bits of data, that change_pan() needs to work its magic. $EVENT_ID represents the ID of the incoming note that triggered the on note callback. $PanPos is the variable we defined in the on init section; the maximum panning can be –1000 (fully left) or 1000 (fully right). The third variable is called the relative-bit, and can be either zero or one. It determines whether the panning is applied relative to the initial panning of the note or the current panning, if panning has already been applied. The relative bit doesn’t matter much in this script but it has to be there or else Kontakt complains when you click on apply to initialize the script after editing.

The above image shows you what it looks like when the Kontakt script interpreter finds something it doesn’t like – in this case, it’s the missing one or zero that represents the relative-bit. Scripting and programming are all about formal correctness.

So here’s what happens – an incoming note triggers the callback, and the change_pan() function pans the note 70% right. Then, the callback moves to the next line and executes the instructions there. The $PanPos value is being assigned a new value by the := symbol. The new value is the same as the old value, but multiplied by minus one.

That means the next note will be panned to a position of –700, or 70% left. After that, the multiplication by minus one happens again and the value of $PanPos becomes 700 again, ready to pan the next note to the right. And so on, for each incoming note.

Now that you know how the script works, how about adding some enhancements? For starters, that hardcoded “700” is an annoyance. In order to change the amount of panning, you have to open the script and edit it. I think a knob is called for here. It’d also be nice to have the knob show up in Kontakt’s performance view, like this:

And here’s the script that will make it so:

on init
    declare ui_knob $PanKnob (0,100,1)
    make_persistent ($PanKnob)

    declare $PanPos
    $PanPos := $PanKnob

    make_perfview
end on

on ui_control ($PanKnob)
    $PanPos := $PanKnob * 10
end on 

on note
	change_pan($EVENT_ID,$PanPos,0)
	$PanPos := ($PanPos * -1)
end on

You can probably already figure out that declare ui_knob $PanKnob creates a knob. The three parameters (0,100,1) tell Kontakt that the knob will have a range of 0 to 100 and that the ratio of the value displayed will be one to one – it’s possible to have a different resolution than the one displayed.

make_persistent ($PanKnob) tells Kontakt that it should save the knob position when the patch is saved. We’re still using the $PanPos variable but now it gets its value from the persistent knob position.

Another addition to the init section is make_perfview. This tells Kontakt to create a performance view tab for the script, so the instrument doesn’t have to be in edit mode to access the script’s GUI controls.

After the init section we have a new type of callback – on ui_control. This has the $PanKnob variable as a parameter, so any time you adjust the value of the knob, this callback is triggered. It does something very simple – it multiplies the value of $PanKnob by ten and assigns it to $PanPos. The reason the value is multiplied by ten is to scale it up to the –1000 to 1000 range Kontakt uses for panning.

The on note callback remains the same as before. Why use two variables – why not just use $PanKnob in the on note callback? The script has to remember whether the value is going to be positive or negative for the next note – left or right. In programming, there’s usually a bazillion ways to do something, so if you think of a better way, go ahead!

Here’s a before and after example of what the PanPos script does. In the second run-through I’ve set the value at 70% which makes the panning obvious. Try it on headphones. A value of around 40 to 50% lends an instrument some spaciousness in a subtler way.

Kontakt PanPos script from Create Digital Media on Vimeo.

Now how about something completely different – a script that randomly lets note events through, with the velocity determining the probability that an event will trigger a sound. I did something like this in Reaktor in the Frankenloop instrument – now it’s time to implement the function in Kontakt scripting.

Not too elaborate – only two controls! The Random button activates and deactivates the script, and the Target knob chooses the affected note. I like to set the Target knob to affect the hi-hat in a groove, so it creates variation in that but leaves the bass, snare and other drums alone. If you play with the sequenced velocities of your targeted note and use them as probabilities, you can create some very interesting variations. Here’s a before and after video of what it does:

Randomize script in Kontakt from Create Digital Media on Vimeo.

Here’s the script itself:

on init
    declare ui_button $Random
    make_persistent($Random)

    declare ui_knob $Target (0,127,1)
    make_persistent($Target)

    make_perfview
end on

on note
    message("Note: " & $EVENT_NOTE)

    if($Random = 1)
        if($Target = $EVENT_NOTE)
            if ($EVENT_VELOCITY < random(0,127))
                ignore_event($EVENT_ID)
            end if
        end if
    end if
end on

A quick rundown of the new elements you’re seeing in this script – there’s a button in this one, and buttons only have two values, zero and one, so we don’t have to assign a range, unlike the knob, which takes a range of zero to 127 to cover possible MIDI note pitches.

When a note hits the script, we employ a message function to print the incoming note’s MIDI pitch in the Kontakt status area (look to the bottom of your Kontakt window, on the left hand side). This will let you play a note that you want to randomize and see its MIDI pitch so you can set the Target knob accordingly.

Now we have some nested if statements in the on note section. I’ll read through it in plain language. If the random button is on, and if the event is the same pitch as the target knob, and if the velocity (volume) of the note is less than a randomly generated value, ignore the note – that is, don’t play it. Otherwise, don’t do anything, which plays the note. Incidentally, what I’m creating by writing here in plain language is something called pseudocode; it can help you to express your program in pseudocode before you write the actual program.

Here’s a zip archive containing the two scripts demonstrated in this article. Your homework, if you choose to accept it, is to work out a way for the Randomize script to accept a range of notes – for example, between the values of two knobs. You’ll probably need to refer to the Kontakt script language manual, and of course you can always ask questions here. Happy scripting!