Renoise Expressions

This may be crazy talk, but i’ve never seen anything like it in another package. At work i do 3d animation and compositing, and something i use a lot in animation is to modify parameters with expressions.

As an example, to make an object rotate constantly, i could do something like this:

myObject.rotateY = frame; where frame is a variable that, you guessed it, describes the frame number the animation was playing.

Alternatively, i could use myObject.rotateY = 360*sin(frame); which would spin rotateY back and forth a full 360 degrees in a sinus curve based on the frame parameter.

Now consider the interdependencies of parameters you can create with such expressions. You can have an object’s scale alter based on its velocity, or its proximity to another, or it’s position in a list of objects, or whatever, and that’s literally a fragment of the tip of the iceberg.

Imagine this:

You create a Filter2 device, and give it a name such as “myFilter” with an optional text input field. Then you create en Expression metadevice that is basically just a text box and scrollbar.
In this device you type the following:

myFilter.frequency = (songPosition/songLength)*100;

This would modulate the frequency of the filter from 0 to 100 from the beginning of your song to the end.

Now create a Distortion device, name it myDistortion

In your expression metadevice, add the following: = 100*sin(myFilter.frequency);

This would modulate myDistortion’s drive between -100 and +100 (which you would again normalize down to 0-100, but i’m too lazy to write that here for the sake of this example) according to myFilter’s frequency, which is already being modulated by the expression we created earlier.

Another example would be something like this, a little more abstract in my mind right now:

You have an instrument called “breakbeat” in a track called “breaks”

breaks.pan = breakbeat.outSignal;

Those of you familiar with envelope followers know this would modulate the track’s pan according to the output level at that given moment sent from the breakbeat instrument.

This could let instruments alter parameters on tracks they aren’t even playing on, which could let you fake such things as compressor sidechaining etc.

This just popped in my mind so i don’t have a world of examples, but i really do believe this could be a tremendously powerful addition to the software, and would let those of us willing to take the extra hours out to learn the scripting language essentially create our own metadevices (to a certain extent).

As for the implementation i assume Renoise as it is is class instance based when it comes to dsp chains and whatnot, so logically each instance should already have variables “available” for such expressions.

Any thoughts on this?

  • Andreas SJ

here’s an image describing the kind of device i’m trying to suggest

edit: sorry about that atrocious code highlighting :stuck_out_tongue_winking_eye: i was rushing

You’ve just described something I’ve wanted in a tracker for years now. Making internal values such as track amplitude available to the user, then providing a way for them to be applied to other parameters, with a few basic math functions available on top… oh man, it would be so ridiculously incredible!

I’ll second that :w00t:

opensound control (OSC) would give these abilities to renoise plus a hundred fold.…98bbe70902f739b

I don’t see what a scripting language inherently has to do with OSC.
All i’m asking is that renoise’s internal variables be made available, in some form, to those of us wanting to make parameter dependencies that currently aren’t available, or may never be made available.

I don’t see the immediate connection.

of course you would need an interpreter.

we have posted this idea before, but the amount of depth you defined is very nice. this would be something i would thoroughly enjoy.
btw where’s mr. Freud? i never see him post on here…

Oh the freudman doesn’t burn as much for this as i do :stuck_out_tongue_winking_eye:
He’s more of a relaxed end-user that thinks more about making music than how to make it.

He would, for example, probably never use expressions if it were implemented ;)

sunjammer: I think this idea (and the mockup you’ve made) sounds very nice. :slight_smile:

Sounds like CSound (or ) to me (waveshaping and generating)
Owh, and CSound is ofcourse open source.

Woha! Thats would be so darn cool! It would be a first in music program history?

But why not also connect the parameters to the instruments!

A simpler way to do it would be by wiring them and modulate the instruments parameters with expressions…

Yeah, this idea was kind of mentioned in this post.This method could also save using the rather laborious automation envelope editor (which is still good, just not as functional as I could wish for)

And I like it!

But surely to work with any worthwhile accuracy, sub-tick timing should be implemented first to cater for higher frequency modulations etc.

Damn, a meta-device like the FLS’ Formula Controller would be teh ultimate roxxorz!!!

And this idea here is even better!!! I’m for it!

The idea came originally from wanting a renoise compressor that supports sidechaining. Then i thought instead of bugging the developers for that feature, it’d be infinitely better to have them give us the musicians the ability to create such sidechaining for ourselves.

If anyone wonders, sidechaining a compressor involves compressing signal A based on a separate signal B. For instance you could compress a bassline with a kick drum to make sure the kick would sound clear over the bassline.

In expression terms this would look somewhat like this (off the top of my mind, hypothetical obviously)

myCompressor.ratio = myTrack.outputLevel;

or something like that ;)

I think this would take a fair time for the team to implement, but i think the long term effect would be worth it. Basically users could distribute expressions in their dsp chain files that would create complex interactions the dsps themselves don’t allow for out of the box.

I think as a community building device, it’s also a very interesting concept.

If anyone asks me to write up a specification for such a scripting languge (which would be ECMAscript based as close as i could get, because ECMA is the shiznit), i will.

An expression is basically a way of telling Renoise what to do with values.
When you adjust the cutoff frequency of a filter, you are, in the most basic of terms, adjusting a number between a minimum value and a maximum value, 0% through 100%.

If you somehow translate every value you use in renoise down to a scale like that, such as 0-100% with decimals, you could send any number from any device to any parameter.

For instance, there’s no reason a track’s volume slider can’t send it’s slider position elsewhere, say to a filter. 50% on the volume would be 50% cutoff.

I’m being super simple here ;)

Basically, an expression is a way of telling renoise specifically how to create connections between values in the program.

And is that not all that matters? :D


Sorry if this is a bad thing :P
I cannot emphasize how convenient such a feature would be. Every time i use Renoise i see a connection i’d like to make or a relationship i’d like to establish.

The way it is now we’d always be asking the developers for metadevices to create such connections; my proposal is a device that can create any number of connections anywhere in the song as long as the user is willing to learn as basic API, and i’m sure any highend user will adore such a feature.

Consider it a less visual but more hands on response to Reason’s cabling.

OctaMED (Amiga version), has its own expression scripting which can be executed using certain commands whilst playing, or used for creating complex edits, which I used on the odd occasion. But there wasn’t much call for it as I used MIDI at the time, and only used it to send messages to devices when I needed to do long, live sets. The ARexx support came in useful as well.

Renoise could offer infinite possibilities with this, and yes, it would be an exceptional community building tool IMO.

:rolleyes: yeah, right…

I mean, it looks complicated, that ‘expressions’ window that you made a picture of.

I don’t want to be a plague or whatever… but I just don’t see the cool-ness of this feature. As of now. Maybe if I’ll understand this better or something…

That example that you posted (50% volume=50% cutoff) would be faster achieved with automation envelopes, no?
I know, it’s just a single example.

But I do see the niceness of having sidechaining. That’s also a commercially appealing feature, indeed.
But for the rest, it seems overkill for the way I work. What values am I supposed to connect?

More features in the advanced edit, like in that topic that In-Fluence posted. That makes sense to me. And a more advanced automation.

This post is strictly for discussion purposes, no harm intended.

sidechain compressing would be one of the features possible with this. (not just compressing: sidechain-eq’ing/filtering/distorting/… everything :) )
in fl studio this is all possible with the peakcontroller+formulacontroller, but this feature in renoise would be the s… :)
(and it should look exactly like in your picture, sunjammer. like it a lot)


Excellent implementation idea too…

Please, pretty please…