OSC and Renoise, anyone using it?

Howdy all. After looking through Neurogami’s Ossia Score post https://forum.renoise.com/t/ossia-score-tool-for-scripting-stuff-via-osc/49063 I got thinking about a project I’ve shelved using Renoise and vst’s. As the music data will be generated from algorithms in an external program, like Ossia Score, Sonic Pi or even Processing, OSC seems like a natural way to transmit it to Renoise.

I’m just wondering if anyone is using OSC in Renoise and if so, would you care to spend a few lines describing what you’ve done? Perks, pitfalls, hair removal moments, the usual stuff.

Cheers and thanks. :slight_smile:

1 Like

Personally I tried it just for some remote control capabilities but I found it to be too much effort to set-up. I guess I don’t need that functionality enough to persist with it though…

I wrote a tool, OSC Jumper:https://github.com/Neurogami/renoise-ng/tree/master/lua/com.neurogami.OscJumper.xrnx

It defines a number of custom OSC handlers for looping and jumping around patterns.

The intent is to use Renoise for live performing, and being able to change the pattern loop on-demand (likely by using predefined messages to navigate to a planned sequence of loops).

The tool runs its own OSC server, so Renoise is listening for OSC on two different ports. In order to still be able to send the standard Renoise OSC messages my tool forwards on any messages it does not know how to handle.

One issue I’ve run into is matching the available OSC messages that can be sent from a client to what can be handled by Renoise.

For example, if you use TouchOSC there may be cases where you cannot craft an outgoing message and arguments that aligns to what Renoise wants. (This might have changed; I haven’t checked in a while.)

I think this comes up in cases where what is really an argument appears as part of the message.

For example:


The track number is going to change and not all OSC clients let you define messages with variables embedded into the address pattern.

Worse, some OSC clients don’t let you define the messages at all.

I’ve been using Control (http://charlie-roberts.com/Control/) on my phone because (while quirky) it allowed me to design suitable custom screens and OSC messages. But I don’t think I manged to get it to embed variables in the address pattern either.

My solution was to write an OSC proxy that runs on the same machine as Renoise. It accepts the messages coming from TouchOSC or wherever and remaps them to Renoise format.

I then wrote an Android app that looks something like a numeric keypad, sending fairly generic messages. I then remap these via proxy to whatever I happen to need.

I use this quite a bit with Reaper; it makes track comping much easier, as I use OSC commands to change what tracks are muted (as I A/B test different takes).

I need to do the same with Renoise so I can quickly alter some fx (compression, eq) settings and compare how they sound. (For example, if I want to compare a boost at 100 Hz vs one at 250 Hz, and quickly toggle one or the other or neither. Doing that by hand would get too tedious.)

I think what I will have to do is employ fx naming conventions, as that makes it easier in Renoise Lua to find a specific fx.

Once you decide to try to use OSC to control Renoise you still have to sort out how to make Renoise do your bidding. : )

Well, OSC seems to have two usage scenarios:

  1. An external remote control program compatible with OSC.
  2. Directly from a script tool (something like “integrated” into Renoise).

I have used it several times to program several tools, basically to control the notes, (trigger note_on note_off).The reason is because there is no choice but to use OSC to be able to play the notes from the tool.There is no other way yet. Some examples:

  1. A virtual piano to record notes with mouse clicks (and sound).
  2. A chord trigger.
  3. A step sequencer of 32 steps.
  4. A trigger of multiple notes, (or multiple phrases).

All these tools use these 2 things ( trigger/ note_on() or note_off()):

---- Realtime Messages
 /renoise/trigger/note_on ( instr(int32/64), track(int32/64), note(int32/64), velocity(int32/64) )
 /renoise/trigger/note_off( instr(int32/64), track(int32/64), note(int32/64) )

The only real practical problem that I have detected is the synchronization of what you intend to play with the tool adjusted to the playback of the song, with the progress of the pattern editor, since it could be useful for live recording.This, unfortunately, is aggravated by the use of VSTi’s, which for some reason does not work well with Renoise (at least the 64-bit version with Windows). I’m sure Taktik will review all this at some point, because it does not work properly (VSTi + tools + Renoise = problems).

But, despite these drawbacks, the use of OSC is the closest thing to what can make a tool fun. Most available tools are made to manipulate data here and there, they can be useful, but tremendously boring. With OSC you make “the tool sound”.

However, I find it useful to use OSC for a tool. Because the tool is together with Renoise. You see it with your eyes, and you know what you are doing.Through an external program, remotely, I find it difficult to imagine how to use the OSC for a specific control. That is, if you do not visually see what happens in the Renoise window, it seems that you lose control.

If, in addition, configuring OSC from a remote program unrelated to Renoise implies following certain rules or guidelines that even cost to understand or simply costs some time to apply, its use will be reduced to very few interested people. Nowadays, everyone wants things very fast and uncomplicated, easy to manage. Only people who are dedicated and eager to experiment will actually use OSC.

From my point of view, it is something too complicated that only a few have taken advantage of it. In the end it all comes down to “ease of use”.

Having said all this, I would prefer Renoise to have an API capable of offering sound control, specifically what it can execute in real time, without forcing the user to have to activate OSC.

If we analyze most scenarios, Renoise alone is already quite complex software to control in its entirety. Adding remote control through OSC may seem great, just like Rewire. But do people really use it in depth?I can not imagine having to use two DAWs to compose a song through Renoise. Similarly, if MIDI In control exists,It is strange to use OSC to control certain basic parts of Renoise, such as play, stop or similar.

In the end, using OSC remotely seems to be reduced to an experimental scenario, rather than something really useful or habitual to use.

Thank you for the information guys. It appears I will spend a bit more time researching, and reading Neuro’s book as well, before I commit my time to this project. I know where my destination is, it’s now just a matter of how to get there. :slight_smile:


One other use of OSC with Renoise I had been looking at was to control Renoise from the Leap Motion and/or the Microsoft Kinect.

I recently got around to updating my Processing library for the Leap, so I should work on an example that sends OSC to Renoise.

(My larger goal is a program that allows proper address message and argument configuration.)

Processing, very cool. I’ve been messing around with it for a couple of years myself. Right now, I’m working with 3.3.7, the oscP5, Combinatorics and GenerativeDesign libraries. My current project is inspired by works of Oskar Fischinger, Walter Ruttmann and Viking Eggeling from the '20’s and '30’s. It’s not real time as I prefer to arrange and choreograph my work.

BTW Neuro, I really enjoyed your book. Cleared up some questions, learned some stuff and the graphics were a hoot. :slight_smile:


1 Like

Here’s an example OSC handler I wrote to help me manipulate an “EQ 10” device.

This code gets added to your local copy of GlobalOscActions.lua

-- Set NG 10 EQ value for given frequency index
   add_track_action {
    pattern = "/ng/eq10/frequency",
    description = "Set track XXX's 'NG EQ 10' frequncy, value, and Q for given param index.\n"..
    "XXX is the track index, -1 the currently selected track",

    arguments = { argument("freq_index", "number"), argument("freq", "number"), argument("value", "number"), argument("q", "number") },

    handler = function(track_index, freq_index, value, freq, q)
     local track = renoise.song().tracks[track_index]
     local ng_eq_device = nil
     print("See if we can set NG EQ 10 ...")
     for index, device in ipairs(track.devices) do
      if device.display_name == "NG EQ 10" then
       print(" ***FOUND NG EQ 10***")
       ng_eq_device = device
       ng_eq_device.parameters[freq_index].value = freq
       ng_eq_device.parameters[freq_index+10].value = value
       ng_eq_device.parameters[freq_index+20].value = q
       print("Did it change NG EQ 10?")

It assumes the target track has a single EG 10 device that has been renamed to NG EQ 10.

(I like using custom names for anything to be targeted by code as it makes it easier to find the right device.)

Once that is in place you can send messages such as this:

/renoise/song/track/1/ng/eq10/frequency 5 500 -6 1

to change EQ values.

1 Like

Wonderful! Thanks for taking the time to post this example. The osc coding basics are getting much clearer. B)

If I understand correctly, I need to copy the original GlobalActionsOsc.lua file into my username/AppData/Roaming/Renoise/V3.1.1/Scripts directory and modify it.

I’ll use your code as a basis and hack it for a couple of Renoise devices to see if I grok it and then try and send some data from Processing. Let you know how I get on.

Cheers and thanks again. :slight_smile:

BTW, this is a hack I used to get parameter names:

local track = renoise.song().tracks[1]
local ng_eq_device = nil

for index, device in ipairs(track.devices) do
 if device.display_name == "NG EQ 10" then
  ng_eq_device = device

for i,l in ipairs(ng_eq_device.parameters) do

You’l need to change what device it inspects

I ran that in the scripting terminal editor and copy/pasted the code to file for reference.

Note: I learned A LOT by looking at the source of other people’s tools. And by asking questions here.

This is a very cool, helpful, community.

1 Like

Hello for your inspiration Iam usin OSC for control live setup in renoise

Its simple midi action for muting and effecting channels + change Vsti plugins presets.

Plus i mapped two nanoKontrol2 for eq and volume settings and finnaly i use Gridpie renoise plugin for control patterns.

photo of my setup


Hello, I am wanting to send OSC from Renoise to control/trigger live visuals.
I’ve had no trouble sending OSC to Renoise, and this thread is great for extending these capabilities, but can anyone tell me how I might send an OSC message at a specific line/position in the Pattern?

First, in your tool you must create your own link “osc client” (a class), that is, the tool can send messages to Renoise for him to interpret them.

The sending of messages depends on the message itself. Three very common are (in real time):

 ---- Realtime Messages
 /renoise/trigger/note_on(instr(int32/64), track(int32/64), note(int32/64), velocity(int32/64))
 /renoise/trigger/note_off(instr(int32/64), track(int32/64), note(int32/64))

Once you have your OSC code, you just have to invoke a trigger reference function. You can investigate the code of the KangarooX120 tool, which OSC uses to note_on, note_off:
– in functions.lua search: KNG_OscClient:trigger_instrument( note_on, instr, track, note, velocity )
– in functions.lua search:

  • KNG_OSC_CLIENT:trigger_instrument( true, ins, trk, nte, vel )
  • KNG_OSC_CLIENT:trigger_instrument( false, ins, trk, nte )

The code is set to the tool. You can use your own code.
The messages you can use (or even manipulate) are in (Windows): C:\Program Files\Renoise 3.1.1\Resources\Scripts\GlobalOscActions.lua

…to control/trigger live visuals??? What do you mean by “live visuals”?

Thanks for this.
I am working in Isadora creating ‘live-visuals’.
What I mean is that I create visual shows, made up of many ‘scenes’, and each scene has a number of parameters that can be adjusted in real-time. ( a mix of video footage and generative content).
I want to use renoise as the timing and selection engine for the visual show.

Looks like I need to build a custom tool… sounds like a fun project.

How do you send data to Processing? I simply wish to trigger images when a sound in the tracker triggers.

I just happened on this thread while searching for some OSC info and saw this last comment.

For anyone else curious about using Processing from Renoise, I did it to create visuals timed to a track I wrote