I just got my interest in SC kindled and am especially interested in the fact that it’s more straightforward for me to program algorithms in scLang as opposed to the graphical environment of Pd. But I guess my macbook or a raspi with a pisound card will be more suited for this than the organelle.

1 Like

I think it all depends what you want to do… for sure there are limitations on the processing power on the Organelle, so comparing it to a MacBook is apples n oranges - but its still very useable with SC.
you just need to experiment to see what is possible , a bit of synthesis and effects is fine, but don’t expect huge reverbs or things needing ffts.

whats nice with both SC and PD, is if you bare in mind the restrictions, you can develop on the comfort of your MacBook, then just transfer it over to the Organelle once the main development is done.

rPI vs Organelle, the difference will not be huge for SC , since by default SC does is single-threaded (so cannot use multiple cores efficiently).
supernova (the SC multi thread engine) does not appear that stable on the rPI if you look over at lines, you will see the monome are rolling back Norns away from supernova due to instability. though oddly, on my rPI + PiSound Ive never seen an issue so far.

Im still experimenting with SC on both Organelle and rPI, as like you I actually prefer text languages to graphical patchers… and I also really like the live coding side of SC (jitlib).
I definitely hope to be continue my explorations over the next few months :slight_smile:

Well I’ll start by installing SC on the organelle and see what can be done, in terms of synthesis. The object oriented approach of SC is indeed intuitive to a programmer. I’m especially interested the algorithmic generation of drones and soundscapes to integrate in my guitar rig.

1 Like

Hi there !
Thank you Technobear for making SC an option on the Oganelle. I’m new to SC. And getting more comfortable with it. It’s really a different approach than PD and you get much more organic result I find. Not really in the sound synthesis itself, but rather in the way of making instruments.

Now for a quick question :
How do I get access to the “function” button on the Organelle. Not sure how to call it, the button next to the keyboard under the led. I don’t see any callback for it in your example.

Thank you !

Jesse

I’m also interested in checking the mother SC patch ? I tried unzipping the SC_install files but could not find the mother patch.
Thank you
Jesse

I released the supercollider mother (mother.scd) as part of the Organelle OS (3.x)
so its in /root/mother.scd
but you can also find it online here:

you mean the aux button?
similar procedure as others callbacks
(knobs~, notes~, ~encoder_turn, ~encoder_button, ~footswitch)

~auxfunc = {
	arg func, msg, key, vel;
	if(vel>0 , {
    	~led.value(1);
	} , {
		~led.value(0);
	};)
};

~aux.addDependant(~auxfunc);

I’ve been concentrating on Orac recently,
but I do want to return to SC once thats completed…as Ive really been enjoying messing with supercollider recently particularly the whole pdef, ndef side which I think is really cool :slight_smile:

ideally I want to do is extend Orac so that it can have a supercollider backend, this is actually not that far off, as most of Orac is actually the C++ backend, this is what handles all the parameters etc, so its “just” a matter of switching the interfacing code to talk to SC rather than PD… anyway, more experiments need to prove the concept :slight_smile:

2 Likes

Hi Mark !

Thanks for the info. I didn’t suspect the mother patch to be already part of the Organelle package. But I suppose it makes sense. Yes the “aux” button, that’s the one ! Thank you for that too.

I checked out your Orac work when it was released. Such a great tool, and I was drawn to it because you also had the MI ports included. My first ever eurorack module was Rings, I love physical modelling, and Emilie’s work and the open source vision she has is a great addition to the musical world !

Yes, the pdef/pbind combo is a really interesting metaphor for sequencing. I’ve been having a lot of fun making organic, nearly nature sounding patches with it. And I want to bring that to the Organelle. I’ve started with a simple supersaw patch using the great sounding VarSaw. I’ll clean it up and add it to the patch storage database, apart from your example patch I didn’t see any other synth in SC on there.

And I didn’t know about ndef, looks very interesting too. SC, feels like digging inside a mine to find new treasures.

If you need someone to test out an ORAC -> SC workflow let me know !

Thanks again for all your hard work !

Jesse

3 Likes

that would be really cool…
I really wanted to do a full fledged example showing why SC is so cool on the Organelle, but also really needed to finish the work I was doing on Kontrol/Orac on the PD side - so ended up stopping once I had the basics in place - hoping someone would go from there…

but, I think SC on the Organelle is in a bit of a ‘chicken n’ egg’ stage
PD is definitely ‘easier’ for non-programmers, due to its visual nature, and theres lots of examples, to build on - but also to demonstrate why its so cool.
but with no examples for SC, most are going to say “why sc?, Pd works?”, and also when you first approach SC, it can be pretty intimidating, so if you have no simple examples - it’s hard to know where to start … so you really are looking for Organelle owners who are experienced SC programmers, and thats quite a small subset I suspect :wink:

but I do think SC offers a lot for the Organelle, my personal thoughts are its better for more complex patches - as generally, imho, visual patching starts to breakdown when patches get really bit.

what Im keen to see though it how well SC performs on the Organelle, compared to PD for more complex patches - theoretically I think it should be better, but we will only know when we try :slight_smile:

1 Like

Yep, I’ve started with visual programming languages myself, mainly for visual work. But when I started to grasp the power of a scripted language with arrays and objects, etc, I knew I needed to find this flexibility for music creation too.

I’ll take the time to “really clean up” the patch and comment it as much as I can then. :wink:
Well, I’m glad to be part of this small subset then !!

I’ll let you know when I put the patch online.

Thanks

2 Likes

Hi Mark,

I’d like to limit the polyphony of my supersaw patch before I put it online. I’m not sure what would be the best method for that. I’m using your dictionary method for the moment. But the processor will hit its limit around 16 note polyphony. It’s not simple to keep track of the oldest note and still have access to the pitch of each note to release them when needed. Any pointers ? Haven’t really found any info online. Everyone seems to create a 128 entry array and never bother limiting polyphony ! :wink:

Thanks

Jesse

I am quite unable to actually help with this problem, as sc is still confounding to me. But I know technobear is busy this week with orac, and thought you might have some luck here if you haven’t found this forum.

Its relatively new and unindexed, found it through lines. Not too active, but definitely a lot of people asking questions and getting answers.

And I am really excited to see a proper organelle patch with sc which is why I hope you figure this out!

1 Like

yeah apologies @vjess , I will get back to you as soon as Orac 2.0 is out the door.

realistically, it’ll likely be next week, as the eurorack stuff is released on Friday, but then I’ll no doubt be doing all sorts of followups on things, as people start playing with it over the weekend.

Hi @miker2049 !
Thanks for the link to the forum. I’ll check it out. (Need to spend more time on the lines website…).

And no worries @thetechnobear, Orac 2.0 looks amazing, I didn’t realise you were taking it to so many different platforms. Its amazing work, and so nice of you to share it with the community.

I’ve spent nearly 8-10 hours trying to fix this polyphony issue. I need to move on, so I’ll leave it here for the moment. I’m aware that polyphony handling isn’t a very simple coding issue to tackle. But I was so close to getting a working system. But it never completely worked :frowning: !

Hi,
the link on github to download the mother.scd patch is not working anymore.
Can you share it again, please ?
thxs

with OS 4.0 C&G just reorganised the folder structure slightly, you can find it here:

thanks so much for the quick answer !

Hi @thetechnobear , I have some questions about the mother.scd patch, if you like to exchange about this topic…
As there is a lot of good sounding SC patches out there, I was planning to adapt some for my organelle! (and share it with the community)
But I’m not sure to understand what is missing, in order to use all the functionalities of the organelle (like aux button, expression pedal, midi messages, output volume ?)

Also, I couldn’t play a sound file using some buffer manipulation examples (that I can adapted, following the example of simple synth) and I didn’t understand what was the reason (I tried to put the sound file in the same folder as the main.scd patch or using a sound that should be installed with supercollider). I wanted to check error messages in the dialog window of supercollider, using VNC viewer on a laptop but apparently the patch window is not opening with the sc app on organelle desktop (unlike PD which is possible to program directly in the organelle, with this method). Is it something doable by any way ?
I don’t have a long experience with sc but I have a friend who is kind of sc guru. He may help if needed, but for that I must know a bit more about how the mother patch works.

If you can give some help to start, it would be really nice !

have you taken a look at my example patch?

Ive also explained this patch in this post

you should make sure you understand how this works and implement a few patches before you considering ‘extending it’

how to extend past the functionality I’ve implemented this should be fairly straightforward using what I have already implemented as a basis.

bare in mind that all communication with the screen and hardware is done via OSC message to/from the mother host - you can see how these messages are handled in PureData, and simply implement these in the mother.scd in the same way I did the current set of messages.

note: re vumeter
so \OrganelleAudioLevel in mother.scd is now wrong, the reason is because OS 4.0 changed the call to /oled/vumeter to include a peak level - you can see this in mother.pd.
so if you wish this to work, you will need to override this OSCdef to correct it.

note:
its important to recognise, you do not to have use what I have done in mother.scd at all! ,
really these are just ‘helper’ functions, that I thought would be be useful to have - but your supercollider patch, could ignore them entirely, and simply use things like OSCdef (as i do in mother.scd) directly… which you may find simpler?!

This is standard supercollider stuff, try using a fixed path.
What I would recommend is getting the patches working on your desktop first, and then learn to adapt them to the Organelle environment (i.e. adding the ‘UI’) - really there is not much different.
obviously, the Organelle has not where near the cpu resources or memory that a desktop/laptop has, so keep this in mind during the development phase.

on a more general note, Id highly recommend Eli Fieldsteel’s Supercollider videos, they are absolutely amazing - a gem of youtube, and will really help you get started in Supercollider.

1 Like

Hi @thetechnobear !

Thanks again, for all your help :wink: So nice !
I finally succeeded in doing a first Supercollider patch for the Organelle.
It’s a simple metal percussion rhythm generator based on a physical model, that I took from SC examples.
Simple but it already sounds quite good. Still, there is some mysteries about some Organelle functions I’d like to solve before sharing it in Patchstorage website.
As I’m a new forum user, I can’t upload a zip file, so I send you the code directly, at the end of this message.

There is 3 things I’d like to do with it:

  • make the output vumeters work. (I took the code from the mother patch that I thought could do the job, but I don’t know how to do, as there is no documentation about it)
  • use the AUX button as a sustain control. (same pb as above)
  • in a later version I would like to synchronise to a midi clock, to generate rhythms accordingly. (any explanations in how the midi is handled by this version of Organelle/Supercollider would be really great)

If I can do that, I’ll start soon to share some patches, cause there is a lot of interesting things out there, just waiting to be shrunk into this cute little box :smiley: !

Here is my code (sorry it’s many not very convenient, and tell me if there a way to send directly the zip file):

//////
// initialise
~voices = Dictionary.new;
~bandwith=8000.0;
~partials=8;
~impulse=0.01;
~ringtime=2.0;
~oled.screen(1,format(“Bandwith % Hz”,~bandwith.asInteger));
~oled.screen(2,format(“Partials %”,~partials.asInteger));
~oled.screen(3,format(“Impulse %”,~impulse.asStringPrec(3)));
~oled.screen(4,format(“RingTime % sec”,~ringtime.asStringPrec(3)));
~oled.screen(5,“Sustain OFF”);

// output for vumeter and volume control
~mainVolume = 0.8;
~mainOut = nil;
~outL = Bus.audio(s,1);
~outR = Bus.audio(s,1);
~mainOutDef = SynthDef(\mainOutput,
{
arg amp = 0.8;
var insig,sig, peaksig;
insig = SoundIn.ar([0,1]);
sig = In.ar(~outL,2);
sig = sig * amp;
Out.ar(0,sig);
peaksig=[insig[0],insig[1],sig[0],sig[1]];
SendPeakRMS.kr(peaksig, 5, 3, “/audioLevel”);
}
);

// create knob callback
~knobfunc = {
arg func, msg, knob, value;
if(knob==0, {
~bandwith = value.linexp(0,1,20,8000);
~oled.screen(1,format(“Bandwith % Hz”,~bandwith.asInteger));

});
if(knob==1, {
	~partials = value.linlin(0,1,2,16).asInteger;
	~oled.screen(2,format("Partials %",~partials));

});
if(knob==2, {
	~impulse = value.linexp(0,1,0.003,3.0);
	~oled.screen(3,format("Impulse %",~impulse.asStringPrec(3)));

});
if(knob==3, {
	~ringtime = value.linexp(0,1,0.1,10.0);
	~oled.screen(4,format("RingTime % s",~ringtime.asStringPrec(3)));

});

};
// register knob callback
~knobs.addDependant(~knobfunc);

// aux callback

~aux[\key_hit] = {
arg self,key,vel;
self.changed(\aux,vel>0);
if(~aux>0,
{~oled.screen(5,“Sustain ON”);
~led.value(7);
},
{~oled.screen(5,“Sustain OFF”);
~led.value(0);
});
};

// create notes callback
~notesfunc = {
arg func, msg, note, vel;
if(vel>0 , {
if(~voices[note]!=nil,{~voices[note].set(\gate,0);});
~voices[note] = Synth.new(“KlankSynth_”++~partials.asSymbol,[
\freq, (note).linexp(60,83,20,8000),
\bandwith, ~bandwith,
\impulse, ~impulse,
\ringtime, ~ringtime,
\pan, 1.0.rand2,
\rhythm, #[0.125,0.25,0.375,0.5,0.75,1,1.5,2].choose
// \amp, (vel / 3.0) .clip(0,0.3)
]
);
~led.value(1);
} , {
if(~voices[note]!=nil,{~voices[note].set(\gate,0);});
~voices[note] = nil;
~led.value(0);
}; )
};
// register key callback
~notes.addDependant(~notesfunc);

//other callbacks
//~encoder_turn
//~encoder_button
//~footswitch

// metallic synths

SynthDef(\KlankSynth_2, {
arg freq=20, bandwith=8000.0, impulse=0.5, ringtime=2.0, gate=1, pan=0.0, rhythm=1;
var trig, p, exc, x, sig, env, partials=2;
exc = BrownNoise.ar(Decay2.kr(Impulse.kr(rhythm,0,0.04), 0.1, impulse));
env = EnvGen.ar(Env.adsr(),gate,doneAction:2);

sig = (Klank.ar(`[Array.fill(partials, {linrand(bandwith)+freq}),nil,Array.fill(partials, {rrand(0.1,ringtime)})], exc) * 0.35).softclip;
sig = sig * env;
sig = Pan2.ar(sig,pan);
Out.ar(~outL,sig);

}
).add;

SynthDef(\KlankSynth_3, {
arg freq=20, bandwith=8000.0, impulse=0.5, ringtime=2.0, gate=1, pan=0.0, rhythm=1;
var trig, p, exc, x, sig, env, partials=3;
exc = BrownNoise.ar(Decay2.kr(Impulse.kr(rhythm,0,0.04), 0.1, impulse));
env = EnvGen.ar(Env.adsr(),gate,doneAction:2);

sig = (Klank.ar(`[Array.fill(partials, {linrand(bandwith)+freq}),nil,Array.fill(partials, {rrand(0.1,ringtime)})], exc) * 0.35).softclip;
sig = sig * env;
sig = Pan2.ar(sig,pan);
Out.ar(~outL,sig);

}
).add;

SynthDef(\KlankSynth_4, {
arg freq=20, bandwith=8000.0, impulse=0.5, ringtime=2.0, gate=1, pan=0.0, rhythm=1;
var trig, p, exc, x, sig, env, partials=4;
exc = BrownNoise.ar(Decay2.kr(Impulse.kr(rhythm,0,0.04), 0.1, impulse));
env = EnvGen.ar(Env.adsr(),gate,doneAction:2);

sig = (Klank.ar(`[Array.fill(partials, {linrand(bandwith)+freq}),nil,Array.fill(partials, {rrand(0.1,ringtime)})], exc) * 0.35).softclip;
sig = sig * env;
sig = Pan2.ar(sig,pan);
Out.ar(~outL,sig);

}
).add;

SynthDef(\KlankSynth_5, {
arg freq=20, bandwith=8000.0, impulse=0.5, ringtime=2.0, gate=1, pan=0.0, rhythm=1;
var trig, p, exc, x, sig, env, partials=5;
exc = BrownNoise.ar(Decay2.kr(Impulse.kr(rhythm,0,0.04), 0.1, impulse));
env = EnvGen.ar(Env.adsr(),gate,doneAction:2);

sig = (Klank.ar(`[Array.fill(partials, {linrand(bandwith)+freq}),nil,Array.fill(partials, {rrand(0.1,ringtime)})], exc) * 0.35).softclip;
sig = sig * env;
sig = Pan2.ar(sig,pan);
Out.ar(~outL,sig);

}
).add;

SynthDef(\KlankSynth_6, {
arg freq=20, bandwith=8000.0, impulse=0.5, ringtime=2.0, gate=1, pan=0.0, rhythm=1;
var trig, p, exc, x, sig, env, partials=6;
exc = BrownNoise.ar(Decay2.kr(Impulse.kr(rhythm,0,0.04), 0.1, impulse));
env = EnvGen.ar(Env.adsr(),gate,doneAction:2);

sig = (Klank.ar(`[Array.fill(partials, {linrand(bandwith)+freq}),nil,Array.fill(partials, {rrand(0.1,ringtime)})], exc) * 0.35).softclip;
sig = sig * env;
sig = Pan2.ar(sig,pan);
Out.ar(~outL,sig);

}
).add;

SynthDef(\KlankSynth_7, {
arg freq=20, bandwith=8000.0, impulse=0.5, ringtime=2.0, gate=1, pan=0.0, rhythm=1;
var trig, p, exc, x, sig, env, partials=7;
exc = BrownNoise.ar(Decay2.kr(Impulse.kr(rhythm,0,0.04), 0.1, impulse));
env = EnvGen.ar(Env.adsr(),gate,doneAction:2);

sig = (Klank.ar(`[Array.fill(partials, {linrand(bandwith)+freq}),nil,Array.fill(partials, {rrand(0.1,ringtime)})], exc) * 0.35).softclip;
sig = sig * env;
sig = Pan2.ar(sig,pan);
Out.ar(~outL,sig);

}
).add;

SynthDef(\KlankSynth_8, {
arg freq=20, bandwith=8000.0, impulse=0.5, ringtime=2.0, gate=1, pan=0.0, rhythm=1;
var trig, p, exc, x, sig, env, partials=8;
exc = BrownNoise.ar(Decay2.kr(Impulse.kr(rhythm,0,0.04), 0.1, impulse));
env = EnvGen.ar(Env.adsr(),gate,doneAction:2);

sig = (Klank.ar(`[Array.fill(partials, {linrand(bandwith)+freq}),nil,Array.fill(partials, {rrand(0.1,ringtime)})], exc) * 0.35).softclip;
sig = sig * env;
sig = Pan2.ar(sig,pan);
Out.ar(~outL,sig);

}
).add;

SynthDef(\KlankSynth_9, {
arg freq=20, bandwith=8000.0, impulse=0.5, ringtime=2.0, gate=1, pan=0.0, rhythm=1;
var trig, p, exc, x, sig, env, partials=9;
exc = BrownNoise.ar(Decay2.kr(Impulse.kr(rhythm,0,0.04), 0.1, impulse));
env = EnvGen.ar(Env.adsr(),gate,doneAction:2);

sig = (Klank.ar(`[Array.fill(partials, {linrand(bandwith)+freq}),nil,Array.fill(partials, {rrand(0.1,ringtime)})], exc) * 0.35).softclip;
sig = sig * env;
sig = Pan2.ar(sig,pan);
Out.ar(~outL,sig);

}
).add;

SynthDef(\KlankSynth_10, {
arg freq=20, bandwith=8000.0, impulse=0.5, ringtime=2.0, gate=1, pan=0.0, rhythm=1;
var trig, p, exc, x, sig, env, partials=10;
exc = BrownNoise.ar(Decay2.kr(Impulse.kr(rhythm,0,0.04), 0.1, impulse));
env = EnvGen.ar(Env.adsr(),gate,doneAction:2);

sig = (Klank.ar(`[Array.fill(partials, {linrand(bandwith)+freq}),nil,Array.fill(partials, {rrand(0.1,ringtime)})], exc) * 0.35).softclip;
sig = sig * env;
sig = Pan2.ar(sig,pan);
Out.ar(~outL,sig);

}
).add;

SynthDef(\KlankSynth_11, {
arg freq=20, bandwith=8000.0, impulse=0.5, ringtime=2.0, gate=1, pan=0.0, rhythm=1;
var trig, p, exc, x, sig, env, partials=11;
exc = BrownNoise.ar(Decay2.kr(Impulse.kr(rhythm,0,0.04), 0.1, impulse));
env = EnvGen.ar(Env.adsr(),gate,doneAction:2);

sig = (Klank.ar(`[Array.fill(partials, {linrand(bandwith)+freq}),nil,Array.fill(partials, {rrand(0.1,ringtime)})], exc) * 0.35).softclip;
sig = sig * env;
sig = Pan2.ar(sig,pan);
Out.ar(~outL,sig);

}
).add;

SynthDef(\KlankSynth_12, {
arg freq=20, bandwith=8000.0, impulse=0.5, ringtime=2.0, gate=1, pan=0.0, rhythm=1;
var trig, p, exc, x, sig, env, partials=12;
exc = BrownNoise.ar(Decay2.kr(Impulse.kr(rhythm,0,0.04), 0.1, impulse));
env = EnvGen.ar(Env.adsr(),gate,doneAction:2);

sig = (Klank.ar(`[Array.fill(partials, {linrand(bandwith)+freq}),nil,Array.fill(partials, {rrand(0.1,ringtime)})], exc) * 0.35).softclip;
sig = sig * env;
sig = Pan2.ar(sig,pan);
Out.ar(~outL,sig);

}
).add;

SynthDef(\KlankSynth_13, {
arg freq=20, bandwith=8000.0, impulse=0.5, ringtime=2.0, gate=1, pan=0.0, rhythm=1;
var trig, p, exc, x, sig, env, partials=13;
exc = BrownNoise.ar(Decay2.kr(Impulse.kr(rhythm,0,0.04), 0.1, impulse));
env = EnvGen.ar(Env.adsr(),gate,doneAction:2);

sig = (Klank.ar(`[Array.fill(partials, {linrand(bandwith)+freq}),nil,Array.fill(partials, {rrand(0.1,ringtime)})], exc) * 0.35).softclip;
sig = sig * env;
sig = Pan2.ar(sig,pan);
Out.ar(~outL,sig);

}
).add;

SynthDef(\KlankSynth_14, {
arg freq=20, bandwith=8000.0, impulse=0.5, ringtime=2.0, gate=1, pan=0.0, rhythm=1;
var trig, p, exc, x, sig, env, partials=14;
exc = BrownNoise.ar(Decay2.kr(Impulse.kr(rhythm,0,0.04), 0.1, impulse));
env = EnvGen.ar(Env.adsr(),gate,doneAction:2);

sig = (Klank.ar(`[Array.fill(partials, {linrand(bandwith)+freq}),nil,Array.fill(partials, {rrand(0.1,ringtime)})], exc) * 0.35).softclip;
sig = sig * env;
sig = Pan2.ar(sig,pan);
Out.ar(~outL,sig);

}
).add;

SynthDef(\KlankSynth_15, {
arg freq=20, bandwith=8000.0, impulse=0.5, ringtime=2.0, gate=1, pan=0.0, rhythm=1;
var trig, p, exc, x, sig, env, partials=15;
exc = BrownNoise.ar(Decay2.kr(Impulse.kr(rhythm,0,0.04), 0.1, impulse));
env = EnvGen.ar(Env.adsr(),gate,doneAction:2);

sig = (Klank.ar(`[Array.fill(partials, {linrand(bandwith)+freq}),nil,Array.fill(partials, {rrand(0.1,ringtime)})], exc) * 0.35).softclip;
sig = sig * env;
sig = Pan2.ar(sig,pan);
Out.ar(~outL,sig);

}
).add;

SynthDef(\KlankSynth_16, {
arg freq=20, bandwith=8000.0, impulse=0.5, ringtime=2.0, gate=1, pan=0.0, rhythm=1;
var trig, p, exc, x, sig, env, partials=16;
exc = BrownNoise.ar(Decay2.kr(Impulse.kr(rhythm,0,0.04), 0.1, impulse));
env = EnvGen.ar(Env.adsr(),gate,doneAction:2);

sig = (Klank.ar(`[Array.fill(partials, {linrand(bandwith)+freq}),nil,Array.fill(partials, {rrand(0.1,ringtime)})], exc) * 0.35).softclip;
sig = sig * env;
sig = Pan2.ar(sig,pan);
Out.ar(~outL,sig);

}
).add;

OSCdef( \OrganelleAudioLevel,
{
arg msg, time, addr, recvPort;
var peakInL,peakInR,peakOutL,peakOutR;
peakInL = (msg[3] * 11).asInteger;
peakInR = (msg[5] * 11).asInteger;
peakOutL = (msg[7] * 11).asInteger;
peakOutR = (msg[9] * 11).asInteger;

	~motherHost.sendMsg("/oled/vumeter", peakInL,peakInR,peakOutL,peakOutR);
},
"/audioLevel"

);

tl;dr use this snippet. Read on for details.

OSCdef(\OrganelleAudioLevel, { arg msg, time, addr, recvPort;
		var peakInL, peakInR, peakOutL, peakOutR;
		peakInL = (msg[3] * 11).asInteger;
		peakInR = (msg[5] * 11).asInteger;
		peakOutL = (msg[7] * 11).asInteger;
		peakOutR = (msg[9] * 11).asInteger;

		~motherHost.sendMsg("/oled/vumeter", peakInL, peakInR, peakOutL, peakOutR, 1);
	},
	"/audioLevel"
);

I’m a total n00b when it comes to Supercollider, but the snippet above adjusts the OSCdef(\OrganelleAudioLevel with the tip @thetechnobear mentioned farther above.

The key is the 5th argument required by /oled/vumeter. From what I can tell this argument allows the meter to track what the last peak was, I’m cheating and just statically assigning 1 so that the meter at least works. Perhaps in the future I’ll not be so lazy and adjust so that it works as intended and of course post back here.

In general just crack open mother.pd to see the full functionality available for OSC messages.