Pure Data is a wonder: a free and open source environment for creating your own musical and multimedia creations with graphical programming, from Miller Puckette, the original creator of Max. You can produce everything from interactive sequencers and drum machines to synths to video performance tools by connecting patch cables visually, and you can run on virtually any platform, from BeagleBoards and Rasberry Pi to Mac, Windows, and Linux desktop. Via libpd, you can target other development languages and environments, embed engines in games, or work with Android and iOS.

It’s so important, in fact, that CDM invites Hans-Christoph Steiner, one of the key developers of Pd-extended, to give us a tour of what’s new. (Note: because Pd-extended includes various additional objects or “externals” that Pd Vanilla lacks, you should be careful when building patches for libpd. What I like to do is use Pd-extended as my editing environment, then double-check patches by opening them in Vanilla to make sure I haven’t accidentally used an object that’s not part of the bare-bones version. I can then substitute an object, copy an abstraction, or if necessary build that external.) -Ed.

The Pd-extended 0.43 release has been brewing an extra long time, about 18 months now, mostly because there are lots of big improvements. We wanted to make sure we got it right, so your patches all work, but the improvements all shine, so its taken a while. It’s now solidly beta, so we’re looking for testers. Download a beta build to try here:

http://puredata.info/downloads/pd-extended/releases/0.43.1

First off, the pd-gui side of Pd has been rewritten from scratch. The focus for most of the recent work has been on the editing experience, making your patching experience as productive and flexible as possible. To give some background, Pd has always been made up of two programs: pd is the core engine and pd-gui is the GUI. Since basically all computers now come with multiple CPU cores, this means that pd-gui will usually run on a separate CPU core than pd, so they don’t step on each other’s toes. pd can entirely take over its own core. If you want to make your patch use more CPU cores, then check out the [pd~] object introduced in the last release, but fine-tuned in this one.

There are so many ideas for making a better editing experience in Pd; this release makes big strides to address the editing experience. There are new features like Magic Glass, Autotips, Autopatch and Perf Mode, all available on the Edit menu.

• Magic Glass lets you magically see the messages as they pass through the cords. Just turn it on and hover above a cord, and you’ll see the messages as they go by. You can even look at signal/audio cords.
• Autotips gives you tips about what an object does, what its inlet expects, and what comes out of the outlets.
• Autopatch mode automatically connects objects as you create them.
• Perf Mode, is a mode for performance that makes it harder to accidentally close windows that are part of your performance.

A whole new Pd Window

The Pd Window is also majorly overhauled. First of all, it’s fast. Much much faster than the old one. You can now print thousands of messages per second to the Pd Window and still edit your patch. No more will an accidental dump of info cause the GUI to freeze up (well, okay, maybe if you send 10,000 messages/second, but that is way too many). There are also five levels of printing messages to the Pd Window: fatal, error, normal, debug, all. If you are only interested in fatal errors, switch the Pd Window to 0 – fatal, and you’ll only see the worst problems. You want to see every single message to debug? Switch to 4 – all, and you’ll drink from the firehose.

There is also the new log library, which lets you easily send messages for those different levels. And all messages logged with the objects from the log library are clickable: when you Ctrl-Click or Cmd-click (Mac OS X) on the line in the Pd Window, it’ll pop up the patch where the message came from, and highlight the specific object that printed it. That even works for many messages from other objects, as well.

The Pd Window also includes very basic level meters for monitoring the input and output levels. And for those who want to play with the GUI in realtime, you can type Tcl code in the Tcl entry field, and directly modify and probe the running GUI.

Customize the GUI with Plugins

One thing that you can do now is customize the GUI using GUI plugins. You can change all sorts of colors, some fonts, and many behaviors. Want to create a new object when you triple-click? Try the tripleclick example plugin Want to make the patch cords disappear when you leave Edit Mode? Check out the “only show cords in edit mode” example. Those are the simple ones. There is also Tab Completion, a search engine for the docs, a category browser for the right-click menu, a buttonbar for creating objects, and more.

You can find many GUI plugins in the new section of the downloads page as well as documentation for making your own. (What kind of GUI plugin will you write?)

Write Pd objects in more languages

Traditionally, Pd objects are written in Pd (abstractions), C and some in C++. This new release includes two “loaders”, Lua and Tcl, which allow you to write regular Pd objects in either Lua or Tcl. Pd is not the best for processing strings, so if you need to do that, you can now easily use Lua or Tcl, both very easy scripting languages for working with strings. Lua is often used for OpenGL work, so you can also run Lua objects to work in conjunction with Gem. Also, the Tcl loader lets you write GUI objects in pure Tcl, no C needed.

Multi-processing, Pd-style!

The [pd~] object now works out of box. In case you missed the introduction of the [pd~] object in the last release, we’ll introduce you now. [pd~] is Pd itself incapsulated into an object. You can run any patch inside that instance of Pd, the difference is that the Pd in the [pd~] object runs in a totally separate process. So if your computer has multiple CPU cores, which basically all computers do these days, then the Pd process inside the [pd~] object will run on a separate core. This means you can have a heavy Pd patch spread across multiple cores or CPUs. Or for people who work with video and audio together, you can have one instance for video running at a normal priority, then another instance for audio running at a high priority to make sure there aren’t clicks in the audio caused by heavy video processing.

Autotips, generated from help patches

This release also provides a new “autotips” feature to provide instant information about objects and their inlets and outlets. It is one of the first new developments to showcase all of the meta data that is now included in all of the help patches. (Check out the [pd META] subpatches.) When you hover above an inlet or the object itself in Edit Mode, you’ll see a short text description pop up on the lower left corner. But, of course, using a GUI plugin, you could customize how they are displayed to make it how you want to see it. If you want to add autotips to your object, then just add a [pd META] subpatch to your objects’ help patches, and fill out the description, etc. Voila! They’ll have instant information.

What’s next?

The core pd process still handles a lot of the GUI stuff, but we are working on splitting that out for the 0.44 release. That is a big chunk of work, but it will also bring big gains. In particular, it means that it will be possible for people to write their own GUIs for Pd, covering not just the display of the patch, but also the editing, and everything else. You like OpenFrameworks, Python, iOS, JUCE, Qt, etc.? Write your own pd-gui using the toolkit of your choice. That’s the idea at least. That will take a solid chunk of work, so we are looking for people to join that effort.

Try it yourself:

http://puredata.info/downloads/pd-extended/releases/0.43.1
http://puredata.info/downloads/pd-extended

Where to learn Pd:

Resources to start learning

-Hans-Christoph Steiner for CDM

In a marvel of DIY engineering, one intrepid user of the tracker-made-modern music making environment Renoise has reconstructed the basic elements of the Ableton Live interface. With quantized clip launching on channels and even a crossfader, it’s unmistakably a copy of what Ableton does. I don’t think you’d dump your install of Ableton for this; the whole reason you’d want a feature like this is really if you prefer other elements of Renoise that are different from Live. But as a proof-of-concept, it’s pretty extraordinary. (Ableton users, the ball’s in your court: someone want to make a tracker in Max for Live?)

mxb has more information on the Renoise forum:
Cells! Preview

We love the bleeding edge, but as mxb notes, “this is still at a very early beta stage; if anyone has any suggestions or feature requests, [they should] make them in the thread on Renoise forums.”

All of this is possible because of Renoise’s powerful scripting environment.

The Cells! video above is a bit primitive – mxb says it’s a result of poor screen capture software, which is also responsible for sync disappearing – but you get the idea. mxb has also built a four-oscillator synth called ReSynth, and previously-mentioned sample import.

http://tools.renoise.com/users/mxb [all of mxb's creations]
http://tools.renoise.com/tools/resynth

There’s a beautiful immediacy and tactile quality to hardware step sequencers. And there’s all the flexibility, convenience, and power of software.

Solution: combine them.

We’ve been following various custom creations for the music production tool Renoise – the latest being a lovely performance grid, and back in 2009, the beginnings of Launchpad grid sequencing.

You can thank Renoise’s powerful API, which allows its users to modify the way the app works with surprising ease (at least for the hack-inclined), all for free.

The latest is Lauflicht, an 8-, 16-, or 32-step step sequencer for the Novation Launchpad controller (or, alternatively, other controllers like the monome) and Renoise. What’s nice about it is, you can add as many tracks as you want, with whatever samples and instruments you want, but then trigger those steps from hardware. Now, this will appeal of course to those who want these kind of regular rhythms – I’m already anticipating some frustrated responses from our fans of non-duple rhythms and polyrhythms in comments. But if that is what you want, this looks fantastic.

The creator sells the tool for EUR24. How much that means to you is dependent, of course, on the stability of the Greek government. (Sigh.)

Side note: rockin’ domain name.
http://www.stepsequencer.net/

Via BrenMcGuire on CDM comments – thanks!

Lots more videos; check the site for the artist’s own techno tracks:

If you just want to fire up Renoise, the modern tracker/music production app, and not worry about the fact that its innards are hackable, you can. But for a reason why you might at least want to explore customization of this music tool, give the video above a look. It starts sleepy and slow … and then, part of the way through, as creator Dac Chartrand starts demoing the tool, something really special happens. (Anyway, that’s what I think. See if you agree.)

Dac explains his work, completed at the recent Montreal Music Hackday:

My Renoise hack was Grid Pie. One of the new trends in our community is the concept of a meta-interface. In essence, programmers use the Lua API to transform Renoise into something else, hide the Renoise window, and work with hardware interfaces connected to their own scripts. Three current examples: MPE, Step Sequencer Lauflicht and Duplex. Grid Pie is “yet another meta interface.” It turns Renoise into a live performance audio recombination machine. Still in alpha, but people were into the demo I gave. I got a lot of handshakes and positive feedback.

It’s an alpha, so your mileage may vary, but I’ll bet this whets some appetites for people who hadn’t yet realized the power of the Renoise API.

http://wiki.musichackday.org/index.php?title=Grid_Pie

MOTU’s MachFive sampler, while perhaps not getting the kind of attention rivals from NI and Steinberg have, has had in its history some compelling features. Those features were in a multi-window interface, though, that not all of us loved – while I can’t find the review, I know when I covered it for Keyboard, I praised powerful editing features like the slicer but lamented the UI.

MachFive’s new UI looks radically different. The tabbed layout and modules and preset browsing all recall NI’s products, but there are new twists, too, like slick, readable waveform views, gorgeous EQ visualizations borrowed from MOTU’s DP DAW, and plenty of shiny. The results look far more usable, which means easier access to new sonic capabilities. And that’s good news, because it’s those features where things get interesting. Just a few highlights:

• Granular stretching and re-pitch sounds, licensed from IRCAM. I’m fairly certain this is the first time I’ve seen the Paris research center as a specific bullet point in product promo, but there are samples that sound terrific.
• New scripting which MOTU touts for modeling things like strumming and fingering on guitars – and lots of other things, too. New sound content will take advantage of the scripting features. And, oh, yeah, if you’re thinking that scripting is available elsewhere, CDM’s nerdier readers will like this: the scripting engine is now in Lua.
• Hybrid synth engine covering wavetable, subtractive, and FM synthesis. Earlier today, readers were talking about disappointment that Omnisphere, the massive sample-based synth, lacked samples. Well, here you go – here’s one strong sample/synth hybrid contender. (Omnisphere’s another animal, but that doesn’t make this any less interesting.)
• Modular effects architecture, convolution reverb mean greater ability to apply effects, from buses to individual oscillators and keygroups.
• Oberheim-style Xpander filter.
• Tons of ready-to-use MIDI scripting.
• Powerful arpeggiator and micro-tuner.

You also get 45 GB of sound content (wowsa), full-screen mode, an updated slicer/looper, and expansion of MachFive’s already-extensive support for third party samples, even including obscure old formats.

I’m intrigued: the intelligent new layer rule interface, the overhauled UI and sound engine, and then extensive micro-tuning and Lua scripting start to make me interested, even with intense competition in this arena. For experimental sound design, there’s some real potential here. Stay tuned.

In the meantime, pictures:

More:
http://www.motu.com/products/software/machfive/

http://www.motu.com/products/software/machfive/technology.html

Renoise 2.7 is now available, following some eight weeks of testing by the community. The update, which the developers describe as “back to the beats” in reference to focusing in this release cycle on musical workflow, delivers plenty of features that make the modern tracker more modern. I wrote about them back in March, with some detailed Q&A from the developers – including tips on where to get started:

Renoise 2.7 Adds Sample and Slice Savvy; Tips and Inside Info from the Developers

The short version: better automation, sample slicing, and sample keyzones, plus improved DSP and audio routing and MIDI routing, make Renoise more usable. For people slicing up and sampling audio, even, I dare say, MPC-style, it’s a huge release.

2.7 Release notes

But that’s not the only story here. Renoise are also announcing 500 MB of free sounds designed by Puremagnetik, all in the native XRNI file format. That’s from a sound house better known for Ableton Live sounds than Renoise. And, at the opposite end of the spectrum from preset soundware, Renoise is involved in a Berlin Music Hackday that could bring new DIY features to the tool – plus tooling that makes it easier to grab and update tools from the community.

We’ll start with the Puremagnetik news. Rather than just tell you about the sounds, Puremagnetik’s Micah Frank shares how the sound set was built, and what they learned about making soundware for Renoise. That includes some valuable tips for anyone interested in programming sounds in the environment, as well as insight if you’re just curious to try the resulting sound pack free. Micah shares:

About Puremagnetik: Puremagnetik is a sound development company that I founded in 2006. I had freelanced as a sound designer with Ableton for some years and didn’t see many 3rd party choices for that platform. Puremagnetik was launched as an affordable subscription service offering new “Micropaks” every month, with a focus on Ableton Live content. That was 5 years ago and we are continuing to produce new packs every month. As of this writing we have almost 60 Micropaks in the catalog, a number of bundles, standalone libraries and Max for Live content. We have close to 40k registered users and are working with a number of developers (desktop and mobile) to help realize their sound libraries. By the time you read this, we will also be offering content in Renoise’s XRNI format.

Why Renoise: Always on the lookout for products that break away from conventions, I became interested in content development for Renoise soon after the 2.6 release. It’s obvious that Renoise is created by a small and dedicated team of developers backed by a strong, supportive community. To my surprise, I couldn’t find many resources for Renoise format instruments. All of the above reasons factored into Puremagnetik’s conception in the first place – to fill a niche within a community of dedicated individuals that are passionate about their work. Once the Keyzone Editor was introduced, it was clear to me that someone had to make content for this innovative product.

What it was like making the 500M sample pack: The first thing we did is comb through our entire catalog and pick a well-rounded selection of kits and multisample instruments. We are working with an independent developer (Renoise user MXB in building a tool to translate our libraries to XRNI. [That tool is now released; see comments. -Ed.] So this was a huge asset in efficiently building this library. After importing the sounds they were fine tuned and tweaked with modulations and envelopes. The final step was exporting the monolithic XRNI files. Throughout the entire process we worked alongside the Renoise team to ensure that Q/A standards and selection of sounds was spot-on.

Thoughts on the latest XRNI format: Despite its simple interface there is a lot going on under the hood. I personally love the “point” setting in the envelope params. And the selection of filters really kicks ass (my favorite is the Low Distortion). Just in coupling these two things, one is presented with vast sound design possibilities, and that’s before you beat sync pitch envelopes!

For the most part, editing is very intuitive if you have previously built multisample instruments. The instrument editor is still in its infancy so there are some parameter persistency issues that need to be ironed out. It is somewhat cumbersome to save variations of the same instrument as it saves each one as a single monolithic (flac compressed) file.

Overall, it’s easy enough to dive into the editor, tweak the available settings and resave the instrument however you like.

Room for improvement in the format: The most valuable thing for us from a development standpoint is sample grouping capabilities. Our instruments really become 3 dimensional once we can program group modulations based on user events. Our TeeBee instrument for example is heavily dependent on groups of samples to create a realistic emulation of the original TB303. So this is a feature I would like to see implemented.

I would love to be able to save track DSPs with the instrument but perhaps that could conflict with Renoise’s native architecture and workflow. However, this capability when combined with Renoise’s effects and Meta Devices could open enormous possibilities for sound design.

More LFO waveforms with an even slower frequency would be very welcomed into my Renoise sound design toolbox!

Each parameter setting has 4 envelope preset slots but these are currently shared between parameters and are only session specific. It would be really cool to have independent preset buttons per parameter that save with the instrument. That way, the user can load it up and call any number of combinations for instant sound shaping variations.

Velocity crossfading.

Visit Puremagnetik at http://puremagnetik.com/ — you’ll see new Renoise-format sounds starting to appear.

Included in this pack:
Analog Synth Basses
Circuit Bent Drum Kits
Buchla Drum Kits
Mellotron Strings and Flutes
Glitch, Toy & Lo-Fi Sounds
Fender Rhodes Mark II
Model-C Clavinet
Electric Guitar
Upright Bass
Classic Analog Synths
Grand Piano

And there’s more soundware free with this release, too, I see from the Renoise site:

Additionally, Berlin based artist and longtime user Beatslaughter has blessed us with a touch of evil in his sample pack “Beatslaughter SoundPack Volume 1″.

Those two sample packs total over 800 MB and let producers jump into all the latest sampling features of Renoise 2.7. The packs are free for all registered users new and old, and are waiting in the Backstage.

Get Your Tools Faster

It’s like an App Store for Renoise hacks: tools.renoise.com has gotten an upgrade, and there’s a new automatic updater called the Tool Updater. Combined, this should make it easier to keep your tools fresh, and customize Renoise to do what you need. I’m a huge fan of the lightweight hacking mechanism they’ve built into Renoise, and the fact that it’s an integral part of the software.

Hack Renoise

As a mentor at Music Hackday Berlin, if you happen to be in Germany later this month, you can learn how to hack Renoise from the developers. I’d love to see some new projects. (I may even try to see if I can drop by, if I’m in fact in England around the same time!)

Renoise will be mentoring at Music Hack Day Berlin. The event takes place on the weekend of May 28th in the MTV Network offices located at the Spree river. Erik, dblue and Taktik will be on site to discuss Renoise, the Lua API, drink beer, and give out high fives. Check our community forums in the upcoming days for more details.

Background/info:
http://musichackday.org/
http://vimeo.com/7129735
http://www.wired.com/epicenter/2011/02/music-hack-day-nyc/
http://fuse.tv/music/music-hack-day/
http://www.billboard.biz/bbbiz/industry/digital-and-mobile/midem-2011-can-hacking-save-music-1005009032.story
http://blog.programmableweb.com/2010/02/03/48-hours-31-hacks-stockholm-music-hack-day/

And yes, I’ll happily, happily share any interesting hacks or creations here on CDM.

Of course, there’s plenty here to enjoy in Renoise even if you don’t hack – you can grab some free sounds and go play! Let us know what you think.

Ever wish your music software could do something your way, something it can’t do now? Wish you could just get in there and change it yourself?

That’s some of the ambition of Renoise 2.6, the multi-platform music creation tool. By opening up the entire music tracker to scripting, users can create custom functionality and control surface. But scripting – while it sounds like the domain of hard-core geeks – doesn’t have to be daunting. That’s important, as presumably you want to spend some time making music. Scripting should save you time and let you express ideas more directly, not act as an impediment. So, the design of the Duplex feature in Renoise does work to make this customization accessible.

Renoise 2.6 has just gone gold master, meaning you can add it to your stable music setup. New in this release:

• Lua scripting. Customize the app using an elegant, clean, friendly language.
• OSC, MIDI support. Integrated control with Duplex (MIDI/OSC), native Open Sound Control support.
• Extensive hardware support. Maybe you don’t want to write a line of code, ever. You can let someone else do it for you, and reap the rewards. Already, Renoise has native, fully-integrated support for the AlphaTrack, BCF-2000, BCR-2000, KONTROL49, FaderPort, microKONTROL, nanoKONTROL, Launchpad, Remote SL-MKII, Nocturn, Monome, Ohm64, iPad via TouchOSC… all thanks to community support for the new scripting engine.
• Sample autoseek. Absolutely essential to making audio behave in the way it does in linear arrangement tools, the sample will play back from the position in the timeline, rather than from the beginning each time you hit play. (Seems obvious, but it’s part of making Renoise bridge tracker-style apps and more conventional, linear ones.)
• Better performance, compatibility. Tweaked performance on Linux and Mac, expanded file format compatibility, plus 64-bit Linux, DSSI Linux support. Renoise is a reason to run Linux, and Linux a reason to run Renoise, if you hadn’t guessed that yet. No, seriously, you’ll enjoy it. (I always feel like it’s telling someone to go vegan. Linux can actually be fun. And you still get to eat bacon.)

The release date seems the perfect time to really explain what Duplex is about, and what it means to you. First, it’s best to see it in action in this Duplex video. What you see is fully integrated hardware and software, but in a way that doesn’t necessarily require specific hardware. (There’s no “Renoise” logo on the controller – and you could substitute something very different and get the same impact.)

More information on the Renoise forum from the video’s creator, Danoise: Duplex – Playing With Loops

Basically, I’m arranging a small song on-the-fly, using a Launchpad + monome. Since the song was basically written using the StepSequencer, the vertical resolution of each pattern is just 8 lines. I then use the new loop feature in the Matrix to “pair” patterns into longer sequences.

This is just one possible workflow among many, but it’s one that’s I’ve found to be immensely rewarding when you’re sketching a tune out.

Bjørn Nesby, Duplex’s lead developer, explains his creation to CDM:

Duplex is aimed at both people who are willing to create their own scripts, and those who just want a nice way to interact with their music using Renoise. Many of the scripts (called ‘applications’ in Duplex) are pretty generic in nature, and will simply take control of a specific part of Renoise, like the Mixer or Pattern Matrix. This is something everybody can use, so this is where I focused my efforts to begin with. More exotic applications are also planned, but we needed to get the fundamentals in place first.

A thing that was clear from the beginning was, that the whole setup and configuration process needed to be as simple as possible. I think we succeeded in that, as my personal copy of Renoise will automatically launch the applications I need when the program starts, on three separate controllers. And I’ve heard from many people that they love this aspect of Duplex, as it reduces a potentially tedious startup process to an absolute minimum. Of course you can have an initial device setup process that you need to go through (like selecting the input and output ports for your device, which might vary from system to system), but in most cases you’d only need to go through this once, after which the device is ready to use.

And I believe this is not just about ‘convenience’, because sometimes you need to be absolutely focused on the music and not the order of which you launch various programs – especially true when you bring your music to the stage.

However, I have to point out that the configuration process is not perfect yet. There’s still room for improvement when customizing application mappings – this is currently done by editing some of the accompanying configuration files by hand, and although that might sound scary, it’s actually a pretty straightforward thing to do (and if not, the Renoise forum is there to help people out). Also, finetuning a setup like this is hardly part of the music-making process itself, so I hope it’s something people can live with for a little while longer.

From a developer point of view, the Duplex framework might be technically interesting as it attempts to follow the ‘write once, run everywhere’ model, as known from the mobile computing world, but instead applied to musical gear. For example, the Mixer application is able to run on all devices, from the Novation Nocturn to the monome128. Physically speaking, those are two very different devices, but everything in the Duplex API is abstracted to the point where a standard user-interface element like a slider can be a rotary dial (Nocturn), or an array of buttons (monome). In the application code, you simply create a slider, and base your logic around that. The framework will do all the dirty work of translating that into *actual* controls. This is possible because everything in Duplex is based around a descriptive XML file, the control-map. Unlike a traditional MIDI implementation chart, the control-map will not only describe the parameters and their ranges, but rather the complete physical layout of the device. Once a proper description has been made (and they are not hard to make, several of Duplex’ control-maps are user-contributed) you can launch an application on e.g. the monome that creates virtual sliders from individual buttons, because each button “knows” where it’s located in a X/Y coordinate space.

I’ve also tried to keep the syntax as familiar as possible. Many people who’ve done a bit of actionscript will probably recognize many of the concepts in this framework, hopefully making the whole experience a little less daunting for budding scripters.

One unique aspect of Duplex: the virtual control surface. When Duplex is installed, you can try out all the various supported devices, even if you don’t own them. Again, it’s the control-map structure that makes this possible, as you can define things like button size, color etc. Of course, this is not the same as the real thing (try hitting two buttons simultaneously using a mouse?), but it’s still interesting to play with, a huge advantage for developers as you can design a control-map that device owners can then try out and test, and makes for self-documenting applications, as you can assign tool-tips to the control surface that display exactly what each button does.

More information:
What’s New in Renoise 2.6 – Renoise Geek Edition.

Renoise Lua Scripting

2.6 Forum Discussion

And, of course, you can discuss Renoise and other trackers on our own Noisepages community. Specifically, we’re looking at how to use trackers in live performance.

Trackers for Live Performance @ Noisepages

Renoise, the tracker-style music production host, has gotten a massive injection of customizability, scriptability, and hackability. If all you want to do is plug in some controller hardware and have more tangible control of music making, that scriptability can be nicely hidden away. But if you are ready to hack on your music app, this is some enormous news.

For that reason, Renoise 2.6 is being called even by its makers the “Renoise Geek Edition.” But if this hackability catches on, it could mean a music tool that’s more fun to use for everyone – not just scripting geeks.

2.6 has been released into a private beta for registered users, with the full release anticipated soon.

The video at top sums up why the open API is potentially a big deal for everyone. Right now, you can use a pre-built script for two-way integration of hardware like Novation’s Launchpad. As other folks get into the tools used here, though, that could (if hackers get so inspired) lead to lots of other hardware support and musical ideas.

The other big news, at the opposite end of the spectrum, is that longer samples now “autoseek.” That’s best seen in the video below, although I can put it this way – this means if your music isn’t all microsamples, you can now more easily produce and perform in Renoise.

Here’s my personal take on the 2.6 changes. Keep in mind, I’m just wrapping my head around this stuff, too, so take this with a grain of salt. But I can at least express why I’m excited about digging into this release, having followed these developments for some time:

Script everything – using a truly open API. Firefox has extensions. Renoise has Lua scripts. You can customize the user interface, manipulate musical elements in your song, control MIDI, audio, and OpenSoundControl, or actually dive in and create features Renoise doesn’t have yet. Those ready to code can use the elegant scripting language Lua, which means that – while you’ll definitely need some basic coding chops – the results are surprisingly simple and readable.

http://code.google.com/p/xrnx/

You don’t need a separate add-on product, and the API is fully documented, free, with a whole bundle of scripts and snippets under an open source MIT license. Renoise itself remains proprietary, but that means the scripts themselves are free to remix, and coders are free to distribute their work to all Renoise users.

That approach contrasts with the solution devised by Cycling ’74 and Ableton for Ableton Live. Live is not directly scriptable; the so-called “Live API” used by hackers was a set of private APIs. Max for Live provides some, but not all of this functionality, and it’s a paid add-on, so you can’t distribute your work to all Live users. On the other hand, the Lua scripting engine is just a scripting engine – it’s not the synth, sequencer, effect, and multimedia-processing platform that Max is. For some, that may actually make the simpler, more direct Lua interface more appealing; they’re just not directly comparable.

Two-way control of everything.

Using these scripting features, it’s possible to get much richer, two-way communication between control hardware and Renoise software.

That means one of two things:

You don’t care about code. No problem — grab control templates from a community of people who do care enough to hack things together. If you’ve got a Behringer BCF/BCR, Novation ReMOTE, Nocturn SL, or Launchpad, or Livid Ohm 64, you can get started right away. For everything else, watch for the community to fill in the gaps. (monome?)

You’re a coder. Dive in and make things work the way you want. What’s ground-breaking about what Renoise have done is that everything is built atop an open, extensible API for the software itself – rather than kludging together various protocols and tools, which has been the traditional industry solution (if you’re lucky, and there’s any customization at all). Renoise’s Duplex uses an object-oriented system for describing hardware and software and communicating events bi-directionally between them. It’s all built in the API, so it’s all customizable. There’s even an onscreen tool so you can mock-up interactions with hardware you don’t yet own (or haven’t yet built).

Everyone can share their work at a centralized site:

http://tools.renoise.com

OSC Support

Renoise joins MOTU Digital Performer, the open source DAW Ardour, and a host of visual apps that support full, native OSC. That means support for networked, transparent control from anywhere to anything. You can even send Lua scripts as OSC commands, so this new API is really controllable from anything.

Better Linux Support

Linux now adds DSSI plug-in support, bringing a full complement of Linux plug-in compatibility, as well as 64-bit Linux support.

More Support, Tweaks

Mac, Linux performance enhancements (especially on 64-bit Linux), and better support for hardware-based plugins (which I’m assuming means latency compensation) round out this update.

Needless to say, this is all something we’ll be covering more. Stay tuned here.

Thanks to Johann Baron Lanteigne and everyone who sent this in.

From the source:
http://www.renoise.com/about/what-s-new-2-6/

Augustus Loop is a tape delay effect with some out-there features – try a one-hour maximum delay setting, tap-in length, virtual tape features, the ability to sync multiple instances, and lots of unusual sound design features. It can do things that even tape wouldn’t imagine.

Version 2.2.0 has some nice new features. It incorporates 64-bit support, although unfortunately that 64-bit support is Mac-only for now.

Also new in version 2.0 (2.2 is the 64-bit bump):
A skinnable, scriptable GUI
OSC support for full control with OSC (grab your iPhone, folks)
MIDI and OSC scripting in Lua, for customizing control

Those are some trends I’d like to see more of. It proves that plug-ins can be more open to user customization, and that even a tiny, independent developer can embrace the flexibility of OSC as a control protocol.

Demo times out after 15 minutes; US$49 for the full version. Mac + Windows (AU + VST).

Explore the goodness and some of Expert Sleepers’ other unusual plugs:
http://www.expert-sleepers.co.uk/augustusloop.html

Have you been paying attention to Renoise, the modernized tracker? You might want to start. The cat is out of the bag on Renoise 2.5′s new beta (available immediately to registered users), and it looks like it may be a dramatic leap forward. Even better, 2.6 promises to allow a level of customization, scripting, and integration we haven’t seen in any music tool, anywhere.

Two memes have gripped the underground electronic music over recent years. One has been the tracker, and its atomic, ground-up musical process, embodied in new and old software and in the love of handheld game systems like the Game Boy. The other has been the grid as a way of reconceiving and playing musical patterns, from Ableton Live to the monome.

Now imagine if these two memes collided.

And, oh yeah, imagine if you suddenly got the modulate-anything, script-anything, customize-anything, control-anything-with-anything, use OSC and MIDI and keyboards everywhere you’ve been asking for. A beta that’s about to drop should begin to answer whether Renoise will be the first app to pull it all off, with major new features coming early in the year and powerful scripting and customization later in 2010.

Have a look at this (very fuzzy) video, and you’ll see something is up.

First, let’s back up and talk about the Pattern Matrix. Look deeper than its skin, and it does appear to be something different from previous things with rectangles and steps and clips.

A long-standing problem with trackers has been that they’re so atomic, it’s often difficult to form larger structures. The Pattern Matrix promises to do this and more, with clever, keyboard-controlled boxes that allow you to mess with the larger form of your work. Unlike something like the Ableton Live clip view, this matrix is resizable, and you can see what’s happening inside each box (and inside is all the usual tracker goodness).

While you ruminate on that, there’s more. Meta devices in Renoise that modulate other parameters can now be chained… anywhere. This has been possible to limited effect with hacking or MIDI routing in other hosts, but in Renoise, these modulations are everywhere.

In another interesting feature, Renoise will be able to take plug-in VST and AU instruments and magically turn them into sampled instruments (which could be very handy for taking them on your Linux-powered netbook at a gig, without worrying about crashing).

Let’s do the quick bullet-point list to sum up what’s coming in 2.5:

• A Pattern Matrix that lets you seamless control and trigger and see anything at any level of your arrangement – something really quite new, like a combination of the best of a step sequencer, a matrix of clips, and a tracker.
• Meta-Device cross-track routing of modulation and control so you can connect and modulate everything with everything.
• Instant creation of sample-based instruments
• Internal effects: cabinet simulation, stutter audio (yeah, that’ll get overused), signal-following meta device (whaaa?), instant linking to an X/Y pad
• Improved timing and plugin delay compensation
• Mac plug-in crash guards, MIDI chords, MP3s on Linux, UI tweaks…

Check out the full 2.5 feature list.

Extensive thread by developer taktik (with some very juicy tidbits, to say the least)

As for when you can get it, registered users get the beta first. Full details from the source:

Pricing and Availability

Beta versions are exclusive to registered users. The first public 2.5 versions will be Release Candidates. The final version is expected to be released at the beginning of next year.

As usual we will test the beta for as long as necessary to make it rock solid, avoiding annoying floods of small updates to fix crucial issues.

The price of Renoise will change from 49 Euro to 59 Euro when the final version is released – This price is for a multi-platform license. That means that a single license is valid for Windows, Mac OSX, and Linux.

To ease the transition, everyone that buys Renoise 2.5 before the final version will get Renoise for the old price of 49 Euro. This covers upgrades up until and including version 3.5.

Real Integrated Customization Coming: Lua, OSC

Now, here’s the real bombshell. We’ve seen limited customization and scripting in music hosts. But what if all of this went further? That’s what Renoise is promising to do later in 2010.

From the Renoise forums:

We usually can not promise exact release dates and plans, but this time its “very likely” that we’ll throw in a Renoise 2.6 release right after this release. Well, soon, as soon as 2.5 went final. This mainly will be a “Renoise nerds” release – in a positive way.

For this release we already are working on integrating a scripting language into Renoise, actually already some of the new features in Renoise 2.5 are built with it, which will allow you to (and more):

- OSC support, create interactive MIDI controller scripts.

For example: control Renoise with a Monome, Mackie Control and so on, without having to manually “map” the controller. Just plug in the controller and you’re ready to go.

- Extend Renoise with the features you always wanted: Just like Extensions in for example Firefox, you will be able to extend Renoise with the features you want, like beatslicing, note shuffling, auto composing algorthms, whatever. Thoise scripts allow bidirectional comminication with Renoise, but not just with the song, as we have
it now for the XRNS tools.

You will also have the ability to write custom Renoise GUIs for your scripts, assign keyboard shorcuts and so on, to perfectly integrate them to Renoise.

More details about this will follow later, after the Renoise 2.5 release was done.

Of course, if successful – and keeping in mind this hasn’t been formally announced – this could go further than what even Max for Live has done this year, by being built from the ground up to integrate directly with the tool.

I could comment further, but I have a feeling this already has a few heads reeling.

Yes, I’ll be following this closely.