From 236e3fa711bc08a10367cbdb19a15e5e541e3360 Mon Sep 17 00:00:00 2001
From: Steven Wilson <2165238+mendeni@users.noreply.github.com>
Date: Fri, 16 Jan 2026 08:30:04 -0500
Subject: [PATCH 01/20] Add OSCManager component

---
 CMakeLists.txt                    |  3 ++
 Source/OSCManager.cpp             | 77 +++++++++++++++++++++++++++++++
 Source/OSCManager.h               | 21 +++++++++
 Source/SonobusPluginEditor.cpp    |  2 +-
 Source/SonobusPluginProcessor.cpp | 18 ++++++++
 Source/SonobusPluginProcessor.h   |  4 ++
 6 files changed, 124 insertions(+), 1 deletion(-)
 create mode 100644 Source/OSCManager.cpp
 create mode 100644 Source/OSCManager.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9a7567a5a..a647d02d4 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -280,6 +280,8 @@ function(sono_add_custom_plugin_target target_name product_name formats is_instr
         Source/MonitorDelayView.h
         Source/OptionsView.cpp
         Source/OptionsView.h
+        Source/OSCManager.cpp
+        Source/OSCManager.h
         Source/ParametricEqView.h
         Source/PeersContainerView.cpp
         Source/PeersContainerView.h
@@ -614,6 +616,7 @@ function(sono_add_custom_plugin_target target_name product_name formats is_instr
             juce::juce_dsp
 	    juce::juce_cryptography
             juce::juce_audio_plugin_client
+            juce::juce_osc
             
             ff_meters
             
diff --git a/Source/OSCManager.cpp b/Source/OSCManager.cpp
new file mode 100644
index 000000000..6b50aef5e
--- /dev/null
+++ b/Source/OSCManager.cpp
@@ -0,0 +1,77 @@
+#include "OSCManager.h"
+
+OSCManager::OSCManager()
+{
+    juce::Logger::writeToLog("OSCManager initialized.");
+}
+
+OSCManager::~OSCManager()
+{
+    sender.disconnect();
+    disconnect();
+}
+
+// Initialize Receiver
+bool OSCManager::initializeReceiver(int port)
+{
+    if (!connect(port))
+    {
+        juce::Logger::writeToLog("Receiver failed to connect on port " + juce::String(port));
+        return false;
+    }
+
+    addListener(this, "/volumeControl");
+    juce::Logger::writeToLog("Receiver connected on port " + juce::String(port));
+    return true;
+}
+
+// Initialize Sender
+bool OSCManager::initializeSender(const juce::String& targetIP, int port)
+{
+    senderConnected = sender.connect(targetIP, port);
+    if (!senderConnected)
+    {
+        juce::Logger::writeToLog("Sender failed to connect to " + targetIP + ":" + juce::String(port));
+    }
+    return senderConnected;
+}
+
+// Send Message
+void OSCManager::sendMessage(const juce::String& address, const juce::var& value)
+{
+    if (senderConnected)
+    {
+        if (value.isDouble())
+        {
+            sender.send(address, static_cast<float>(value));  // Convert double to float
+        }
+        else if (value.isInt())
+        {
+            sender.send(address, static_cast<int>(value));
+        }
+        else if (value.isString())
+        {
+            sender.send(address, value.toString());
+        }
+        else
+        {
+            juce::Logger::writeToLog("Unsupported var type in sendMessage for: " + address);
+        }
+    }
+    else
+    {
+        juce::Logger::writeToLog("OSC Sender is not connected! Cannot send message to: " + address);
+    }
+}
+
+// Handle Received Messages
+void OSCManager::oscMessageReceived(const juce::OSCMessage& message)
+{
+    juce::Logger::writeToLog("Incoming OSC message: " + message.getAddressPattern().toString());
+
+    if (message.getAddressPattern().toString() == "/OutGainSlider")
+    {
+      float volume = message[0].getFloat32();
+      mOutGainSlider.setValue(volume);
+    }
+}
diff --git a/Source/OSCManager.h b/Source/OSCManager.h
new file mode 100644
index 000000000..db6d4dcc4
--- /dev/null
+++ b/Source/OSCManager.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <juce_osc/juce_osc.h>
+
+class OSCManager : private juce::OSCReceiver,
+                   private juce::OSCReceiver::ListenerWithOSCAddress<juce::OSCReceiver::MessageLoopCallback>
+{
+public:
+    OSCManager();
+    ~OSCManager();
+
+    bool initializeReceiver(int port);
+    bool initializeSender(const juce::String& targetIP, int port);
+    void sendMessage(const juce::String& address, const juce::var& value);
+
+private:
+    void oscMessageReceived(const juce::OSCMessage& message) override;
+
+    juce::OSCSender sender;
+    bool senderConnected = false;  // Track sender connection state
+};
diff --git a/Source/SonobusPluginEditor.cpp b/Source/SonobusPluginEditor.cpp
index 97f98182e..cbac2574f 100644
--- a/Source/SonobusPluginEditor.cpp
+++ b/Source/SonobusPluginEditor.cpp
@@ -5,6 +5,7 @@
 
 #include "SonobusPluginProcessor.h"
 #include "SonobusPluginEditor.h"
+#include "OSCManager.h"
 
 #include "BeatToggleGrid.h"
 
@@ -6143,4 +6144,3 @@ void SonobusAudioProcessorEditor::SonobusMenuBarModel::menuItemSelected (int men
     }
 #endif
 }
-
diff --git a/Source/SonobusPluginProcessor.cpp b/Source/SonobusPluginProcessor.cpp
index a12a044f5..0a36ea3a8 100644
--- a/Source/SonobusPluginProcessor.cpp
+++ b/Source/SonobusPluginProcessor.cpp
@@ -837,6 +837,24 @@ mState (*this, &mUndoManager, "SonoBusAoO",
     
     initializeAoo();
 
+    // Initialize the OSC receiver
+    const int receivePort = 9000;
+    if (!oscManager.initializeReceiver(receivePort))
+    {
+        juce::Logger::writeToLog("Failed to initialize OSC Receiver.");
+    }
+
+    // Initialize the OSC sender
+    const juce::String targetIPAddress = "10.10.10.10"; // Replace with actual destination
+    const int targetPort = 8000;
+    if (!oscManager.initializeSender(targetIPAddress, targetPort))
+    {
+        juce::Logger::writeToLog("Failed to initialize OSC Sender.");
+    }
+
+    // Example: Send a test message
+    // oscManager.sendMessage("/testMessage", 123);
+
     mFreshInit = false; // need to ensure this before loaddefaultpluginstate
 
     if (isplugin) {
diff --git a/Source/SonobusPluginProcessor.h b/Source/SonobusPluginProcessor.h
index 52065ef31..0c1aae103 100644
--- a/Source/SonobusPluginProcessor.h
+++ b/Source/SonobusPluginProcessor.h
@@ -22,6 +22,8 @@
 
 #include "SoundboardChannelProcessor.h"
 
+#include "OSCManager.h"
+
 typedef MVerb<float> MVerbFloat;
 
 namespace SonoAudio {
@@ -834,6 +836,8 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
 private:
     //==============================================================================
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (SonobusAudioProcessor)
+
+    OSCManager oscManager;
     
     struct PeerStateCache
     {

From 1a0ac4302c3f0bc6df73e554bf37f3fcdb3b9483 Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Fri, 23 Jan 2026 13:12:23 -0500
Subject: [PATCH 02/20] Add generic control registration system for OSC receive
 on selected controls

OSC receive for these controls:
```
/OutGainSlider
/MainMuteButton
/RecvSyncButton
/OptionsMaxRecvPaddingSlider
/OptionsRecStealth
```
---
 Source/OSCManager.cpp             | 40 ++++++++++++--
 Source/OSCManager.h               | 10 ++++
 Source/OptionsView.h              |  2 +
 Source/SonobusPluginEditor.cpp    | 92 +++++++++++++++++++++++++++++++
 Source/SonobusPluginProcessor.cpp | 13 +++--
 Source/SonobusPluginProcessor.h   |  2 +
 6 files changed, 150 insertions(+), 9 deletions(-)

diff --git a/Source/OSCManager.cpp b/Source/OSCManager.cpp
index 6b50aef5e..8e01eccb6 100644
--- a/Source/OSCManager.cpp
+++ b/Source/OSCManager.cpp
@@ -20,6 +20,7 @@ bool OSCManager::initializeReceiver(int port)
         return false;
     }
 
+    // Legacy listener - keeping for backward compatibility
     addListener(this, "/volumeControl");
     juce::Logger::writeToLog("Receiver connected on port " + juce::String(port));
     return true;
@@ -64,14 +65,43 @@ void OSCManager::sendMessage(const juce::String& address, const juce::var& value
     }
 }
 
+// Register Control
+void OSCManager::registerControl(const juce::String& address, ControlCallback callback)
+{
+    controlRegistry[address] = callback;
+    // Also register as a listener for this OSC address pattern
+    addListener(this, address);
+    juce::Logger::writeToLog("Registered control for OSC address: " + address);
+}
+
+// Unregister Control
+void OSCManager::unregisterControl(const juce::String& address)
+{
+    auto it = controlRegistry.find(address);
+    if (it != controlRegistry.end())
+    {
+        controlRegistry.erase(it);
+        // Note: JUCE doesn't provide a way to remove a specific listener,
+        // but the callback will no longer be called since it's removed from the registry
+        juce::Logger::writeToLog("Unregistered control for OSC address: " + address);
+    }
+}
+
 // Handle Received Messages
 void OSCManager::oscMessageReceived(const juce::OSCMessage& message)
 {
-    juce::Logger::writeToLog("Incoming OSC message: " + message.getAddressPattern().toString());
-
-    if (message.getAddressPattern().toString() == "/OutGainSlider")
+    juce::String address = message.getAddressPattern().toString();
+    juce::Logger::writeToLog("Incoming OSC message: " + address);
+    
+    // Check if a callback is registered for this address
+    auto it = controlRegistry.find(address);
+    if (it != controlRegistry.end())
+    {
+        // Call the registered callback
+        it->second(message);
+    }
+    else
     {
-      float volume = message[0].getFloat32();
-      mOutGainSlider.setValue(volume);
+        juce::Logger::writeToLog("No handler registered for OSC address: " + address);
     }
 }
diff --git a/Source/OSCManager.h b/Source/OSCManager.h
index db6d4dcc4..e91137fa1 100644
--- a/Source/OSCManager.h
+++ b/Source/OSCManager.h
@@ -1,6 +1,8 @@
 #pragma once
 
 #include <juce_osc/juce_osc.h>
+#include <functional>
+#include <map>
 
 class OSCManager : private juce::OSCReceiver,
                    private juce::OSCReceiver::ListenerWithOSCAddress<juce::OSCReceiver::MessageLoopCallback>
@@ -12,10 +14,18 @@ class OSCManager : private juce::OSCReceiver,
     bool initializeReceiver(int port);
     bool initializeSender(const juce::String& targetIP, int port);
     void sendMessage(const juce::String& address, const juce::var& value);
+    
+    // Generic control registration
+    using ControlCallback = std::function<void(const juce::OSCMessage&)>;
+    void registerControl(const juce::String& address, ControlCallback callback);
+    void unregisterControl(const juce::String& address);
 
 private:
     void oscMessageReceived(const juce::OSCMessage& message) override;
 
     juce::OSCSender sender;
     bool senderConnected = false;  // Track sender connection state
+    
+    // Control registry for dynamic OSC message handling
+    std::map<juce::String, ControlCallback> controlRegistry;
 };
diff --git a/Source/OptionsView.h b/Source/OptionsView.h
index b1fbdee24..64101c20d 100644
--- a/Source/OptionsView.h
+++ b/Source/OptionsView.h
@@ -68,6 +68,8 @@ public MultiTimer
 
     void showWarnings();
 
+    Slider* getOptionsMaxRecvPaddingSlider() { return mOptionsMaxRecvPaddingSlider.get(); }
+    ToggleButton* getOptionsRecStealth() { return mOptionsRecStealth.get(); }
 
     std::function<AudioDeviceManager*()> getAudioDeviceManager; // = []() { return 0; };
     std::function<Value*()> getShouldOverrideSampleRateValue; // = []() { return 0; };
diff --git a/Source/SonobusPluginEditor.cpp b/Source/SonobusPluginEditor.cpp
index b0868df86..aa2a21a4d 100644
--- a/Source/SonobusPluginEditor.cpp
+++ b/Source/SonobusPluginEditor.cpp
@@ -1366,6 +1366,90 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
     
     processor.addClientListener(this);
     processor.getTransportSource().addChangeListener (this);
+    
+    // Register OSC controls with the OSCManager
+    OSCManager& oscManager = processor.getOSCManager();
+    
+    // Register OutGainSlider - updates slider value with a float
+    oscManager.registerControl("/OutGainSlider", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                if (mOutGainSlider) {
+                    mOutGainSlider->setValue(value, juce::NotificationType::sendNotificationAsync);
+                }
+            });
+        }
+    });
+    
+    // Register MainMuteButton - toggles mute button state with a boolean
+    oscManager.registerControl("/MainMuteButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool muteState = false;
+            if (message[0].isInt32()) {
+                muteState = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                muteState = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, muteState]() {
+                if (mMainMuteButton) {
+                    mMainMuteButton->setToggleState(muteState, juce::NotificationType::sendNotificationAsync);
+                }
+            });
+        }
+    });
+    
+    // Register RecvSyncButton - triggers button click event (accepts only integer 1)
+    oscManager.registerControl("/RecvSyncButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isInt32()) {
+            int value = message[0].getInt32();
+            if (value == 1) {
+                juce::MessageManager::callAsync([this]() {
+                    if (mRecvSyncButton) {
+                        buttonClicked(mRecvSyncButton.get());
+                    }
+                });
+            }
+        }
+    });
+    
+    // Register OptionsMaxRecvPaddingSlider - updates sync receive padding parameter directly
+    oscManager.registerControl("/OptionsMaxRecvPaddingSlider", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                // Set the parameter directly, which updates the processor's internal value
+                // and any UI controls (like the slider in Options view if open)
+                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramMaxRecvPaddingMs)) {
+                    float normalizedValue = param->convertTo0to1(value);
+                    param->setValueNotifyingHost(normalizedValue);
+                }
+            });
+        }
+    });
+    
+    // Register OptionsRecStealth - toggles stealth recording state with a boolean
+    oscManager.registerControl("/OptionsRecStealth", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool stealthState = false;
+            if (message[0].isInt32()) {
+                stealthState = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                stealthState = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, stealthState]() {
+                // Set the processor value directly, which updates internal state
+                // and any UI controls (like the checkbox in Options view if open)
+                processor.setRecordStealth(stealthState);
+                // Also update the UI checkbox if Options view is open
+                if (mOptionsView) {
+                    if (auto* checkbox = mOptionsView->getOptionsRecStealth()) {
+                        checkbox->setToggleState(stealthState, juce::NotificationType::dontSendNotification);
+                    }
+                }
+            });
+        }
+    });
 
     // handles registering commands
     updateUseKeybindings();
@@ -1399,6 +1483,14 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
 
 SonobusAudioProcessorEditor::~SonobusAudioProcessorEditor()
 {
+    // Unregister OSC controls to prevent use-after-free
+    OSCManager& oscManager = processor.getOSCManager();
+    oscManager.unregisterControl("/OutGainSlider");
+    oscManager.unregisterControl("/MainMuteButton");
+    oscManager.unregisterControl("/RecvSyncButton");
+    oscManager.unregisterControl("/OptionsMaxRecvPaddingSlider");
+    oscManager.unregisterControl("/OptionsRecStealth");
+    
     if (menuBarModel) {
         menuBarModel->setApplicationCommandManagerToWatch(nullptr);
 #if JUCE_MAC
diff --git a/Source/SonobusPluginProcessor.cpp b/Source/SonobusPluginProcessor.cpp
index ed756b14a..7f31a889a 100644
--- a/Source/SonobusPluginProcessor.cpp
+++ b/Source/SonobusPluginProcessor.cpp
@@ -843,22 +843,22 @@ mState (*this, &mUndoManager, "SonoBusAoO",
     initializeAoo();
 
     // Initialize the OSC receiver
-    const int receivePort = 9000;
+    const int receivePort = 6000;
     if (!oscManager.initializeReceiver(receivePort))
     {
         juce::Logger::writeToLog("Failed to initialize OSC Receiver.");
     }
 
     // Initialize the OSC sender
-    const juce::String targetIPAddress = "10.10.10.10"; // Replace with actual destination
-    const int targetPort = 8000;
+    const juce::String targetIPAddress = "127.0.0.1"; // Replace with actual destination
+    const int targetPort = 6001;
     if (!oscManager.initializeSender(targetIPAddress, targetPort))
     {
         juce::Logger::writeToLog("Failed to initialize OSC Sender.");
     }
 
     // Example: Send a test message
-    // oscManager.sendMessage("/testMessage", 123);
+    oscManager.sendMessage("/testMessage", 123);
 
     mFreshInit = false; // need to ensure this before loaddefaultpluginstate
 
@@ -8457,6 +8457,11 @@ AudioProcessorValueTreeState& SonobusAudioProcessor::getValueTreeState()
     return mState;
 }
 
+OSCManager& SonobusAudioProcessor::getOSCManager()
+{
+    return oscManager;
+}
+
 ValueTree AooServerConnectionInfo::getValueTree() const
 {
     ValueTree item(recentsItemKey);
diff --git a/Source/SonobusPluginProcessor.h b/Source/SonobusPluginProcessor.h
index 833e93b51..4ce8eee1f 100644
--- a/Source/SonobusPluginProcessor.h
+++ b/Source/SonobusPluginProcessor.h
@@ -236,6 +236,8 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
     bool loadDefaultPluginSettings();
     
     AudioProcessorValueTreeState& getValueTreeState();
+    
+    OSCManager& getOSCManager();
 
     static String paramInGain;
     static String paramInMonitorMonoPan;

From c1bba80a8a838dc0225a6e8b9658b117d4779a42 Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Fri, 23 Jan 2026 22:10:29 -0500
Subject: [PATCH 03/20] Extend OSC functionality with configurable targets,
 outbound messages, and global enable/disable (#15)

* Add OSC configuration storage and UI elements
* Added outbound OSC messages for UI value changes
    mMainMuteButton
    mOutGainSlider
    mRecvSyncButton
    mOptionsRecStealth
---
 Source/OSCManager.cpp             |  15 +++
 Source/OSCManager.h               |   2 +
 Source/OptionsView.cpp            | 155 ++++++++++++++++++++++++++++++
 Source/OptionsView.h              |  13 +++
 Source/SonobusPluginEditor.cpp    |  30 ++++++
 Source/SonobusPluginProcessor.cpp |  88 ++++++++++++++---
 Source/SonobusPluginProcessor.h   |  19 ++++
 7 files changed, 307 insertions(+), 15 deletions(-)

diff --git a/Source/OSCManager.cpp b/Source/OSCManager.cpp
index 8e01eccb6..5e4640e5a 100644
--- a/Source/OSCManager.cpp
+++ b/Source/OSCManager.cpp
@@ -37,6 +37,21 @@ bool OSCManager::initializeSender(const juce::String& targetIP, int port)
     return senderConnected;
 }
 
+// Disconnect Receiver
+void OSCManager::disconnectReceiver()
+{
+    disconnect();
+    juce::Logger::writeToLog("OSC Receiver disconnected.");
+}
+
+// Disconnect Sender
+void OSCManager::disconnectSender()
+{
+    sender.disconnect();
+    senderConnected = false;
+    juce::Logger::writeToLog("OSC Sender disconnected.");
+}
+
 // Send Message
 void OSCManager::sendMessage(const juce::String& address, const juce::var& value)
 {
diff --git a/Source/OSCManager.h b/Source/OSCManager.h
index e91137fa1..19cf21e88 100644
--- a/Source/OSCManager.h
+++ b/Source/OSCManager.h
@@ -13,6 +13,8 @@ class OSCManager : private juce::OSCReceiver,
 
     bool initializeReceiver(int port);
     bool initializeSender(const juce::String& targetIP, int port);
+    void disconnectReceiver();
+    void disconnectSender();
     void sendMessage(const juce::String& address, const juce::var& value);
     
     // Generic control registration
diff --git a/Source/OptionsView.cpp b/Source/OptionsView.cpp
index 75e8062bb..e31d53b1d 100644
--- a/Source/OptionsView.cpp
+++ b/Source/OptionsView.cpp
@@ -367,6 +367,46 @@ OptionsView::OptionsView(SonobusAudioProcessor& proc, std::function<AudioDeviceM
     configLabel(mOptionsMaxRecvPaddingLabel.get(), false);
     mOptionsMaxRecvPaddingLabel->setJustificationType(Justification::centredLeft);
 
+    // OSC Enable toggle
+    mOSCEnabledButton = std::make_unique<ToggleButton>(TRANS("Enable OSC"));
+    mOSCEnabledButton->addListener(this);
+    mOSCEnabledButton->setTooltip(TRANS("Enable or disable OSC (Open Sound Control) functionality"));
+
+    // OSC Configuration UI elements
+    mOSCTargetIPAddressLabel = std::make_unique<Label>("", TRANS("OSC Target IP Address:"));
+    configLabel(mOSCTargetIPAddressLabel.get(), false);
+    mOSCTargetIPAddressLabel->setJustificationType(Justification::centredRight);
+    
+    mOSCTargetIPAddressEditor = std::make_unique<TextEditor>("osctargetip");
+    mOSCTargetIPAddressEditor->addListener(this);
+    mOSCTargetIPAddressEditor->setFont(Font(16 * SonoLookAndFeel::getFontScale()));
+    configEditor(mOSCTargetIPAddressEditor.get());
+    mOSCTargetIPAddressEditor->setTooltip(TRANS("IP address for outbound OSC messages"));
+    
+    mOSCTargetPortLabel = std::make_unique<Label>("", TRANS("OSC Target Port:"));
+    configLabel(mOSCTargetPortLabel.get(), false);
+    mOSCTargetPortLabel->setJustificationType(Justification::centredRight);
+    
+    mOSCTargetPortEditor = std::make_unique<TextEditor>("osctargetport");
+    mOSCTargetPortEditor->addListener(this);
+    mOSCTargetPortEditor->setFont(Font(16 * SonoLookAndFeel::getFontScale()));
+    mOSCTargetPortEditor->setKeyboardType(TextEditor::numericKeyboard);
+    mOSCTargetPortEditor->setInputRestrictions(5, "0123456789");
+    configEditor(mOSCTargetPortEditor.get());
+    mOSCTargetPortEditor->setTooltip(TRANS("Port for outbound OSC messages (1-65535)"));
+    
+    mOSCReceivePortLabel = std::make_unique<Label>("", TRANS("OSC Receive Port:"));
+    configLabel(mOSCReceivePortLabel.get(), false);
+    mOSCReceivePortLabel->setJustificationType(Justification::centredRight);
+    
+    mOSCReceivePortEditor = std::make_unique<TextEditor>("oscrecvport");
+    mOSCReceivePortEditor->addListener(this);
+    mOSCReceivePortEditor->setFont(Font(16 * SonoLookAndFeel::getFontScale()));
+    mOSCReceivePortEditor->setKeyboardType(TextEditor::numericKeyboard);
+    mOSCReceivePortEditor->setInputRestrictions(5, "0123456789");
+    configEditor(mOSCReceivePortEditor.get());
+    mOSCReceivePortEditor->setTooltip(TRANS("Port for receiving OSC messages (1-65535)"));
+
     mOptionsSavePluginDefaultButton = std::make_unique<TextButton>("saveopt");
     mOptionsSavePluginDefaultButton->setButtonText(TRANS("Save as default plugin options"));
     mOptionsSavePluginDefaultButton->setLookAndFeel(&smallLNF);
@@ -407,6 +447,15 @@ OptionsView::OptionsView(SonobusAudioProcessor& proc, std::function<AudioDeviceM
     mOptionsComponent->addAndMakeVisible(mOptionsAutoDropThreshLabel.get());
     mOptionsComponent->addAndMakeVisible(mOptionsMaxRecvPaddingSlider.get());
     mOptionsComponent->addAndMakeVisible(mOptionsMaxRecvPaddingLabel.get());
+    
+    // Add OSC Configuration UI elements
+    mOptionsComponent->addAndMakeVisible(mOSCEnabledButton.get());
+    mOptionsComponent->addAndMakeVisible(mOSCTargetIPAddressLabel.get());
+    mOptionsComponent->addAndMakeVisible(mOSCTargetIPAddressEditor.get());
+    mOptionsComponent->addAndMakeVisible(mOSCTargetPortLabel.get());
+    mOptionsComponent->addAndMakeVisible(mOSCTargetPortEditor.get());
+    mOptionsComponent->addAndMakeVisible(mOSCReceivePortLabel.get());
+    mOptionsComponent->addAndMakeVisible(mOSCReceivePortEditor.get());
 
     if (!JUCEApplication::isStandaloneApp()) {
         mOptionsComponent->addAndMakeVisible(mOptionsSavePluginDefaultButton.get());
@@ -682,6 +731,21 @@ void OptionsView::updateState(bool ignorecheck)
     mOptionsRecFinishOpenButton->setToggleState(processor.getRecordFinishOpens(), dontSendNotification);
     mOptionsRecStealth->setToggleState(processor.getRecordStealth(), dontSendNotification);
 
+    // Update OSC Configuration UI
+    bool oscEnabled = processor.getOSCEnabled();
+    mOSCEnabledButton->setToggleState(oscEnabled, dontSendNotification);
+    mOSCTargetIPAddressEditor->setText(processor.getOSCTargetIPAddress(), dontSendNotification);
+    mOSCTargetPortEditor->setText(String(processor.getOSCTargetPort()), dontSendNotification);
+    mOSCReceivePortEditor->setText(String(processor.getOSCReceivePort()), dontSendNotification);
+    
+    // Enable/disable OSC fields based on OSC enabled state
+    mOSCTargetIPAddressEditor->setEnabled(oscEnabled);
+    mOSCTargetIPAddressEditor->setAlpha(oscEnabled ? 1.0 : 0.6);
+    mOSCTargetPortEditor->setEnabled(oscEnabled);
+    mOSCTargetPortEditor->setAlpha(oscEnabled ? 1.0 : 0.6);
+    mOSCReceivePortEditor->setEnabled(oscEnabled);
+    mOSCReceivePortEditor->setAlpha(oscEnabled ? 1.0 : 0.6);
+
     mRecFormatChoice->setSelectedId((int)processor.getDefaultRecordingFormat(), dontSendNotification);
     mRecBitsChoice->setSelectedId((int)processor.getDefaultRecordingBitsPerSample(), dontSendNotification);
 
@@ -782,6 +846,36 @@ void OptionsView::updateLayout()
     optionsMaxRecvPaddingBox.items.add(FlexItem(42, 12));
     optionsMaxRecvPaddingBox.items.add(FlexItem(100, minitemheight, *mOptionsMaxRecvPaddingSlider).withMargin(0).withFlex(1));
 
+    // OSC Configuration layout
+    optionsOSCEnabledBox.items.clear();
+    optionsOSCEnabledBox.flexDirection = FlexBox::Direction::row;
+    optionsOSCEnabledBox.items.add(FlexItem(10, 12).withFlex(0));
+    optionsOSCEnabledBox.items.add(FlexItem(180, minpassheight, *mOSCEnabledButton).withMargin(0).withFlex(1));
+    
+    optionsOSCTargetIPBox.items.clear();
+    optionsOSCTargetIPBox.flexDirection = FlexBox::Direction::row;
+    optionsOSCTargetIPBox.items.add(FlexItem(10, 12));
+    optionsOSCTargetIPBox.items.add(FlexItem(minButtonWidth, minitemheight, *mOSCTargetIPAddressLabel).withMargin(0).withFlex(0));
+    optionsOSCTargetIPBox.items.add(FlexItem(3, 5));
+    optionsOSCTargetIPBox.items.add(FlexItem(100, minitemheight, *mOSCTargetIPAddressEditor).withMargin(0).withFlex(1));
+    optionsOSCTargetIPBox.items.add(FlexItem(10, 5));
+    
+    optionsOSCTargetPortBox.items.clear();
+    optionsOSCTargetPortBox.flexDirection = FlexBox::Direction::row;
+    optionsOSCTargetPortBox.items.add(FlexItem(10, 12));
+    optionsOSCTargetPortBox.items.add(FlexItem(minButtonWidth, minitemheight, *mOSCTargetPortLabel).withMargin(0).withFlex(0));
+    optionsOSCTargetPortBox.items.add(FlexItem(3, 5));
+    optionsOSCTargetPortBox.items.add(FlexItem(80, minitemheight, *mOSCTargetPortEditor).withMargin(0).withFlex(0.5));
+    optionsOSCTargetPortBox.items.add(FlexItem(10, 5));
+    
+    optionsOSCReceivePortBox.items.clear();
+    optionsOSCReceivePortBox.flexDirection = FlexBox::Direction::row;
+    optionsOSCReceivePortBox.items.add(FlexItem(10, 12));
+    optionsOSCReceivePortBox.items.add(FlexItem(minButtonWidth, minitemheight, *mOSCReceivePortLabel).withMargin(0).withFlex(0));
+    optionsOSCReceivePortBox.items.add(FlexItem(3, 5));
+    optionsOSCReceivePortBox.items.add(FlexItem(80, minitemheight, *mOSCReceivePortEditor).withMargin(0).withFlex(0.5));
+    optionsOSCReceivePortBox.items.add(FlexItem(10, 5));
+
 
     optionsUdpBox.items.clear();
     optionsUdpBox.flexDirection = FlexBox::Direction::row;
@@ -861,6 +955,17 @@ void OptionsView::updateLayout()
     optionsBox.items.add(FlexItem(4, 3));
     optionsBox.items.add(FlexItem(100, minitemheight, optionsMaxRecvPaddingBox).withMargin(2).withFlex(0));
     optionsBox.items.add(FlexItem(4, 10));
+    
+    // Add OSC Configuration boxes
+    optionsBox.items.add(FlexItem(100, minpassheight, optionsOSCEnabledBox).withMargin(2).withFlex(0));
+    optionsBox.items.add(FlexItem(4, 3));
+    optionsBox.items.add(FlexItem(100, minitemheight, optionsOSCTargetIPBox).withMargin(2).withFlex(0));
+    optionsBox.items.add(FlexItem(4, 3));
+    optionsBox.items.add(FlexItem(100, minitemheight, optionsOSCTargetPortBox).withMargin(2).withFlex(0));
+    optionsBox.items.add(FlexItem(4, 3));
+    optionsBox.items.add(FlexItem(100, minitemheight, optionsOSCReceivePortBox).withMargin(2).withFlex(0));
+    optionsBox.items.add(FlexItem(4, 10));
+    
     optionsBox.items.add(FlexItem(100, minitemheight, optionsDefaultLevelBox).withMargin(2).withFlex(0));
     optionsBox.items.add(FlexItem(4, 6));
     optionsBox.items.add(FlexItem(100, minpassheight, optionsInputLimitBox).withMargin(2).withFlex(0));
@@ -1077,6 +1182,27 @@ void OptionsView::textEditorFocusLost (TextEditor& ed)
         int port = mOptionsUdpPortEditor->getText().getIntValue();
         changeUdpPort(port);
     }
+    else if (&ed == mOSCTargetIPAddressEditor.get()) {
+        processor.setOSCTargetIPAddress(mOSCTargetIPAddressEditor->getText());
+    }
+    else if (&ed == mOSCTargetPortEditor.get()) {
+        int port = mOSCTargetPortEditor->getText().getIntValue();
+        // Validate port range (1-65535)
+        if (port < 1 || port > 65535) {
+            port = 6001; // Reset to default
+            mOSCTargetPortEditor->setText(String(port), dontSendNotification);
+        }
+        processor.setOSCTargetPort(port);
+    }
+    else if (&ed == mOSCReceivePortEditor.get()) {
+        int port = mOSCReceivePortEditor->getText().getIntValue();
+        // Validate port range (1-65535)
+        if (port < 1 || port > 65535) {
+            port = 6000; // Reset to default
+            mOSCReceivePortEditor->setText(String(port), dontSendNotification);
+        }
+        processor.setOSCReceivePort(port);
+    }
 }
 
 void OptionsView::changeUdpPort(int port)
@@ -1156,6 +1282,35 @@ void OptionsView::buttonClicked (Button* buttonThatWasClicked)
     }
     else if (buttonThatWasClicked == mOptionsRecStealth.get()) {
         processor.setRecordStealth(mOptionsRecStealth->getToggleState());
+        
+        // Send OSC message for OptionsRecStealth state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OptionsRecStealth", mOptionsRecStealth->getToggleState() ? 1 : 0);
+        }
+    }
+    else if (buttonThatWasClicked == mOSCEnabledButton.get()) {
+        bool enabled = mOSCEnabledButton->getToggleState();
+        processor.setOSCEnabled(enabled);
+        
+        // Update the enabled/disabled state of OSC fields
+        mOSCTargetIPAddressEditor->setEnabled(enabled);
+        mOSCTargetIPAddressEditor->setAlpha(enabled ? 1.0 : 0.6);
+        mOSCTargetPortEditor->setEnabled(enabled);
+        mOSCTargetPortEditor->setAlpha(enabled ? 1.0 : 0.6);
+        mOSCReceivePortEditor->setEnabled(enabled);
+        mOSCReceivePortEditor->setAlpha(enabled ? 1.0 : 0.6);
+    }
+    else if (buttonThatWasClicked == mOSCEnabledButton.get()) {
+        bool enabled = mOSCEnabledButton->getToggleState();
+        processor.setOSCEnabled(enabled);
+        
+        // Update the enabled/disabled state of OSC fields
+        mOSCTargetIPAddressEditor->setEnabled(enabled);
+        mOSCTargetIPAddressEditor->setAlpha(enabled ? 1.0 : 0.6);
+        mOSCTargetPortEditor->setEnabled(enabled);
+        mOSCTargetPortEditor->setAlpha(enabled ? 1.0 : 0.6);
+        mOSCReceivePortEditor->setEnabled(enabled);
+        mOSCReceivePortEditor->setAlpha(enabled ? 1.0 : 0.6);
     }
     else if (buttonThatWasClicked == mOptionsUseSpecificUdpPortButton.get()) {
         if (!mOptionsUseSpecificUdpPortButton->getToggleState()) {
diff --git a/Source/OptionsView.h b/Source/OptionsView.h
index 64101c20d..526f2ca56 100644
--- a/Source/OptionsView.h
+++ b/Source/OptionsView.h
@@ -155,6 +155,15 @@ public MultiTimer
     std::unique_ptr<Label> mOptionsLanguageLabel;
     std::unique_ptr<ToggleButton> mOptionsUnivFontButton;
 
+    // OSC Configuration UI elements
+    std::unique_ptr<ToggleButton> mOSCEnabledButton;
+    std::unique_ptr<Label> mOSCTargetIPAddressLabel;
+    std::unique_ptr<TextEditor> mOSCTargetIPAddressEditor;
+    std::unique_ptr<Label> mOSCTargetPortLabel;
+    std::unique_ptr<TextEditor> mOSCTargetPortEditor;
+    std::unique_ptr<Label> mOSCReceivePortLabel;
+    std::unique_ptr<TextEditor> mOSCReceivePortEditor;
+
 
     std::unique_ptr<Label> mOptionsRecFilesStaticLabel;
     std::unique_ptr<ToggleButton> mOptionsRecMixButton;
@@ -193,6 +202,10 @@ public MultiTimer
     FlexBox optionsAutoDropThreshBox;
     FlexBox optionsMaxRecvPaddingBox;
     FlexBox optionsPluginDefaultBox;
+    FlexBox optionsOSCEnabledBox;
+    FlexBox optionsOSCTargetIPBox;
+    FlexBox optionsOSCTargetPortBox;
+    FlexBox optionsOSCReceivePortBox;
 
     FlexBox recOptionsBox;
     FlexBox optionsRecordFormatBox;
diff --git a/Source/SonobusPluginEditor.cpp b/Source/SonobusPluginEditor.cpp
index aa2a21a4d..4663724e8 100644
--- a/Source/SonobusPluginEditor.cpp
+++ b/Source/SonobusPluginEditor.cpp
@@ -703,6 +703,10 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
     processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramInMonitorMonoPan, this);
     processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramInMonitorPan1, this);
     processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramInMonitorPan2, this);
+    
+    // Add parameter listeners for OSC message sending
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramWet, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramMaxRecvPaddingMs, this);
 
 
     mConnectButton = std::make_unique<SonoTextButton>("directconnect");
@@ -1518,6 +1522,10 @@ SonobusAudioProcessorEditor::~SonobusAudioProcessorEditor()
     processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramInMonitorMonoPan, this);
     processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramInMonitorPan1, this);
     processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramInMonitorPan2, this);
+    
+    // Remove parameter listeners for OSC message sending
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramWet, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramMaxRecvPaddingMs, this);
 
 
     
@@ -2203,6 +2211,11 @@ void SonobusAudioProcessorEditor::buttonClicked (Button* buttonThatWasClicked)
             // set peer jitter buffer to new value
             processor.setRemotePeerBufferTime(j, processor.getRemotePeerBufferTime(j) + deltaMs);
         }
+        
+        // Send OSC message for RecvSyncButton click
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/RecvSyncButton", 1);
+        }
     }
     else if (buttonThatWasClicked == mMainMuteButton.get()) {
         // allow or disallow sending to all peers, handled by button attachment
@@ -2212,6 +2225,11 @@ void SonobusAudioProcessorEditor::buttonClicked (Button* buttonThatWasClicked)
         } else {
             showPopTip(TRANS("Sending your audio to others"), 3000, mMainMuteButton.get());
         }
+        
+        // Send OSC message for MainMuteButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/MainMuteButton", mMainMuteButton->getToggleState() ? 1 : 0);
+        }
     }
     else if (buttonThatWasClicked == mMonDelayButton.get()) {
         if (!monDelayCalloutBox) {
@@ -3940,6 +3958,18 @@ void SonobusAudioProcessorEditor::parameterChanged (const String& pname, float n
         }
         triggerAsyncUpdate();
     }
+    else if (pname == SonobusAudioProcessor::paramWet) {
+        // Send OSC message for OutGainSlider (wet) value change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OutGainSlider", newValue);
+        }
+    }
+    else if (pname == SonobusAudioProcessor::paramMaxRecvPaddingMs) {
+        // Send OSC message for OptionsMaxRecvPaddingSlider value change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OptionsMaxRecvPaddingSlider", newValue);
+        }
+    }
     else if (pname == SonobusAudioProcessor::paramMetEnabled) {
         {
             const ScopedLock sl (clientStateLock);
diff --git a/Source/SonobusPluginProcessor.cpp b/Source/SonobusPluginProcessor.cpp
index 7f31a889a..09dd1fa4b 100644
--- a/Source/SonobusPluginProcessor.cpp
+++ b/Source/SonobusPluginProcessor.cpp
@@ -98,6 +98,10 @@ static String recordStealthKey("RecordStealth");
 static String defRecordDirKey("DefaultRecordDir");
 static String defRecordDirURLKey("DefaultRecordDirURL");
 static String lastBrowseDirKey("LastBrowseDir");
+static String oscEnabledKey("OSCEnabled");
+static String oscTargetIPAddressKey("OSCTargetIPAddress");
+static String oscTargetPortKey("OSCTargetPort");
+static String oscReceivePortKey("OSCReceivePort");
 static String sliderSnapKey("SliderSnapToMouse");
 static String disableShortcutsKey("DisableKeyShortcuts");
 static String peerDisplayModeKey("PeerDisplayMode");
@@ -842,24 +846,21 @@ mState (*this, &mUndoManager, "SonoBusAoO",
     
     initializeAoo();
 
-    // Initialize the OSC receiver
-    const int receivePort = 6000;
-    if (!oscManager.initializeReceiver(receivePort))
-    {
-        juce::Logger::writeToLog("Failed to initialize OSC Receiver.");
-    }
+    // Initialize OSC only if enabled
+    if (mOSCEnabled) {
+        // Initialize the OSC receiver with configurable port
+        if (!oscManager.initializeReceiver(mOSCReceivePort))
+        {
+            juce::Logger::writeToLog("Failed to initialize OSC Receiver on port " + juce::String(mOSCReceivePort));
+        }
 
-    // Initialize the OSC sender
-    const juce::String targetIPAddress = "127.0.0.1"; // Replace with actual destination
-    const int targetPort = 6001;
-    if (!oscManager.initializeSender(targetIPAddress, targetPort))
-    {
-        juce::Logger::writeToLog("Failed to initialize OSC Sender.");
+        // Initialize the OSC sender with configurable target
+        if (!oscManager.initializeSender(mOSCTargetIPAddress, mOSCTargetPort))
+        {
+            juce::Logger::writeToLog("Failed to initialize OSC Sender to " + mOSCTargetIPAddress + ":" + juce::String(mOSCTargetPort));
+        }
     }
 
-    // Example: Send a test message
-    oscManager.sendMessage("/testMessage", 123);
-
     mFreshInit = false; // need to ensure this before loaddefaultpluginstate
 
     if (isplugin) {
@@ -8462,6 +8463,45 @@ OSCManager& SonobusAudioProcessor::getOSCManager()
     return oscManager;
 }
 
+void SonobusAudioProcessor::setOSCEnabled(bool enabled)
+{
+    mOSCEnabled = enabled;
+    
+    if (enabled) {
+        // Initialize OSC when enabled
+        oscManager.initializeReceiver(mOSCReceivePort);
+        oscManager.initializeSender(mOSCTargetIPAddress, mOSCTargetPort);
+    } else {
+        // Disconnect OSC when disabled
+        oscManager.disconnectReceiver();
+        oscManager.disconnectSender();
+    }
+}
+
+void SonobusAudioProcessor::setOSCTargetIPAddress(const String& ipAddress)
+{
+    mOSCTargetIPAddress = ipAddress;
+    if (mOSCEnabled) {
+        oscManager.initializeSender(mOSCTargetIPAddress, mOSCTargetPort);
+    }
+}
+
+void SonobusAudioProcessor::setOSCTargetPort(int port)
+{
+    mOSCTargetPort = port;
+    if (mOSCEnabled) {
+        oscManager.initializeSender(mOSCTargetIPAddress, mOSCTargetPort);
+    }
+}
+
+void SonobusAudioProcessor::setOSCReceivePort(int port)
+{
+    mOSCReceivePort = port;
+    if (mOSCEnabled) {
+        oscManager.initializeReceiver(mOSCReceivePort);
+    }
+}
+
 ValueTree AooServerConnectionInfo::getValueTree() const
 {
     ValueTree item(recentsItemKey);
@@ -8568,6 +8608,12 @@ void SonobusAudioProcessor::getStateInformationWithOptions(MemoryBlock& destData
     }
     extraTree.setProperty(defRecordDirURLKey, mDefaultRecordDir.toString(false), nullptr);
 
+    // OSC Configuration
+    extraTree.setProperty(oscEnabledKey, mOSCEnabled, nullptr);
+    extraTree.setProperty(oscTargetIPAddressKey, mOSCTargetIPAddress, nullptr);
+    extraTree.setProperty(oscTargetPortKey, mOSCTargetPort, nullptr);
+    extraTree.setProperty(oscReceivePortKey, mOSCReceivePort, nullptr);
+
     extraTree.setProperty(lastBrowseDirKey, mLastBrowseDir, nullptr);
     extraTree.setProperty(sliderSnapKey, mSliderSnapToMouse, nullptr);
     extraTree.setProperty(disableShortcutsKey, mDisableKeyboardShortcuts, nullptr);
@@ -8710,6 +8756,18 @@ void SonobusAudioProcessor::setStateInformationWithOptions (const void* data, in
 
             setRecordFinishOpens(extraTree.getProperty(recordFinishOpenKey, mRecordFinishOpens));
             setRecordStealth(extraTree.getProperty(recordStealthKey, mRecordStealth));
+            
+            // OSC Configuration
+            mOSCEnabled = extraTree.getProperty(oscEnabledKey, mOSCEnabled);
+            mOSCTargetIPAddress = extraTree.getProperty(oscTargetIPAddressKey, mOSCTargetIPAddress);
+            mOSCTargetPort = extraTree.getProperty(oscTargetPortKey, mOSCTargetPort);
+            mOSCReceivePort = extraTree.getProperty(oscReceivePortKey, mOSCReceivePort);
+            
+            // Reinitialize OSC with loaded settings if enabled
+            if (mOSCEnabled) {
+                oscManager.initializeSender(mOSCTargetIPAddress, mOSCTargetPort);
+                oscManager.initializeReceiver(mOSCReceivePort);
+            }
 
 
 #if !(JUCE_IOS)
diff --git a/Source/SonobusPluginProcessor.h b/Source/SonobusPluginProcessor.h
index 4ce8eee1f..643eca5ec 100644
--- a/Source/SonobusPluginProcessor.h
+++ b/Source/SonobusPluginProcessor.h
@@ -783,6 +783,19 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
     bool getReconnectAfterServerLoss() const { return mReconnectAfterServerLoss.get(); }
     void setReconnectAfterServerLoss(bool flag) { mReconnectAfterServerLoss = flag; }
 
+    // OSC Configuration
+    bool getOSCEnabled() const { return mOSCEnabled; }
+    void setOSCEnabled(bool enabled);
+    
+    String getOSCTargetIPAddress() const { return mOSCTargetIPAddress; }
+    void setOSCTargetIPAddress(const String& ipAddress);
+    
+    int getOSCTargetPort() const { return mOSCTargetPort; }
+    void setOSCTargetPort(int port);
+    
+    int getOSCReceivePort() const { return mOSCReceivePort; }
+    void setOSCReceivePort(int port);
+
 
     PeerDisplayMode getPeerDisplayMode() const { return mPeerDisplayMode; }
     void setPeerDisplayMode(PeerDisplayMode mode) { mPeerDisplayMode = mode; }
@@ -1231,6 +1244,12 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
     bool mRecordFinishOpens = true;
     bool mRecordStealth = false;
     URL mDefaultRecordDir;
+    
+    // OSC Configuration
+    bool mOSCEnabled = false;  // OSC disabled by default
+    String mOSCTargetIPAddress = "127.0.0.1";
+    int mOSCTargetPort = 6001;
+    int mOSCReceivePort = 6000;
     String mLastError;
     int mSelfRecordChannels = 2;
     int mActiveInputChannels = 2;

From ecafd171a5ff161b73624566b0e3e9b470f58875 Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Sat, 24 Jan 2026 23:11:04 -0500
Subject: [PATCH 04/20] Add OSC support for remaining UI controls (main,
 options, recording tabs, nested controls, and comprehensive dynamic Input
 Group controls) (#16)

---
 Source/ChannelGroupsView.cpp   |  112 ++
 Source/ChannelGroupsView.h     |   11 +
 Source/MonitorDelayView.h      |   20 +
 Source/OptionsView.cpp         |   78 ++
 Source/OptionsView.h           |   30 +
 Source/SonobusPluginEditor.cpp | 2247 ++++++++++++++++++++++++++++++--
 doc/OSC_COMMANDS.md            |  872 +++++++++++++
 tests/oscsend.sh               |  230 ++++
 tests/oscsend_comprehensive.sh |  477 +++++++
 9 files changed, 3960 insertions(+), 117 deletions(-)
 create mode 100644 doc/OSC_COMMANDS.md
 create mode 100755 tests/oscsend.sh
 create mode 100755 tests/oscsend_comprehensive.sh

diff --git a/Source/ChannelGroupsView.cpp b/Source/ChannelGroupsView.cpp
index 5a7bd6172..116f097a3 100644
--- a/Source/ChannelGroupsView.cpp
+++ b/Source/ChannelGroupsView.cpp
@@ -264,6 +264,15 @@ void ChannelGroupEffectsView::compressorParamsChanged(CompressorView *comp, Sono
         if (wason != ison) {
             listeners.call (&ChannelGroupEffectsView::Listener::effectsEnableChanged, this);
         }
+        
+        // Send OSC updates for compressor parameters
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "CompressorEnable", params.enabled ? 1.0f : 0.0f);
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "CompressorThreshold", params.thresholdDb);
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "CompressorRatio", params.ratio);
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "CompressorAttack", params.attackMs);
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "CompressorRelease", params.releaseMs);
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "CompressorMakeupGain", params.makeupGainDb);
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "CompressorAuto", params.automakeupGain ? 1.0f : 0.0f);
     }
 
 }
@@ -289,6 +298,13 @@ void ChannelGroupEffectsView::expanderParamsChanged(ExpanderView *comp, SonoAudi
         if (wason != ison) {
             listeners.call (&ChannelGroupEffectsView::Listener::effectsEnableChanged, this);
         }
+        
+        // Send OSC updates for expander (noise gate) parameters
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "ExpanderEnable", params.enabled ? 1.0f : 0.0f);
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "ExpanderNoiseFloor", params.thresholdDb);
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "ExpanderRatio", params.ratio);
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "ExpanderAttack", params.attackMs);
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "ExpanderRelease", params.releaseMs);
     }
 }
 
@@ -312,6 +328,19 @@ void ChannelGroupEffectsView::parametricEqParamsChanged(ParametricEqView *comp,
         if (wason != ison) {
             listeners.call (&ChannelGroupEffectsView::Listener::effectsEnableChanged, this);
         }
+        
+        // Send OSC updates for EQ parameters
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "EqEnable", params.enabled ? 1.0f : 0.0f);
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "EqLowShelfFreq", params.lowShelfFreq);
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "EqLowShelfGain", params.lowShelfGain);
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "EqPara1Freq", params.para1Freq);
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "EqPara1Gain", params.para1Gain);
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "EqPara1Q", params.para1Q);
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "EqHighShelfFreq", params.highShelfFreq);
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "EqHighShelfGain", params.highShelfGain);
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "EqPara2Freq", params.para2Freq);
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "EqPara2Gain", params.para2Gain);
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "EqPara2Q", params.para2Q);
     }
 }
 
@@ -337,6 +366,9 @@ void ChannelGroupEffectsView::reverbSendLevelChanged(ReverbSendView *comp, float
         if (wason != ison) {
             listeners.call (&ChannelGroupEffectsView::Listener::effectsEnableChanged, this);
         }
+        
+        // Send OSC update for input reverb send
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "InputReverbSend", revlevel);
     }
 }
 
@@ -348,6 +380,9 @@ void ChannelGroupEffectsView::polarityInvertChanged(PolarityInvertView *comp, bo
     else {
         // input mode
         processor.setInputPolarityInvert(groupIndex, polinv);
+        
+        // Send OSC update for polarity invert
+        processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "PolarityInvert", polinv ? 1.0f : 0.0f);
     }
     listeners.call (&ChannelGroupEffectsView::Listener::effectsEnableChanged, this);
 }
@@ -503,6 +538,9 @@ void ChannelGroupMonitorEffectsView::updateStateForInput()
 {
     DelayParams monDelayParams;
 
+    // Set the group index for OSC addressing
+    delayView->setGroupIndex(groupIndex);
+
     if (groupIndex == -1) {
         // met
         if (processor.getMetronomeMonitorDelayParams(monDelayParams)) {
@@ -612,6 +650,11 @@ void ChannelGroupMonitorEffectsView::reverbSendLevelChanged(ReverbSendView *comp
         if (wason != ison) {
             listeners.call (&ChannelGroupMonitorEffectsView::Listener::monitorEffectsEnableChanged, this);
         }
+        
+        // Send OSC message for Input Group Mon Reverb Send change
+        if (groupIndex >= 0 && processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "MonReverbSend", revlevel);
+        }
     }
 }
 
@@ -652,6 +695,12 @@ void ChannelGroupMonitorEffectsView::monitorDelayParamsChanged(MonitorDelayView
         } else {
             wason = processor.getInputMonitorEffectsActive(groupIndex);
             processor.setInputMonitorDelayParams(groupIndex, params);
+            
+            // Send OSC messages for Input Group Mon Delay parameters
+            if (groupIndex >= 0 && processor.getOSCEnabled()) {
+                processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "MonDelayEnable", params.enabled ? 1.0f : 0.0f);
+                processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "MonDelayTime", params.delayTimeMs);
+            }
         }
 
         if (processor.getLinkMonitoringDelayTimes()) {
@@ -682,6 +731,16 @@ void ChannelGroupMonitorEffectsView::monitorDelayParamsChanged(MonitorDelayView
                 eparam.delayTimeMs = deltimems;
                 processor.getSoundboardProcessor()->setMonitorDelayParams(eparam);
             }
+            
+            // Send OSC message for Link Delay Time (global setting)
+            if (processor.getOSCEnabled()) {
+                processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "MonDelayLink", 1.0f);
+            }
+        } else {
+            // Send OSC message for Link Delay Time being disabled
+            if (groupIndex >= 0 && processor.getOSCEnabled()) {
+                processor.getOSCManager().sendMessage("/InputGroup" + String(groupIndex + 1) + "MonDelayLink", 0.0f);
+            }
         }
 
         if (wason != ison) {
@@ -961,6 +1020,10 @@ ChannelGroupsView::ChannelGroupsView(SonobusAudioProcessor& proc, bool peerMode,
         } else {
             showInputReverbView(false);
         }
+        // Send OSC message for InReverbButton click
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/InReverbButton", 1);
+        }
     };
 
     mMonDelayButton = std::make_unique<TextButton>(TRANS("Monitor Delay"));
@@ -969,6 +1032,10 @@ ChannelGroupsView::ChannelGroupsView(SonobusAudioProcessor& proc, bool peerMode,
     addChildComponent(mMonDelayButton.get());
     mMonDelayButton->onClick = [this]() {
         toggleAllMonitorDelay();
+        // Send OSC message for MonDelayButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/MonDelayButton", mMonDelayButton->getToggleState() ? 1 : 0);
+        }
     };
 
 
@@ -1688,10 +1755,18 @@ void ChannelGroupsView::rebuildChannelViews(bool notify)
 
             mMetChannelView->panSlider->onValueChange = [this]() {
                 processor.setMetronomePan(mMetChannelView->panSlider->getValue());
+                // Send OSC message for MetPanSlider value change
+                if (processor.getOSCEnabled()) {
+                    processor.getOSCManager().sendMessage("/MetPanSlider", static_cast<float>(mMetChannelView->panSlider->getValue()));
+                }
             };
 
             mMetChannelView->monitorSlider->onValueChange = [this]() {
                 processor.setMetronomeMonitor(mMetChannelView->monitorSlider->getValue());
+                // Send OSC message for MetMonitorSlider value change
+                if (processor.getOSCEnabled()) {
+                    processor.getOSCManager().sendMessage("/MetMonitorSlider", static_cast<float>(mMetChannelView->monitorSlider->getValue()));
+                }
             };
 
             setupChildren(mMetChannelView.get());
@@ -1761,6 +1836,10 @@ void ChannelGroupsView::rebuildChannelViews(bool notify)
 
             mFileChannelView->levelSlider->onValueChange = [this]() {
                 processor.setFilePlaybackGain(mFileChannelView->levelSlider->getValue());
+                // Send OSC message for File Playback Pre Level change
+                if (processor.getOSCEnabled()) {
+                    processor.getOSCManager().sendMessage("/FilePlaybackPreLevel", static_cast<float>(mFileChannelView->levelSlider->getValue()));
+                }
             };
 
             //mFileChannelView->panSlider->onValueChange = [this]() {
@@ -1769,6 +1848,10 @@ void ChannelGroupsView::rebuildChannelViews(bool notify)
 
             mFileChannelView->monitorSlider->onValueChange = [this]() {
                 processor.setFilePlaybackMonitor(mFileChannelView->monitorSlider->getValue());
+                // Send OSC message for FileMonitorSlider value change
+                if (processor.getOSCEnabled()) {
+                    processor.getOSCManager().sendMessage("/FileMonitorSlider", static_cast<float>(mFileChannelView->monitorSlider->getValue()));
+                }
             };
 
             setupChildren(mFileChannelView.get());
@@ -1823,6 +1906,10 @@ void ChannelGroupsView::rebuildChannelViews(bool notify)
 
             mSoundboardChannelView->levelSlider->onValueChange = [this]() {
                 processor.getSoundboardProcessor()->setGain(mSoundboardChannelView->levelSlider->getValue());
+                // Send OSC message for SoundboardLevelSlider value change
+                if (processor.getOSCEnabled()) {
+                    processor.getOSCManager().sendMessage("/SoundboardLevelSlider", static_cast<float>(mSoundboardChannelView->levelSlider->getValue()));
+                }
             };
 
             //mSoundboardChannelView->panSlider->onValueChange = [this]() {
@@ -1831,6 +1918,10 @@ void ChannelGroupsView::rebuildChannelViews(bool notify)
 
             mSoundboardChannelView->monitorSlider->onValueChange = [this]() {
                 processor.getSoundboardProcessor()->setMonitorGain(mSoundboardChannelView->monitorSlider->getValue());
+                // Send OSC message for SoundboardMonitorSlider value change
+                if (processor.getOSCEnabled()) {
+                    processor.getOSCManager().sendMessage("/SoundboardMonitorSlider", static_cast<float>(mSoundboardChannelView->monitorSlider->getValue()));
+                }
             };
 
             setupChildren(mSoundboardChannelView.get());
@@ -3521,6 +3612,7 @@ void ChannelGroupsView::buttonClicked (Button* buttonThatWasClicked)
 
             if (pvf->muteButton.get() == buttonThatWasClicked) {
                 processor.setInputGroupMuted(changroup, buttonThatWasClicked->getToggleState());
+                processor.getOSCManager().sendMessage("/InputGroup" + String(changroup + 1) + "Mute", buttonThatWasClicked->getToggleState() ? 1.0f : 0.0f);
                 updateChannelViews();
                 break;
             }
@@ -3554,6 +3646,8 @@ void ChannelGroupsView::buttonClicked (Button* buttonThatWasClicked)
                         else {
                             processor.setInputGroupSoloed(j, false);
                         }
+                        // Send OSC for each group
+                        processor.getOSCManager().sendMessage("/InputGroup" + String(j + 1) + "Solo", (newsolo && changroup == j) ? 1.0f : 0.0f);
                     }
 
                     // change solo for main monitor too
@@ -3563,6 +3657,7 @@ void ChannelGroupsView::buttonClicked (Button* buttonThatWasClicked)
                 } else {
                     bool newsolo = buttonThatWasClicked->getToggleState();
                     processor.setInputGroupSoloed (changroup, newsolo);
+                    processor.getOSCManager().sendMessage("/InputGroup" + String(changroup + 1) + "Solo", newsolo ? 1.0f : 0.0f);
 
                     //if (newsolo) {
                        // only enable main in solo
@@ -4815,10 +4910,18 @@ void ChannelGroupsView::sliderValueChanged (Slider* slider)
 
             if (pvf->levelSlider.get() == slider) {
                 processor.setInputGroupGain(changroup, pvf->levelSlider->getValue());
+                // Send OSC message for Input Group Pre Level change
+                if (processor.getOSCEnabled()) {
+                    processor.getOSCManager().sendMessage("/InputGroup" + String(changroup + 1) + "PreLevel", static_cast<float>(pvf->levelSlider->getValue()));
+                }
                 break;
             }
             else if (pvf->monitorSlider.get() == slider) {
                 processor.setInputMonitor(changroup, pvf->monitorSlider->getValue());
+                // Send OSC message for Input Group Monitor change
+                if (processor.getOSCEnabled()) {
+                    processor.getOSCManager().sendMessage("/InputGroup" + String(changroup + 1) + "Monitor", static_cast<float>(pvf->monitorSlider->getValue()));
+                }
                 break;
             }
             else if (pvf->panSlider.get() == slider) {
@@ -4827,9 +4930,18 @@ void ChannelGroupsView::sliderValueChanged (Slider* slider)
                     float pan2 = pvf->panSlider->getMaxValue();
                     processor.setInputChannelPan(changroup, 0, pan1);
                     processor.setInputChannelPan(changroup, 1, pan2);
+                    // Send OSC message for Input Group Pan (dual channel)
+                    if (processor.getOSCEnabled()) {
+                        processor.getOSCManager().sendMessage("/InputGroup" + String(changroup + 1) + "PanLeft", pan1);
+                        processor.getOSCManager().sendMessage("/InputGroup" + String(changroup + 1) + "PanRight", pan2);
+                    }
                 }
                 else {
                     processor.setInputChannelPan(changroup, chi, pvf->panSlider->getValue());
+                    // Send OSC message for Input Group Pan (single channel)
+                    if (processor.getOSCEnabled()) {
+                        processor.getOSCManager().sendMessage("/InputGroup" + String(changroup + 1) + "Pan", static_cast<float>(pvf->panSlider->getValue()));
+                    }
                 }
                 break;
             }
diff --git a/Source/ChannelGroupsView.h b/Source/ChannelGroupsView.h
index f3fe3bb3a..bed6d2d50 100644
--- a/Source/ChannelGroupsView.h
+++ b/Source/ChannelGroupsView.h
@@ -143,6 +143,10 @@ public EffectsBaseView::HeaderListener
 
     void effectsHeaderClicked(EffectsBaseView *comp) override;
 
+    // Public accessors for OSC control
+    MonitorDelayView* getDelayView() { return delayView.get(); }
+    ReverbSendView* getReverbSendView() { return reverbSendView.get(); }
+
 
     int  groupIndex = 0;
     bool peerMode = false;
@@ -373,6 +377,13 @@ public MultiTimer
     void applyToAllSliders(std::function<void(Slider *)> & routine);
 
     void updateLayout(bool notify=true);
+    
+    // Getters for OSC access to nested controls
+    ChannelGroupView* getFileChannelView() { return mFileChannelView.get(); }
+    ChannelGroupView* getSoundboardChannelView() { return mSoundboardChannelView.get(); }
+    ChannelGroupView* getMetChannelView() { return mMetChannelView.get(); }
+    TextButton* getInReverbButton() { return mInReverbButton.get(); }
+    TextButton* getMonDelayButton() { return mMonDelayButton.get(); }
 
 
     std::function<AudioDeviceManager*()> getAudioDeviceManager; // = []() { return 0; };
diff --git a/Source/MonitorDelayView.h b/Source/MonitorDelayView.h
index cb284594c..ab91cf3f5 100644
--- a/Source/MonitorDelayView.h
+++ b/Source/MonitorDelayView.h
@@ -55,6 +55,11 @@ class MonitorDelayView    : public EffectsBaseView,
         linkButton.setButtonText(TRANS("Link Delay Time with other inputs"));
         linkButton.onClick = [this]() {
             processor.setLinkMonitoringDelayTimes(linkButton.getToggleState());
+            
+            // Send OSC message for link button state change (only for input groups >= 0)
+            if (processor.getOSCEnabled() && mGroupIndex >= 0) {
+                processor.getOSCManager().sendMessage("/InputGroup" + String(mGroupIndex + 1) + "MonDelayLink", linkButton.getToggleState() ? 1.0f : 0.0f);
+            }
         };
 
         // these are in the header component
@@ -189,6 +194,11 @@ class MonitorDelayView    : public EffectsBaseView,
         if (buttonThatWasClicked == &enableButton) {
             mParams.enabled = enableButton.getToggleState();
             headerComponent.repaint();
+            
+            // Send OSC message for enable button state change (only for input groups >= 0)
+            if (processor.getOSCEnabled() && mGroupIndex >= 0) {
+                processor.getOSCManager().sendMessage("/InputGroup" + String(mGroupIndex + 1) + "MonDelayEnable", mParams.enabled ? 1.0f : 0.0f);
+            }
         }
         else if (buttonThatWasClicked == &autoButton) {
             auto autoScalar = autoModeChoice.getSelectedItemIndex() == 1 ? 2.0f : 1.0f;
@@ -206,6 +216,11 @@ class MonitorDelayView    : public EffectsBaseView,
         mParams.enabled = !enableButton.getToggleState();
         //processor.setMonitoringDelayActive(!enableButton.getToggleState());
         updateParams(mParams);
+        
+        // Send OSC message for enable button state change (only for input groups >= 0)
+        if (processor.getOSCEnabled() && mGroupIndex >= 0) {
+            processor.getOSCManager().sendMessage("/InputGroup" + String(mGroupIndex + 1) + "MonDelayEnable", mParams.enabled ? 1.0f : 0.0f);
+        }
 
         listeners.call (&MonitorDelayView::Listener::monitorDelayParamsChanged, this, mParams);
     }
@@ -249,6 +264,10 @@ class MonitorDelayView    : public EffectsBaseView,
         headerComponent.repaint();
     }
 
+    // Setter for group index (needed for OSC addressing)
+    void setGroupIndex(int index) { mGroupIndex = index; }
+    int getGroupIndex() const { return mGroupIndex; }
+
     
 private:
     
@@ -274,6 +293,7 @@ class MonitorDelayView    : public EffectsBaseView,
     FlexBox infoBox;
 
     SonoAudio::DelayParams mParams;
+    int mGroupIndex = 0;  // Group index for OSC addressing
 
 
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MonitorDelayView)
diff --git a/Source/OptionsView.cpp b/Source/OptionsView.cpp
index e31d53b1d..9765b8521 100644
--- a/Source/OptionsView.cpp
+++ b/Source/OptionsView.cpp
@@ -334,6 +334,11 @@ OptionsView::OptionsView(SonobusAudioProcessor& proc, std::function<AudioDeviceM
     mOptionsAutoDropThreshSlider->onValueChange = [this]() {
         auto thresh = 1.0 / jmax(1.0, mOptionsAutoDropThreshSlider->getValue());
         processor.setAutoresizeBufferDropRateThreshold(thresh);
+        
+        // Send OSC message for OptionsAutoDropThreshSlider value change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OptionsAutoDropThreshSlider", static_cast<float>(mOptionsAutoDropThreshSlider->getValue()));
+        }
     };
 
     mOptionsAutoDropThreshSlider->setTooltip(TRANS("This controls how sensitive the auto-jitter buffer adjustment is when there are audio dropouts. The jitter buffer size will be increased if there are any dropouts within the number of seconds specified here. When this value is smaller it will be less likely to increase the jitter buffer size automatically."));
@@ -1184,6 +1189,11 @@ void OptionsView::textEditorFocusLost (TextEditor& ed)
     }
     else if (&ed == mOSCTargetIPAddressEditor.get()) {
         processor.setOSCTargetIPAddress(mOSCTargetIPAddressEditor->getText());
+        
+        // Send OSC message for OSCTargetIPAddress change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OSCTargetIPAddress", mOSCTargetIPAddressEditor->getText());
+        }
     }
     else if (&ed == mOSCTargetPortEditor.get()) {
         int port = mOSCTargetPortEditor->getText().getIntValue();
@@ -1193,6 +1203,11 @@ void OptionsView::textEditorFocusLost (TextEditor& ed)
             mOSCTargetPortEditor->setText(String(port), dontSendNotification);
         }
         processor.setOSCTargetPort(port);
+        
+        // Send OSC message for OSCTargetPort change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OSCTargetPort", port);
+        }
     }
     else if (&ed == mOSCReceivePortEditor.get()) {
         int port = mOSCReceivePortEditor->getText().getIntValue();
@@ -1202,6 +1217,11 @@ void OptionsView::textEditorFocusLost (TextEditor& ed)
             mOSCReceivePortEditor->setText(String(port), dontSendNotification);
         }
         processor.setOSCReceivePort(port);
+        
+        // Send OSC message for OSCReceivePort change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OSCReceivePort", port);
+        }
     }
 }
 
@@ -1212,6 +1232,11 @@ void OptionsView::changeUdpPort(int port)
         processor.setUseSpecificUdpPort(port);
 
         //updateState();
+        
+        // Send OSC message for OptionsUdpPortEditor change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OptionsUdpPortEditor", port);
+        }
     }
     updateState(true);
 
@@ -1248,6 +1273,11 @@ void OptionsView::buttonClicked (Button* buttonThatWasClicked)
             params.enabled = mOptionsInputLimiterButton->getToggleState();
             processor.setInputLimiterParams(j, params);
         }
+        
+        // Send OSC message for OptionsInputLimiterButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OptionsInputLimiterButton", mOptionsInputLimiterButton->getToggleState() ? 1 : 0);
+        }
     }
     else if (buttonThatWasClicked == mOptionsRecMixButton.get()
              || buttonThatWasClicked == mOptionsRecSelfButton.get()
@@ -1267,15 +1297,38 @@ void OptionsView::buttonClicked (Button* buttonThatWasClicked)
         }
 
         processor.setDefaultRecordingOptions(recmask);
+        
+        // Send OSC messages for recording button state changes
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OptionsRecMixButton", mOptionsRecMixButton->getToggleState() ? 1 : 0);
+            processor.getOSCManager().sendMessage("/OptionsRecSelfButton", mOptionsRecSelfButton->getToggleState() ? 1 : 0);
+            processor.getOSCManager().sendMessage("/OptionsRecOthersButton", mOptionsRecOthersButton->getToggleState() ? 1 : 0);
+            processor.getOSCManager().sendMessage("/OptionsRecMixMinusButton", mOptionsRecMixMinusButton->getToggleState() ? 1 : 0);
+        }
     }
     else if (buttonThatWasClicked == mOptionsChangeAllFormatButton.get()) {
         processor.setChangingDefaultAudioCodecSetsExisting(mOptionsChangeAllFormatButton->getToggleState());
+        
+        // Send OSC message for OptionsChangeAllFormatButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OptionsChangeAllFormatButton", mOptionsChangeAllFormatButton->getToggleState() ? 1 : 0);
+        }
     }
     else if (buttonThatWasClicked == mOptionsRecSelfPostFxButton.get()) {
         processor.setSelfRecordingPreFX(!mOptionsRecSelfPostFxButton->getToggleState());
+        
+        // Send OSC message for OptionsRecSelfPostFxButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OptionsRecSelfPostFxButton", mOptionsRecSelfPostFxButton->getToggleState() ? 1 : 0);
+        }
     }
     else if (buttonThatWasClicked == mOptionsRecSelfSilenceMutedButton.get()) {
         processor.setSelfRecordingSilenceWhenMuted(mOptionsRecSelfSilenceMutedButton->getToggleState());
+        
+        // Send OSC message for OptionsRecSelfSilenceMutedButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OptionsRecSelfSilenceMutedButton", mOptionsRecSelfSilenceMutedButton->getToggleState() ? 1 : 0);
+        }
     }
     else if (buttonThatWasClicked == mOptionsRecFinishOpenButton.get()) {
         processor.setRecordFinishOpens(mOptionsRecFinishOpenButton->getToggleState());
@@ -1319,6 +1372,11 @@ void OptionsView::buttonClicked (Button* buttonThatWasClicked)
         } else {
             updateState(true);
         }
+        
+        // Send OSC message for OptionsUseSpecificUdpPortButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OptionsUseSpecificUdpPortButton", mOptionsUseSpecificUdpPortButton->getToggleState() ? 1 : 0);
+        }
     }
     else if (buttonThatWasClicked == mOptionsOverrideSamplerateButton.get()) {
 
@@ -1326,6 +1384,11 @@ void OptionsView::buttonClicked (Button* buttonThatWasClicked)
             Value * val = getShouldOverrideSampleRateValue();
             val->setValue((bool)mOptionsOverrideSamplerateButton->getToggleState());
         }
+        
+        // Send OSC message for OptionsOverrideSamplerateButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OptionsOverrideSamplerateButton", mOptionsOverrideSamplerateButton->getToggleState() ? 1 : 0);
+        }
     }
     else if (buttonThatWasClicked == mOptionsAllowBluetoothInput.get()) {
 
@@ -1350,6 +1413,11 @@ void OptionsView::buttonClicked (Button* buttonThatWasClicked)
             //    startTimer(CheckForNewVersionTimerId, 3000);
             //}
         }
+        
+        // Send OSC message for OptionsShouldCheckForUpdateButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OptionsShouldCheckForUpdateButton", mOptionsShouldCheckForUpdateButton->getToggleState() ? 1 : 0);
+        }
     }
     else if (buttonThatWasClicked == mOptionsSliderSnapToMouseButton.get()) {
         bool newval = mOptionsSliderSnapToMouseButton->getToggleState();
@@ -1360,6 +1428,11 @@ void OptionsView::buttonClicked (Button* buttonThatWasClicked)
         if (updateSliderSnap) {
             updateSliderSnap();
         }
+        
+        // Send OSC message for OptionsSliderSnapToMouseButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OptionsSliderSnapToMouseButton", newval ? 1 : 0);
+        }
     }
     else if (buttonThatWasClicked == mOptionsDisableShortcutButton.get()) {
         bool newval = mOptionsDisableShortcutButton->getToggleState();
@@ -1367,6 +1440,11 @@ void OptionsView::buttonClicked (Button* buttonThatWasClicked)
         if (updateKeybindings) {
             updateKeybindings();
         }
+        
+        // Send OSC message for OptionsDisableShortcutButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OptionsDisableShortcutButton", newval ? 1 : 0);
+        }
     }
     else if (buttonThatWasClicked == mOptionsSavePluginDefaultButton.get()) {
         processor.saveCurrentAsDefaultPluginSettings();
diff --git a/Source/OptionsView.h b/Source/OptionsView.h
index 526f2ca56..5be1317b1 100644
--- a/Source/OptionsView.h
+++ b/Source/OptionsView.h
@@ -70,6 +70,36 @@ public MultiTimer
 
     Slider* getOptionsMaxRecvPaddingSlider() { return mOptionsMaxRecvPaddingSlider.get(); }
     ToggleButton* getOptionsRecStealth() { return mOptionsRecStealth.get(); }
+    
+    // Additional getters for OSC support
+    ToggleButton* getOptionsDynamicResamplingButton() { return mOptionsDynamicResamplingButton.get(); }
+    ToggleButton* getOptionsAutoReconnectButton() { return mOptionsAutoReconnectButton.get(); }
+    ToggleButton* getOptionsInputLimiterButton() { return mOptionsInputLimiterButton.get(); }
+    Slider* getOptionsDefaultLevelSlider() { return mOptionsDefaultLevelSlider.get(); }
+    Slider* getOptionsAutoDropThreshSlider() { return mOptionsAutoDropThreshSlider.get(); }
+    SonoChoiceButton* getOptionsAutosizeDefaultChoice() { return mOptionsAutosizeDefaultChoice.get(); }
+    SonoChoiceButton* getOptionsFormatChoiceDefaultChoice() { return mOptionsFormatChoiceDefaultChoice.get(); }
+    ToggleButton* getOptionsMetRecordedButton() { return mOptionsMetRecordedButton.get(); }
+    ToggleButton* getOptionsRecFinishOpenButton() { return mOptionsRecFinishOpenButton.get(); }
+    ToggleButton* getOptionsRecMixButton() { return mOptionsRecMixButton.get(); }
+    ToggleButton* getOptionsRecMixMinusButton() { return mOptionsRecMixMinusButton.get(); }
+    ToggleButton* getOptionsRecSelfButton() { return mOptionsRecSelfButton.get(); }
+    ToggleButton* getOptionsRecOthersButton() { return mOptionsRecOthersButton.get(); }
+    ToggleButton* getOptionsRecSelfPostFxButton() { return mOptionsRecSelfPostFxButton.get(); }
+    ToggleButton* getOptionsRecSelfSilenceMutedButton() { return mOptionsRecSelfSilenceMutedButton.get(); }
+    ToggleButton* getOptionsChangeAllFormatButton() { return mOptionsChangeAllFormatButton.get(); }
+    ToggleButton* getOptionsSliderSnapToMouseButton() { return mOptionsSliderSnapToMouseButton.get(); }
+    ToggleButton* getOptionsDisableShortcutButton() { return mOptionsDisableShortcutButton.get(); }
+    SonoChoiceButton* getRecFormatChoice() { return mRecFormatChoice.get(); }
+    SonoChoiceButton* getRecBitsChoice() { return mRecBitsChoice.get(); }
+    Slider* getBufferTimeSlider() { return mBufferTimeSlider.get(); }
+    ToggleButton* getOptionsUseSpecificUdpPortButton() { return mOptionsUseSpecificUdpPortButton.get(); }
+    ToggleButton* getOptionsOverrideSamplerateButton() { return mOptionsOverrideSamplerateButton.get(); }
+    ToggleButton* getOptionsShouldCheckForUpdateButton() { return mOptionsShouldCheckForUpdateButton.get(); }
+    TextEditor* getOptionsUdpPortEditor() { return mOptionsUdpPortEditor.get(); }
+    TextEditor* getOSCTargetIPAddressEditor() { return mOSCTargetIPAddressEditor.get(); }
+    TextEditor* getOSCTargetPortEditor() { return mOSCTargetPortEditor.get(); }
+    TextEditor* getOSCReceivePortEditor() { return mOSCReceivePortEditor.get(); }
 
     std::function<AudioDeviceManager*()> getAudioDeviceManager; // = []() { return 0; };
     std::function<Value*()> getShouldOverrideSampleRateValue; // = []() { return 0; };
diff --git a/Source/SonobusPluginEditor.cpp b/Source/SonobusPluginEditor.cpp
index 4663724e8..f24513c09 100644
--- a/Source/SonobusPluginEditor.cpp
+++ b/Source/SonobusPluginEditor.cpp
@@ -707,6 +707,27 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
     // Add parameter listeners for OSC message sending
     processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramWet, this);
     processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramMaxRecvPaddingMs, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramDry, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramMetGain, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramMetTempo, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramMainReverbLevel, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramMainReverbSize, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramMainReverbDamping, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramMainReverbPreDelay, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramInputReverbLevel, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramInputReverbSize, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramInputReverbDamping, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramInputReverbPreDelay, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramSyncMetToHost, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramSyncMetToFilePlayback, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramMainInMute, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramMainMonitorSolo, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramDynamicResampling, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramAutoReconnectLast, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramDefaultPeerLevel, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramDefaultAutoNetbuf, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramDefaultSendQual, this);
+    processor.getValueTreeState().addParameterListener (SonobusAudioProcessor::paramDefaultNetbufMs, this);
 
 
     mConnectButton = std::make_unique<SonoTextButton>("directconnect");
@@ -1130,7 +1151,13 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
         mPlaybackSlider->setPopupDisplayEnabled(true, true, this);
         mPlaybackSlider->valueFromTextFunction = [](const String& s) -> float { return Decibels::decibelsToGain(s.getFloatValue()); };
         mPlaybackSlider->textFromValueFunction = [](float v) -> String { return Decibels::toString(Decibels::gainToDecibels(v), 1); };
-        mPlaybackSlider->onValueChange = [this] { processor.setFilePlaybackGain(mPlaybackSlider->getValue()); };
+        mPlaybackSlider->onValueChange = [this] { 
+            processor.setFilePlaybackGain(mPlaybackSlider->getValue()); 
+            // Send OSC message for PlaybackSlider value change
+            if (processor.getOSCEnabled()) {
+                processor.getOSCManager().sendMessage("/PlaybackSlider", static_cast<float>(mPlaybackSlider->getValue()));
+            }
+        };
         mPlaybackSlider->setWantsKeyboardFocus(true);
 
         mFileSendAudioButton = std::make_unique<SonoDrawableButton>("sendmute", DrawableButton::ButtonStyle::ImageFitted);
@@ -1336,124 +1363,1798 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
         menuBarModel->setApplicationCommandManagerToWatch(&commandManager);
 
         
-#if JUCE_MAC
-        auto extraAppleMenuItems = PopupMenu();
-        extraAppleMenuItems.addCommandItem(&commandManager, SonobusCommands::ShowOptions);
+#if JUCE_MAC
+        auto extraAppleMenuItems = PopupMenu();
+        extraAppleMenuItems.addCommandItem(&commandManager, SonobusCommands::ShowOptions);
+        
+        MenuBarModel::setMacMainMenu(menuBarModel.get(), &extraAppleMenuItems);
+#endif
+
+#if (JUCE_WINDOWS || JUCE_LINUX)
+        mMenuBar = std::make_unique<MenuBarComponent>(menuBarModel.get());
+        //mMenuBar->setFocusContainerType(FocusContainerType::keyboardFocusContainer);
+        mMenuBar->setWantsKeyboardFocus(true);
+        addAndMakeVisible(mMenuBar.get());
+#endif
+
+        // look for link in clipboard        
+        if (mConnectView->attemptToPasteConnectionFromClipboard()) {
+            // show connect immediately
+            showConnectPopup(true);
+            // switch to group page
+            mConnectView->showPrivateGroupTab();
+
+            updateServerStatusLabel(TRANS("Filled in Group information from clipboard! Press 'Connect to Group' to join..."), false);
+        }
+        
+        
+        // check for update!
+        // LatestVersionCheckerAndUpdater::getInstance()->checkForNewVersion (false);
+        
+    } else  {
+        setResizable(true, true);    
+    }
+    
+    processor.addClientListener(this);
+    processor.getTransportSource().addChangeListener (this);
+    
+    // Register OSC controls with the OSCManager
+    OSCManager& oscManager = processor.getOSCManager();
+    
+    // Register OutGainSlider - updates slider value with a float
+    oscManager.registerControl("/OutGainSlider", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                if (mOutGainSlider) {
+                    mOutGainSlider->setValue(value, juce::NotificationType::sendNotificationAsync);
+                }
+            });
+        }
+    });
+    
+    // Register MainMuteButton - toggles mute button state with a boolean
+    oscManager.registerControl("/MainMuteButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool muteState = false;
+            if (message[0].isInt32()) {
+                muteState = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                muteState = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, muteState]() {
+                if (mMainMuteButton) {
+                    mMainMuteButton->setToggleState(muteState, juce::NotificationType::sendNotificationAsync);
+                }
+            });
+        }
+    });
+    
+    // Register RecvSyncButton - triggers button click event (accepts only integer 1)
+    oscManager.registerControl("/RecvSyncButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isInt32()) {
+            int value = message[0].getInt32();
+            if (value == 1) {
+                juce::MessageManager::callAsync([this]() {
+                    if (mRecvSyncButton) {
+                        buttonClicked(mRecvSyncButton.get());
+                    }
+                });
+            }
+        }
+    });
+    
+    // Register OptionsMaxRecvPaddingSlider - updates sync receive padding parameter directly
+    oscManager.registerControl("/OptionsMaxRecvPaddingSlider", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                // Set the parameter directly, which updates the processor's internal value
+                // and any UI controls (like the slider in Options view if open)
+                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramMaxRecvPaddingMs)) {
+                    float normalizedValue = param->convertTo0to1(value);
+                    param->setValueNotifyingHost(normalizedValue);
+                }
+            });
+        }
+    });
+    
+    // Register OptionsRecStealth - toggles stealth recording state with a boolean
+    oscManager.registerControl("/OptionsRecStealth", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool stealthState = false;
+            if (message[0].isInt32()) {
+                stealthState = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                stealthState = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, stealthState]() {
+                // Set the processor value directly, which updates internal state
+                // and any UI controls (like the checkbox in Options view if open)
+                processor.setRecordStealth(stealthState);
+                // Also update the UI checkbox if Options view is open
+                if (mOptionsView) {
+                    if (auto* checkbox = mOptionsView->getOptionsRecStealth()) {
+                        checkbox->setToggleState(stealthState, juce::NotificationType::dontSendNotification);
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register DrySlider - updates slider value with a float
+    oscManager.registerControl("/DrySlider", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                if (mDrySlider) {
+                    mDrySlider->setValue(value, juce::NotificationType::sendNotificationAsync);
+                }
+            });
+        }
+    });
+    
+    // Register MainRecvMuteButton - toggles receive mute button state with a boolean
+    oscManager.registerControl("/MainRecvMuteButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool muteState = false;
+            if (message[0].isInt32()) {
+                muteState = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                muteState = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, muteState]() {
+                if (mMainRecvMuteButton) {
+                    mMainRecvMuteButton->setToggleState(muteState, juce::NotificationType::sendNotificationAsync);
+                }
+            });
+        }
+    });
+    
+    // Register MainPushToTalkButton - triggers push to talk action (1 = press, 0 = release)
+    oscManager.registerControl("/MainPushToTalkButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isInt32()) {
+            int value = message[0].getInt32();
+            juce::MessageManager::callAsync([this, value]() {
+                if (mMainPushToTalkButton && mMainPushToTalkButton->isEnabled()) {
+                    if (value == 1) {
+                        // Push down
+                        if (auto* sendMuteParam = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramMainSendMute)) {
+                            mPushToTalkWasMuted = sendMuteParam->getValue() > 0;
+                        }
+                        if (auto* recvMuteParam = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramMainRecvMute)) {
+                            recvMuteParam->setValueNotifyingHost(1.0);
+                        }
+                        if (auto* sendMuteParam = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramMainSendMute)) {
+                            sendMuteParam->setValueNotifyingHost(0.0);
+                        }
+                    } else if (value == 0) {
+                        // Release
+                        if (auto* sendMuteParam = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramMainSendMute)) {
+                            sendMuteParam->setValueNotifyingHost(mPushToTalkWasMuted ? 1.0 : 0.0);
+                        }
+                        if (auto* recvMuteParam = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramMainRecvMute)) {
+                            recvMuteParam->setValueNotifyingHost(0.0);
+                        }
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register MetLevelSlider - updates slider value with a float
+    oscManager.registerControl("/MetLevelSlider", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                if (mMetLevelSlider) {
+                    mMetLevelSlider->setValue(value, juce::NotificationType::sendNotificationAsync);
+                }
+            });
+        }
+    });
+    
+    // Register MetEnableButton - toggles metronome enable state with a boolean
+    oscManager.registerControl("/MetEnableButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool enableState = false;
+            if (message[0].isInt32()) {
+                enableState = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                enableState = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, enableState]() {
+                if (mMetEnableButton) {
+                    mMetEnableButton->setToggleState(enableState, juce::NotificationType::sendNotificationAsync);
+                }
+            });
+        }
+    });
+    
+    // Register MetTempoSlider - updates slider value with a float
+    oscManager.registerControl("/MetTempoSlider", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                if (mMetTempoSlider) {
+                    mMetTempoSlider->setValue(value, juce::NotificationType::sendNotificationAsync);
+                }
+            });
+        }
+    });
+    
+    // Register RecordingButton - toggles recording state with a boolean
+    oscManager.registerControl("/RecordingButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool recordState = false;
+            if (message[0].isInt32()) {
+                recordState = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                recordState = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, recordState]() {
+                if (mRecordingButton) {
+                    // Only trigger if state is different from current
+                    if (mRecordingButton->getToggleState() != recordState) {
+                        buttonClicked(mRecordingButton.get());
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register BufferMinButton - triggers buffer reset button click event (accepts only integer 1)
+    oscManager.registerControl("/BufferMinButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isInt32()) {
+            int value = message[0].getInt32();
+            if (value == 1) {
+                juce::MessageManager::callAsync([this]() {
+                    if (mBufferMinButton) {
+                        buttonClicked(mBufferMinButton.get());
+                    }
+                });
+            }
+        }
+    });
+    
+    // Register OptionsDynamicResamplingButton - toggles dynamic resampling state
+    oscManager.registerControl("/OptionsDynamicResamplingButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramDynamicResampling)) {
+                    param->setValueNotifyingHost(state ? 1.0f : 0.0f);
+                }
+            });
+        }
+    });
+    
+    // Register OptionsAutoReconnectButton - toggles auto-reconnect state
+    oscManager.registerControl("/OptionsAutoReconnectButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramAutoReconnectLast)) {
+                    param->setValueNotifyingHost(state ? 1.0f : 0.0f);
+                }
+            });
+        }
+    });
+    
+    // Register OptionsInputLimiterButton - toggles input limiter state
+    oscManager.registerControl("/OptionsInputLimiterButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                // Apply limiter state to all input groups, matching the button handler behavior
+                SonoAudio::CompressorParams params;
+                for (int j=0; j < processor.getInputGroupCount(); ++j) {
+                    processor.getInputLimiterParams(j, params);
+                    params.enabled = state;
+                    processor.setInputLimiterParams(j, params);
+                }
+                if (mOptionsView) {
+                    if (auto* checkbox = mOptionsView->getOptionsInputLimiterButton()) {
+                        checkbox->setToggleState(state, juce::NotificationType::dontSendNotification);
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register OptionsDefaultLevelSlider - updates default peer level parameter
+    oscManager.registerControl("/OptionsDefaultLevelSlider", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramDefaultPeerLevel)) {
+                    float normalizedValue = param->convertTo0to1(value);
+                    param->setValueNotifyingHost(normalizedValue);
+                }
+            });
+        }
+    });
+    
+    // Register OptionsAutosizeDefaultChoice - updates default autonetbuf parameter
+    oscManager.registerControl("/OptionsAutosizeDefaultChoice", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isInt32()) {
+            int value = message[0].getInt32();
+            juce::MessageManager::callAsync([this, value]() {
+                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramDefaultAutoNetbuf)) {
+                    float normalizedValue = param->convertTo0to1(static_cast<float>(value));
+                    param->setValueNotifyingHost(normalizedValue);
+                }
+            });
+        }
+    });
+    
+    // Register OptionsFormatChoiceDefaultChoice - updates default send quality parameter
+    oscManager.registerControl("/OptionsFormatChoiceDefaultChoice", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isInt32()) {
+            int value = message[0].getInt32();
+            juce::MessageManager::callAsync([this, value]() {
+                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramDefaultSendQual)) {
+                    float normalizedValue = param->convertTo0to1(static_cast<float>(value));
+                    param->setValueNotifyingHost(normalizedValue);
+                }
+            });
+        }
+    });
+    
+    // Register OptionsMetRecordedButton - toggles metronome recorded state
+    oscManager.registerControl("/OptionsMetRecordedButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramMetIsRecorded)) {
+                    param->setValueNotifyingHost(state ? 1.0f : 0.0f);
+                }
+            });
+        }
+    });
+    
+    // Register OptionsRecMixButton - toggles record mix state
+    oscManager.registerControl("/OptionsRecMixButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                uint32 recmask = processor.getDefaultRecordingOptions();
+                if (state) {
+                    recmask |= SonobusAudioProcessor::RecordMix;
+                } else {
+                    recmask &= ~SonobusAudioProcessor::RecordMix;
+                }
+                // Ensure at least one option is selected
+                if (recmask == 0) {
+                    recmask = SonobusAudioProcessor::RecordMix;
+                }
+                processor.setDefaultRecordingOptions(recmask);
+                if (mOptionsView) {
+                    if (auto* checkbox = mOptionsView->getOptionsRecMixButton()) {
+                        checkbox->setToggleState((recmask & SonobusAudioProcessor::RecordMix) != 0, juce::NotificationType::dontSendNotification);
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register OptionsRecSelfButton - toggles record self state
+    oscManager.registerControl("/OptionsRecSelfButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                uint32 recmask = processor.getDefaultRecordingOptions();
+                if (state) {
+                    recmask |= SonobusAudioProcessor::RecordSelf;
+                } else {
+                    recmask &= ~SonobusAudioProcessor::RecordSelf;
+                }
+                // Ensure at least one option is selected
+                if (recmask == 0) {
+                    recmask = SonobusAudioProcessor::RecordMix;
+                }
+                processor.setDefaultRecordingOptions(recmask);
+                if (mOptionsView) {
+                    if (auto* checkbox = mOptionsView->getOptionsRecSelfButton()) {
+                        checkbox->setToggleState((recmask & SonobusAudioProcessor::RecordSelf) != 0, juce::NotificationType::dontSendNotification);
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register OptionsRecOthersButton - toggles record others state
+    oscManager.registerControl("/OptionsRecOthersButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                uint32 recmask = processor.getDefaultRecordingOptions();
+                if (state) {
+                    recmask |= SonobusAudioProcessor::RecordIndividualUsers;
+                } else {
+                    recmask &= ~SonobusAudioProcessor::RecordIndividualUsers;
+                }
+                // Ensure at least one option is selected
+                if (recmask == 0) {
+                    recmask = SonobusAudioProcessor::RecordMix;
+                }
+                processor.setDefaultRecordingOptions(recmask);
+                if (mOptionsView) {
+                    if (auto* checkbox = mOptionsView->getOptionsRecOthersButton()) {
+                        checkbox->setToggleState((recmask & SonobusAudioProcessor::RecordIndividualUsers) != 0, juce::NotificationType::dontSendNotification);
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register OptionsRecMixMinusButton
+    oscManager.registerControl("/OptionsRecMixMinusButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                uint32 recmask = processor.getDefaultRecordingOptions();
+                if (state) {
+                    recmask |= SonobusAudioProcessor::RecordMixMinusSelf;
+                } else {
+                    recmask &= ~SonobusAudioProcessor::RecordMixMinusSelf;
+                }
+                // Ensure at least one option is selected
+                if (recmask == 0) {
+                    recmask = SonobusAudioProcessor::RecordMix;
+                }
+                processor.setDefaultRecordingOptions(recmask);
+                if (mOptionsView) {
+                    if (auto* checkbox = mOptionsView->getOptionsRecMixMinusButton()) {
+                        checkbox->setToggleState((recmask & SonobusAudioProcessor::RecordMixMinusSelf) != 0, juce::NotificationType::dontSendNotification);
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register MainReverbEnabled (replaces EffectsButton for OSC)
+    oscManager.registerControl("/MainReverbEnabled", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramMainReverbEnabled)) {
+                    param->setValueNotifyingHost(state ? 1.0f : 0.0f);
+                }
+            });
+        }
+    });
+    
+    // Register ReverbLevelSlider
+    oscManager.registerControl("/ReverbLevelSlider", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                if (mReverbLevelSlider) {
+                    mReverbLevelSlider->setValue(value, juce::NotificationType::sendNotificationAsync);
+                }
+            });
+        }
+    });
+    
+    // Register ReverbSizeSlider
+    oscManager.registerControl("/ReverbSizeSlider", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                if (mReverbSizeSlider) {
+                    mReverbSizeSlider->setValue(value, juce::NotificationType::sendNotificationAsync);
+                }
+            });
+        }
+    });
+    
+    // Register ReverbDampingSlider
+    oscManager.registerControl("/ReverbDampingSlider", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                if (mReverbDampingSlider) {
+                    mReverbDampingSlider->setValue(value, juce::NotificationType::sendNotificationAsync);
+                }
+            });
+        }
+    });
+    
+    // Register ReverbPreDelaySlider
+    oscManager.registerControl("/ReverbPreDelaySlider", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                if (mReverbPreDelaySlider) {
+                    mReverbPreDelaySlider->setValue(value, juce::NotificationType::sendNotificationAsync);
+                }
+            });
+        }
+    });
+    
+    // Register MetSyncButton
+    oscManager.registerControl("/MetSyncButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramSyncMetToHost)) {
+                    param->setValueNotifyingHost(state ? 1.0f : 0.0f);
+                }
+            });
+        }
+    });
+    
+    // Register MetSyncFileButton
+    oscManager.registerControl("/MetSyncFileButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramSyncMetToFilePlayback)) {
+                    param->setValueNotifyingHost(state ? 1.0f : 0.0f);
+                }
+            });
+        }
+    });
+    
+    // Register InMuteButton
+    oscManager.registerControl("/InMuteButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramMainInMute)) {
+                    param->setValueNotifyingHost(state ? 1.0f : 0.0f);
+                }
+            });
+        }
+    });
+    
+    // Register InSoloButton
+    oscManager.registerControl("/InSoloButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramMainMonitorSolo)) {
+                    param->setValueNotifyingHost(state ? 1.0f : 0.0f);
+                }
+            });
+        }
+    });
+    
+    // Register OptionsRecSelfPostFxButton
+    oscManager.registerControl("/OptionsRecSelfPostFxButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                processor.setSelfRecordingPreFX(!state);
+                if (mOptionsView) {
+                    if (auto* checkbox = mOptionsView->getOptionsRecSelfPostFxButton()) {
+                        checkbox->setToggleState(state, juce::NotificationType::dontSendNotification);
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register OptionsRecSelfSilenceMutedButton
+    oscManager.registerControl("/OptionsRecSelfSilenceMutedButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                processor.setSelfRecordingSilenceWhenMuted(state);
+                if (mOptionsView) {
+                    if (auto* checkbox = mOptionsView->getOptionsRecSelfSilenceMutedButton()) {
+                        checkbox->setToggleState(state, juce::NotificationType::dontSendNotification);
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register OptionsDisableShortcutButton
+    oscManager.registerControl("/OptionsDisableShortcutButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                processor.setDisableKeyboardShortcuts(state);
+                if (mOptionsView) {
+                    if (auto* checkbox = mOptionsView->getOptionsDisableShortcutButton()) {
+                        checkbox->setToggleState(state, juce::NotificationType::dontSendNotification);
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register OptionsChangeAllFormatButton
+    oscManager.registerControl("/OptionsChangeAllFormatButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                processor.setChangingDefaultAudioCodecSetsExisting(state);
+                if (mOptionsView) {
+                    if (auto* checkbox = mOptionsView->getOptionsChangeAllFormatButton()) {
+                        checkbox->setToggleState(state, juce::NotificationType::dontSendNotification);
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register OptionsAutoDropThreshSlider
+    oscManager.registerControl("/OptionsAutoDropThreshSlider", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                // The slider value is converted to threshold: thresh = 1.0 / max(1.0, sliderValue)
+                auto thresh = 1.0 / jmax(1.0, static_cast<double>(value));
+                processor.setAutoresizeBufferDropRateThreshold(thresh);
+                if (mOptionsView) {
+                    if (auto* slider = mOptionsView->getOptionsAutoDropThreshSlider()) {
+                        slider->setValue(value, juce::NotificationType::dontSendNotification);
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register BufferTimeSlider
+    oscManager.registerControl("/BufferTimeSlider", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramDefaultNetbufMs)) {
+                    float normalizedValue = param->convertTo0to1(value);
+                    param->setValueNotifyingHost(normalizedValue);
+                }
+            });
+        }
+    });
+    
+    // Register OptionsUseSpecificUdpPortButton
+    oscManager.registerControl("/OptionsUseSpecificUdpPortButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                processor.setUseSpecificUdpPort(state ? processor.getUseSpecificUdpPort() : 0);
+                if (mOptionsView) {
+                    if (auto* checkbox = mOptionsView->getOptionsUseSpecificUdpPortButton()) {
+                        checkbox->setToggleState(state, juce::NotificationType::sendNotificationAsync);
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register OptionsOverrideSamplerateButton
+    oscManager.registerControl("/OptionsOverrideSamplerateButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                if (mOptionsView) {
+                    if (auto* checkbox = mOptionsView->getOptionsOverrideSamplerateButton()) {
+                        checkbox->setToggleState(state, juce::NotificationType::sendNotificationAsync);
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register OptionsShouldCheckForUpdateButton
+    oscManager.registerControl("/OptionsShouldCheckForUpdateButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                if (mOptionsView) {
+                    if (auto* checkbox = mOptionsView->getOptionsShouldCheckForUpdateButton()) {
+                        checkbox->setToggleState(state, juce::NotificationType::sendNotificationAsync);
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register OptionsUdpPortEditor
+    oscManager.registerControl("/OptionsUdpPortEditor", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isInt32()) {
+            int port = message[0].getInt32();
+            juce::MessageManager::callAsync([this, port]() {
+                processor.setUseSpecificUdpPort(port);
+                if (mOptionsView) {
+                    if (auto* editor = mOptionsView->getOptionsUdpPortEditor()) {
+                        editor->setText(String(port), juce::NotificationType::dontSendNotification);
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register OSCTargetIPAddress
+    oscManager.registerControl("/OSCTargetIPAddress", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isString()) {
+            String ipAddress = message[0].getString();
+            juce::MessageManager::callAsync([this, ipAddress]() {
+                processor.setOSCTargetIPAddress(ipAddress);
+                if (mOptionsView) {
+                    if (auto* editor = mOptionsView->getOSCTargetIPAddressEditor()) {
+                        editor->setText(ipAddress, juce::NotificationType::dontSendNotification);
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register OSCTargetPort
+    oscManager.registerControl("/OSCTargetPort", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isInt32()) {
+            int port = message[0].getInt32();
+            juce::MessageManager::callAsync([this, port]() {
+                if (port >= 1 && port <= 65535) {
+                    processor.setOSCTargetPort(port);
+                    if (mOptionsView) {
+                        if (auto* editor = mOptionsView->getOSCTargetPortEditor()) {
+                            editor->setText(String(port), juce::NotificationType::dontSendNotification);
+                        }
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register OSCReceivePort
+    oscManager.registerControl("/OSCReceivePort", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isInt32()) {
+            int port = message[0].getInt32();
+            juce::MessageManager::callAsync([this, port]() {
+                if (port >= 1 && port <= 65535) {
+                    processor.setOSCReceivePort(port);
+                    if (mOptionsView) {
+                        if (auto* editor = mOptionsView->getOSCReceivePortEditor()) {
+                            editor->setText(String(port), juce::NotificationType::dontSendNotification);
+                        }
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register OptionsSliderSnapToMouseButton
+    oscManager.registerControl("/OptionsSliderSnapToMouseButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                processor.setSlidersSnapToMousePosition(state);
+                if (mOptionsView) {
+                    if (auto* checkbox = mOptionsView->getOptionsSliderSnapToMouseButton()) {
+                        checkbox->setToggleState(state, juce::NotificationType::sendNotificationAsync);
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register MetSendButton
+    oscManager.registerControl("/MetSendButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramSendMetAudio)) {
+                    param->setValueNotifyingHost(state ? 1.0f : 0.0f);
+                }
+            });
+        }
+    });
+    
+    // Register FileSendButton
+    oscManager.registerControl("/FileSendButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramSendFileAudio)) {
+                    param->setValueNotifyingHost(state ? 1.0f : 0.0f);
+                }
+            });
+        }
+    });
+    
+    // Register SoundboardSendButton
+    oscManager.registerControl("/SoundboardSendButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramSendSoundboardAudio)) {
+                    param->setValueNotifyingHost(state ? 1.0f : 0.0f);
+                }
+            });
+        }
+    });
+    
+    // Register PlaybackSlider
+    oscManager.registerControl("/PlaybackSlider", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                processor.setFilePlaybackGain(value);
+                if (mPlaybackSlider) {
+                    mPlaybackSlider->setValue(value, juce::NotificationType::dontSendNotification);
+                }
+            });
+        }
+    });
+    
+    // Register SoundboardLevelSlider
+    oscManager.registerControl("/SoundboardLevelSlider", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                if (processor.getSoundboardProcessor()) {
+                    processor.getSoundboardProcessor()->setGain(value);
+                    // Update UI if available
+                    if (auto* channelGroups = getInputChannelGroupsView()) {
+                        if (auto* soundboardView = channelGroups->getSoundboardChannelView()) {
+                            if (soundboardView->levelSlider) {
+                                soundboardView->levelSlider->setValue(value, juce::NotificationType::dontSendNotification);
+                            }
+                        }
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register SoundboardMonitorSlider
+    oscManager.registerControl("/SoundboardMonitorSlider", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                if (processor.getSoundboardProcessor()) {
+                    processor.getSoundboardProcessor()->setMonitorGain(value);
+                    // Update UI if available
+                    if (auto* channelGroups = getInputChannelGroupsView()) {
+                        if (auto* soundboardView = channelGroups->getSoundboardChannelView()) {
+                            if (soundboardView->monitorSlider) {
+                                soundboardView->monitorSlider->setValue(value, juce::NotificationType::dontSendNotification);
+                            }
+                        }
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register FileMonitorSlider
+    oscManager.registerControl("/FileMonitorSlider", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                processor.setFilePlaybackMonitor(value);
+                // Update UI if available
+                if (auto* channelGroups = getInputChannelGroupsView()) {
+                    if (auto* fileView = channelGroups->getFileChannelView()) {
+                        if (fileView->monitorSlider) {
+                            fileView->monitorSlider->setValue(value, juce::NotificationType::dontSendNotification);
+                        }
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register MetPanSlider
+    oscManager.registerControl("/MetPanSlider", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                processor.setMetronomePan(value);
+                if (auto* channelGroups = getInputChannelGroupsView()) {
+                    if (auto* metView = channelGroups->getMetChannelView()) {
+                        if (metView->panSlider) {
+                            metView->panSlider->setValue(value, juce::NotificationType::dontSendNotification);
+                        }
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register MetMonitorSlider
+    oscManager.registerControl("/MetMonitorSlider", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                processor.setMetronomeMonitor(value);
+                if (auto* channelGroups = getInputChannelGroupsView()) {
+                    if (auto* metView = channelGroups->getMetChannelView()) {
+                        if (metView->monitorSlider) {
+                            metView->monitorSlider->setValue(value, juce::NotificationType::dontSendNotification);
+                        }
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register InputReverbLevel
+    oscManager.registerControl("/InputReverbLevel", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramInputReverbLevel)) {
+                    float normalizedValue = param->convertTo0to1(value);
+                    param->setValueNotifyingHost(normalizedValue);
+                }
+            });
+        }
+    });
+    
+    // Register InputReverbSize
+    oscManager.registerControl("/InputReverbSize", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramInputReverbSize)) {
+                    float normalizedValue = param->convertTo0to1(value);
+                    param->setValueNotifyingHost(normalizedValue);
+                }
+            });
+        }
+    });
+    
+    // Register InputReverbDamping
+    oscManager.registerControl("/InputReverbDamping", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramInputReverbDamping)) {
+                    float normalizedValue = param->convertTo0to1(value);
+                    param->setValueNotifyingHost(normalizedValue);
+                }
+            });
+        }
+    });
+    
+    // Register InputReverbPreDelay
+    oscManager.registerControl("/InputReverbPreDelay", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramInputReverbPreDelay)) {
+                    float normalizedValue = param->convertTo0to1(value);
+                    param->setValueNotifyingHost(normalizedValue);
+                }
+            });
+        }
+    });
+    
+    // Register InReverbButton
+    oscManager.registerControl("/InReverbButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isInt32()) {
+            int trigger = message[0].getInt32();
+            if (trigger != 0) {
+                juce::MessageManager::callAsync([this]() {
+                    if (auto* channelGroups = getInputChannelGroupsView()) {
+                        if (auto* button = channelGroups->getInReverbButton()) {
+                            button->triggerClick();
+                        }
+                    }
+                });
+            }
+        }
+    });
+    
+    // Register MonDelayButton
+    oscManager.registerControl("/MonDelayButton", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0) {
+            bool state = false;
+            if (message[0].isInt32()) {
+                state = (message[0].getInt32() != 0);
+            } else if (message[0].isFloat32()) {
+                state = (message[0].getFloat32() != 0.0f);
+            }
+            juce::MessageManager::callAsync([this, state]() {
+                if (auto* channelGroups = getInputChannelGroupsView()) {
+                    if (auto* button = channelGroups->getMonDelayButton()) {
+                        if (button->getToggleState() != state) {
+                            button->triggerClick();
+                        }
+                    }
+                }
+            });
+        }
+    });
+    
+    // Register Input Group Pre Level sliders (support up to 16 input groups)
+    for (int groupIndex = 0; groupIndex < 16; ++groupIndex) {
+        String oscAddress = "/InputGroup" + String(groupIndex + 1) + "PreLevel";
+        oscManager.registerControl(oscAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float value = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, value]() {
+                    // Only set if the input group exists
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        processor.setInputGroupGain(groupIndex, value);
+                        // Update UI if the channel groups view exists
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+    }
+
+    // Register File Playback Pre Level slider
+    oscManager.registerControl("/FilePlaybackPreLevel", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32();
+            juce::MessageManager::callAsync([this, value]() {
+                processor.setFilePlaybackGain(value);
+                if (auto* channelGroups = getInputChannelGroupsView()) {
+                    channelGroups->updateChannelViews();
+                }
+            });
+        }
+    });
+
+    // Register Input Group Pan, Monitor, and M.FX controls (support up to 16 input groups)
+    for (int groupIndex = 0; groupIndex < 16; ++groupIndex) {
+        // Pan slider (single channel)
+        String panAddress = "/InputGroup" + String(groupIndex + 1) + "Pan";
+        oscManager.registerControl(panAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float value = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, value]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        processor.setInputChannelPan(groupIndex, 0, value);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Pan slider (dual channel left)
+        String panLeftAddress = "/InputGroup" + String(groupIndex + 1) + "PanLeft";
+        oscManager.registerControl(panLeftAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float value = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, value]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        processor.setInputChannelPan(groupIndex, 0, value);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Pan slider (dual channel right)
+        String panRightAddress = "/InputGroup" + String(groupIndex + 1) + "PanRight";
+        oscManager.registerControl(panRightAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float value = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, value]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        processor.setInputChannelPan(groupIndex, 1, value);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Monitor slider
+        String monitorAddress = "/InputGroup" + String(groupIndex + 1) + "Monitor";
+        oscManager.registerControl(monitorAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float value = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, value]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        processor.setInputMonitor(groupIndex, value);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // M.FX Additional Monitoring Delay Enable
+        String monDelayEnableAddress = "/InputGroup" + String(groupIndex + 1) + "MonDelayEnable";
+        oscManager.registerControl(monDelayEnableAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                bool enabled = message[0].getFloat32() > 0.5f;
+                juce::MessageManager::callAsync([this, groupIndex, enabled]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::DelayParams params;
+                        processor.getInputMonitorDelayParams(groupIndex, params);
+                        params.enabled = enabled;
+                        processor.setInputMonitorDelayParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // M.FX Delay Time
+        String monDelayTimeAddress = "/InputGroup" + String(groupIndex + 1) + "MonDelayTime";
+        oscManager.registerControl(monDelayTimeAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float delayTime = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, delayTime]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::DelayParams params;
+                        processor.getInputMonitorDelayParams(groupIndex, params);
+                        params.delayTimeMs = delayTime;
+                        processor.setInputMonitorDelayParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // M.FX Link Delay Time
+        String monDelayLinkAddress = "/InputGroup" + String(groupIndex + 1) + "MonDelayLink";
+        oscManager.registerControl(monDelayLinkAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                bool linked = message[0].getFloat32() > 0.5f;
+                juce::MessageManager::callAsync([this, groupIndex, linked]() {
+                    // Link delay is a global setting, not per-group
+                    processor.setLinkMonitoringDelayTimes(linked);
+                    if (auto* channelGroups = getInputChannelGroupsView()) {
+                        channelGroups->updateChannelViews();
+                    }
+                });
+            }
+        });
+        
+        // M.FX Main Reverb Send
+        String monReverbSendAddress = "/InputGroup" + String(groupIndex + 1) + "MonReverbSend";
+        oscManager.registerControl(monReverbSendAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float reverbSend = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, reverbSend]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        processor.setInputReverbSend(groupIndex, reverbSend, false);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+    }
+
+    // Register Input Group Mute, Solo, and FX controls (support up to 16 input groups)
+    for (int groupIndex = 0; groupIndex < 16; ++groupIndex) {
+        // Mute toggle
+        String muteAddress = "/InputGroup" + String(groupIndex + 1) + "Mute";
+        oscManager.registerControl(muteAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                bool muted = message[0].getFloat32() > 0.5f;
+                juce::MessageManager::callAsync([this, groupIndex, muted]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        processor.setInputGroupMuted(groupIndex, muted);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Solo toggle
+        String soloAddress = "/InputGroup" + String(groupIndex + 1) + "Solo";
+        oscManager.registerControl(soloAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                bool soloed = message[0].getFloat32() > 0.5f;
+                juce::MessageManager::callAsync([this, groupIndex, soloed]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        processor.setInputGroupSoloed(groupIndex, soloed);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Input Reverb Send slider
+        String inputReverbSendAddress = "/InputGroup" + String(groupIndex + 1) + "InputReverbSend";
+        oscManager.registerControl(inputReverbSendAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float reverbSend = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, reverbSend]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        processor.setInputReverbSend(groupIndex, reverbSend, true);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Polarity Invert toggle
+        String polarityInvertAddress = "/InputGroup" + String(groupIndex + 1) + "PolarityInvert";
+        oscManager.registerControl(polarityInvertAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                bool inverted = message[0].getFloat32() > 0.5f;
+                juce::MessageManager::callAsync([this, groupIndex, inverted]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        processor.setInputPolarityInvert(groupIndex, inverted);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Compressor Enable toggle
+        String compressorEnableAddress = "/InputGroup" + String(groupIndex + 1) + "CompressorEnable";
+        oscManager.registerControl(compressorEnableAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                bool enabled = message[0].getFloat32() > 0.5f;
+                juce::MessageManager::callAsync([this, groupIndex, enabled]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getInputCompressorParams(groupIndex, params);
+                        params.enabled = enabled;
+                        processor.setInputCompressorParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Compressor Threshold
+        String compressorThresholdAddress = "/InputGroup" + String(groupIndex + 1) + "CompressorThreshold";
+        oscManager.registerControl(compressorThresholdAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float threshold = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, threshold]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getInputCompressorParams(groupIndex, params);
+                        params.thresholdDb = threshold;
+                        processor.setInputCompressorParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Compressor Ratio
+        String compressorRatioAddress = "/InputGroup" + String(groupIndex + 1) + "CompressorRatio";
+        oscManager.registerControl(compressorRatioAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float ratio = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, ratio]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getInputCompressorParams(groupIndex, params);
+                        params.ratio = ratio;
+                        processor.setInputCompressorParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Compressor Attack
+        String compressorAttackAddress = "/InputGroup" + String(groupIndex + 1) + "CompressorAttack";
+        oscManager.registerControl(compressorAttackAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float attack = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, attack]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getInputCompressorParams(groupIndex, params);
+                        params.attackMs = attack;
+                        processor.setInputCompressorParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Compressor Release
+        String compressorReleaseAddress = "/InputGroup" + String(groupIndex + 1) + "CompressorRelease";
+        oscManager.registerControl(compressorReleaseAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float release = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, release]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getInputCompressorParams(groupIndex, params);
+                        params.releaseMs = release;
+                        processor.setInputCompressorParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Compressor Makeup Gain
+        String compressorMakeupGainAddress = "/InputGroup" + String(groupIndex + 1) + "CompressorMakeupGain";
+        oscManager.registerControl(compressorMakeupGainAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float makeupGain = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, makeupGain]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getInputCompressorParams(groupIndex, params);
+                        params.makeupGainDb = makeupGain;
+                        processor.setInputCompressorParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Compressor Auto Makeup Gain
+        String compressorAutoAddress = "/InputGroup" + String(groupIndex + 1) + "CompressorAuto";
+        oscManager.registerControl(compressorAutoAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                bool autoMakeup = message[0].getFloat32() > 0.5f;
+                juce::MessageManager::callAsync([this, groupIndex, autoMakeup]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getInputCompressorParams(groupIndex, params);
+                        params.automakeupGain = autoMakeup;
+                        processor.setInputCompressorParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Expander (Noise Gate) Enable toggle
+        String expanderEnableAddress = "/InputGroup" + String(groupIndex + 1) + "ExpanderEnable";
+        oscManager.registerControl(expanderEnableAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                bool enabled = message[0].getFloat32() > 0.5f;
+                juce::MessageManager::callAsync([this, groupIndex, enabled]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getInputExpanderParams(groupIndex, params);
+                        params.enabled = enabled;
+                        processor.setInputExpanderParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Expander Noise Floor
+        String expanderNoiseFloorAddress = "/InputGroup" + String(groupIndex + 1) + "ExpanderNoiseFloor";
+        oscManager.registerControl(expanderNoiseFloorAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float noiseFloor = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, noiseFloor]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getInputExpanderParams(groupIndex, params);
+                        params.thresholdDb = noiseFloor;
+                        processor.setInputExpanderParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Expander Ratio
+        String expanderRatioAddress = "/InputGroup" + String(groupIndex + 1) + "ExpanderRatio";
+        oscManager.registerControl(expanderRatioAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float ratio = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, ratio]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getInputExpanderParams(groupIndex, params);
+                        params.ratio = ratio;
+                        processor.setInputExpanderParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Expander Attack
+        String expanderAttackAddress = "/InputGroup" + String(groupIndex + 1) + "ExpanderAttack";
+        oscManager.registerControl(expanderAttackAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float attack = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, attack]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getInputExpanderParams(groupIndex, params);
+                        params.attackMs = attack;
+                        processor.setInputExpanderParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Expander Release
+        String expanderReleaseAddress = "/InputGroup" + String(groupIndex + 1) + "ExpanderRelease";
+        oscManager.registerControl(expanderReleaseAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float release = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, release]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getInputExpanderParams(groupIndex, params);
+                        params.releaseMs = release;
+                        processor.setInputExpanderParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Parametric EQ Enable toggle
+        String eqEnableAddress = "/InputGroup" + String(groupIndex + 1) + "EqEnable";
+        oscManager.registerControl(eqEnableAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                bool enabled = message[0].getFloat32() > 0.5f;
+                juce::MessageManager::callAsync([this, groupIndex, enabled]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getInputEqParams(groupIndex, params);
+                        params.enabled = enabled;
+                        processor.setInputEqParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // EQ Low Shelf Frequency
+        String eqLowShelfFreqAddress = "/InputGroup" + String(groupIndex + 1) + "EqLowShelfFreq";
+        oscManager.registerControl(eqLowShelfFreqAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float freq = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, freq]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getInputEqParams(groupIndex, params);
+                        params.lowShelfFreq = freq;
+                        processor.setInputEqParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // EQ Low Shelf Gain
+        String eqLowShelfGainAddress = "/InputGroup" + String(groupIndex + 1) + "EqLowShelfGain";
+        oscManager.registerControl(eqLowShelfGainAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float gain = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, gain]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getInputEqParams(groupIndex, params);
+                        params.lowShelfGain = gain;
+                        processor.setInputEqParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
         
-        MenuBarModel::setMacMainMenu(menuBarModel.get(), &extraAppleMenuItems);
-#endif
-
-#if (JUCE_WINDOWS || JUCE_LINUX)
-        mMenuBar = std::make_unique<MenuBarComponent>(menuBarModel.get());
-        //mMenuBar->setFocusContainerType(FocusContainerType::keyboardFocusContainer);
-        mMenuBar->setWantsKeyboardFocus(true);
-        addAndMakeVisible(mMenuBar.get());
-#endif
-
-        // look for link in clipboard        
-        if (mConnectView->attemptToPasteConnectionFromClipboard()) {
-            // show connect immediately
-            showConnectPopup(true);
-            // switch to group page
-            mConnectView->showPrivateGroupTab();
-
-            updateServerStatusLabel(TRANS("Filled in Group information from clipboard! Press 'Connect to Group' to join..."), false);
-        }
+        // EQ Parametric 1 Frequency
+        String eqPara1FreqAddress = "/InputGroup" + String(groupIndex + 1) + "EqPara1Freq";
+        oscManager.registerControl(eqPara1FreqAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float freq = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, freq]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getInputEqParams(groupIndex, params);
+                        params.para1Freq = freq;
+                        processor.setInputEqParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
         
+        // EQ Parametric 1 Gain
+        String eqPara1GainAddress = "/InputGroup" + String(groupIndex + 1) + "EqPara1Gain";
+        oscManager.registerControl(eqPara1GainAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float gain = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, gain]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getInputEqParams(groupIndex, params);
+                        params.para1Gain = gain;
+                        processor.setInputEqParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
         
-        // check for update!
-        // LatestVersionCheckerAndUpdater::getInstance()->checkForNewVersion (false);
+        // EQ Parametric 1 Q
+        String eqPara1QAddress = "/InputGroup" + String(groupIndex + 1) + "EqPara1Q";
+        oscManager.registerControl(eqPara1QAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float q = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, q]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getInputEqParams(groupIndex, params);
+                        params.para1Q = q;
+                        processor.setInputEqParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
         
-    } else  {
-        setResizable(true, true);    
-    }
-    
-    processor.addClientListener(this);
-    processor.getTransportSource().addChangeListener (this);
-    
-    // Register OSC controls with the OSCManager
-    OSCManager& oscManager = processor.getOSCManager();
-    
-    // Register OutGainSlider - updates slider value with a float
-    oscManager.registerControl("/OutGainSlider", [this](const juce::OSCMessage& message) {
-        if (message.size() > 0 && message[0].isFloat32()) {
-            float value = message[0].getFloat32();
-            juce::MessageManager::callAsync([this, value]() {
-                if (mOutGainSlider) {
-                    mOutGainSlider->setValue(value, juce::NotificationType::sendNotificationAsync);
-                }
-            });
-        }
-    });
-    
-    // Register MainMuteButton - toggles mute button state with a boolean
-    oscManager.registerControl("/MainMuteButton", [this](const juce::OSCMessage& message) {
-        if (message.size() > 0) {
-            bool muteState = false;
-            if (message[0].isInt32()) {
-                muteState = (message[0].getInt32() != 0);
-            } else if (message[0].isFloat32()) {
-                muteState = (message[0].getFloat32() != 0.0f);
+        // EQ High Shelf Frequency
+        String eqHighShelfFreqAddress = "/InputGroup" + String(groupIndex + 1) + "EqHighShelfFreq";
+        oscManager.registerControl(eqHighShelfFreqAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float freq = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, freq]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getInputEqParams(groupIndex, params);
+                        params.highShelfFreq = freq;
+                        processor.setInputEqParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
             }
-            juce::MessageManager::callAsync([this, muteState]() {
-                if (mMainMuteButton) {
-                    mMainMuteButton->setToggleState(muteState, juce::NotificationType::sendNotificationAsync);
-                }
-            });
-        }
-    });
-    
-    // Register RecvSyncButton - triggers button click event (accepts only integer 1)
-    oscManager.registerControl("/RecvSyncButton", [this](const juce::OSCMessage& message) {
-        if (message.size() > 0 && message[0].isInt32()) {
-            int value = message[0].getInt32();
-            if (value == 1) {
-                juce::MessageManager::callAsync([this]() {
-                    if (mRecvSyncButton) {
-                        buttonClicked(mRecvSyncButton.get());
+        });
+        
+        // EQ High Shelf Gain
+        String eqHighShelfGainAddress = "/InputGroup" + String(groupIndex + 1) + "EqHighShelfGain";
+        oscManager.registerControl(eqHighShelfGainAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float gain = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, gain]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getInputEqParams(groupIndex, params);
+                        params.highShelfGain = gain;
+                        processor.setInputEqParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
                     }
                 });
             }
-        }
-    });
-    
-    // Register OptionsMaxRecvPaddingSlider - updates sync receive padding parameter directly
-    oscManager.registerControl("/OptionsMaxRecvPaddingSlider", [this](const juce::OSCMessage& message) {
-        if (message.size() > 0 && message[0].isFloat32()) {
-            float value = message[0].getFloat32();
-            juce::MessageManager::callAsync([this, value]() {
-                // Set the parameter directly, which updates the processor's internal value
-                // and any UI controls (like the slider in Options view if open)
-                if (auto* param = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramMaxRecvPaddingMs)) {
-                    float normalizedValue = param->convertTo0to1(value);
-                    param->setValueNotifyingHost(normalizedValue);
-                }
-            });
-        }
-    });
-    
-    // Register OptionsRecStealth - toggles stealth recording state with a boolean
-    oscManager.registerControl("/OptionsRecStealth", [this](const juce::OSCMessage& message) {
-        if (message.size() > 0) {
-            bool stealthState = false;
-            if (message[0].isInt32()) {
-                stealthState = (message[0].getInt32() != 0);
-            } else if (message[0].isFloat32()) {
-                stealthState = (message[0].getFloat32() != 0.0f);
+        });
+        
+        // EQ Parametric 2 Frequency
+        String eqPara2FreqAddress = "/InputGroup" + String(groupIndex + 1) + "EqPara2Freq";
+        oscManager.registerControl(eqPara2FreqAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float freq = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, freq]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getInputEqParams(groupIndex, params);
+                        params.para2Freq = freq;
+                        processor.setInputEqParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
             }
-            juce::MessageManager::callAsync([this, stealthState]() {
-                // Set the processor value directly, which updates internal state
-                // and any UI controls (like the checkbox in Options view if open)
-                processor.setRecordStealth(stealthState);
-                // Also update the UI checkbox if Options view is open
-                if (mOptionsView) {
-                    if (auto* checkbox = mOptionsView->getOptionsRecStealth()) {
-                        checkbox->setToggleState(stealthState, juce::NotificationType::dontSendNotification);
+        });
+        
+        // EQ Parametric 2 Gain
+        String eqPara2GainAddress = "/InputGroup" + String(groupIndex + 1) + "EqPara2Gain";
+        oscManager.registerControl(eqPara2GainAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float gain = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, gain]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getInputEqParams(groupIndex, params);
+                        params.para2Gain = gain;
+                        processor.setInputEqParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
                     }
-                }
-            });
-        }
-    });
+                });
+            }
+        });
+        
+        // EQ Parametric 2 Q
+        String eqPara2QAddress = "/InputGroup" + String(groupIndex + 1) + "EqPara2Q";
+        oscManager.registerControl(eqPara2QAddress, [this, groupIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float q = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, groupIndex, q]() {
+                    if (groupIndex < processor.getInputGroupCount()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getInputEqParams(groupIndex, params);
+                        params.para2Q = q;
+                        processor.setInputEqParams(groupIndex, params);
+                        if (auto* channelGroups = getInputChannelGroupsView()) {
+                            channelGroups->updateChannelViews();
+                        }
+                    }
+                });
+            }
+        });
+    }
 
     // handles registering commands
     updateUseKeybindings();
@@ -1494,6 +3195,111 @@ SonobusAudioProcessorEditor::~SonobusAudioProcessorEditor()
     oscManager.unregisterControl("/RecvSyncButton");
     oscManager.unregisterControl("/OptionsMaxRecvPaddingSlider");
     oscManager.unregisterControl("/OptionsRecStealth");
+    oscManager.unregisterControl("/DrySlider");
+    oscManager.unregisterControl("/MainRecvMuteButton");
+    oscManager.unregisterControl("/MainPushToTalkButton");
+    oscManager.unregisterControl("/MetLevelSlider");
+    oscManager.unregisterControl("/MetEnableButton");
+    oscManager.unregisterControl("/MetTempoSlider");
+    oscManager.unregisterControl("/RecordingButton");
+    oscManager.unregisterControl("/BufferMinButton");
+    oscManager.unregisterControl("/OptionsDynamicResamplingButton");
+    oscManager.unregisterControl("/OptionsAutoReconnectButton");
+    oscManager.unregisterControl("/OptionsInputLimiterButton");
+    oscManager.unregisterControl("/OptionsDefaultLevelSlider");
+    oscManager.unregisterControl("/OptionsAutosizeDefaultChoice");
+    oscManager.unregisterControl("/OptionsFormatChoiceDefaultChoice");
+    oscManager.unregisterControl("/OptionsMetRecordedButton");
+    oscManager.unregisterControl("/OptionsRecMixButton");
+    oscManager.unregisterControl("/OptionsRecSelfButton");
+    oscManager.unregisterControl("/OptionsRecOthersButton");
+    oscManager.unregisterControl("/OptionsRecMixMinusButton");
+    oscManager.unregisterControl("/MainReverbEnabled");
+    oscManager.unregisterControl("/ReverbLevelSlider");
+    oscManager.unregisterControl("/ReverbSizeSlider");
+    oscManager.unregisterControl("/ReverbDampingSlider");
+    oscManager.unregisterControl("/ReverbPreDelaySlider");
+    oscManager.unregisterControl("/MetSyncButton");
+    oscManager.unregisterControl("/MetSyncFileButton");
+    oscManager.unregisterControl("/InMuteButton");
+    oscManager.unregisterControl("/InSoloButton");
+    oscManager.unregisterControl("/OptionsRecSelfPostFxButton");
+    oscManager.unregisterControl("/OptionsRecSelfSilenceMutedButton");
+    oscManager.unregisterControl("/OptionsDisableShortcutButton");
+    oscManager.unregisterControl("/OptionsChangeAllFormatButton");
+    oscManager.unregisterControl("/OptionsAutoDropThreshSlider");
+    oscManager.unregisterControl("/BufferTimeSlider");
+    oscManager.unregisterControl("/OptionsUseSpecificUdpPortButton");
+    oscManager.unregisterControl("/OptionsOverrideSamplerateButton");
+    oscManager.unregisterControl("/OptionsShouldCheckForUpdateButton");
+    oscManager.unregisterControl("/OptionsUdpPortEditor");
+    oscManager.unregisterControl("/OSCTargetIPAddress");
+    oscManager.unregisterControl("/OSCTargetPort");
+    oscManager.unregisterControl("/OSCReceivePort");
+    oscManager.unregisterControl("/OptionsSliderSnapToMouseButton");
+    oscManager.unregisterControl("/MetSendButton");
+    oscManager.unregisterControl("/FileSendButton");
+    oscManager.unregisterControl("/SoundboardSendButton");
+    oscManager.unregisterControl("/PlaybackSlider");
+    oscManager.unregisterControl("/SoundboardLevelSlider");
+    oscManager.unregisterControl("/SoundboardMonitorSlider");
+    oscManager.unregisterControl("/FileMonitorSlider");
+    oscManager.unregisterControl("/MetPanSlider");
+    oscManager.unregisterControl("/MetMonitorSlider");
+    oscManager.unregisterControl("/InputReverbLevel");
+    oscManager.unregisterControl("/InputReverbSize");
+    oscManager.unregisterControl("/InputReverbDamping");
+    oscManager.unregisterControl("/InputReverbPreDelay");
+    oscManager.unregisterControl("/InReverbButton");
+    oscManager.unregisterControl("/MonDelayButton");
+    
+    // Unregister Input Group Pre Level sliders (up to 16 input groups)
+    for (int groupIndex = 0; groupIndex < 16; ++groupIndex) {
+        String oscAddress = "/InputGroup" + String(groupIndex + 1) + "PreLevel";
+        oscManager.unregisterControl(oscAddress);
+    }
+    
+    // Unregister File Playback Pre Level
+    oscManager.unregisterControl("/FilePlaybackPreLevel");
+    
+    // Unregister Input Group Pan, Monitor, and M.FX controls (up to 16 input groups)
+    for (int groupIndex = 0; groupIndex < 16; ++groupIndex) {
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "Pan");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "PanLeft");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "PanRight");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "Monitor");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "MonDelayEnable");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "MonDelayTime");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "MonDelayLink");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "MonReverbSend");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "Mute");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "Solo");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "InputReverbSend");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "PolarityInvert");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "CompressorEnable");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "CompressorThreshold");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "CompressorRatio");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "CompressorAttack");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "CompressorRelease");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "CompressorMakeupGain");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "CompressorAuto");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "ExpanderEnable");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "ExpanderNoiseFloor");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "ExpanderRatio");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "ExpanderAttack");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "ExpanderRelease");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "EqEnable");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "EqLowShelfFreq");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "EqLowShelfGain");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "EqPara1Freq");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "EqPara1Gain");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "EqPara1Q");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "EqHighShelfFreq");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "EqHighShelfGain");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "EqPara2Freq");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "EqPara2Gain");
+        oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "EqPara2Q");
+    }
     
     if (menuBarModel) {
         menuBarModel->setApplicationCommandManagerToWatch(nullptr);
@@ -1526,6 +3332,27 @@ SonobusAudioProcessorEditor::~SonobusAudioProcessorEditor()
     // Remove parameter listeners for OSC message sending
     processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramWet, this);
     processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramMaxRecvPaddingMs, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramDry, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramMetGain, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramMetTempo, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramMainReverbLevel, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramMainReverbSize, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramMainReverbDamping, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramMainReverbPreDelay, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramInputReverbLevel, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramInputReverbSize, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramInputReverbDamping, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramInputReverbPreDelay, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramSyncMetToHost, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramSyncMetToFilePlayback, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramMainInMute, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramMainMonitorSolo, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramDynamicResampling, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramAutoReconnectLast, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramDefaultPeerLevel, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramDefaultAutoNetbuf, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramDefaultSendQual, this);
+    processor.getValueTreeState().removeParameterListener (SonobusAudioProcessor::paramDefaultNetbufMs, this);
 
 
     
@@ -2181,10 +4008,15 @@ void SonobusAudioProcessorEditor::buttonClicked (Button* buttonThatWasClicked)
             showEffectsConfig(true);
         } else {
             showEffectsConfig(false);
-        }        
+        }
     }
     else if (buttonThatWasClicked == mBufferMinButton.get()) {
         resetJitterBufferForAll();
+        
+        // Send OSC message for BufferMinButton click
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/BufferMinButton", 1);
+        }
     }
     else if (buttonThatWasClicked == mRecvSyncButton.get()) {
         SonobusAudioProcessor::LatencyInfo latinfo;
@@ -2257,6 +4089,11 @@ void SonobusAudioProcessorEditor::buttonClicked (Button* buttonThatWasClicked)
                 showPopTip(TRANS("Unmuted all who were not muted previously"), 3000, mMainRecvMuteButton.get());
             }
         }
+        
+        // Send OSC message for MainRecvMuteButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/MainRecvMuteButton", mMainRecvMuteButton->getToggleState() ? 1 : 0);
+        }
     }
     else if (buttonThatWasClicked == mMetSendButton.get()) {
         // handled by button attachment
@@ -2481,6 +4318,11 @@ void SonobusAudioProcessorEditor::buttonClicked (Button* buttonThatWasClicked)
             mRecordingButton->setToggleState(true, dontSendNotification);
 
         }
+        
+        // Send OSC message for RecordingButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/RecordingButton", processor.isRecordingToFile() ? 1 : 0);
+        }
     }
     else if (buttonThatWasClicked == mFileBrowseButton.get()) {
         if (mFileChooser.get() == nullptr) {
@@ -3455,6 +5297,11 @@ void SonobusAudioProcessorEditor::mouseDown (const MouseEvent& event)
             mPushToTalkWasMuted = processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramMainSendMute)->getValue() > 0;
             processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramMainRecvMute)->setValueNotifyingHost(1.0);            
             processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramMainSendMute)->setValueNotifyingHost(0.0);
+            
+            // Send OSC message for MainPushToTalkButton press
+            if (processor.getOSCEnabled()) {
+                processor.getOSCManager().sendMessage("/MainPushToTalkButton", 1);
+            }
         }
     }
 }
@@ -3472,6 +5319,11 @@ void SonobusAudioProcessorEditor::mouseUp (const MouseEvent& event)
             // back to mute self, hear others
             processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramMainSendMute)->setValueNotifyingHost(mPushToTalkWasMuted ? 1.0 : 0.0);            
             processor.getValueTreeState().getParameter(SonobusAudioProcessor::paramMainRecvMute)->setValueNotifyingHost(0.0);
+            
+            // Send OSC message for MainPushToTalkButton release
+            if (processor.getOSCEnabled()) {
+                processor.getOSCManager().sendMessage("/MainPushToTalkButton", 0);
+            }
         }
     }
     else if (event.eventComponent == mReverbTitleLabel.get()) {
@@ -3951,13 +5803,6 @@ void SonobusAudioProcessorEditor::parameterChanged (const String& pname, float n
         }
         triggerAsyncUpdate();
     }
-    else if (pname == SonobusAudioProcessor::paramMainRecvMute) {
-        {
-            const ScopedLock sl (clientStateLock);
-            clientEvents.add(ClientEvent(ClientEvent::PeerChangedState, ""));
-        }
-        triggerAsyncUpdate();
-    }
     else if (pname == SonobusAudioProcessor::paramWet) {
         // Send OSC message for OutGainSlider (wet) value change
         if (processor.getOSCEnabled()) {
@@ -3970,7 +5815,40 @@ void SonobusAudioProcessorEditor::parameterChanged (const String& pname, float n
             processor.getOSCManager().sendMessage("/OptionsMaxRecvPaddingSlider", newValue);
         }
     }
+    else if (pname == SonobusAudioProcessor::paramDry) {
+        // Send OSC message for DrySlider value change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/DrySlider", newValue);
+        }
+    }
+    else if (pname == SonobusAudioProcessor::paramMetGain) {
+        // Send OSC message for MetLevelSlider value change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/MetLevelSlider", newValue);
+        }
+    }
+    else if (pname == SonobusAudioProcessor::paramMetTempo) {
+        // Send OSC message for MetTempoSlider value change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/MetTempoSlider", newValue);
+        }
+    }
     else if (pname == SonobusAudioProcessor::paramMetEnabled) {
+        // Send OSC message for MetEnableButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/MetEnableButton", newValue > 0 ? 1 : 0);
+        }
+        {
+            const ScopedLock sl (clientStateLock);
+            clientEvents.add(ClientEvent(ClientEvent::PeerChangedState, ""));
+        }
+        triggerAsyncUpdate();
+    }
+    else if (pname == SonobusAudioProcessor::paramMainRecvMute) {
+        // Send OSC message for MainRecvMuteButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/MainRecvMuteButton", newValue > 0 ? 1 : 0);
+        }
         {
             const ScopedLock sl (clientStateLock);
             clientEvents.add(ClientEvent(ClientEvent::PeerChangedState, ""));
@@ -3978,13 +5856,57 @@ void SonobusAudioProcessorEditor::parameterChanged (const String& pname, float n
         triggerAsyncUpdate();
     }
     else if (pname == SonobusAudioProcessor::paramMetIsRecorded) {
+        // Send OSC message for OptionsMetRecordedButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OptionsMetRecordedButton", newValue > 0 ? 1 : 0);
+        }
         {
             const ScopedLock sl (clientStateLock);
             clientEvents.add(ClientEvent(ClientEvent::PeerChangedState, ""));
         }
         triggerAsyncUpdate();
     }
+    else if (pname == SonobusAudioProcessor::paramDynamicResampling) {
+        // Send OSC message for OptionsDynamicResamplingButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OptionsDynamicResamplingButton", newValue > 0 ? 1 : 0);
+        }
+    }
+    else if (pname == SonobusAudioProcessor::paramAutoReconnectLast) {
+        // Send OSC message for OptionsAutoReconnectButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OptionsAutoReconnectButton", newValue > 0 ? 1 : 0);
+        }
+    }
+    else if (pname == SonobusAudioProcessor::paramDefaultPeerLevel) {
+        // Send OSC message for OptionsDefaultLevelSlider value change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OptionsDefaultLevelSlider", newValue);
+        }
+    }
+    else if (pname == SonobusAudioProcessor::paramDefaultAutoNetbuf) {
+        // Send OSC message for OptionsAutosizeDefaultChoice value change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OptionsAutosizeDefaultChoice", static_cast<int>(newValue));
+        }
+    }
+    else if (pname == SonobusAudioProcessor::paramDefaultSendQual) {
+        // Send OSC message for OptionsFormatChoiceDefaultChoice value change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OptionsFormatChoiceDefaultChoice", static_cast<int>(newValue));
+        }
+    }
+    else if (pname == SonobusAudioProcessor::paramDefaultNetbufMs) {
+        // Send OSC message for BufferTimeSlider value change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/BufferTimeSlider", newValue);
+        }
+    }
     else if (pname == SonobusAudioProcessor::paramSendFileAudio) {
+        // Send OSC message for FileSendButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/FileSendButton", newValue > 0 ? 1 : 0);
+        }
         {
             const ScopedLock sl (clientStateLock);
             clientEvents.add(ClientEvent(ClientEvent::PeerChangedState, ""));
@@ -3992,6 +5914,21 @@ void SonobusAudioProcessorEditor::parameterChanged (const String& pname, float n
         triggerAsyncUpdate();
     }
     else if (pname == SonobusAudioProcessor::paramSendSoundboardAudio) {
+        // Send OSC message for SoundboardSendButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/SoundboardSendButton", newValue > 0 ? 1 : 0);
+        }
+        {
+            const ScopedLock sl (clientStateLock);
+            clientEvents.add(ClientEvent(ClientEvent::PeerChangedState, ""));
+        }
+        triggerAsyncUpdate();
+    }
+    else if (pname == SonobusAudioProcessor::paramSendMetAudio) {
+        // Send OSC message for MetSendButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/MetSendButton", newValue > 0 ? 1 : 0);
+        }
         {
             const ScopedLock sl (clientStateLock);
             clientEvents.add(ClientEvent(ClientEvent::PeerChangedState, ""));
@@ -4006,12 +5943,88 @@ void SonobusAudioProcessorEditor::parameterChanged (const String& pname, float n
         triggerAsyncUpdate();
     }
     else if (pname == SonobusAudioProcessor::paramMainReverbEnabled) {
+        // Send OSC message for MainReverbEnabled state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/MainReverbEnabled", newValue > 0 ? 1 : 0);
+        }
         {
             const ScopedLock sl (clientStateLock);
             clientEvents.add(ClientEvent(ClientEvent::PeerChangedState, ""));
         }
         triggerAsyncUpdate();
     }
+    else if (pname == SonobusAudioProcessor::paramMainReverbLevel) {
+        // Send OSC message for ReverbLevelSlider value change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/ReverbLevelSlider", newValue);
+        }
+    }
+    else if (pname == SonobusAudioProcessor::paramMainReverbSize) {
+        // Send OSC message for ReverbSizeSlider value change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/ReverbSizeSlider", newValue);
+        }
+    }
+    else if (pname == SonobusAudioProcessor::paramMainReverbDamping) {
+        // Send OSC message for ReverbDampingSlider value change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/ReverbDampingSlider", newValue);
+        }
+    }
+    else if (pname == SonobusAudioProcessor::paramMainReverbPreDelay) {
+        // Send OSC message for ReverbPreDelaySlider value change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/ReverbPreDelaySlider", newValue);
+        }
+    }
+    else if (pname == SonobusAudioProcessor::paramInputReverbLevel) {
+        // Send OSC message for InputReverbLevel value change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/InputReverbLevel", newValue);
+        }
+    }
+    else if (pname == SonobusAudioProcessor::paramInputReverbSize) {
+        // Send OSC message for InputReverbSize value change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/InputReverbSize", newValue);
+        }
+    }
+    else if (pname == SonobusAudioProcessor::paramInputReverbDamping) {
+        // Send OSC message for InputReverbDamping value change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/InputReverbDamping", newValue);
+        }
+    }
+    else if (pname == SonobusAudioProcessor::paramInputReverbPreDelay) {
+        // Send OSC message for InputReverbPreDelay value change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/InputReverbPreDelay", newValue);
+        }
+    }
+    else if (pname == SonobusAudioProcessor::paramSyncMetToHost) {
+        // Send OSC message for MetSyncButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/MetSyncButton", newValue > 0 ? 1 : 0);
+        }
+    }
+    else if (pname == SonobusAudioProcessor::paramSyncMetToFilePlayback) {
+        // Send OSC message for MetSyncFileButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/MetSyncFileButton", newValue > 0 ? 1 : 0);
+        }
+    }
+    else if (pname == SonobusAudioProcessor::paramMainInMute) {
+        // Send OSC message for InMuteButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/InMuteButton", newValue > 0 ? 1 : 0);
+        }
+    }
+    else if (pname == SonobusAudioProcessor::paramMainMonitorSolo) {
+        // Send OSC message for InSoloButton state change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/InSoloButton", newValue > 0 ? 1 : 0);
+        }
+    }
     else if (pname == SonobusAudioProcessor::paramSendChannels) {
         {
             const ScopedLock sl (clientStateLock);
diff --git a/doc/OSC_COMMANDS.md b/doc/OSC_COMMANDS.md
new file mode 100644
index 000000000..655f499f0
--- /dev/null
+++ b/doc/OSC_COMMANDS.md
@@ -0,0 +1,872 @@
+# SonoBus OSC Commands Documentation
+
+This document describes all available OSC (Open Sound Control) commands for controlling SonoBus remotely.
+
+## Overview
+
+SonoBus supports bidirectional OSC communication, allowing external controllers to both send commands to control the application and receive status updates when controls change.
+
+## Configuration
+
+OSC can be configured in the Options tab:
+- **Enable OSC**: Toggle OSC functionality on/off
+- **Target IP Address**: IP address to send OSC messages to (default: 127.0.0.1)
+- **Target Port**: Port to send OSC messages to (default: 9000)
+- **Receive Port**: Port to listen for incoming OSC messages (default: 9001)
+
+## OSC Address Format
+
+All OSC addresses follow the pattern: `/<ControlName>`
+
+## Control Types
+
+### Sliders (Float Values)
+Sliders accept and send float values representing the parameter value.
+- **Send**: `/address <float value>`
+- **Receive**: Application sends float value when slider changes
+
+### Toggle Buttons (On/Off State)
+Toggle buttons accept and send integer values (0 = off, 1 = on).
+- **Send**: `/address <int 0|1>`
+- **Receive**: Application sends 0 or 1 when toggle state changes
+
+### Push Buttons (Trigger Actions)
+Push buttons accept integer value 1 to trigger their action.
+- **Send**: `/address <int 1>`
+- **Receive**: Application sends 1 when button is clicked
+
+### Push-Hold Buttons (Press/Release)
+Push-hold buttons accept integer values (1 = press, 0 = release).
+- **Send**: `/address <int 0|1>`
+- **Receive**: Application sends 1 on press, 0 on release
+
+### Choice Buttons (Selection)
+Choice buttons accept and send integer values representing the selected option ID.
+- **Send**: `/address <int option_id>`
+- **Receive**: Application sends option ID when selection changes
+
+## Main UI Controls
+
+### Audio Controls
+
+#### `/DrySlider`
+**Type**: Slider  
+**Description**: Controls the monitor (dry) level - your own audio that you hear  
+**Data Type**: Float  
+**Range**: Audio level in decibels  
+**Parameter**: `paramDry`
+
+#### `/OutGainSlider`
+**Type**: Slider  
+**Description**: Controls the output (wet) level - mix of all incoming audio  
+**Data Type**: Float  
+**Range**: Audio level in decibels  
+**Parameter**: `paramWet`
+
+### Main Control Buttons
+
+#### `/MainMuteButton`
+**Type**: Toggle Button  
+**Description**: Mutes/unmutes sending your audio to others  
+**Data Type**: Integer (0 = unmuted/sending, 1 = muted/not sending)  
+**Parameter**: `paramMainSendMute`
+
+#### `/MainRecvMuteButton`
+**Type**: Toggle Button  
+**Description**: Mutes/unmutes receiving audio from all other users  
+**Data Type**: Integer (0 = unmuted/receiving, 1 = muted/not receiving)  
+**Parameter**: `paramMainRecvMute`
+
+#### `/MainPushToTalkButton`
+**Type**: Push-Hold Button  
+**Description**: Push to talk - temporarily unmutes sending and mutes receiving  
+**Data Type**: Integer (1 = press/talk, 0 = release/listen)  
+**Behavior**: 
+- When pressed (1): Unmutes send, mutes receive
+- When released (0): Restores previous send mute state, unmutes receive
+
+### Metronome Controls
+
+#### `/MetEnableButton`
+**Type**: Toggle Button  
+**Description**: Enables/disables the metronome  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Parameter**: `paramMetEnabled`
+
+#### `/MetLevelSlider`
+**Type**: Slider  
+**Description**: Controls the metronome level/volume  
+**Data Type**: Float  
+**Range**: Audio level  
+**Parameter**: `paramMetGain`
+
+#### `/MetTempoSlider`
+**Type**: Slider  
+**Description**: Controls the metronome tempo in BPM  
+**Data Type**: Float  
+**Range**: Tempo in beats per minute  
+**Parameter**: `paramMetTempo`
+
+#### `/MetSyncButton`
+**Type**: Toggle Button  
+**Description**: Synchronizes metronome to host DAW tempo  
+**Data Type**: Integer (0 = not synced, 1 = synced to host)  
+**Parameter**: `paramSyncMetToHost`
+
+#### `/MetSyncFileButton`
+**Type**: Toggle Button  
+**Description**: Synchronizes metronome to file playback tempo  
+**Data Type**: Integer (0 = not synced, 1 = synced to file)  
+**Parameter**: `paramSyncMetToFilePlayback`
+
+### Input Monitor Controls
+
+#### `/InMuteButton`
+**Type**: Toggle Button  
+**Description**: Mutes/unmutes your input monitor (what you hear of your own audio)  
+**Data Type**: Integer (0 = unmuted, 1 = muted)  
+**Parameter**: `paramMainInMute`
+
+#### `/InSoloButton`
+**Type**: Toggle Button  
+**Description**: Solos your input monitor  
+**Data Type**: Integer (0 = not soloed, 1 = soloed)  
+**Parameter**: `paramMainMonitorSolo`
+
+### Utility Buttons
+
+#### `/BufferMinButton`
+**Type**: Push Button  
+**Description**: Resets the jitter buffer to minimum for all connected users  
+**Data Type**: Integer (1 to trigger)  
+**Action**: Resets all peer jitter buffers
+
+#### `/RecvSyncButton`
+**Type**: Push Button  
+**Description**: Synchronizes receive latency for all users  
+**Data Type**: Integer (1 to trigger)  
+**Action**: Adjusts all peer jitter buffers to match the highest latency
+
+#### `/RecordingButton`
+**Type**: Toggle Button  
+**Description**: Starts/stops recording audio to file  
+**Data Type**: Integer (0 = stop recording, 1 = start recording)  
+**Behavior**: Toggles recording state
+- When turned on: Starts recording with current settings
+- When turned off: Stops recording and saves file
+
+### Main Reverb Controls
+
+#### `/MainReverbEnabled`
+**Type**: Toggle Button  
+**Description**: Enables/disables the main reverb effect  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Parameter**: `paramMainReverbEnabled`
+
+#### `/ReverbLevelSlider`
+**Type**: Slider  
+**Description**: Controls the reverb level/mix  
+**Data Type**: Float  
+**Range**: Audio level  
+**Parameter**: `paramMainReverbLevel`
+
+#### `/ReverbSizeSlider`
+**Type**: Slider  
+**Description**: Controls the reverb room size  
+**Data Type**: Float  
+**Range**: Room size parameter  
+**Parameter**: `paramMainReverbSize`
+
+#### `/ReverbDampingSlider`
+**Type**: Slider  
+**Description**: Controls the reverb damping (high frequency absorption)  
+**Data Type**: Float  
+**Range**: Damping parameter  
+**Parameter**: `paramMainReverbDamping`
+
+#### `/ReverbPreDelaySlider`
+**Type**: Slider  
+**Description**: Controls the reverb pre-delay time  
+**Data Type**: Float  
+**Range**: Pre-delay time in milliseconds  
+**Parameter**: `paramMainReverbPreDelay`
+
+### File Playback Controls
+
+#### `/FileSendButton`
+**Type**: Toggle Button  
+**Description**: Enables/disables sending file playback audio to all users  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Parameter**: `paramSendFileAudio`
+
+#### `/PlaybackSlider`
+**Type**: Slider  
+**Description**: Controls the file playback level/gain  
+**Data Type**: Float  
+**Range**: Audio level (0.0 - 2.0, where 1.0 is unity gain)  
+**Action**: Sets file playback volume
+
+#### `/FileMonitorSlider`
+**Type**: Slider  
+**Description**: Controls the file playback monitor level (what you hear)  
+**Data Type**: Float  
+**Range**: Audio level  
+**Action**: Sets file playback monitor volume
+
+### Soundboard Controls
+
+#### `/SoundboardSendButton`
+**Type**: Toggle Button  
+**Description**: Enables/disables sending soundboard audio to all users  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Parameter**: `paramSendSoundboardAudio`
+
+#### `/SoundboardLevelSlider`
+**Type**: Slider  
+**Description**: Controls the soundboard output level/gain  
+**Data Type**: Float  
+**Range**: Audio level  
+**Action**: Sets soundboard output volume
+
+#### `/SoundboardMonitorSlider`
+**Type**: Slider  
+**Description**: Controls the soundboard monitor level (what you hear)  
+**Data Type**: Float  
+**Range**: Audio level  
+**Action**: Sets soundboard monitor volume
+
+### Metronome Advanced Controls
+
+#### `/MetSendButton`
+**Type**: Toggle Button  
+**Description**: Enables/disables sending metronome to all users  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Parameter**: `paramSendMetAudio`
+
+#### `/MetPanSlider`
+**Type**: Slider  
+**Description**: Controls the metronome stereo pan position  
+**Data Type**: Float  
+**Range**: -1.0 (full left) to 1.0 (full right), 0.0 is center  
+**Action**: Sets metronome pan position
+
+#### `/MetMonitorSlider`
+**Type**: Slider  
+**Description**: Controls the metronome monitor level (what you hear)  
+**Data Type**: Float  
+**Range**: Audio level  
+**Action**: Sets metronome monitor volume
+
+### Input Reverb Controls
+
+#### `/InReverbButton`
+**Type**: Toggle Button  
+**Description**: Opens/closes the input reverb configuration panel  
+**Data Type**: Integer (1 to trigger)  
+**Action**: Toggles input reverb panel visibility
+
+#### `/InputReverbLevel`
+**Type**: Slider  
+**Description**: Controls the input reverb level/mix  
+**Data Type**: Float  
+**Range**: Audio level  
+**Parameter**: `paramInputReverbLevel`
+
+#### `/InputReverbSize`
+**Type**: Slider  
+**Description**: Controls the input reverb room size  
+**Data Type**: Float  
+**Range**: Room size parameter  
+**Parameter**: `paramInputReverbSize`
+
+#### `/InputReverbDamping`
+**Type**: Slider  
+**Description**: Controls the input reverb damping (high frequency absorption)  
+**Data Type**: Float  
+**Range**: Damping parameter  
+**Parameter**: `paramInputReverbDamping`
+
+#### `/InputReverbPreDelay`
+**Type**: Slider  
+**Description**: Controls the input reverb pre-delay time  
+**Data Type**: Float  
+**Range**: Pre-delay time in milliseconds  
+**Parameter**: `paramInputReverbPreDelay`
+
+### Monitor Delay Controls
+
+#### `/MonDelayButton`
+**Type**: Toggle Button  
+**Description**: Toggles monitor delay enabled on all input groups  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Action**: Enables/disables monitor delay for all inputs
+
+### Input Group Pre Level Controls
+
+SonoBus supports OSC control for up to 16 Input Groups. Each Input Group can be controlled independently using numbered OSC addresses.
+
+#### `/InputGroup[1-16]PreLevel`
+**Type**: Slider  
+**Description**: Controls the pre-fader level (gain) for the specified Input Group  
+**Data Type**: Float  
+**Range**: Audio level (0.0 - 2.0, where 1.0 is unity gain)  
+**Examples**:
+- `/InputGroup1PreLevel` - Controls Pre Level for Input Group 1
+- `/InputGroup2PreLevel` - Controls Pre Level for Input Group 2
+- `/InputGroup16PreLevel` - Controls Pre Level for Input Group 16
+
+**Note**: Input Groups are numbered 1-16. Only Input Groups that exist at runtime will respond to OSC messages. The number and configuration of Input Groups is determined by the user's audio setup.
+
+#### `/InputGroup[1-16]Pan`
+**Type**: Slider  
+**Description**: Controls the stereo pan position for single-channel Input Groups  
+**Data Type**: Float  
+**Range**: -1.0 (hard left) to 1.0 (hard right), 0.0 = center  
+**Examples**:
+- `/InputGroup1Pan` - Controls Pan for Input Group 1
+- `/InputGroup2Pan` - Controls Pan for Input Group 2
+
+#### `/InputGroup[1-16]PanLeft`
+**Type**: Slider  
+**Description**: Controls the left channel pan for dual-channel Input Groups  
+**Data Type**: Float  
+**Range**: -1.0 (hard left) to 1.0 (hard right), 0.0 = center  
+**Note**: Used when Input Group has stereo input channels
+
+#### `/InputGroup[1-16]PanRight`
+**Type**: Slider  
+**Description**: Controls the right channel pan for dual-channel Input Groups  
+**Data Type**: Float  
+**Range**: -1.0 (hard left) to 1.0 (hard right), 0.0 = center  
+**Note**: Used when Input Group has stereo input channels
+
+#### `/InputGroup[1-16]Monitor`
+**Type**: Slider  
+**Description**: Controls the monitor level (local monitoring gain) for the specified Input Group  
+**Data Type**: Float  
+**Range**: Audio level (0.0 - 2.0, where 1.0 is unity gain)  
+**Examples**:
+- `/InputGroup1Monitor` - Controls Monitor level for Input Group 1
+- `/InputGroup2Monitor` - Controls Monitor level for Input Group 2
+
+#### `/InputGroup[1-16]MonDelayEnable`
+**Type**: Toggle Button  
+**Description**: Enables/disables additional monitoring delay for the specified Input Group  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Note**: Part of the M.FX (Monitoring Effects) controls
+
+#### `/InputGroup[1-16]MonDelayTime`
+**Type**: Slider  
+**Description**: Sets the monitoring delay time in milliseconds for the specified Input Group  
+**Data Type**: Float  
+**Range**: 0.0 - 5000.0 ms  
+**Note**: Part of the M.FX (Monitoring Effects) controls
+
+#### `/InputGroup[1-16]MonDelayLink`
+**Type**: Toggle Button  
+**Description**: Links delay time with other inputs (global setting)  
+**Data Type**: Integer (0 = unlinked, 1 = linked)  
+**Note**: This is a global setting that affects all Input Groups
+
+#### `/InputGroup[1-16]MonReverbSend`
+**Type**: Slider  
+**Description**: Controls the main reverb send level for the specified Input Group's monitoring  
+**Data Type**: Float  
+**Range**: Audio level (0.0 - 1.0)  
+**Note**: Part of the M.FX (Monitoring Effects) controls
+
+#### `/InputGroup[1-16]Mute`
+**Type**: Toggle Button  
+**Description**: Mutes/unmutes the specified Input Group  
+**Data Type**: Integer (0 = unmuted, 1 = muted)  
+**Note**: Stateful control - maintains mute state
+
+#### `/InputGroup[1-16]Solo`
+**Type**: Toggle Button  
+**Description**: Solos/unsolos the specified Input Group  
+**Data Type**: Integer (0 = not soloed, 1 = soloed)  
+**Note**: Stateful control - when any Input Group is soloed, only soloed groups are heard
+
+#### `/InputGroup[1-16]InputReverbSend`
+**Type**: Slider  
+**Description**: Controls the input reverb send level (applied before sending to peers)  
+**Data Type**: Float  
+**Range**: Audio level (0.0 - 1.0)  
+**Note**: Part of the Input FX controls
+
+#### `/InputGroup[1-16]PolarityInvert`
+**Type**: Toggle Button  
+**Description**: Inverts the polarity/phase of the specified Input Group  
+**Data Type**: Integer (0 = normal, 1 = inverted)  
+**Note**: Part of the Input FX controls
+
+### Input Group Compressor Controls
+
+#### `/InputGroup[1-16]CompressorEnable`
+**Type**: Toggle Button  
+**Description**: Enables/disables the compressor effect for the specified Input Group  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Note**: Part of the Input FX controls
+
+#### `/InputGroup[1-16]CompressorThreshold`
+**Type**: Slider  
+**Description**: Sets the compressor threshold in dB  
+**Data Type**: Float  
+**Range**: -60.0 to 0.0 dB  
+
+#### `/InputGroup[1-16]CompressorRatio`
+**Type**: Slider  
+**Description**: Sets the compressor ratio  
+**Data Type**: Float  
+**Range**: 1.0 to 20.0 (e.g., 4.0 means 4:1 ratio)  
+
+#### `/InputGroup[1-16]CompressorAttack`
+**Type**: Slider  
+**Description**: Sets the compressor attack time in milliseconds  
+**Data Type**: Float  
+**Range**: 1.0 to 1000.0 ms  
+
+#### `/InputGroup[1-16]CompressorRelease`
+**Type**: Slider  
+**Description**: Sets the compressor release time in milliseconds  
+**Data Type**: Float  
+**Range**: 1.0 to 1000.0 ms  
+
+#### `/InputGroup[1-16]CompressorMakeupGain`
+**Type**: Slider  
+**Description**: Sets the compressor makeup gain in dB  
+**Data Type**: Float  
+**Range**: 0.0 to 60.0 dB  
+
+#### `/InputGroup[1-16]CompressorAuto`
+**Type**: Toggle Button  
+**Description**: Enables/disables automatic makeup gain calculation  
+**Data Type**: Integer (0 = manual, 1 = automatic)  
+
+### Input Group Expander (Noise Gate) Controls
+
+#### `/InputGroup[1-16]ExpanderEnable`
+**Type**: Toggle Button  
+**Description**: Enables/disables the noise gate effect for the specified Input Group  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Note**: Part of the Input FX controls
+
+#### `/InputGroup[1-16]ExpanderNoiseFloor`
+**Type**: Slider  
+**Description**: Sets the noise gate threshold (noise floor) in dB  
+**Data Type**: Float  
+**Range**: -96.0 to 0.0 dB  
+
+#### `/InputGroup[1-16]ExpanderRatio`
+**Type**: Slider  
+**Description**: Sets the expander ratio  
+**Data Type**: Float  
+**Range**: 1.0 to 20.0  
+
+#### `/InputGroup[1-16]ExpanderAttack`
+**Type**: Slider  
+**Description**: Sets the expander attack time in milliseconds  
+**Data Type**: Float  
+**Range**: 1.0 to 1000.0 ms  
+
+#### `/InputGroup[1-16]ExpanderRelease`
+**Type**: Slider  
+**Description**: Sets the expander release time in milliseconds  
+**Data Type**: Float  
+**Range**: 1.0 to 1000.0 ms  
+
+### Input Group Parametric EQ Controls
+
+#### `/InputGroup[1-16]EqEnable`
+**Type**: Toggle Button  
+**Description**: Enables/disables the parametric EQ effect for the specified Input Group  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Note**: Part of the Input FX controls
+
+#### `/InputGroup[1-16]EqLowShelfFreq`
+**Type**: Slider  
+**Description**: Sets the low shelf filter frequency in Hz  
+**Data Type**: Float  
+**Range**: 20.0 to 2000.0 Hz  
+**Default**: 60.0 Hz
+
+#### `/InputGroup[1-16]EqLowShelfGain`
+**Type**: Slider  
+**Description**: Sets the low shelf filter gain in dB  
+**Data Type**: Float  
+**Range**: -24.0 to 24.0 dB  
+
+#### `/InputGroup[1-16]EqPara1Freq`
+**Type**: Slider  
+**Description**: Sets the parametric band 1 center frequency in Hz  
+**Data Type**: Float  
+**Range**: 20.0 to 20000.0 Hz  
+**Default**: 90.0 Hz
+
+#### `/InputGroup[1-16]EqPara1Gain`
+**Type**: Slider  
+**Description**: Sets the parametric band 1 gain in dB  
+**Data Type**: Float  
+**Range**: -24.0 to 24.0 dB  
+
+#### `/InputGroup[1-16]EqPara1Q`
+**Type**: Slider  
+**Description**: Sets the parametric band 1 Q (bandwidth)  
+**Data Type**: Float  
+**Range**: 0.1 to 10.0  
+**Default**: 1.5
+
+#### `/InputGroup[1-16]EqHighShelfFreq`
+**Type**: Slider  
+**Description**: Sets the high shelf filter frequency in Hz  
+**Data Type**: Float  
+**Range**: 500.0 to 16000.0 Hz  
+**Default**: 10000.0 Hz
+
+#### `/InputGroup[1-16]EqHighShelfGain`
+**Type**: Slider  
+**Description**: Sets the high shelf filter gain in dB  
+**Data Type**: Float  
+**Range**: -24.0 to 24.0 dB  
+
+#### `/InputGroup[1-16]EqPara2Freq`
+**Type**: Slider  
+**Description**: Sets the parametric band 2 center frequency in Hz  
+**Data Type**: Float  
+**Range**: 20.0 to 20000.0 Hz  
+**Default**: 360.0 Hz
+
+#### `/InputGroup[1-16]EqPara2Gain`
+**Type**: Slider  
+**Description**: Sets the parametric band 2 gain in dB  
+**Data Type**: Float  
+**Range**: -24.0 to 24.0 dB  
+
+#### `/InputGroup[1-16]EqPara2Q`
+**Type**: Slider  
+**Description**: Sets the parametric band 2 Q (bandwidth)  
+**Data Type**: Float  
+**Range**: 0.1 to 10.0  
+**Default**: 4.0
+
+### File Playback Controls
+
+#### `/FilePlaybackPreLevel`
+**Type**: Slider  
+**Description**: Controls the pre-fader level (gain) for File Playback  
+**Data Type**: Float  
+**Range**: Audio level (0.0 - 2.0, where 1.0 is unity gain)
+
+## Options Tab Controls
+
+### Audio Options
+
+#### `/OptionsDynamicResamplingButton`
+**Type**: Toggle Button  
+**Description**: Enables/disables drift correction (dynamic resampling)  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Parameter**: `paramDynamicResampling`  
+**Note**: Not recommended for most users
+
+#### `/OptionsInputLimiterButton`
+**Type**: Toggle Button  
+**Description**: Enables/disables the input FX limiter  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Action**: Applies limiter to all input groups
+
+#### `/OptionsDefaultLevelSlider`
+**Type**: Slider  
+**Description**: Sets the default level for new peer connections  
+**Data Type**: Float  
+**Range**: Audio level in decibels  
+**Parameter**: `paramDefaultPeerLevel`
+
+#### `/OptionsMaxRecvPaddingSlider`
+**Type**: Slider  
+**Description**: Sets the maximum receive padding in milliseconds  
+**Data Type**: Float  
+**Range**: 0.0 - 500.0 ms  
+**Parameter**: `paramMaxRecvPaddingMs`
+
+### Connection Options
+
+#### `/OptionsAutoReconnectButton`
+**Type**: Toggle Button  
+**Description**: Enables/disables automatic reconnection to the last group  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Parameter**: `paramAutoReconnectLast`
+
+### Default Format Options
+
+#### `/OptionsAutosizeDefaultChoice`
+**Type**: Choice Button  
+**Description**: Sets the default auto network buffer setting for new connections  
+**Data Type**: Integer (option ID)  
+**Parameter**: `paramDefaultAutoNetbuf`  
+**Options**:
+- 0: Off
+- 1: Auto
+- 2: Auto Increased
+
+#### `/OptionsFormatChoiceDefaultChoice`
+**Type**: Choice Button  
+**Description**: Sets the default audio format/quality for new connections  
+**Data Type**: Integer (option ID)  
+**Parameter**: `paramDefaultSendQual`  
+**Options**: Various codec quality settings (PCM, Opus at different bitrates)
+
+#### `/BufferTimeSlider`
+**Type**: Slider  
+**Description**: Sets the default jitter buffer size in milliseconds  
+**Data Type**: Float  
+**Range**: Buffer time in milliseconds  
+**Parameter**: `paramDefaultNetbufMs`
+
+#### `/OptionsAutoDropThreshSlider`
+**Type**: Slider  
+**Description**: Controls auto-jitter buffer adjustment sensitivity based on dropout rate  
+**Data Type**: Float  
+**Range**: 1.0 - 20.0 seconds  
+**Note**: Threshold for automatic buffer size increases when dropouts occur
+
+### UI Options
+
+#### `/OptionsDisableShortcutButton`
+**Type**: Toggle Button  
+**Description**: Enables/disables keyboard shortcuts  
+**Data Type**: Integer (0 = shortcuts enabled, 1 = shortcuts disabled)  
+**Action**: Toggles keyboard shortcut functionality
+
+#### `/OptionsSliderSnapToMouseButton`
+**Type**: Toggle Button  
+**Description**: Controls whether sliders snap to clicked position  
+**Data Type**: Integer (0 = no snap, 1 = snap to mouse)  
+**Action**: Changes slider behavior for all sliders
+
+#### `/OptionsChangeAllFormatButton`
+**Type**: Toggle Button  
+**Description**: When enabled, changing default codec also changes existing peer connections  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Action**: Controls codec change behavior
+
+### System Options
+
+#### `/OptionsUseSpecificUdpPortButton`
+**Type**: Toggle Button  
+**Description**: Enables/disables use of a specific UDP port  
+**Data Type**: Integer (0 = system-chosen port, 1 = use specific port)  
+**Action**: Toggles specific UDP port usage
+
+#### `/OptionsUdpPortEditor`
+**Type**: Text Input  
+**Description**: Sets the specific UDP port to use (when enabled)  
+**Data Type**: Integer (port number)  
+**Range**: 1-65535  
+**Note**: Only active when UseSpecificUdpPort is enabled
+
+#### `/OptionsOverrideSamplerateButton`
+**Type**: Toggle Button  
+**Description**: Enables/disables sample rate override  
+**Data Type**: Integer (0 = use device rate, 1 = override)  
+**Action**: Toggles sample rate override (standalone app only)
+
+#### `/OptionsShouldCheckForUpdateButton`
+**Type**: Toggle Button  
+**Description**: Enables/disables automatic update checking  
+**Data Type**: Integer (0 = no auto-check, 1 = auto-check)  
+**Action**: Controls automatic update check behavior (standalone app only)
+
+### OSC Configuration
+
+#### `/OSCTargetIPAddress`
+**Type**: Text Input  
+**Description**: Sets the IP address for outbound OSC messages  
+**Data Type**: String (IP address)  
+**Default**: "127.0.0.1"
+
+#### `/OSCTargetPort`
+**Type**: Text Input  
+**Description**: Sets the port for outbound OSC messages  
+**Data Type**: Integer (port number)  
+**Range**: 1-65535  
+**Default**: 6001
+
+#### `/OSCReceivePort`
+**Type**: Text Input  
+**Description**: Sets the port for receiving OSC messages  
+**Data Type**: Integer (port number)  
+**Range**: 1-65535  
+**Default**: 6000
+
+## Recording Tab Controls
+
+### Recording Options
+
+#### `/OptionsRecStealth`
+**Type**: Toggle Button  
+**Description**: Enables/disables stealth recording (no visual indication to others)  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Action**: Sets stealth recording mode
+
+#### `/OptionsMetRecordedButton`
+**Type**: Toggle Button  
+**Description**: Enables/disables recording the metronome to file  
+**Data Type**: Integer (0 = not recorded, 1 = recorded)  
+**Parameter**: `paramMetIsRecorded`
+
+#### `/OptionsRecSelfPostFxButton`
+**Type**: Toggle Button  
+**Description**: Records your audio after FX processing (post-FX)  
+**Data Type**: Integer (0 = pre-FX, 1 = post-FX)  
+**Action**: Controls recording point for self audio
+
+#### `/OptionsRecSelfSilenceMutedButton`
+**Type**: Toggle Button  
+**Description**: Silences self recording when muted  
+**Data Type**: Integer (0 = record when muted, 1 = silence when muted)  
+**Action**: Controls self recording behavior when muted
+
+#### `/OptionsRecMixButton`
+**Type**: Toggle Button  
+**Description**: Enables/disables recording the output mix  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Action**: Includes/excludes output mix in recording
+
+#### `/OptionsRecSelfButton`
+**Type**: Toggle Button  
+**Description**: Enables/disables recording your own audio (dry)  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Action**: Includes/excludes your audio in recording
+
+#### `/OptionsRecOthersButton`
+**Type**: Toggle Button  
+**Description**: Enables/disables recording individual user tracks  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Action**: Includes/excludes individual user tracks in recording
+
+#### `/OptionsRecMixMinusButton`
+**Type**: Toggle Button  
+**Description**: Enables/disables recording the full mix without yourself  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Action**: Includes/excludes the output mix minus your own audio in recording
+
+**Note**: At least one recording option must be enabled. If all are disabled, RecMix is automatically enabled.
+
+## Example OSC Messages
+
+### Using Pure Data or Max/MSP
+
+```
+# Mute your audio
+/MainMuteButton 1
+
+# Unmute your audio
+/MainMuteButton 0
+
+# Set output gain to specific level
+/OutGainSlider -6.0
+
+# Enable metronome
+/MetEnableButton 1
+
+# Set metronome tempo to 120 BPM
+/MetTempoSlider 120.0
+
+# Start recording
+/RecordingButton 1
+
+# Push to talk (press)
+/MainPushToTalkButton 1
+
+# Push to talk (release)
+/MainPushToTalkButton 0
+
+# Reset jitter buffers
+/BufferMinButton 1
+
+# Enable stealth recording
+/OptionsRecStealth 1
+
+# Set default format to specific codec
+/OptionsFormatChoiceDefaultChoice 4
+```
+
+### Using Python with python-osc
+
+```python
+from pythonosc import udp_client
+
+# Create OSC client
+client = udp_client.SimpleUDPClient("127.0.0.1", 9001)
+
+# Mute sending
+client.send_message("/MainMuteButton", 1)
+
+# Set output level
+client.send_message("/OutGainSlider", -3.0)
+
+# Enable metronome
+client.send_message("/MetEnableButton", 1)
+
+# Set tempo
+client.send_message("/MetTempoSlider", 120.0)
+
+# Start recording
+client.send_message("/RecordingButton", 1)
+```
+
+### Using TouchOSC
+
+Create controls with the following OSC addresses:
+- Toggle button with address `/MainMuteButton` sending 0/1
+- Fader with address `/OutGainSlider` sending float values
+- Button with address `/RecordingButton` sending 0/1
+- XY Pad with `/MetTempoSlider` on one axis
+
+## Receiving OSC Messages from SonoBus
+
+When controls change in SonoBus (either by UI interaction or incoming OSC), the application sends OSC messages with the new values to the configured target IP and port. This allows external controllers to stay synchronized with the application state.
+
+Example listening in Python:
+```python
+from pythonosc import dispatcher
+from pythonosc import osc_server
+
+def handle_mute(unused_addr, value):
+    print(f"Mute state changed to: {value}")
+
+def handle_slider(unused_addr, value):
+    print(f"Slider value changed to: {value}")
+
+# Create dispatcher
+disp = dispatcher.Dispatcher()
+disp.map("/MainMuteButton", handle_mute)
+disp.map("/OutGainSlider", handle_slider)
+
+# Create server
+server = osc_server.ThreadingOSCUDPServer(("127.0.0.1", 9000), disp)
+print("Listening for OSC messages...")
+server.serve_forever()
+```
+
+## Notes
+
+- All OSC communication is done over UDP
+- Messages are sent only when OSC is enabled in the Options tab
+- Float values are sent as OSC float32
+- Integer values are sent as OSC int32
+- Changes to parameters via OSC will trigger the same behavior as UI interaction
+- Some controls may have range limits enforced by the application
+
+## Troubleshooting
+
+1. **Not receiving messages**: Check that the receive port matches your sender's target port
+2. **Not sending messages**: Verify OSC is enabled and target IP/port are correct
+3. **Values not applying**: Ensure data types match (float vs int) and values are in valid range
+4. **Network issues**: If using remote control, ensure firewall allows UDP traffic on OSC ports
+
+## Related Resources
+
+- [OSC Specification](http://opensoundcontrol.org/spec-1_0)
+- [TouchOSC](https://hexler.net/products/touchosc)
+- [python-osc](https://github.com/attwad/python-osc)
diff --git a/tests/oscsend.sh b/tests/oscsend.sh
new file mode 100755
index 000000000..f1857854d
--- /dev/null
+++ b/tests/oscsend.sh
@@ -0,0 +1,230 @@
+#!/bin/bash -x
+
+# Sends OSC messages to localhost port 6000
+# Each message is followed by a sleep for UI control verification
+
+# Audio Controls
+oscsend localhost 6000 /DrySlider f 1.0
+sleep 2
+oscsend localhost 6000 /DrySlider f 0.5
+sleep 2
+
+oscsend localhost 6000 /OutGainSlider f 1.0
+sleep 2
+oscsend localhost 6000 /OutGainSlider f 0.5
+sleep 2
+
+# Main Control Buttons
+oscsend localhost 6000 /MainMuteButton i 1
+sleep 2
+oscsend localhost 6000 /MainMuteButton i 0
+sleep 2
+
+oscsend localhost 6000 /MainRecvMuteButton i 1
+sleep 2
+oscsend localhost 6000 /MainRecvMuteButton i 0
+sleep 2
+
+oscsend localhost 6000 /MainPushToTalkButton i 1
+sleep 2
+oscsend localhost 6000 /MainPushToTalkButton i 0
+sleep 2
+
+# Metronome Controls
+oscsend localhost 6000 /MetEnableButton i 1
+sleep 2
+oscsend localhost 6000 /MetEnableButton i 0
+sleep 2
+
+oscsend localhost 6000 /MetLevelSlider f 0.8
+sleep 2
+oscsend localhost 6000 /MetLevelSlider f 0.4
+sleep 2
+
+oscsend localhost 6000 /MetTempoSlider f 120.0
+sleep 2
+oscsend localhost 6000 /MetTempoSlider f 60.0
+sleep 2
+
+# -- not sure where this is located in UI
+oscsend localhost 6000 /MetSyncButton i 1
+sleep 2
+oscsend localhost 6000 /MetSyncButton i 0
+sleep 2
+
+oscsend localhost 6000 /MetSyncFileButton i 1
+sleep 2
+oscsend localhost 6000 /MetSyncFileButton i 0
+sleep 2
+
+oscsend localhost 6000 /MetSendButton i 1
+sleep 2
+oscsend localhost 6000 /MetSendButton i 0
+sleep 2
+
+# Input Monitor Controls
+oscsend localhost 6000 /InMuteButton i 1
+sleep 2
+oscsend localhost 6000 /InMuteButton i 0
+sleep 2
+
+oscsend localhost 6000 /InSoloButton i 1
+sleep 2
+oscsend localhost 6000 /InSoloButton i 0
+sleep 2
+
+# Utility Buttons
+oscsend localhost 6000 /BufferMinButton i 1
+sleep 2
+
+oscsend localhost 6000 /RecvSyncButton i 1
+sleep 2
+
+oscsend localhost 6000 /RecordingButton i 1
+sleep 2
+oscsend localhost 6000 /RecordingButton i 0
+sleep 2
+
+# Example Command for Main Reverb Controls
+oscsend localhost 6000 /MainReverbEnabled i 1
+sleep 2
+oscsend localhost 6000 /MainReverbEnabled i 0
+sleep 2
+
+oscsend localhost 6000 /ReverbLevelSlider f 1.0
+sleep 2
+oscsend localhost 6000 /ReverbLevelSlider f 0.5
+sleep 2
+
+oscsend localhost 6000 /ReverbSizeSlider f 1.0
+sleep 2
+oscsend localhost 6000 /ReverbSizeSlider f 0.5
+sleep 2
+
+oscsend localhost 6000 /ReverbDampingSlider f 1.0
+sleep 2
+oscsend localhost 6000 /ReverbDampingSlider f 0.5
+sleep 2
+
+oscsend localhost 6000 /ReverbPreDelaySlider f 20.0
+sleep 2
+oscsend localhost 6000 /ReverbPreDelaySlider f 60.0
+sleep 2
+
+# Options Options
+oscsend localhost 6000 /OptionsDynamicResamplingButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsDynamicResamplingButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsUseSpecificUdpPortButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsUseSpecificUdpPortButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsUdpPortEditor i 12000
+sleep 2
+oscsend localhost 6000 /OptionsUdpPortEditor i 13000
+sleep 2
+
+oscsend localhost 6000 /OptionsOverrideSamplerateButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsOverrideSamplerateButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsShouldCheckForUpdateButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsShouldCheckForUpdateButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsAutoReconnectButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsAutoReconnectButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsSliderSnapToMouseButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsSliderSnapToMouseButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsInputLimiterButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsInputLimiterButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsDefaultLevelSlider f 0.73
+sleep 2
+oscsend localhost 6000 /OptionsDefaultLevelSlider f 0.1
+sleep 2
+
+oscsend localhost 6000 /OSCTargetIPAddress s "127.0.0.2"
+sleep 2
+oscsend localhost 6000 /OSCTargetIPAddress s "127.0.0.1"
+sleep 2
+
+oscsend localhost 6000 /OSCTargetPort i "9999"
+sleep 2
+oscsend localhost 6000 /OSCTargetPort i "6001"
+sleep 2
+
+# oscsend localhost 6000 /OSCReceivePort i "9998"
+# sleep 2
+# oscsend localhost 6000 /OSCReceivePort i "6000"
+#sleep 2
+
+oscsend localhost 6000 /OptionsMaxRecvPaddingSlider f 20.0
+sleep 2
+oscsend localhost 6000 /OptionsMaxRecvPaddingSlider f 10.0
+sleep 2
+
+oscsend localhost 6000 /OptionsAutoDropThreshSlider f 1.0
+sleep 2
+oscsend localhost 6000 /OptionsAutoDropThreshSlider f 33.0
+sleep 2
+
+oscsend localhost 6000 /BufferTimeSlider f 1.0
+sleep 2
+oscsend localhost 6000 /BufferTimeSlider f 33.0
+sleep 2
+
+oscsend localhost 6000 /OptionsChangeAllFormatButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsChangeAllFormatButton i 0
+sleep 2
+
+# Recording Options
+oscsend localhost 6000 /OptionsRecStealth i 1
+sleep 2
+oscsend localhost 6000 /OptionsRecStealth i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsRecSelfSilenceMutedButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsRecSelfSilenceMutedButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsRecSelfPostFxButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsRecSelfPostFxButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsMetRecordedButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsMetRecordedButton i 0
+sleep 2
+
+# -- Record features
+oscsend localhost 6000 /OptionsRecSelfButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsRecSelfButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsRecOthersButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsRecOthersButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsRecMixMinusButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsRecMixMinusButton i 0
+sleep 2
diff --git a/tests/oscsend_comprehensive.sh b/tests/oscsend_comprehensive.sh
new file mode 100755
index 000000000..a80de9348
--- /dev/null
+++ b/tests/oscsend_comprehensive.sh
@@ -0,0 +1,477 @@
+#!/bin/bash -x
+
+# Comprehensive OSC Test Script for SonoBus
+# Sends OSC messages to localhost port 6000
+# Each message is followed by a sleep for UI control verification
+
+echo "=== Audio Controls ==="
+oscsend localhost 6000 /DrySlider f 1.0
+sleep 2
+oscsend localhost 6000 /DrySlider f 0.5
+sleep 2
+
+oscsend localhost 6000 /OutGainSlider f 1.0
+sleep 2
+oscsend localhost 6000 /OutGainSlider f 0.5
+sleep 2
+
+echo "=== Main Control Buttons ==="
+oscsend localhost 6000 /MainMuteButton i 1
+sleep 2
+oscsend localhost 6000 /MainMuteButton i 0
+sleep 2
+
+oscsend localhost 6000 /MainRecvMuteButton i 1
+sleep 2
+oscsend localhost 6000 /MainRecvMuteButton i 0
+sleep 2
+
+oscsend localhost 6000 /MainPushToTalkButton i 1
+sleep 2
+oscsend localhost 6000 /MainPushToTalkButton i 0
+sleep 2
+
+echo "=== Input Monitor Controls ==="
+oscsend localhost 6000 /InMuteButton i 1
+sleep 2
+oscsend localhost 6000 /InMuteButton i 0
+sleep 2
+
+oscsend localhost 6000 /InSoloButton i 1
+sleep 2
+oscsend localhost 6000 /InSoloButton i 0
+sleep 2
+
+echo "=== Metronome Controls ==="
+oscsend localhost 6000 /MetEnableButton i 1
+sleep 2
+oscsend localhost 6000 /MetEnableButton i 0
+sleep 2
+
+oscsend localhost 6000 /MetLevelSlider f 0.8
+sleep 2
+oscsend localhost 6000 /MetLevelSlider f 0.4
+sleep 2
+
+oscsend localhost 6000 /MetTempoSlider f 120.0
+sleep 2
+oscsend localhost 6000 /MetTempoSlider f 60.0
+sleep 2
+
+oscsend localhost 6000 /MetSyncButton i 1
+sleep 2
+oscsend localhost 6000 /MetSyncButton i 0
+sleep 2
+
+oscsend localhost 6000 /MetSyncFileButton i 1
+sleep 2
+oscsend localhost 6000 /MetSyncFileButton i 0
+sleep 2
+
+oscsend localhost 6000 /MetSendButton i 1
+sleep 2
+oscsend localhost 6000 /MetSendButton i 0
+sleep 2
+
+oscsend localhost 6000 /MetPanSlider f -0.5
+sleep 2
+oscsend localhost 6000 /MetPanSlider f 0.5
+sleep 2
+
+oscsend localhost 6000 /MetMonitorSlider f 0.8
+sleep 2
+oscsend localhost 6000 /MetMonitorSlider f 0.4
+sleep 2
+
+echo "=== Utility Buttons ==="
+oscsend localhost 6000 /BufferMinButton i 1
+sleep 2
+
+oscsend localhost 6000 /RecvSyncButton i 1
+sleep 2
+
+oscsend localhost 6000 /RecordingButton i 1
+sleep 2
+oscsend localhost 6000 /RecordingButton i 0
+sleep 2
+
+echo "=== Main Reverb Controls ==="
+oscsend localhost 6000 /MainReverbEnabled i 1
+sleep 2
+oscsend localhost 6000 /MainReverbEnabled i 0
+sleep 2
+
+oscsend localhost 6000 /ReverbLevelSlider f 1.0
+sleep 2
+oscsend localhost 6000 /ReverbLevelSlider f 0.5
+sleep 2
+
+oscsend localhost 6000 /ReverbSizeSlider f 1.0
+sleep 2
+oscsend localhost 6000 /ReverbSizeSlider f 0.5
+sleep 2
+
+oscsend localhost 6000 /ReverbDampingSlider f 1.0
+sleep 2
+oscsend localhost 6000 /ReverbDampingSlider f 0.5
+sleep 2
+
+oscsend localhost 6000 /ReverbPreDelaySlider f 20.0
+sleep 2
+oscsend localhost 6000 /ReverbPreDelaySlider f 60.0
+sleep 2
+
+echo "=== Input Reverb Controls ==="
+oscsend localhost 6000 /InReverbButton i 1
+sleep 2
+oscsend localhost 6000 /InReverbButton i 0
+sleep 2
+
+oscsend localhost 6000 /InputReverbLevel f 0.8
+sleep 2
+oscsend localhost 6000 /InputReverbLevel f 0.4
+sleep 2
+
+oscsend localhost 6000 /InputReverbSize f 0.9
+sleep 2
+oscsend localhost 6000 /InputReverbSize f 0.5
+sleep 2
+
+oscsend localhost 6000 /InputReverbDamping f 0.7
+sleep 2
+oscsend localhost 6000 /InputReverbDamping f 0.3
+sleep 2
+
+oscsend localhost 6000 /InputReverbPreDelay f 30.0
+sleep 2
+oscsend localhost 6000 /InputReverbPreDelay f 10.0
+sleep 2
+
+echo "=== Monitor Delay ==="
+oscsend localhost 6000 /MonDelayButton i 1
+sleep 2
+oscsend localhost 6000 /MonDelayButton i 0
+sleep 2
+
+echo "=== File Playback Controls ==="
+oscsend localhost 6000 /FileSendButton i 1
+sleep 2
+oscsend localhost 6000 /FileSendButton i 0
+sleep 2
+
+oscsend localhost 6000 /PlaybackSlider f 0.9
+sleep 2
+oscsend localhost 6000 /PlaybackSlider f 0.5
+sleep 2
+
+oscsend localhost 6000 /FileMonitorSlider f 0.8
+sleep 2
+oscsend localhost 6000 /FileMonitorSlider f 0.4
+sleep 2
+
+oscsend localhost 6000 /FilePlaybackPreLevel f 0.7
+sleep 2
+oscsend localhost 6000 /FilePlaybackPreLevel f 0.3
+sleep 2
+
+echo "=== Soundboard Controls ==="
+oscsend localhost 6000 /SoundboardSendButton i 1
+sleep 2
+oscsend localhost 6000 /SoundboardSendButton i 0
+sleep 2
+
+oscsend localhost 6000 /SoundboardLevelSlider f 0.9
+sleep 2
+oscsend localhost 6000 /SoundboardLevelSlider f 0.5
+sleep 2
+
+oscsend localhost 6000 /SoundboardMonitorSlider f 0.8
+sleep 2
+oscsend localhost 6000 /SoundboardMonitorSlider f 0.4
+sleep 2
+
+echo "=== Input Group 1 Controls ==="
+oscsend localhost 6000 /InputGroup1PreLevel f 0.8
+sleep 2
+oscsend localhost 6000 /InputGroup1PreLevel f 0.5
+sleep 2
+
+oscsend localhost 6000 /InputGroup1Pan f -0.5
+sleep 2
+oscsend localhost 6000 /InputGroup1Pan f 0.5
+sleep 2
+
+oscsend localhost 6000 /InputGroup1PanLeft f -0.3
+sleep 2
+oscsend localhost 6000 /InputGroup1PanLeft f 0.3
+sleep 2
+
+oscsend localhost 6000 /InputGroup1PanRight f -0.4
+sleep 2
+oscsend localhost 6000 /InputGroup1PanRight f 0.4
+sleep 2
+
+oscsend localhost 6000 /InputGroup1Monitor f 0.7
+sleep 2
+oscsend localhost 6000 /InputGroup1Monitor f 0.3
+sleep 2
+
+echo "=== Input Group 1 M.FX Controls ==="
+oscsend localhost 6000 /InputGroup1MonDelayEnable i 1
+sleep 2
+oscsend localhost 6000 /InputGroup1MonDelayEnable i 0
+sleep 2
+
+oscsend localhost 6000 /InputGroup1MonDelayTime f 100.0
+sleep 2
+oscsend localhost 6000 /InputGroup1MonDelayTime f 50.0
+sleep 2
+
+oscsend localhost 6000 /InputGroup1MonDelayLink i 1
+sleep 2
+oscsend localhost 6000 /InputGroup1MonDelayLink i 0
+sleep 2
+
+oscsend localhost 6000 /InputGroup1MonReverbSend f 0.8
+sleep 2
+oscsend localhost 6000 /InputGroup1MonReverbSend f 0.4
+sleep 2
+
+echo "=== Input Group 1 Mute/Solo Controls ==="
+oscsend localhost 6000 /InputGroup1Mute i 1
+sleep 2
+oscsend localhost 6000 /InputGroup1Mute i 0
+sleep 2
+
+oscsend localhost 6000 /InputGroup1Solo i 1
+sleep 2
+oscsend localhost 6000 /InputGroup1Solo i 0
+sleep 2
+
+echo "=== Input Group 1 FX Controls ==="
+oscsend localhost 6000 /InputGroup1InputReverbSend f 0.6
+sleep 2
+oscsend localhost 6000 /InputGroup1InputReverbSend f 0.3
+sleep 2
+
+oscsend localhost 6000 /InputGroup1PolarityInvert i 1
+sleep 2
+oscsend localhost 6000 /InputGroup1PolarityInvert i 0
+sleep 2
+
+echo "=== Input Group 1 Compressor Controls ==="
+oscsend localhost 6000 /InputGroup1CompressorEnable i 1
+sleep 2
+oscsend localhost 6000 /InputGroup1CompressorThreshold f -20.0
+sleep 2
+oscsend localhost 6000 /InputGroup1CompressorRatio f 4.0
+sleep 2
+oscsend localhost 6000 /InputGroup1CompressorAttack f 15.0
+sleep 2
+oscsend localhost 6000 /InputGroup1CompressorRelease f 100.0
+sleep 2
+oscsend localhost 6000 /InputGroup1CompressorMakeupGain f 10.0
+sleep 2
+oscsend localhost 6000 /InputGroup1CompressorAuto i 1
+sleep 2
+oscsend localhost 6000 /InputGroup1CompressorAuto i 0
+sleep 2
+oscsend localhost 6000 /InputGroup1CompressorEnable i 0
+sleep 2
+
+echo "=== Input Group 1 Expander (Noise Gate) Controls ==="
+oscsend localhost 6000 /InputGroup1ExpanderEnable i 1
+sleep 2
+oscsend localhost 6000 /InputGroup1ExpanderNoiseFloor f -40.0
+sleep 2
+oscsend localhost 6000 /InputGroup1ExpanderRatio f 3.0
+sleep 2
+oscsend localhost 6000 /InputGroup1ExpanderAttack f 5.0
+sleep 2
+oscsend localhost 6000 /InputGroup1ExpanderRelease f 150.0
+sleep 2
+oscsend localhost 6000 /InputGroup1ExpanderEnable i 0
+sleep 2
+
+echo "=== Input Group 1 Parametric EQ Controls ==="
+oscsend localhost 6000 /InputGroup1EqEnable i 1
+sleep 2
+oscsend localhost 6000 /InputGroup1EqLowShelfFreq f 80.0
+sleep 2
+oscsend localhost 6000 /InputGroup1EqLowShelfGain f 3.0
+sleep 2
+oscsend localhost 6000 /InputGroup1EqPara1Freq f 200.0
+sleep 2
+oscsend localhost 6000 /InputGroup1EqPara1Gain f -2.0
+sleep 2
+oscsend localhost 6000 /InputGroup1EqPara1Q f 2.0
+sleep 2
+oscsend localhost 6000 /InputGroup1EqHighShelfFreq f 8000.0
+sleep 2
+oscsend localhost 6000 /InputGroup1EqHighShelfGain f -3.0
+sleep 2
+oscsend localhost 6000 /InputGroup1EqPara2Freq f 500.0
+sleep 2
+oscsend localhost 6000 /InputGroup1EqPara2Gain f 4.0
+sleep 2
+oscsend localhost 6000 /InputGroup1EqPara2Q f 3.0
+sleep 2
+oscsend localhost 6000 /InputGroup1EqEnable i 0
+sleep 2
+
+echo "=== Input Group 2 Controls (if exists) ==="
+oscsend localhost 6000 /InputGroup2PreLevel f 0.7
+sleep 2
+oscsend localhost 6000 /InputGroup2PreLevel f 0.4
+sleep 2
+
+oscsend localhost 6000 /InputGroup2Pan f -0.3
+sleep 2
+oscsend localhost 6000 /InputGroup2Pan f 0.3
+sleep 2
+
+oscsend localhost 6000 /InputGroup2Monitor f 0.6
+sleep 2
+oscsend localhost 6000 /InputGroup2Monitor f 0.2
+sleep 2
+
+echo "=== Options Tab Controls ==="
+oscsend localhost 6000 /OptionsDynamicResamplingButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsDynamicResamplingButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsUseSpecificUdpPortButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsUseSpecificUdpPortButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsUdpPortEditor i 12000
+sleep 2
+oscsend localhost 6000 /OptionsUdpPortEditor i 13000
+sleep 2
+
+oscsend localhost 6000 /OptionsOverrideSamplerateButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsOverrideSamplerateButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsShouldCheckForUpdateButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsShouldCheckForUpdateButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsAutoReconnectButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsAutoReconnectButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsSliderSnapToMouseButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsSliderSnapToMouseButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsDisableShortcutButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsDisableShortcutButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsInputLimiterButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsInputLimiterButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsDefaultLevelSlider f 0.73
+sleep 2
+oscsend localhost 6000 /OptionsDefaultLevelSlider f 0.1
+sleep 2
+
+oscsend localhost 6000 /OptionsMaxRecvPaddingSlider f 20.0
+sleep 2
+oscsend localhost 6000 /OptionsMaxRecvPaddingSlider f 10.0
+sleep 2
+
+oscsend localhost 6000 /OptionsAutoDropThreshSlider f 1.0
+sleep 2
+oscsend localhost 6000 /OptionsAutoDropThreshSlider f 33.0
+sleep 2
+
+oscsend localhost 6000 /BufferTimeSlider f 1.0
+sleep 2
+oscsend localhost 6000 /BufferTimeSlider f 33.0
+sleep 2
+
+oscsend localhost 6000 /OptionsChangeAllFormatButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsChangeAllFormatButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsAutosizeDefaultChoice i 1
+sleep 2
+oscsend localhost 6000 /OptionsAutosizeDefaultChoice i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsFormatChoiceDefaultChoice i 2
+sleep 2
+oscsend localhost 6000 /OptionsFormatChoiceDefaultChoice i 1
+sleep 2
+
+echo "=== OSC Configuration Controls ==="
+oscsend localhost 6000 /OSCTargetIPAddress s "127.0.0.2"
+sleep 2
+oscsend localhost 6000 /OSCTargetIPAddress s "127.0.0.1"
+sleep 2
+
+oscsend localhost 6000 /OSCTargetPort i 9999
+sleep 2
+oscsend localhost 6000 /OSCTargetPort i 6001
+sleep 2
+
+# Note: OSCReceivePort commented out to avoid changing port during test
+# oscsend localhost 6000 /OSCReceivePort i 9998
+# sleep 2
+# oscsend localhost 6000 /OSCReceivePort i 6000
+# sleep 2
+
+echo "=== Recording Options ==="
+oscsend localhost 6000 /OptionsRecStealth i 1
+sleep 2
+oscsend localhost 6000 /OptionsRecStealth i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsRecSelfSilenceMutedButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsRecSelfSilenceMutedButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsRecSelfPostFxButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsRecSelfPostFxButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsMetRecordedButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsMetRecordedButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsRecMixButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsRecMixButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsRecSelfButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsRecSelfButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsRecOthersButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsRecOthersButton i 0
+sleep 2
+
+oscsend localhost 6000 /OptionsRecMixMinusButton i 1
+sleep 2
+oscsend localhost 6000 /OptionsRecMixMinusButton i 0
+sleep 2
+
+echo "=== OSC Test Complete ==="

From 99acf9ae1323fb6c7514832723298500b467472d Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Mon, 26 Jan 2026 19:02:24 -0500
Subject: [PATCH 05/20] Add OSC controls for remote peer management and FX with
 state broadcasting and automatic peer sync (#19)

---
 Source/ChannelGroupsView.cpp      |   60 ++
 Source/OSCManager.cpp             |    2 +-
 Source/OptionsView.cpp            |   48 +-
 Source/OptionsView.h              |    4 +
 Source/PeersContainerView.cpp     |   29 +-
 Source/SonobusPluginEditor.cpp    | 1180 ++++++++++++++++++++++++++++-
 Source/SonobusPluginEditor.h      |    8 +
 Source/SonobusPluginProcessor.cpp |   13 +
 Source/SonobusPluginProcessor.h   |    4 +
 doc/OSC_COMMANDS.md               |  351 +++++++++
 tests/oscsend.sh                  |  230 ------
 tests/oscsend_comprehensive.sh    |  127 ++++
 12 files changed, 1784 insertions(+), 272 deletions(-)
 delete mode 100755 tests/oscsend.sh

diff --git a/Source/ChannelGroupsView.cpp b/Source/ChannelGroupsView.cpp
index 116f097a3..fd341e4e8 100644
--- a/Source/ChannelGroupsView.cpp
+++ b/Source/ChannelGroupsView.cpp
@@ -254,6 +254,17 @@ void ChannelGroupEffectsView::compressorParamsChanged(CompressorView *comp, Sono
         if (wason != ison) {
             listeners.call (&ChannelGroupEffectsView::Listener::effectsEnableChanged, this);
         }
+        
+        // Send OSC feedback for peer compressor parameters (only for first 16 peers, channel group 0)
+        if (processor.getOSCEnabled() && peerIndex < 16 && groupIndex == 0) {
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "CompressorEnable", params.enabled ? 1 : 0);
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "CompressorThreshold", params.thresholdDb);
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "CompressorRatio", params.ratio);
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "CompressorAttack", params.attackMs);
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "CompressorRelease", params.releaseMs);
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "CompressorMakeupGain", params.makeupGainDb);
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "CompressorAuto", params.automakeupGain ? 1 : 0);
+        }
     }
     else {
         bool wason = processor.getInputEffectsActive(groupIndex);
@@ -288,6 +299,15 @@ void ChannelGroupEffectsView::expanderParamsChanged(ExpanderView *comp, SonoAudi
         if (wason != ison) {
             listeners.call (&ChannelGroupEffectsView::Listener::effectsEnableChanged, this);
         }
+        
+        // Send OSC feedback for peer expander parameters (only for first 16 peers, channel group 0)
+        if (processor.getOSCEnabled() && peerIndex < 16 && groupIndex == 0) {
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "ExpanderEnable", params.enabled ? 1 : 0);
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "ExpanderNoiseFloor", params.thresholdDb);
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "ExpanderRatio", params.ratio);
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "ExpanderAttack", params.attackMs);
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "ExpanderRelease", params.releaseMs);
+        }
     }
     else {
         bool wason = processor.getInputEffectsActive(groupIndex);
@@ -319,6 +339,21 @@ void ChannelGroupEffectsView::parametricEqParamsChanged(ParametricEqView *comp,
         if (wason != ison) {
             listeners.call (&ChannelGroupEffectsView::Listener::effectsEnableChanged, this);
         }
+        
+        // Send OSC feedback for peer EQ parameters (only for first 16 peers, channel group 0)
+        if (processor.getOSCEnabled() && peerIndex < 16 && groupIndex == 0) {
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqEnable", params.enabled ? 1 : 0);
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqLowShelfFreq", params.lowShelfFreq);
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqLowShelfGain", params.lowShelfGain);
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqPara1Freq", params.para1Freq);
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqPara1Gain", params.para1Gain);
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqPara1Q", params.para1Q);
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqHighShelfFreq", params.highShelfFreq);
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqHighShelfGain", params.highShelfGain);
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqPara2Freq", params.para2Freq);
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqPara2Gain", params.para2Gain);
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqPara2Q", params.para2Q);
+        }
     } else {
         bool wason = processor.getInputEffectsActive(groupIndex);
 
@@ -355,6 +390,11 @@ void ChannelGroupEffectsView::reverbSendLevelChanged(ReverbSendView *comp, float
         if (wason != ison) {
             listeners.call (&ChannelGroupEffectsView::Listener::effectsEnableChanged, this);
         }
+        
+        // Send OSC feedback for peer input reverb send (only for first 16 peers, channel group 0)
+        if (processor.getOSCEnabled() && peerIndex < 16 && groupIndex == 0) {
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "InputReverbSend", revlevel);
+        }
     }
     else {
         bool wason = processor.getInputEffectsActive(groupIndex);
@@ -376,6 +416,11 @@ void ChannelGroupEffectsView::polarityInvertChanged(PolarityInvertView *comp, bo
 {
     if (peerMode) {
         processor.setRemotePeerPolarityInvert(peerIndex, groupIndex, polinv);
+        
+        // Send OSC feedback for peer polarity invert (only for first 16 peers, channel group 0)
+        if (processor.getOSCEnabled() && peerIndex < 16 && groupIndex == 0) {
+            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "PolarityInvert", polinv ? 1 : 0);
+        }
     }
     else {
         // input mode
@@ -4853,6 +4898,11 @@ void ChannelGroupsView::sliderValueChanged (Slider* slider)
 
         if (slider == mMainChannelView->levelSlider.get()) {
             processor.setRemotePeerLevelGain(mPeerIndex, mMainChannelView->levelSlider->getValue());
+            
+            // Send OSC feedback for peer level slider (only for first 16 peers)
+            if (processor.getOSCEnabled() && mPeerIndex < 16) {
+                processor.getOSCManager().sendMessage("/Peer" + String(mPeerIndex + 1) + "Level", static_cast<float>(mMainChannelView->levelSlider->getValue()));
+            }
             return;
         }
         else if (slider == mMainChannelView->panSlider.get()) {
@@ -4861,9 +4911,19 @@ void ChannelGroupsView::sliderValueChanged (Slider* slider)
                 float pan2 = mMainChannelView->panSlider->getMaxValue();
                 processor.setRemotePeerChannelPan(mPeerIndex, changroup, 0, pan1);
                 processor.setRemotePeerChannelPan(mPeerIndex, changroup, 1, pan2);
+                
+                // Send OSC feedback for pan (only for first 16 peers, using first channel value)
+                if (processor.getOSCEnabled() && mPeerIndex < 16) {
+                    processor.getOSCManager().sendMessage("/Peer" + String(mPeerIndex + 1) + "Pan", static_cast<float>(pan1));
+                }
             }
             else {
                 processor.setRemotePeerChannelPan(mPeerIndex, changroup, chi, mMainChannelView->panSlider->getValue());
+                
+                // Send OSC feedback for pan (only for first 16 peers)
+                if (processor.getOSCEnabled() && mPeerIndex < 16) {
+                    processor.getOSCManager().sendMessage("/Peer" + String(mPeerIndex + 1) + "Pan", static_cast<float>(mMainChannelView->panSlider->getValue()));
+                }
             }
             return;
         }
diff --git a/Source/OSCManager.cpp b/Source/OSCManager.cpp
index 5e4640e5a..17a71075d 100644
--- a/Source/OSCManager.cpp
+++ b/Source/OSCManager.cpp
@@ -2,7 +2,7 @@
 
 OSCManager::OSCManager()
 {
-    juce::Logger::writeToLog("OSCManager initialized.");
+    // OSCManager object created, but not initialized until OSC is enabled
 }
 
 OSCManager::~OSCManager()
diff --git a/Source/OptionsView.cpp b/Source/OptionsView.cpp
index 9765b8521..bf1c7485c 100644
--- a/Source/OptionsView.cpp
+++ b/Source/OptionsView.cpp
@@ -2,6 +2,7 @@
 // Copyright (C) 2021 Jesse Chappell
 
 #include "OptionsView.h"
+#include "SonobusPluginEditor.h"
 
 #if JUCE_ANDROID
 #include "juce_core/native/juce_BasicNativeHeaders.h"
@@ -377,6 +378,10 @@ OptionsView::OptionsView(SonobusAudioProcessor& proc, std::function<AudioDeviceM
     mOSCEnabledButton->addListener(this);
     mOSCEnabledButton->setTooltip(TRANS("Enable or disable OSC (Open Sound Control) functionality"));
 
+    mOSCSendStateOnStartButton = std::make_unique<ToggleButton>(TRANS("Send state to target on start"));
+    mOSCSendStateOnStartButton->addListener(this);
+    mOSCSendStateOnStartButton->setTooltip(TRANS("When enabled, sends current values of all OSC-enabled controls to the target address when OSC is enabled"));
+
     // OSC Configuration UI elements
     mOSCTargetIPAddressLabel = std::make_unique<Label>("", TRANS("OSC Target IP Address:"));
     configLabel(mOSCTargetIPAddressLabel.get(), false);
@@ -455,6 +460,7 @@ OptionsView::OptionsView(SonobusAudioProcessor& proc, std::function<AudioDeviceM
     
     // Add OSC Configuration UI elements
     mOptionsComponent->addAndMakeVisible(mOSCEnabledButton.get());
+    mOptionsComponent->addAndMakeVisible(mOSCSendStateOnStartButton.get());
     mOptionsComponent->addAndMakeVisible(mOSCTargetIPAddressLabel.get());
     mOptionsComponent->addAndMakeVisible(mOSCTargetIPAddressEditor.get());
     mOptionsComponent->addAndMakeVisible(mOSCTargetPortLabel.get());
@@ -739,11 +745,14 @@ void OptionsView::updateState(bool ignorecheck)
     // Update OSC Configuration UI
     bool oscEnabled = processor.getOSCEnabled();
     mOSCEnabledButton->setToggleState(oscEnabled, dontSendNotification);
+    mOSCSendStateOnStartButton->setToggleState(processor.getOSCSendStateOnStart(), dontSendNotification);
     mOSCTargetIPAddressEditor->setText(processor.getOSCTargetIPAddress(), dontSendNotification);
     mOSCTargetPortEditor->setText(String(processor.getOSCTargetPort()), dontSendNotification);
     mOSCReceivePortEditor->setText(String(processor.getOSCReceivePort()), dontSendNotification);
     
     // Enable/disable OSC fields based on OSC enabled state
+    mOSCSendStateOnStartButton->setEnabled(oscEnabled);
+    mOSCSendStateOnStartButton->setAlpha(oscEnabled ? 1.0 : 0.6);
     mOSCTargetIPAddressEditor->setEnabled(oscEnabled);
     mOSCTargetIPAddressEditor->setAlpha(oscEnabled ? 1.0 : 0.6);
     mOSCTargetPortEditor->setEnabled(oscEnabled);
@@ -857,6 +866,11 @@ void OptionsView::updateLayout()
     optionsOSCEnabledBox.items.add(FlexItem(10, 12).withFlex(0));
     optionsOSCEnabledBox.items.add(FlexItem(180, minpassheight, *mOSCEnabledButton).withMargin(0).withFlex(1));
     
+    optionsOSCSendStateOnStartBox.items.clear();
+    optionsOSCSendStateOnStartBox.flexDirection = FlexBox::Direction::row;
+    optionsOSCSendStateOnStartBox.items.add(FlexItem(10, 12).withFlex(0));
+    optionsOSCSendStateOnStartBox.items.add(FlexItem(220, minpassheight, *mOSCSendStateOnStartButton).withMargin(0).withFlex(1));
+    
     optionsOSCTargetIPBox.items.clear();
     optionsOSCTargetIPBox.flexDirection = FlexBox::Direction::row;
     optionsOSCTargetIPBox.items.add(FlexItem(10, 12));
@@ -964,6 +978,8 @@ void OptionsView::updateLayout()
     // Add OSC Configuration boxes
     optionsBox.items.add(FlexItem(100, minpassheight, optionsOSCEnabledBox).withMargin(2).withFlex(0));
     optionsBox.items.add(FlexItem(4, 3));
+    optionsBox.items.add(FlexItem(100, minpassheight, optionsOSCSendStateOnStartBox).withMargin(2).withFlex(0));
+    optionsBox.items.add(FlexItem(4, 3));
     optionsBox.items.add(FlexItem(100, minitemheight, optionsOSCTargetIPBox).withMargin(2).withFlex(0));
     optionsBox.items.add(FlexItem(4, 3));
     optionsBox.items.add(FlexItem(100, minitemheight, optionsOSCTargetPortBox).withMargin(2).withFlex(0));
@@ -1346,24 +1362,36 @@ void OptionsView::buttonClicked (Button* buttonThatWasClicked)
         processor.setOSCEnabled(enabled);
         
         // Update the enabled/disabled state of OSC fields
+        mOSCSendStateOnStartButton->setEnabled(enabled);
+        mOSCSendStateOnStartButton->setAlpha(enabled ? 1.0 : 0.6);
         mOSCTargetIPAddressEditor->setEnabled(enabled);
         mOSCTargetIPAddressEditor->setAlpha(enabled ? 1.0 : 0.6);
         mOSCTargetPortEditor->setEnabled(enabled);
         mOSCTargetPortEditor->setAlpha(enabled ? 1.0 : 0.6);
         mOSCReceivePortEditor->setEnabled(enabled);
         mOSCReceivePortEditor->setAlpha(enabled ? 1.0 : 0.6);
+        
+        // If enabling OSC and send state on start is enabled, send all current values
+        if (enabled && processor.getOSCSendStateOnStart()) {
+            if (auto* editor = processor.getActiveEditor()) {
+                if (auto* sonobusEditor = dynamic_cast<SonobusAudioProcessorEditor*>(editor)) {
+                    sonobusEditor->sendAllOSCState();
+                }
+            }
+        }
     }
-    else if (buttonThatWasClicked == mOSCEnabledButton.get()) {
-        bool enabled = mOSCEnabledButton->getToggleState();
-        processor.setOSCEnabled(enabled);
+    else if (buttonThatWasClicked == mOSCSendStateOnStartButton.get()) {
+        bool enabled = mOSCSendStateOnStartButton->getToggleState();
+        processor.setOSCSendStateOnStart(enabled);
         
-        // Update the enabled/disabled state of OSC fields
-        mOSCTargetIPAddressEditor->setEnabled(enabled);
-        mOSCTargetIPAddressEditor->setAlpha(enabled ? 1.0 : 0.6);
-        mOSCTargetPortEditor->setEnabled(enabled);
-        mOSCTargetPortEditor->setAlpha(enabled ? 1.0 : 0.6);
-        mOSCReceivePortEditor->setEnabled(enabled);
-        mOSCReceivePortEditor->setAlpha(enabled ? 1.0 : 0.6);
+        // If enabled and OSC is active, send all current values immediately
+        if (enabled && processor.getOSCEnabled()) {
+            if (auto* editor = processor.getActiveEditor()) {
+                if (auto* sonobusEditor = dynamic_cast<SonobusAudioProcessorEditor*>(editor)) {
+                    sonobusEditor->sendAllOSCState();
+                }
+            }
+        }
     }
     else if (buttonThatWasClicked == mOptionsUseSpecificUdpPortButton.get()) {
         if (!mOptionsUseSpecificUdpPortButton->getToggleState()) {
diff --git a/Source/OptionsView.h b/Source/OptionsView.h
index 5be1317b1..804f6ac8d 100644
--- a/Source/OptionsView.h
+++ b/Source/OptionsView.h
@@ -12,6 +12,8 @@
 #include "SonoDrawableButton.h"
 #include "GenericItemChooser.h"
 
+// Forward declaration
+class SonobusAudioProcessorEditor;
 
 class OptionsView :
 public Component,
@@ -187,6 +189,7 @@ public MultiTimer
 
     // OSC Configuration UI elements
     std::unique_ptr<ToggleButton> mOSCEnabledButton;
+    std::unique_ptr<ToggleButton> mOSCSendStateOnStartButton;
     std::unique_ptr<Label> mOSCTargetIPAddressLabel;
     std::unique_ptr<TextEditor> mOSCTargetIPAddressEditor;
     std::unique_ptr<Label> mOSCTargetPortLabel;
@@ -233,6 +236,7 @@ public MultiTimer
     FlexBox optionsMaxRecvPaddingBox;
     FlexBox optionsPluginDefaultBox;
     FlexBox optionsOSCEnabledBox;
+    FlexBox optionsOSCSendStateOnStartBox;
     FlexBox optionsOSCTargetIPBox;
     FlexBox optionsOSCTargetPortBox;
     FlexBox optionsOSCReceivePortBox;
diff --git a/Source/PeersContainerView.cpp b/Source/PeersContainerView.cpp
index d1023b9b0..c92e27274 100644
--- a/Source/PeersContainerView.cpp
+++ b/Source/PeersContainerView.cpp
@@ -2031,6 +2031,11 @@ void PeersContainerView::buttonClicked (Button* buttonThatWasClicked)
                     // turns off receiving and allow
                     processor.setRemotePeerRecvAllow(i, false);             
                 }
+                
+                // Send OSC feedback for Peer Mute (only for first 16 peers)
+                if (processor.getOSCEnabled() && i < 16) {
+                    processor.getOSCManager().sendMessage("/Peer" + String(i + 1) + "Mute", pvf->recvMutedButton->getToggleState() ? 1 : 0);
+                }
             }
             return;
         }
@@ -2046,6 +2051,12 @@ void PeersContainerView::buttonClicked (Button* buttonThatWasClicked)
                     else {
                         processor.setRemotePeerSoloed(j, false); 
                     }
+                    
+                    // Send OSC feedback for each peer Solo state (only for first 16 peers)
+                    if (processor.getOSCEnabled() && j < 16) {
+                        bool soloState = buttonThatWasClicked->getToggleState() && (i == j);
+                        processor.getOSCManager().sendMessage("/Peer" + String(j + 1) + "Solo", soloState ? 1 : 0);
+                    }
                 }
                     
                 // disable solo for main monitor too
@@ -2054,6 +2065,12 @@ void PeersContainerView::buttonClicked (Button* buttonThatWasClicked)
                 updatePeerViews();
             } else {
                 processor.setRemotePeerSoloed(i, buttonThatWasClicked->getToggleState()); 
+                
+                // Send OSC feedback for Peer Solo (only for first 16 peers)
+                if (processor.getOSCEnabled() && i < 16) {
+                    processor.getOSCManager().sendMessage("/Peer" + String(i + 1) + "Solo", buttonThatWasClicked->getToggleState() ? 1 : 0);
+                }
+                
                 updatePeerViews();
             }
             return;
@@ -2144,13 +2161,23 @@ void PeersContainerView::buttonClicked (Button* buttonThatWasClicked)
                         processor.setRemotePeerBufferTime(j, buftime);
                         if (i==j) {
                             pvf->bufferTimeSlider->setValue(buftime, dontSendNotification);
-                        }                            
+                        }
+                        
+                        // Send OSC feedback for BufferMin (only for first 16 peers)
+                        if (processor.getOSCEnabled() && j < 16) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(j + 1) + "BufferMin", 1);
+                        }
                     }
                 }
             } else {
                 float buftime = 0.0;
                 processor.setRemotePeerBufferTime(i, buftime);
                 pvf->bufferTimeSlider->setValue(buftime, dontSendNotification);
+                
+                // Send OSC feedback for BufferMin (only for first 16 peers)
+                if (processor.getOSCEnabled() && i < 16) {
+                    processor.getOSCManager().sendMessage("/Peer" + String(i + 1) + "BufferMin", 1);
+                }
             }
             
             updatePeerViews();
diff --git a/Source/SonobusPluginEditor.cpp b/Source/SonobusPluginEditor.cpp
index f24513c09..41b5dadb8 100644
--- a/Source/SonobusPluginEditor.cpp
+++ b/Source/SonobusPluginEditor.cpp
@@ -1399,6 +1399,50 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
     processor.getTransportSource().addChangeListener (this);
     
     // Register OSC controls with the OSCManager
+    // OSC controls are registered via registerAllOSCControls() when OSC is enabled
+    
+    // Register OSC controls if OSC is enabled
+    if (processor.getOSCEnabled()) {
+        registerAllOSCControls();
+    }
+    
+    // handles registering commands
+    updateUseKeybindings();
+        
+    commandManager.commandStatusChanged();
+    
+    setWantsKeyboardFocus(true);
+    
+    startTimer(PeriodicUpdateTimerId, 1000);
+
+#if (JUCE_WINDOWS || JUCE_MAC)
+    if (JUCEApplicationBase::isStandaloneApp()) {
+        startTimer(CheckForNewVersionTimerId, 5000);
+    }
+#endif
+
+   // Make sure that before the constructor has finished, you've set the
+   // editor's size to whatever you need it to be.
+
+    //auto defbounds = processor.getLastPluginBounds();
+
+    //setSize (defbounds.getWidth(), defbounds.getHeight());
+
+
+    // to make sure transport area is initialized with the current state
+    if (updateTransportWithURL(processor.getCurrentLoadedTransportURL())) {
+        processor.getTransportSource().sendChangeMessage();
+    }
+
+}
+
+
+void SonobusAudioProcessorEditor::registerAllOSCControls()
+{
+    if (mOSCControlsRegistered) {
+        return; // Already registered
+    }
+    
     OSCManager& oscManager = processor.getOSCManager();
     
     // Register OutGainSlider - updates slider value with a float
@@ -3156,39 +3200,749 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
         });
     }
 
-    // handles registering commands
-    updateUseKeybindings();
+    // Register Peer OSC controls (support up to 16 remote peers)
+    // Each peer maps to the first channel group (changroup=0) for FX controls
+    for (int peerIndex = 0; peerIndex < 16; ++peerIndex) {
+        // Peer Mute - Controls receive active state
+        String peerMuteAddress = "/Peer" + String(peerIndex + 1) + "Mute";
+        oscManager.registerControl(peerMuteAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isInt32()) {
+                bool muted = message[0].getInt32() != 0;
+                juce::MessageManager::callAsync([this, peerIndex, muted]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        // Match UI behavior: when muting, use setRemotePeerRecvAllow to turn off receiving and allow
+                        // when unmuting, use setRemotePeerRecvActive to allow receiving and invites
+                        if (muted) {
+                            processor.setRemotePeerRecvAllow(peerIndex, false);
+                        } else {
+                            processor.setRemotePeerRecvActive(peerIndex, true);
+                        }
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "Mute", muted ? 1 : 0);
+                        }
+                    }
+                });
+            }
+        });
         
-    commandManager.commandStatusChanged();
-    
-    setWantsKeyboardFocus(true);
-    
-    startTimer(PeriodicUpdateTimerId, 1000);
-
-#if (JUCE_WINDOWS || JUCE_MAC)
-    if (JUCEApplicationBase::isStandaloneApp()) {
-        startTimer(CheckForNewVersionTimerId, 5000);
-    }
-#endif
-
-   // Make sure that before the constructor has finished, you've set the
-   // editor's size to whatever you need it to be.
-
-    //auto defbounds = processor.getLastPluginBounds();
-
-    //setSize (defbounds.getWidth(), defbounds.getHeight());
-
-
-    // to make sure transport area is initialized with the current state
-    if (updateTransportWithURL(processor.getCurrentLoadedTransportURL())) {
-        processor.getTransportSource().sendChangeMessage();
+        // Peer Solo
+        String peerSoloAddress = "/Peer" + String(peerIndex + 1) + "Solo";
+        oscManager.registerControl(peerSoloAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isInt32()) {
+                bool soloed = message[0].getInt32() != 0;
+                juce::MessageManager::callAsync([this, peerIndex, soloed]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        processor.setRemotePeerSoloed(peerIndex, soloed);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "Solo", soloed ? 1 : 0);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer Buffer Min - Resets jitter buffer to minimum (push button)
+        String peerBufferMinAddress = "/Peer" + String(peerIndex + 1) + "BufferMin";
+        oscManager.registerControl(peerBufferMinAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isInt32()) {
+                bool trigger = message[0].getInt32() != 0;
+                if (trigger) {
+                    juce::MessageManager::callAsync([this, peerIndex]() {
+                        if (peerIndex < processor.getNumberRemotePeers()) {
+                            // Reset buffer time to minimum (0.0)
+                            float buftime = 0.0;
+                            processor.setRemotePeerBufferTime(peerIndex, buftime);
+                            // Update peer views
+                            if (auto* peersContainer = getPeersContainerView()) {
+                                peersContainer->updatePeerViews(peerIndex);
+                            }
+                            // Send OSC feedback (push button sends 1 when triggered)
+                            if (processor.getOSCEnabled()) {
+                                processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "BufferMin", 1);
+                            }
+                        }
+                    });
+                }
+            }
+        });
+        
+        // Peer Reset Drop - Resets packet drop statistics (push button)
+        String peerResetDropAddress = "/Peer" + String(peerIndex + 1) + "ResetDrop";
+        oscManager.registerControl(peerResetDropAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isInt32()) {
+                bool trigger = message[0].getInt32() != 0;
+                if (trigger) {
+                    juce::MessageManager::callAsync([this, peerIndex]() {
+                        if (peerIndex < processor.getNumberRemotePeers()) {
+                            processor.resetRemotePeerPacketStats(peerIndex);
+                            // Send OSC feedback (push button sends 1 when triggered)
+                            if (processor.getOSCEnabled()) {
+                                processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "ResetDrop", 1);
+                            }
+                        }
+                    });
+                }
+            }
+        });
+        
+        // Peer Level - Controls the level/gain for the peer
+        String peerLevelAddress = "/Peer" + String(peerIndex + 1) + "Level";
+        oscManager.registerControl(peerLevelAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float level = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, level]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        processor.setRemotePeerLevelGain(peerIndex, level);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "Level", level);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer Pan - Controls the pan for the peer (channel group 0, channel 0)
+        String peerPanAddress = "/Peer" + String(peerIndex + 1) + "Pan";
+        oscManager.registerControl(peerPanAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float pan = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, pan]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        // Set pan for channel group 0, channel 0
+                        processor.setRemotePeerChannelPan(peerIndex, 0, 0, pan);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "Pan", pan);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer Input Reverb Send (channel group 0)
+        String peerInputReverbSendAddress = "/Peer" + String(peerIndex + 1) + "InputReverbSend";
+        oscManager.registerControl(peerInputReverbSendAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float revSend = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, revSend]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        processor.setRemotePeerChannelReverbSend(peerIndex, 0, revSend);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "InputReverbSend", revSend);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer Polarity Invert (channel group 0)
+        String peerPolarityInvertAddress = "/Peer" + String(peerIndex + 1) + "PolarityInvert";
+        oscManager.registerControl(peerPolarityInvertAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isInt32()) {
+                bool inverted = message[0].getInt32() != 0;
+                juce::MessageManager::callAsync([this, peerIndex, inverted]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        processor.setRemotePeerPolarityInvert(peerIndex, 0, inverted);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "PolarityInvert", inverted ? 1 : 0);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer Compressor Enable (channel group 0)
+        String peerCompressorEnableAddress = "/Peer" + String(peerIndex + 1) + "CompressorEnable";
+        oscManager.registerControl(peerCompressorEnableAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isInt32()) {
+                bool enabled = message[0].getInt32() != 0;
+                juce::MessageManager::callAsync([this, peerIndex, enabled]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getRemotePeerCompressorParams(peerIndex, 0, params);
+                        params.enabled = enabled;
+                        processor.setRemotePeerCompressorParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "CompressorEnable", enabled ? 1 : 0);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer Compressor Threshold (channel group 0)
+        String peerCompressorThresholdAddress = "/Peer" + String(peerIndex + 1) + "CompressorThreshold";
+        oscManager.registerControl(peerCompressorThresholdAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float threshold = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, threshold]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getRemotePeerCompressorParams(peerIndex, 0, params);
+                        params.thresholdDb = threshold;
+                        processor.setRemotePeerCompressorParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "CompressorThreshold", threshold);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer Compressor Ratio (channel group 0)
+        String peerCompressorRatioAddress = "/Peer" + String(peerIndex + 1) + "CompressorRatio";
+        oscManager.registerControl(peerCompressorRatioAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float ratio = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, ratio]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getRemotePeerCompressorParams(peerIndex, 0, params);
+                        params.ratio = ratio;
+                        processor.setRemotePeerCompressorParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "CompressorRatio", ratio);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer Compressor Attack (channel group 0)
+        String peerCompressorAttackAddress = "/Peer" + String(peerIndex + 1) + "CompressorAttack";
+        oscManager.registerControl(peerCompressorAttackAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float attack = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, attack]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getRemotePeerCompressorParams(peerIndex, 0, params);
+                        params.attackMs = attack;
+                        processor.setRemotePeerCompressorParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "CompressorAttack", attack);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer Compressor Release (channel group 0)
+        String peerCompressorReleaseAddress = "/Peer" + String(peerIndex + 1) + "CompressorRelease";
+        oscManager.registerControl(peerCompressorReleaseAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float release = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, release]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getRemotePeerCompressorParams(peerIndex, 0, params);
+                        params.releaseMs = release;
+                        processor.setRemotePeerCompressorParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "CompressorRelease", release);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer Compressor Makeup Gain (channel group 0)
+        String peerCompressorMakeupGainAddress = "/Peer" + String(peerIndex + 1) + "CompressorMakeupGain";
+        oscManager.registerControl(peerCompressorMakeupGainAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float makeupGain = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, makeupGain]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getRemotePeerCompressorParams(peerIndex, 0, params);
+                        params.makeupGainDb = makeupGain;
+                        processor.setRemotePeerCompressorParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "CompressorMakeupGain", makeupGain);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer Compressor Auto (channel group 0)
+        String peerCompressorAutoAddress = "/Peer" + String(peerIndex + 1) + "CompressorAuto";
+        oscManager.registerControl(peerCompressorAutoAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isInt32()) {
+                bool autoMakeup = message[0].getInt32() != 0;
+                juce::MessageManager::callAsync([this, peerIndex, autoMakeup]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getRemotePeerCompressorParams(peerIndex, 0, params);
+                        params.automakeupGain = autoMakeup;
+                        processor.setRemotePeerCompressorParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "CompressorAuto", autoMakeup ? 1 : 0);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer Expander (Noise Gate) Enable (channel group 0)
+        String peerExpanderEnableAddress = "/Peer" + String(peerIndex + 1) + "ExpanderEnable";
+        oscManager.registerControl(peerExpanderEnableAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isInt32()) {
+                bool enabled = message[0].getInt32() != 0;
+                juce::MessageManager::callAsync([this, peerIndex, enabled]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getRemotePeerExpanderParams(peerIndex, 0, params);
+                        params.enabled = enabled;
+                        processor.setRemotePeerExpanderParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "ExpanderEnable", enabled ? 1 : 0);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer Expander Noise Floor (channel group 0)
+        String peerExpanderNoiseFloorAddress = "/Peer" + String(peerIndex + 1) + "ExpanderNoiseFloor";
+        oscManager.registerControl(peerExpanderNoiseFloorAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float noiseFloor = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, noiseFloor]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getRemotePeerExpanderParams(peerIndex, 0, params);
+                        params.thresholdDb = noiseFloor;
+                        processor.setRemotePeerExpanderParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "ExpanderNoiseFloor", noiseFloor);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer Expander Ratio (channel group 0)
+        String peerExpanderRatioAddress = "/Peer" + String(peerIndex + 1) + "ExpanderRatio";
+        oscManager.registerControl(peerExpanderRatioAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float ratio = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, ratio]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getRemotePeerExpanderParams(peerIndex, 0, params);
+                        params.ratio = ratio;
+                        processor.setRemotePeerExpanderParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "ExpanderRatio", ratio);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer Expander Attack (channel group 0)
+        String peerExpanderAttackAddress = "/Peer" + String(peerIndex + 1) + "ExpanderAttack";
+        oscManager.registerControl(peerExpanderAttackAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float attack = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, attack]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getRemotePeerExpanderParams(peerIndex, 0, params);
+                        params.attackMs = attack;
+                        processor.setRemotePeerExpanderParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "ExpanderAttack", attack);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer Expander Release (channel group 0)
+        String peerExpanderReleaseAddress = "/Peer" + String(peerIndex + 1) + "ExpanderRelease";
+        oscManager.registerControl(peerExpanderReleaseAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float release = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, release]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::CompressorParams params;
+                        processor.getRemotePeerExpanderParams(peerIndex, 0, params);
+                        params.releaseMs = release;
+                        processor.setRemotePeerExpanderParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "ExpanderRelease", release);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer Parametric EQ Enable (channel group 0)
+        String peerEqEnableAddress = "/Peer" + String(peerIndex + 1) + "EqEnable";
+        oscManager.registerControl(peerEqEnableAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isInt32()) {
+                bool enabled = message[0].getInt32() != 0;
+                juce::MessageManager::callAsync([this, peerIndex, enabled]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getRemotePeerEqParams(peerIndex, 0, params);
+                        params.enabled = enabled;
+                        processor.setRemotePeerEqParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqEnable", enabled ? 1 : 0);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer EQ Low Shelf Frequency (channel group 0)
+        String peerEqLowShelfFreqAddress = "/Peer" + String(peerIndex + 1) + "EqLowShelfFreq";
+        oscManager.registerControl(peerEqLowShelfFreqAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float freq = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, freq]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getRemotePeerEqParams(peerIndex, 0, params);
+                        params.lowShelfFreq = freq;
+                        processor.setRemotePeerEqParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqLowShelfFreq", freq);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer EQ Low Shelf Gain (channel group 0)
+        String peerEqLowShelfGainAddress = "/Peer" + String(peerIndex + 1) + "EqLowShelfGain";
+        oscManager.registerControl(peerEqLowShelfGainAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float gain = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, gain]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getRemotePeerEqParams(peerIndex, 0, params);
+                        params.lowShelfGain = gain;
+                        processor.setRemotePeerEqParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqLowShelfGain", gain);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer EQ Parametric 1 Frequency (channel group 0)
+        String peerEqPara1FreqAddress = "/Peer" + String(peerIndex + 1) + "EqPara1Freq";
+        oscManager.registerControl(peerEqPara1FreqAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float freq = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, freq]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getRemotePeerEqParams(peerIndex, 0, params);
+                        params.para1Freq = freq;
+                        processor.setRemotePeerEqParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqPara1Freq", freq);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer EQ Parametric 1 Gain (channel group 0)
+        String peerEqPara1GainAddress = "/Peer" + String(peerIndex + 1) + "EqPara1Gain";
+        oscManager.registerControl(peerEqPara1GainAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float gain = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, gain]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getRemotePeerEqParams(peerIndex, 0, params);
+                        params.para1Gain = gain;
+                        processor.setRemotePeerEqParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqPara1Gain", gain);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer EQ Parametric 1 Q (channel group 0)
+        String peerEqPara1QAddress = "/Peer" + String(peerIndex + 1) + "EqPara1Q";
+        oscManager.registerControl(peerEqPara1QAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float q = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, q]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getRemotePeerEqParams(peerIndex, 0, params);
+                        params.para1Q = q;
+                        processor.setRemotePeerEqParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqPara1Q", q);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer EQ High Shelf Frequency (channel group 0)
+        String peerEqHighShelfFreqAddress = "/Peer" + String(peerIndex + 1) + "EqHighShelfFreq";
+        oscManager.registerControl(peerEqHighShelfFreqAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float freq = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, freq]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getRemotePeerEqParams(peerIndex, 0, params);
+                        params.highShelfFreq = freq;
+                        processor.setRemotePeerEqParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqHighShelfFreq", freq);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer EQ High Shelf Gain (channel group 0)
+        String peerEqHighShelfGainAddress = "/Peer" + String(peerIndex + 1) + "EqHighShelfGain";
+        oscManager.registerControl(peerEqHighShelfGainAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float gain = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, gain]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getRemotePeerEqParams(peerIndex, 0, params);
+                        params.highShelfGain = gain;
+                        processor.setRemotePeerEqParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqHighShelfGain", gain);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer EQ Parametric 2 Frequency (channel group 0)
+        String peerEqPara2FreqAddress = "/Peer" + String(peerIndex + 1) + "EqPara2Freq";
+        oscManager.registerControl(peerEqPara2FreqAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float freq = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, freq]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getRemotePeerEqParams(peerIndex, 0, params);
+                        params.para2Freq = freq;
+                        processor.setRemotePeerEqParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqPara2Freq", freq);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer EQ Parametric 2 Gain (channel group 0)
+        String peerEqPara2GainAddress = "/Peer" + String(peerIndex + 1) + "EqPara2Gain";
+        oscManager.registerControl(peerEqPara2GainAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float gain = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, gain]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getRemotePeerEqParams(peerIndex, 0, params);
+                        params.para2Gain = gain;
+                        processor.setRemotePeerEqParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqPara2Gain", gain);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer EQ Parametric 2 Q (channel group 0)
+        String peerEqPara2QAddress = "/Peer" + String(peerIndex + 1) + "EqPara2Q";
+        oscManager.registerControl(peerEqPara2QAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            if (message.size() > 0 && message[0].isFloat32()) {
+                float q = message[0].getFloat32();
+                juce::MessageManager::callAsync([this, peerIndex, q]() {
+                    if (peerIndex < processor.getNumberRemotePeers()) {
+                        SonoAudio::ParametricEqParams params;
+                        processor.getRemotePeerEqParams(peerIndex, 0, params);
+                        params.para2Q = q;
+                        processor.setRemotePeerEqParams(peerIndex, 0, params);
+                        // Update peer views
+                        if (auto* peersContainer = getPeersContainerView()) {
+                            peersContainer->updatePeerViews(peerIndex);
+                        }
+                        // Send OSC feedback
+                        if (processor.getOSCEnabled()) {
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "EqPara2Q", q);
+                        }
+                    }
+                });
+            }
+        });
     }
 
+    
+    mOSCControlsRegistered = true;
 }
 
-SonobusAudioProcessorEditor::~SonobusAudioProcessorEditor()
+void SonobusAudioProcessorEditor::unregisterAllOSCControls()
 {
-    // Unregister OSC controls to prevent use-after-free
+    if (!mOSCControlsRegistered) {
+        return; // Not registered
+    }
+    
     OSCManager& oscManager = processor.getOSCManager();
     oscManager.unregisterControl("/OutGainSlider");
     oscManager.unregisterControl("/MainMuteButton");
@@ -3301,6 +4055,340 @@ SonobusAudioProcessorEditor::~SonobusAudioProcessorEditor()
         oscManager.unregisterControl("/InputGroup" + String(groupIndex + 1) + "EqPara2Q");
     }
     
+    // Unregister Peer OSC controls (up to 16 peers)
+    for (int peerIndex = 0; peerIndex < 16; ++peerIndex) {
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "Mute");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "Solo");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "BufferMin");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "ResetDrop");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "Level");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "Pan");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "InputReverbSend");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "PolarityInvert");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "CompressorEnable");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "CompressorThreshold");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "CompressorRatio");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "CompressorAttack");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "CompressorRelease");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "CompressorMakeupGain");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "CompressorAuto");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "ExpanderEnable");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "ExpanderNoiseFloor");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "ExpanderRatio");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "ExpanderAttack");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "ExpanderRelease");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "EqEnable");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "EqLowShelfFreq");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "EqLowShelfGain");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "EqPara1Freq");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "EqPara1Gain");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "EqPara1Q");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "EqHighShelfFreq");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "EqHighShelfGain");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "EqPara2Freq");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "EqPara2Gain");
+        oscManager.unregisterControl("/Peer" + String(peerIndex + 1) + "EqPara2Q");
+    }
+    
+    
+    mOSCControlsRegistered = false;
+}
+void SonobusAudioProcessorEditor::sendAllOSCState()
+{
+    if (!processor.getOSCEnabled()) {
+        return; // Don't send if OSC is not enabled
+    }
+    
+    OSCManager& oscManager = processor.getOSCManager();
+    auto& vts = processor.getValueTreeState();
+    
+    // Send main controls
+    if (mOutGainSlider) {
+        oscManager.sendMessage("/OutGainSlider", static_cast<float>(mOutGainSlider->getValue()));
+    }
+    if (mDrySlider) {
+        oscManager.sendMessage("/DrySlider", static_cast<float>(mDrySlider->getValue()));
+    }
+    if (mMainMuteButton) {
+        oscManager.sendMessage("/MainMuteButton", mMainMuteButton->getToggleState() ? 1 : 0);
+    }
+    if (mMainRecvMuteButton) {
+        oscManager.sendMessage("/MainRecvMuteButton", mMainRecvMuteButton->getToggleState() ? 1 : 0);
+    }
+    if (mMainPushToTalkButton) {
+        oscManager.sendMessage("/MainPushToTalkButton", mMainPushToTalkButton->getToggleState() ? 1 : 0);
+    }
+    if (mInMuteButton) {
+        oscManager.sendMessage("/InMuteButton", mInMuteButton->getToggleState() ? 1 : 0);
+    }
+    if (mInSoloButton) {
+        oscManager.sendMessage("/InSoloButton", mInSoloButton->getToggleState() ? 1 : 0);
+    }
+    
+    // Send recording controls
+    if (mRecordingButton) {
+        oscManager.sendMessage("/RecordingButton", mRecordingButton->getToggleState() ? 1 : 0);
+    }
+    
+    // Send buffer controls
+    if (auto* param = vts.getParameter(SonobusAudioProcessor::paramBufferTime)) {
+        oscManager.sendMessage("/BufferTimeSlider", param->convertFrom0to1(param->getValue()));
+    }
+    
+    // Send metronome controls
+    if (mMetLevelSlider) {
+        oscManager.sendMessage("/MetLevelSlider", static_cast<float>(mMetLevelSlider->getValue()));
+    }
+    if (mMetEnableButton) {
+        oscManager.sendMessage("/MetEnableButton", mMetEnableButton->getToggleState() ? 1 : 0);
+    }
+    if (mMetTempoSlider) {
+        oscManager.sendMessage("/MetTempoSlider", static_cast<float>(mMetTempoSlider->getValue()));
+    }
+    if (auto* param = vts.getParameter(SonobusAudioProcessor::paramMetIsRecorded)) {
+        oscManager.sendMessage("/OptionsMetRecordedButton", param->getValue() > 0.5f ? 1 : 0);
+    }
+    if (auto* param = vts.getParameter(SonobusAudioProcessor::paramSendMetAudio)) {
+        oscManager.sendMessage("/MetSendButton", param->getValue() > 0.5f ? 1 : 0);
+    }
+    if (auto* param = vts.getParameter(SonobusAudioProcessor::paramSyncMetToFilePlayback)) {
+        oscManager.sendMessage("/MetSyncFileButton", param->getValue() > 0.5f ? 1 : 0);
+    }
+    
+    // Send file playback controls
+    if (auto* param = vts.getParameter(SonobusAudioProcessor::paramSendFileAudio)) {
+        oscManager.sendMessage("/FileSendButton", param->getValue() > 0.5f ? 1 : 0);
+    }
+    
+    // Send reverb controls
+    if (mReverbEnabledButton) {
+        oscManager.sendMessage("/MainReverbEnabled", mReverbEnabledButton->getToggleState() ? 1 : 0);
+    }
+    if (mReverbLevelSlider) {
+        oscManager.sendMessage("/ReverbLevelSlider", static_cast<float>(mReverbLevelSlider->getValue()));
+    }
+    if (mReverbSizeSlider) {
+        oscManager.sendMessage("/ReverbSizeSlider", static_cast<float>(mReverbSizeSlider->getValue()));
+    }
+    if (mReverbDampingSlider) {
+        oscManager.sendMessage("/ReverbDampingSlider", static_cast<float>(mReverbDampingSlider->getValue()));
+    }
+    if (mReverbPreDelaySlider) {
+        oscManager.sendMessage("/ReverbPreDelaySlider", static_cast<float>(mReverbPreDelaySlider->getValue()));
+    }
+    
+    // Send options controls that we know exist
+    if (auto* param = vts.getParameter(SonobusAudioProcessor::paramMaxRecvPaddingMs)) {
+        oscManager.sendMessage("/OptionsMaxRecvPaddingSlider", param->convertFrom0to1(param->getValue()));
+    }
+    if (auto* param = vts.getParameter(SonobusAudioProcessor::paramDynamicResampling)) {
+        oscManager.sendMessage("/OptionsDynamicResamplingButton", param->getValue() > 0.5f ? 1 : 0);
+    }
+    if (auto* param = vts.getParameter(SonobusAudioProcessor::paramAutoReconnectLast)) {
+        oscManager.sendMessage("/OptionsAutoReconnectButton", param->getValue() > 0.5f ? 1 : 0);
+    }
+    if (auto* param = vts.getParameter(SonobusAudioProcessor::paramDefaultNetbufMs)) {
+        oscManager.sendMessage("/OptionsDefaultLevelSlider", param->convertFrom0to1(param->getValue()));
+    }
+    if (auto* param = vts.getParameter(SonobusAudioProcessor::paramDefaultAutoNetbuf)) {
+        oscManager.sendMessage("/OptionsAutosizeDefaultChoice", static_cast<int>(param->getValue()));
+    }
+    oscManager.sendMessage("/OptionsRecStealth", processor.getRecordStealth() ? 1 : 0);
+    
+    // Send peer controls
+    int numPeers = processor.getNumberRemotePeers();
+    for (int peerIndex = 0; peerIndex < jmin(numPeers, 16); ++peerIndex) {
+        // Send username (read-only control)
+        String username = processor.getRemotePeerUserName(peerIndex);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "RemotePeerUserName", username);
+        
+        // Peer mute/solo
+        bool muted = !processor.getRemotePeerRecvAllow(peerIndex);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "Mute", muted ? 1 : 0);
+        
+        bool soloed = processor.getRemotePeerSoloed(peerIndex);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "Solo", soloed ? 1 : 0);
+        
+        // Peer level
+        float level = processor.getRemotePeerLevelGain(peerIndex);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "Level", level);
+        
+        // Peer FX - Compressor
+        SonoAudio::CompressorParams compParams;
+        processor.getRemotePeerCompressorParams(peerIndex, 0, compParams);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "CompressorEnable", compParams.enabled ? 1 : 0);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "CompressorThreshold", compParams.thresholdDb);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "CompressorRatio", compParams.ratio);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "CompressorAttack", compParams.attackMs);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "CompressorRelease", compParams.releaseMs);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "CompressorMakeupGain", compParams.makeupGainDb);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "CompressorAuto", compParams.automakeupGain ? 1 : 0);
+        
+        // Peer FX - Expander
+        SonoAudio::CompressorParams expanderParams;
+        processor.getRemotePeerExpanderParams(peerIndex, 0, expanderParams);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "ExpanderEnable", expanderParams.enabled ? 1 : 0);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "ExpanderNoiseFloor", expanderParams.thresholdDb);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "ExpanderRatio", expanderParams.ratio);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "ExpanderAttack", expanderParams.attackMs);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "ExpanderRelease", expanderParams.releaseMs);
+        
+        // Peer FX - EQ
+        SonoAudio::ParametricEqParams eqParams;
+        processor.getRemotePeerEqParams(peerIndex, 0, eqParams);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqEnable", eqParams.enabled ? 1 : 0);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqLowShelfFreq", eqParams.lowShelfFreq);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqLowShelfGain", eqParams.lowShelfGain);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqPara1Freq", eqParams.para1Freq);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqPara1Gain", eqParams.para1Gain);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqPara1Q", eqParams.para1Q);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqHighShelfFreq", eqParams.highShelfFreq);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqHighShelfGain", eqParams.highShelfGain);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqPara2Freq", eqParams.para2Freq);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqPara2Gain", eqParams.para2Gain);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqPara2Q", eqParams.para2Q);
+        
+        // Peer FX - Reverb Send
+        float reverbSend = processor.getRemotePeerChannelReverbSend(peerIndex, 0);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "InputReverbSend", reverbSend);
+        
+        // Peer FX - Polarity Invert
+        bool polarityInvert = processor.getRemotePeerPolarityInvert(peerIndex, 0);
+        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "PolarityInvert", polarityInvert ? 1 : 0);
+    }
+}
+
+void SonobusAudioProcessorEditor::sendPeerOSCState(int peerIndex)
+{
+    if (!processor.getOSCEnabled() || peerIndex < 0 || peerIndex >= processor.getNumberRemotePeers()) {
+        return;
+    }
+    
+    OSCManager& oscManager = processor.getOSCManager();
+    String peerNum = String(peerIndex + 1);
+    
+    // Send username (read-only control)
+    String username = processor.getRemotePeerUserName(peerIndex);
+    oscManager.sendMessage("/Peer" + peerNum + "RemotePeerUserName", username);
+    
+    // Send peer mute/solo
+    bool muted = !processor.getRemotePeerRecvAllow(peerIndex);
+    oscManager.sendMessage("/Peer" + peerNum + "Mute", muted ? 1 : 0);
+    
+    bool soloed = processor.getRemotePeerSoloed(peerIndex);
+    oscManager.sendMessage("/Peer" + peerNum + "Solo", soloed ? 1 : 0);
+    
+    // Send peer level
+    float level = processor.getRemotePeerLevelGain(peerIndex);
+    oscManager.sendMessage("/Peer" + peerNum + "Level", level);
+    
+    // Send peer pan (channel group 0, channel 0)
+    float pan = processor.getRemotePeerChannelPan(peerIndex, 0, 0);
+    oscManager.sendMessage("/Peer" + peerNum + "Pan", pan);
+    
+    // Send compressor FX
+    SonoAudio::CompressorParams compParams;
+    processor.getRemotePeerCompressorParams(peerIndex, 0, compParams);
+    oscManager.sendMessage("/Peer" + peerNum + "CompressorEnable", compParams.enabled ? 1 : 0);
+    oscManager.sendMessage("/Peer" + peerNum + "CompressorThreshold", compParams.thresholdDb);
+    oscManager.sendMessage("/Peer" + peerNum + "CompressorRatio", compParams.ratio);
+    oscManager.sendMessage("/Peer" + peerNum + "CompressorAttack", compParams.attackMs);
+    oscManager.sendMessage("/Peer" + peerNum + "CompressorRelease", compParams.releaseMs);
+    oscManager.sendMessage("/Peer" + peerNum + "CompressorMakeupGain", compParams.makeupGainDb);
+    oscManager.sendMessage("/Peer" + peerNum + "CompressorAuto", compParams.automakeupGain ? 1 : 0);
+    
+    // Send expander FX
+    SonoAudio::CompressorParams expanderParams;
+    processor.getRemotePeerExpanderParams(peerIndex, 0, expanderParams);
+    oscManager.sendMessage("/Peer" + peerNum + "ExpanderEnable", expanderParams.enabled ? 1 : 0);
+    oscManager.sendMessage("/Peer" + peerNum + "ExpanderNoiseFloor", expanderParams.thresholdDb);
+    oscManager.sendMessage("/Peer" + peerNum + "ExpanderRatio", expanderParams.ratio);
+    oscManager.sendMessage("/Peer" + peerNum + "ExpanderAttack", expanderParams.attackMs);
+    oscManager.sendMessage("/Peer" + peerNum + "ExpanderRelease", expanderParams.releaseMs);
+    
+    // Send EQ FX
+    SonoAudio::ParametricEqParams eqParams;
+    processor.getRemotePeerEqParams(peerIndex, 0, eqParams);
+    oscManager.sendMessage("/Peer" + peerNum + "EqEnable", eqParams.enabled ? 1 : 0);
+    oscManager.sendMessage("/Peer" + peerNum + "EqLowShelfFreq", eqParams.lowShelfFreq);
+    oscManager.sendMessage("/Peer" + peerNum + "EqLowShelfGain", eqParams.lowShelfGain);
+    oscManager.sendMessage("/Peer" + peerNum + "EqPara1Freq", eqParams.para1Freq);
+    oscManager.sendMessage("/Peer" + peerNum + "EqPara1Gain", eqParams.para1Gain);
+    oscManager.sendMessage("/Peer" + peerNum + "EqPara1Q", eqParams.para1Q);
+    oscManager.sendMessage("/Peer" + peerNum + "EqHighShelfFreq", eqParams.highShelfFreq);
+    oscManager.sendMessage("/Peer" + peerNum + "EqHighShelfGain", eqParams.highShelfGain);
+    oscManager.sendMessage("/Peer" + peerNum + "EqPara2Freq", eqParams.para2Freq);
+    oscManager.sendMessage("/Peer" + peerNum + "EqPara2Gain", eqParams.para2Gain);
+    oscManager.sendMessage("/Peer" + peerNum + "EqPara2Q", eqParams.para2Q);
+    
+    // Send reverb send
+    float reverbSend = processor.getRemotePeerChannelReverbSend(peerIndex, 0);
+    oscManager.sendMessage("/Peer" + peerNum + "InputReverbSend", reverbSend);
+    
+    // Send polarity invert
+    bool polarityInvert = processor.getRemotePeerPolarityInvert(peerIndex, 0);
+    oscManager.sendMessage("/Peer" + peerNum + "PolarityInvert", polarityInvert ? 1 : 0);
+}
+
+void SonobusAudioProcessorEditor::clearPeerOSCState(int peerIndex)
+{
+    if (!processor.getOSCEnabled() || peerIndex < 0 || peerIndex >= 16) {
+        return;
+    }
+    
+    OSCManager& oscManager = processor.getOSCManager();
+    String peerNum = String(peerIndex + 1);
+    
+    // Clear username to empty string
+    oscManager.sendMessage("/Peer" + peerNum + "RemotePeerUserName", "");
+    
+    // Clear all other peer controls to default/off states
+    oscManager.sendMessage("/Peer" + peerNum + "Mute", 0);
+    oscManager.sendMessage("/Peer" + peerNum + "Solo", 0);
+    oscManager.sendMessage("/Peer" + peerNum + "Level", 1.0f);
+    oscManager.sendMessage("/Peer" + peerNum + "Pan", 0.0f);  // Center pan
+    
+    // Clear compressor
+    oscManager.sendMessage("/Peer" + peerNum + "CompressorEnable", 0);
+    oscManager.sendMessage("/Peer" + peerNum + "CompressorThreshold", 0.0f);
+    oscManager.sendMessage("/Peer" + peerNum + "CompressorRatio", 1.0f);
+    oscManager.sendMessage("/Peer" + peerNum + "CompressorAttack", 0.0f);
+    oscManager.sendMessage("/Peer" + peerNum + "CompressorRelease", 0.0f);
+    oscManager.sendMessage("/Peer" + peerNum + "CompressorMakeupGain", 0.0f);
+    oscManager.sendMessage("/Peer" + peerNum + "CompressorAuto", 0);
+    
+    // Clear expander
+    oscManager.sendMessage("/Peer" + peerNum + "ExpanderEnable", 0);
+    oscManager.sendMessage("/Peer" + peerNum + "ExpanderNoiseFloor", 0.0f);
+    oscManager.sendMessage("/Peer" + peerNum + "ExpanderRatio", 1.0f);
+    oscManager.sendMessage("/Peer" + peerNum + "ExpanderAttack", 0.0f);
+    oscManager.sendMessage("/Peer" + peerNum + "ExpanderRelease", 0.0f);
+    
+    // Clear EQ
+    oscManager.sendMessage("/Peer" + peerNum + "EqEnable", 0);
+    oscManager.sendMessage("/Peer" + peerNum + "EqLowShelfFreq", 0.0f);
+    oscManager.sendMessage("/Peer" + peerNum + "EqLowShelfGain", 0.0f);
+    oscManager.sendMessage("/Peer" + peerNum + "EqPara1Freq", 0.0f);
+    oscManager.sendMessage("/Peer" + peerNum + "EqPara1Gain", 0.0f);
+    oscManager.sendMessage("/Peer" + peerNum + "EqPara1Q", 0.0f);
+    oscManager.sendMessage("/Peer" + peerNum + "EqHighShelfFreq", 0.0f);
+    oscManager.sendMessage("/Peer" + peerNum + "EqHighShelfGain", 0.0f);
+    oscManager.sendMessage("/Peer" + peerNum + "EqPara2Freq", 0.0f);
+    oscManager.sendMessage("/Peer" + peerNum + "EqPara2Gain", 0.0f);
+    oscManager.sendMessage("/Peer" + peerNum + "EqPara2Q", 0.0f);
+    
+    // Clear reverb send
+    oscManager.sendMessage("/Peer" + peerNum + "InputReverbSend", 0.0f);
+    
+    // Clear polarity invert
+    oscManager.sendMessage("/Peer" + peerNum + "PolarityInvert", 0);
+}
+
+SonobusAudioProcessorEditor::~SonobusAudioProcessorEditor()
+{
+    // Unregister OSC controls to prevent use-after-free
+    unregisterAllOSCControls();
+    
     if (menuBarModel) {
         menuBarModel->setApplicationCommandManagerToWatch(nullptr);
 #if JUCE_MAC
@@ -3632,9 +4720,23 @@ void SonobusAudioProcessorEditor::aooClientPeerJoinBlocked(SonobusAudioProcessor
 void SonobusAudioProcessorEditor::aooClientPeerLeft(SonobusAudioProcessor *comp, const String & group, const String & user)  
 {
     DBG("Client peer '" << user  << "' left group '" <<  group << "'");
+    
+    // Find peer index NOW before the peer is removed from the processor's list
+    int peerIndex = -1;
+    if (processor.getOSCEnabled()) {
+        int numPeers = processor.getNumberRemotePeers();
+        for (int i = 0; i < jmin(numPeers, 16); ++i) {
+            if (processor.getRemotePeerUserName(i) == user) {
+                peerIndex = i;
+                break;
+            }
+        }
+    }
+    
     {
         const ScopedLock sl (clientStateLock);        
-        clientEvents.add(ClientEvent(ClientEvent::PeerLeaveEvent, group, true, "", user));
+        // Store the peer index in floatVal so we can clear OSC state in async handler
+        clientEvents.add(ClientEvent(ClientEvent::PeerLeaveEvent, group, true, "", user, static_cast<float>(peerIndex)));
     }
     triggerAsyncUpdate();
 
@@ -6266,10 +7368,21 @@ void SonobusAudioProcessorEditor::handleAsyncUpdate()
                 mChatView->addNewChatMessage(SBChatEvent(SBChatEvent::SystemType, ev.group, ev.user, "", "", mesg));
             }
 
-            // delay update
-            Timer::callAfterDelay(200, [this] {
+            // delay update and send OSC state
+            Timer::callAfterDelay(200, [this, username = ev.user] {
                 updatePeerState(true);
                 updateState(false);
+                
+                // Send OSC state for the newly joined peer
+                if (processor.getOSCEnabled()) {
+                    int numPeers = processor.getNumberRemotePeers();
+                    for (int i = 0; i < jmin(numPeers, 16); ++i) {
+                        if (processor.getRemotePeerUserName(i) == username) {
+                            sendPeerOSCState(i);
+                            break;
+                        }
+                    }
+                }
             });
         }
         else if (ev.type == ClientEvent::PeerLeaveEvent) {
@@ -6279,6 +7392,13 @@ void SonobusAudioProcessorEditor::handleAsyncUpdate()
                 mChatView->addNewChatMessage(SBChatEvent(SBChatEvent::SystemType, ev.group, ev.user, "", "", mesg));
             }
 
+            // Clear OSC state using the peer index that was captured when aooClientPeerLeft was called
+            // (stored in floatVal field)
+            if (processor.getOSCEnabled() && ev.floatVal >= 0.0f) {
+                int peerIndex = static_cast<int>(ev.floatVal);
+                clearPeerOSCState(peerIndex);
+            }
+
             mPeerContainer->peerLeftGroup(ev.group, ev.user);
 
             updatePeerState(true);
diff --git a/Source/SonobusPluginEditor.h b/Source/SonobusPluginEditor.h
index e7cdb999a..ac98c4064 100644
--- a/Source/SonobusPluginEditor.h
+++ b/Source/SonobusPluginEditor.h
@@ -178,6 +178,13 @@ public PeersContainerView::Listener
 
     bool setupLocalisation(const String & overrideLang = {});
 
+    // OSC control registration methods
+    void registerAllOSCControls();
+    void unregisterAllOSCControls();
+    void sendAllOSCState();
+    void sendPeerOSCState(int peerIndex);
+    void clearPeerOSCState(int peerIndex);
+
 private:
 
     void updateLayout();
@@ -730,6 +737,7 @@ public PeersContainerView::Listener
 
     File mSettingsFolder;
     
+    bool mOSCControlsRegistered = false;
 
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (SonobusAudioProcessorEditor)
 };
diff --git a/Source/SonobusPluginProcessor.cpp b/Source/SonobusPluginProcessor.cpp
index 09dd1fa4b..c0d25ac74 100644
--- a/Source/SonobusPluginProcessor.cpp
+++ b/Source/SonobusPluginProcessor.cpp
@@ -99,6 +99,7 @@ static String defRecordDirKey("DefaultRecordDir");
 static String defRecordDirURLKey("DefaultRecordDirURL");
 static String lastBrowseDirKey("LastBrowseDir");
 static String oscEnabledKey("OSCEnabled");
+static String oscSendStateOnStartKey("OSCSendStateOnStart");
 static String oscTargetIPAddressKey("OSCTargetIPAddress");
 static String oscTargetPortKey("OSCTargetPort");
 static String oscReceivePortKey("OSCReceivePort");
@@ -8471,7 +8472,17 @@ void SonobusAudioProcessor::setOSCEnabled(bool enabled)
         // Initialize OSC when enabled
         oscManager.initializeReceiver(mOSCReceivePort);
         oscManager.initializeSender(mOSCTargetIPAddress, mOSCTargetPort);
+        
+        // Register OSC controls in the editor
+        if (auto* editor = dynamic_cast<SonobusAudioProcessorEditor*>(getActiveEditor())) {
+            editor->registerAllOSCControls();
+        }
     } else {
+        // Unregister OSC controls in the editor
+        if (auto* editor = dynamic_cast<SonobusAudioProcessorEditor*>(getActiveEditor())) {
+            editor->unregisterAllOSCControls();
+        }
+        
         // Disconnect OSC when disabled
         oscManager.disconnectReceiver();
         oscManager.disconnectSender();
@@ -8610,6 +8621,7 @@ void SonobusAudioProcessor::getStateInformationWithOptions(MemoryBlock& destData
 
     // OSC Configuration
     extraTree.setProperty(oscEnabledKey, mOSCEnabled, nullptr);
+    extraTree.setProperty(oscSendStateOnStartKey, mOSCSendStateOnStart, nullptr);
     extraTree.setProperty(oscTargetIPAddressKey, mOSCTargetIPAddress, nullptr);
     extraTree.setProperty(oscTargetPortKey, mOSCTargetPort, nullptr);
     extraTree.setProperty(oscReceivePortKey, mOSCReceivePort, nullptr);
@@ -8759,6 +8771,7 @@ void SonobusAudioProcessor::setStateInformationWithOptions (const void* data, in
             
             // OSC Configuration
             mOSCEnabled = extraTree.getProperty(oscEnabledKey, mOSCEnabled);
+            mOSCSendStateOnStart = extraTree.getProperty(oscSendStateOnStartKey, mOSCSendStateOnStart);
             mOSCTargetIPAddress = extraTree.getProperty(oscTargetIPAddressKey, mOSCTargetIPAddress);
             mOSCTargetPort = extraTree.getProperty(oscTargetPortKey, mOSCTargetPort);
             mOSCReceivePort = extraTree.getProperty(oscReceivePortKey, mOSCReceivePort);
diff --git a/Source/SonobusPluginProcessor.h b/Source/SonobusPluginProcessor.h
index 643eca5ec..43a18fccd 100644
--- a/Source/SonobusPluginProcessor.h
+++ b/Source/SonobusPluginProcessor.h
@@ -787,6 +787,9 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
     bool getOSCEnabled() const { return mOSCEnabled; }
     void setOSCEnabled(bool enabled);
     
+    bool getOSCSendStateOnStart() const { return mOSCSendStateOnStart; }
+    void setOSCSendStateOnStart(bool enabled) { mOSCSendStateOnStart = enabled; }
+    
     String getOSCTargetIPAddress() const { return mOSCTargetIPAddress; }
     void setOSCTargetIPAddress(const String& ipAddress);
     
@@ -1247,6 +1250,7 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
     
     // OSC Configuration
     bool mOSCEnabled = false;  // OSC disabled by default
+    bool mOSCSendStateOnStart = true;  // Send state on start by default
     String mOSCTargetIPAddress = "127.0.0.1";
     int mOSCTargetPort = 6001;
     int mOSCReceivePort = 6000;
diff --git a/doc/OSC_COMMANDS.md b/doc/OSC_COMMANDS.md
index 655f499f0..090e8f6b0 100644
--- a/doc/OSC_COMMANDS.md
+++ b/doc/OSC_COMMANDS.md
@@ -557,6 +557,298 @@ SonoBus supports OSC control for up to 16 Input Groups. Each Input Group can be
 **Data Type**: Float  
 **Range**: Audio level (0.0 - 2.0, where 1.0 is unity gain)
 
+## Peer Controls
+
+SonoBus supports OSC control for up to 16 remote peers (connected users). Each peer can be controlled independently using numbered OSC addresses. Peer controls dynamically map to connected peers and will only respond when the specified peer index exists.
+
+**Important Notes:**
+- Peers are numbered 1-16 in OSC addresses (e.g., `/Peer1Mute`, `/Peer2Solo`)
+- Only peers that are currently connected will respond to OSC messages
+- FX controls (Compressor, Expander/Noise Gate, EQ, etc.) operate on the first/main channel group (channel group 0) of each peer
+- Peer numbering corresponds to the order peers connect to the session
+
+### Peer Mute and Solo Controls
+
+#### `/Peer[1-16]Mute`
+**Type**: Toggle Button  
+**Description**: Mutes/unmutes receiving audio from the specified peer  
+**Data Type**: Integer (0 = unmuted/receiving, 1 = muted/not receiving)  
+**Examples**:
+- `/Peer1Mute` - Mutes/unmutes Peer 1
+- `/Peer2Mute` - Mutes/unmutes Peer 2
+- `/Peer16Mute` - Mutes/unmutes Peer 16
+
+**Note**: Muting a peer prevents their audio from being heard locally. This is equivalent to clicking the MUTE button in the peer's UI panel.
+
+#### `/Peer[1-16]Solo`
+**Type**: Toggle Button  
+**Description**: Solos/unsolos the specified peer  
+**Data Type**: Integer (0 = not soloed, 1 = soloed)  
+**Examples**:
+- `/Peer1Solo` - Solos/unsolos Peer 1
+- `/Peer2Solo` - Solos/unsolos Peer 2
+
+**Note**: When any peer is soloed, only soloed peers are heard. This is equivalent to clicking the SOLO button in the peer's UI panel.
+
+#### `/Peer[1-16]BufferMin`
+**Type**: Push Button  
+**Description**: Resets the jitter buffer to the minimum for the specified peer  
+**Data Type**: Integer (1 to trigger)  
+**Examples**:
+- `/Peer1BufferMin` - Resets jitter buffer for Peer 1
+- `/Peer2BufferMin` - Resets jitter buffer for Peer 2
+
+**Note**: This is a momentary push button with no state. Send value 1 to trigger the action.
+
+#### `/Peer[1-16]ResetDrop`
+**Type**: Push Button  
+**Description**: Resets packet drop statistics for the specified peer  
+**Data Type**: Integer (1 to trigger)  
+**Examples**:
+- `/Peer1ResetDrop` - Resets drop stats for Peer 1
+- `/Peer2ResetDrop` - Resets drop stats for Peer 2
+
+**Note**: This is a momentary push button with no state. Send value 1 to trigger the action. Clears the dropped packet counter for the peer.
+
+#### `/Peer[1-16]Level`
+**Type**: Slider  
+**Description**: Controls the level/gain for the specified peer  
+**Data Type**: Float  
+**Range**: 0.0 - 2.0 (0.0 = silence, 1.0 = unity gain, 2.0 = +6dB)  
+**Examples**:
+- `/Peer1Level` - Controls level for Peer 1
+- `/Peer2Level` - Controls level for Peer 2
+
+**Note**: Adjusts the output level/gain for the peer's audio. This is equivalent to moving the level slider in the peer's UI panel.
+
+#### `/Peer[1-16]Pan`
+**Type**: Slider  
+**Description**: Controls the stereo pan position for the specified peer (channel group 0, channel 0)  
+**Data Type**: Float  
+**Range**: -1.0 to 1.0 (-1.0 = full left, 0.0 = center, 1.0 = full right)  
+**Examples**:
+- `/Peer1Pan` - Controls pan for Peer 1
+- `/Peer2Pan` - Controls pan for Peer 2
+
+**Note**: Adjusts the stereo pan position for the peer's audio. This is equivalent to moving the pan slider in the peer's UI panel.
+
+#### `/Peer[1-16]RemotePeerUserName`
+**Type**: Read-Only Text Field  
+**Description**: Provides the username of the connected peer  
+**Data Type**: String  
+**Direction**: Send only (SonoBus → OSC controller)  
+**Examples**:
+- `/Peer1RemotePeerUserName` - Username of Peer 1
+- `/Peer2RemotePeerUserName` - Username of Peer 2
+
+**Note**: This is a read-only control. SonoBus automatically sends the username when a peer joins the session and clears it to an empty string when the peer leaves. OSC messages sent to this address are ignored.
+
+**Note**: This control adjusts the receive level/gain for audio from the peer. Values above 1.0 provide gain boost.
+
+### Peer Input Effects (FX) Controls
+
+All FX controls operate on the first/main channel group (channel group 0) of each peer. These controls affect the audio received from the peer before it is mixed with other audio.
+
+#### `/Peer[1-16]InputReverbSend`
+**Type**: Slider  
+**Description**: Controls the input reverb send level for the specified peer  
+**Data Type**: Float  
+**Range**: 0.0 - 1.0 (0.0 = no reverb, 1.0 = maximum reverb send)  
+**Examples**:
+- `/Peer1InputReverbSend` - Controls input reverb send for Peer 1
+- `/Peer2InputReverbSend` - Controls input reverb send for Peer 2
+
+**Note**: This sends the peer's audio to the input reverb effect before mixing.
+
+#### `/Peer[1-16]PolarityInvert`
+**Type**: Toggle Button  
+**Description**: Inverts the polarity/phase of audio received from the specified peer  
+**Data Type**: Integer (0 = normal polarity, 1 = inverted polarity)  
+**Examples**:
+- `/Peer1PolarityInvert` - Inverts polarity for Peer 1
+- `/Peer2PolarityInvert` - Inverts polarity for Peer 2
+
+**Note**: Polarity inversion can be useful for correcting phase issues between microphones.
+
+### Peer Compressor Controls
+
+#### `/Peer[1-16]CompressorEnable`
+**Type**: Toggle Button  
+**Description**: Enables/disables the compressor effect for the specified peer  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Examples**:
+- `/Peer1CompressorEnable` - Enables/disables compressor for Peer 1
+- `/Peer2CompressorEnable` - Enables/disables compressor for Peer 2
+
+#### `/Peer[1-16]CompressorThreshold`
+**Type**: Slider  
+**Description**: Sets the compressor threshold in dB for the specified peer  
+**Data Type**: Float  
+**Range**: -60.0 to 0.0 dB  
+**Note**: Signals above this level will be compressed
+
+#### `/Peer[1-16]CompressorRatio`
+**Type**: Slider  
+**Description**: Sets the compressor ratio for the specified peer  
+**Data Type**: Float  
+**Range**: 1.0 to 20.0 (e.g., 4.0 means 4:1 ratio)  
+**Note**: Higher ratios result in more aggressive compression
+
+#### `/Peer[1-16]CompressorAttack`
+**Type**: Slider  
+**Description**: Sets the compressor attack time in milliseconds for the specified peer  
+**Data Type**: Float  
+**Range**: 1.0 to 1000.0 ms  
+**Note**: How quickly the compressor responds to signals exceeding the threshold
+
+#### `/Peer[1-16]CompressorRelease`
+**Type**: Slider  
+**Description**: Sets the compressor release time in milliseconds for the specified peer  
+**Data Type**: Float  
+**Range**: 1.0 to 1000.0 ms  
+**Note**: How quickly the compressor recovers after the signal drops below threshold
+
+#### `/Peer[1-16]CompressorMakeupGain`
+**Type**: Slider  
+**Description**: Sets the compressor makeup gain in dB for the specified peer  
+**Data Type**: Float  
+**Range**: 0.0 to 60.0 dB  
+**Note**: Gain applied after compression to compensate for level reduction
+
+#### `/Peer[1-16]CompressorAuto`
+**Type**: Toggle Button  
+**Description**: Enables/disables automatic makeup gain calculation for the specified peer  
+**Data Type**: Integer (0 = manual makeup gain, 1 = automatic)  
+**Note**: When enabled, makeup gain is automatically calculated based on threshold and ratio
+
+### Peer Expander (Noise Gate) Controls
+
+The expander acts as a noise gate, reducing the level of signals below the threshold.
+
+#### `/Peer[1-16]ExpanderEnable`
+**Type**: Toggle Button  
+**Description**: Enables/disables the noise gate effect for the specified peer  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Examples**:
+- `/Peer1ExpanderEnable` - Enables/disables noise gate for Peer 1
+- `/Peer2ExpanderEnable` - Enables/disables noise gate for Peer 2
+
+#### `/Peer[1-16]ExpanderNoiseFloor`
+**Type**: Slider  
+**Description**: Sets the noise gate threshold (noise floor) in dB for the specified peer  
+**Data Type**: Float  
+**Range**: -96.0 to 0.0 dB  
+**Note**: Signals below this level will be attenuated
+
+#### `/Peer[1-16]ExpanderRatio`
+**Type**: Slider  
+**Description**: Sets the expander ratio for the specified peer  
+**Data Type**: Float  
+**Range**: 1.0 to 20.0  
+**Note**: Higher ratios result in more aggressive gating
+
+#### `/Peer[1-16]ExpanderAttack`
+**Type**: Slider  
+**Description**: Sets the expander attack time in milliseconds for the specified peer  
+**Data Type**: Float  
+**Range**: 1.0 to 1000.0 ms  
+**Note**: How quickly the gate opens when signal exceeds threshold
+
+#### `/Peer[1-16]ExpanderRelease`
+**Type**: Slider  
+**Description**: Sets the expander release time in milliseconds for the specified peer  
+**Data Type**: Float  
+**Range**: 1.0 to 1000.0 ms  
+**Note**: How quickly the gate closes when signal drops below threshold
+
+### Peer Parametric EQ Controls
+
+The parametric EQ provides four bands of equalization: low shelf, two parametric bands, and high shelf.
+
+#### `/Peer[1-16]EqEnable`
+**Type**: Toggle Button  
+**Description**: Enables/disables the parametric EQ effect for the specified peer  
+**Data Type**: Integer (0 = disabled, 1 = enabled)  
+**Examples**:
+- `/Peer1EqEnable` - Enables/disables EQ for Peer 1
+- `/Peer2EqEnable` - Enables/disables EQ for Peer 2
+
+#### `/Peer[1-16]EqLowShelfFreq`
+**Type**: Slider  
+**Description**: Sets the low shelf filter frequency in Hz for the specified peer  
+**Data Type**: Float  
+**Range**: 20.0 to 2000.0 Hz  
+**Default**: 60.0 Hz  
+**Note**: Frequency at which the low shelf filter takes effect
+
+#### `/Peer[1-16]EqLowShelfGain`
+**Type**: Slider  
+**Description**: Sets the low shelf filter gain in dB for the specified peer  
+**Data Type**: Float  
+**Range**: -24.0 to 24.0 dB  
+**Note**: Boost or cut applied to frequencies below the low shelf frequency
+
+#### `/Peer[1-16]EqPara1Freq`
+**Type**: Slider  
+**Description**: Sets the parametric band 1 center frequency in Hz for the specified peer  
+**Data Type**: Float  
+**Range**: 20.0 to 20000.0 Hz  
+**Default**: 90.0 Hz  
+**Note**: Center frequency of the first parametric band
+
+#### `/Peer[1-16]EqPara1Gain`
+**Type**: Slider  
+**Description**: Sets the parametric band 1 gain in dB for the specified peer  
+**Data Type**: Float  
+**Range**: -24.0 to 24.0 dB  
+**Note**: Boost or cut applied at the parametric band 1 frequency
+
+#### `/Peer[1-16]EqPara1Q`
+**Type**: Slider  
+**Description**: Sets the parametric band 1 Q (bandwidth) for the specified peer  
+**Data Type**: Float  
+**Range**: 0.1 to 10.0  
+**Default**: 1.5  
+**Note**: Higher Q values result in narrower bandwidth (more selective filtering)
+
+#### `/Peer[1-16]EqHighShelfFreq`
+**Type**: Slider  
+**Description**: Sets the high shelf filter frequency in Hz for the specified peer  
+**Data Type**: Float  
+**Range**: 500.0 to 16000.0 Hz  
+**Default**: 10000.0 Hz  
+**Note**: Frequency at which the high shelf filter takes effect
+
+#### `/Peer[1-16]EqHighShelfGain`
+**Type**: Slider  
+**Description**: Sets the high shelf filter gain in dB for the specified peer  
+**Data Type**: Float  
+**Range**: -24.0 to 24.0 dB  
+**Note**: Boost or cut applied to frequencies above the high shelf frequency
+
+#### `/Peer[1-16]EqPara2Freq`
+**Type**: Slider  
+**Description**: Sets the parametric band 2 center frequency in Hz for the specified peer  
+**Data Type**: Float  
+**Range**: 20.0 to 20000.0 Hz  
+**Default**: 360.0 Hz  
+**Note**: Center frequency of the second parametric band
+
+#### `/Peer[1-16]EqPara2Gain`
+**Type**: Slider  
+**Description**: Sets the parametric band 2 gain in dB for the specified peer  
+**Data Type**: Float  
+**Range**: -24.0 to 24.0 dB  
+**Note**: Boost or cut applied at the parametric band 2 frequency
+
+#### `/Peer[1-16]EqPara2Q`
+**Type**: Slider  
+**Description**: Sets the parametric band 2 Q (bandwidth) for the specified peer  
+**Data Type**: Float  
+**Range**: 0.1 to 10.0  
+**Default**: 4.0  
+**Note**: Higher Q values result in narrower bandwidth (more selective filtering)
+
 ## Options Tab Controls
 
 ### Audio Options
@@ -789,6 +1081,42 @@ SonoBus supports OSC control for up to 16 Input Groups. Each Input Group can be
 
 # Set default format to specific codec
 /OptionsFormatChoiceDefaultChoice 4
+
+# Mute Peer 1
+/Peer1Mute 1
+
+# Unmute Peer 1
+/Peer1Mute 0
+
+# Solo Peer 2
+/Peer2Solo 1
+
+# Enable compressor for Peer 1
+/Peer1CompressorEnable 1
+
+# Set compressor threshold for Peer 1
+/Peer1CompressorThreshold -20.0
+
+# Set compressor ratio for Peer 1
+/Peer1CompressorRatio 4.0
+
+# Enable noise gate for Peer 2
+/Peer2ExpanderEnable 1
+
+# Set noise gate threshold for Peer 2
+/Peer2ExpanderNoiseFloor -40.0
+
+# Enable EQ for Peer 1
+/Peer1EqEnable 1
+
+# Boost low frequencies for Peer 1
+/Peer1EqLowShelfGain 3.0
+
+# Set input reverb send for Peer 3
+/Peer3InputReverbSend 0.5
+
+# Invert polarity for Peer 1
+/Peer1PolarityInvert 1
 ```
 
 ### Using Python with python-osc
@@ -813,6 +1141,26 @@ client.send_message("/MetTempoSlider", 120.0)
 
 # Start recording
 client.send_message("/RecordingButton", 1)
+
+# Mute Peer 1
+client.send_message("/Peer1Mute", 1)
+
+# Solo Peer 2
+client.send_message("/Peer2Solo", 1)
+
+# Enable compressor for Peer 1
+client.send_message("/Peer1CompressorEnable", 1)
+client.send_message("/Peer1CompressorThreshold", -20.0)
+client.send_message("/Peer1CompressorRatio", 4.0)
+
+# Enable noise gate for Peer 2
+client.send_message("/Peer2ExpanderEnable", 1)
+client.send_message("/Peer2ExpanderNoiseFloor", -40.0)
+
+# Apply EQ to Peer 1
+client.send_message("/Peer1EqEnable", 1)
+client.send_message("/Peer1EqLowShelfGain", 3.0)
+client.send_message("/Peer1EqHighShelfGain", -2.0)
 ```
 
 ### Using TouchOSC
@@ -822,6 +1170,9 @@ Create controls with the following OSC addresses:
 - Fader with address `/OutGainSlider` sending float values
 - Button with address `/RecordingButton` sending 0/1
 - XY Pad with `/MetTempoSlider` on one axis
+- Toggle buttons for `/Peer1Mute`, `/Peer2Mute`, etc. sending 0/1
+- Toggle buttons for `/Peer1Solo`, `/Peer2Solo`, etc. sending 0/1
+- Faders for peer FX controls like `/Peer1CompressorThreshold`, `/Peer1EqLowShelfGain`, etc.
 
 ## Receiving OSC Messages from SonoBus
 
diff --git a/tests/oscsend.sh b/tests/oscsend.sh
deleted file mode 100755
index f1857854d..000000000
--- a/tests/oscsend.sh
+++ /dev/null
@@ -1,230 +0,0 @@
-#!/bin/bash -x
-
-# Sends OSC messages to localhost port 6000
-# Each message is followed by a sleep for UI control verification
-
-# Audio Controls
-oscsend localhost 6000 /DrySlider f 1.0
-sleep 2
-oscsend localhost 6000 /DrySlider f 0.5
-sleep 2
-
-oscsend localhost 6000 /OutGainSlider f 1.0
-sleep 2
-oscsend localhost 6000 /OutGainSlider f 0.5
-sleep 2
-
-# Main Control Buttons
-oscsend localhost 6000 /MainMuteButton i 1
-sleep 2
-oscsend localhost 6000 /MainMuteButton i 0
-sleep 2
-
-oscsend localhost 6000 /MainRecvMuteButton i 1
-sleep 2
-oscsend localhost 6000 /MainRecvMuteButton i 0
-sleep 2
-
-oscsend localhost 6000 /MainPushToTalkButton i 1
-sleep 2
-oscsend localhost 6000 /MainPushToTalkButton i 0
-sleep 2
-
-# Metronome Controls
-oscsend localhost 6000 /MetEnableButton i 1
-sleep 2
-oscsend localhost 6000 /MetEnableButton i 0
-sleep 2
-
-oscsend localhost 6000 /MetLevelSlider f 0.8
-sleep 2
-oscsend localhost 6000 /MetLevelSlider f 0.4
-sleep 2
-
-oscsend localhost 6000 /MetTempoSlider f 120.0
-sleep 2
-oscsend localhost 6000 /MetTempoSlider f 60.0
-sleep 2
-
-# -- not sure where this is located in UI
-oscsend localhost 6000 /MetSyncButton i 1
-sleep 2
-oscsend localhost 6000 /MetSyncButton i 0
-sleep 2
-
-oscsend localhost 6000 /MetSyncFileButton i 1
-sleep 2
-oscsend localhost 6000 /MetSyncFileButton i 0
-sleep 2
-
-oscsend localhost 6000 /MetSendButton i 1
-sleep 2
-oscsend localhost 6000 /MetSendButton i 0
-sleep 2
-
-# Input Monitor Controls
-oscsend localhost 6000 /InMuteButton i 1
-sleep 2
-oscsend localhost 6000 /InMuteButton i 0
-sleep 2
-
-oscsend localhost 6000 /InSoloButton i 1
-sleep 2
-oscsend localhost 6000 /InSoloButton i 0
-sleep 2
-
-# Utility Buttons
-oscsend localhost 6000 /BufferMinButton i 1
-sleep 2
-
-oscsend localhost 6000 /RecvSyncButton i 1
-sleep 2
-
-oscsend localhost 6000 /RecordingButton i 1
-sleep 2
-oscsend localhost 6000 /RecordingButton i 0
-sleep 2
-
-# Example Command for Main Reverb Controls
-oscsend localhost 6000 /MainReverbEnabled i 1
-sleep 2
-oscsend localhost 6000 /MainReverbEnabled i 0
-sleep 2
-
-oscsend localhost 6000 /ReverbLevelSlider f 1.0
-sleep 2
-oscsend localhost 6000 /ReverbLevelSlider f 0.5
-sleep 2
-
-oscsend localhost 6000 /ReverbSizeSlider f 1.0
-sleep 2
-oscsend localhost 6000 /ReverbSizeSlider f 0.5
-sleep 2
-
-oscsend localhost 6000 /ReverbDampingSlider f 1.0
-sleep 2
-oscsend localhost 6000 /ReverbDampingSlider f 0.5
-sleep 2
-
-oscsend localhost 6000 /ReverbPreDelaySlider f 20.0
-sleep 2
-oscsend localhost 6000 /ReverbPreDelaySlider f 60.0
-sleep 2
-
-# Options Options
-oscsend localhost 6000 /OptionsDynamicResamplingButton i 1
-sleep 2
-oscsend localhost 6000 /OptionsDynamicResamplingButton i 0
-sleep 2
-
-oscsend localhost 6000 /OptionsUseSpecificUdpPortButton i 1
-sleep 2
-oscsend localhost 6000 /OptionsUseSpecificUdpPortButton i 0
-sleep 2
-
-oscsend localhost 6000 /OptionsUdpPortEditor i 12000
-sleep 2
-oscsend localhost 6000 /OptionsUdpPortEditor i 13000
-sleep 2
-
-oscsend localhost 6000 /OptionsOverrideSamplerateButton i 1
-sleep 2
-oscsend localhost 6000 /OptionsOverrideSamplerateButton i 0
-sleep 2
-
-oscsend localhost 6000 /OptionsShouldCheckForUpdateButton i 1
-sleep 2
-oscsend localhost 6000 /OptionsShouldCheckForUpdateButton i 0
-sleep 2
-
-oscsend localhost 6000 /OptionsAutoReconnectButton i 1
-sleep 2
-oscsend localhost 6000 /OptionsAutoReconnectButton i 0
-sleep 2
-
-oscsend localhost 6000 /OptionsSliderSnapToMouseButton i 1
-sleep 2
-oscsend localhost 6000 /OptionsSliderSnapToMouseButton i 0
-sleep 2
-
-oscsend localhost 6000 /OptionsInputLimiterButton i 1
-sleep 2
-oscsend localhost 6000 /OptionsInputLimiterButton i 0
-sleep 2
-
-oscsend localhost 6000 /OptionsDefaultLevelSlider f 0.73
-sleep 2
-oscsend localhost 6000 /OptionsDefaultLevelSlider f 0.1
-sleep 2
-
-oscsend localhost 6000 /OSCTargetIPAddress s "127.0.0.2"
-sleep 2
-oscsend localhost 6000 /OSCTargetIPAddress s "127.0.0.1"
-sleep 2
-
-oscsend localhost 6000 /OSCTargetPort i "9999"
-sleep 2
-oscsend localhost 6000 /OSCTargetPort i "6001"
-sleep 2
-
-# oscsend localhost 6000 /OSCReceivePort i "9998"
-# sleep 2
-# oscsend localhost 6000 /OSCReceivePort i "6000"
-#sleep 2
-
-oscsend localhost 6000 /OptionsMaxRecvPaddingSlider f 20.0
-sleep 2
-oscsend localhost 6000 /OptionsMaxRecvPaddingSlider f 10.0
-sleep 2
-
-oscsend localhost 6000 /OptionsAutoDropThreshSlider f 1.0
-sleep 2
-oscsend localhost 6000 /OptionsAutoDropThreshSlider f 33.0
-sleep 2
-
-oscsend localhost 6000 /BufferTimeSlider f 1.0
-sleep 2
-oscsend localhost 6000 /BufferTimeSlider f 33.0
-sleep 2
-
-oscsend localhost 6000 /OptionsChangeAllFormatButton i 1
-sleep 2
-oscsend localhost 6000 /OptionsChangeAllFormatButton i 0
-sleep 2
-
-# Recording Options
-oscsend localhost 6000 /OptionsRecStealth i 1
-sleep 2
-oscsend localhost 6000 /OptionsRecStealth i 0
-sleep 2
-
-oscsend localhost 6000 /OptionsRecSelfSilenceMutedButton i 1
-sleep 2
-oscsend localhost 6000 /OptionsRecSelfSilenceMutedButton i 0
-sleep 2
-
-oscsend localhost 6000 /OptionsRecSelfPostFxButton i 1
-sleep 2
-oscsend localhost 6000 /OptionsRecSelfPostFxButton i 0
-sleep 2
-
-oscsend localhost 6000 /OptionsMetRecordedButton i 1
-sleep 2
-oscsend localhost 6000 /OptionsMetRecordedButton i 0
-sleep 2
-
-# -- Record features
-oscsend localhost 6000 /OptionsRecSelfButton i 1
-sleep 2
-oscsend localhost 6000 /OptionsRecSelfButton i 0
-sleep 2
-
-oscsend localhost 6000 /OptionsRecOthersButton i 1
-sleep 2
-oscsend localhost 6000 /OptionsRecOthersButton i 0
-sleep 2
-
-oscsend localhost 6000 /OptionsRecMixMinusButton i 1
-sleep 2
-oscsend localhost 6000 /OptionsRecMixMinusButton i 0
-sleep 2
diff --git a/tests/oscsend_comprehensive.sh b/tests/oscsend_comprehensive.sh
index a80de9348..de21ddece 100755
--- a/tests/oscsend_comprehensive.sh
+++ b/tests/oscsend_comprehensive.sh
@@ -474,4 +474,131 @@ sleep 2
 oscsend localhost 6000 /OptionsRecMixMinusButton i 0
 sleep 2
 
+echo "=== Peer 1 Controls ==="
+oscsend localhost 6000 /Peer1Mute i 1
+sleep 2
+oscsend localhost 6000 /Peer1Mute i 0
+sleep 2
+
+oscsend localhost 6000 /Peer1Solo i 1
+sleep 2
+oscsend localhost 6000 /Peer1Solo i 0
+sleep 2
+
+echo "=== Peer 1 Utility Controls ==="
+oscsend localhost 6000 /Peer1BufferMin i 1
+sleep 2
+
+oscsend localhost 6000 /Peer1ResetDrop i 1
+sleep 2
+
+echo "=== Peer 1 Level Control ==="
+oscsend localhost 6000 /Peer1Level f 0.8
+sleep 2
+oscsend localhost 6000 /Peer1Level f 1.0
+sleep 2
+oscsend localhost 6000 /Peer1Level f 1.2
+sleep 2
+
+echo "=== Peer 1 Pan Control ==="
+oscsend localhost 6000 /Peer1Pan f -1.0
+sleep 2
+oscsend localhost 6000 /Peer1Pan f 0.0
+sleep 2
+oscsend localhost 6000 /Peer1Pan f 1.0
+sleep 2
+
+echo "=== Peer 1 FX Controls ==="
+oscsend localhost 6000 /Peer1InputReverbSend f 0.6
+sleep 2
+oscsend localhost 6000 /Peer1InputReverbSend f 0.3
+sleep 2
+
+oscsend localhost 6000 /Peer1PolarityInvert i 1
+sleep 2
+oscsend localhost 6000 /Peer1PolarityInvert i 0
+sleep 2
+
+echo "=== Peer 1 Compressor Controls ==="
+oscsend localhost 6000 /Peer1CompressorEnable i 1
+sleep 2
+oscsend localhost 6000 /Peer1CompressorThreshold f -20.0
+sleep 2
+oscsend localhost 6000 /Peer1CompressorRatio f 4.0
+sleep 2
+oscsend localhost 6000 /Peer1CompressorAttack f 15.0
+sleep 2
+oscsend localhost 6000 /Peer1CompressorRelease f 100.0
+sleep 2
+oscsend localhost 6000 /Peer1CompressorMakeupGain f 10.0
+sleep 2
+oscsend localhost 6000 /Peer1CompressorAuto i 1
+sleep 2
+oscsend localhost 6000 /Peer1CompressorAuto i 0
+sleep 2
+oscsend localhost 6000 /Peer1CompressorEnable i 0
+sleep 2
+
+echo "=== Peer 1 Expander (Noise Gate) Controls ==="
+oscsend localhost 6000 /Peer1ExpanderEnable i 1
+sleep 2
+oscsend localhost 6000 /Peer1ExpanderNoiseFloor f -40.0
+sleep 2
+oscsend localhost 6000 /Peer1ExpanderRatio f 3.0
+sleep 2
+oscsend localhost 6000 /Peer1ExpanderAttack f 5.0
+sleep 2
+oscsend localhost 6000 /Peer1ExpanderRelease f 150.0
+sleep 2
+oscsend localhost 6000 /Peer1ExpanderEnable i 0
+sleep 2
+
+echo "=== Peer 1 Parametric EQ Controls ==="
+oscsend localhost 6000 /Peer1EqEnable i 1
+sleep 2
+oscsend localhost 6000 /Peer1EqLowShelfFreq f 80.0
+sleep 2
+oscsend localhost 6000 /Peer1EqLowShelfGain f 3.0
+sleep 2
+oscsend localhost 6000 /Peer1EqPara1Freq f 200.0
+sleep 2
+oscsend localhost 6000 /Peer1EqPara1Gain f -2.0
+sleep 2
+oscsend localhost 6000 /Peer1EqPara1Q f 2.0
+sleep 2
+oscsend localhost 6000 /Peer1EqHighShelfFreq f 8000.0
+sleep 2
+oscsend localhost 6000 /Peer1EqHighShelfGain f -3.0
+sleep 2
+oscsend localhost 6000 /Peer1EqPara2Freq f 500.0
+sleep 2
+oscsend localhost 6000 /Peer1EqPara2Gain f 4.0
+sleep 2
+oscsend localhost 6000 /Peer1EqPara2Q f 3.0
+sleep 2
+oscsend localhost 6000 /Peer1EqEnable i 0
+sleep 2
+
+echo "=== Peer 2 Controls (if connected) ==="
+oscsend localhost 6000 /Peer2Mute i 1
+sleep 2
+oscsend localhost 6000 /Peer2Mute i 0
+sleep 2
+
+oscsend localhost 6000 /Peer2Solo i 1
+sleep 2
+oscsend localhost 6000 /Peer2Solo i 0
+sleep 2
+
+oscsend localhost 6000 /Peer2InputReverbSend f 0.5
+sleep 2
+oscsend localhost 6000 /Peer2InputReverbSend f 0.2
+sleep 2
+
+oscsend localhost 6000 /Peer2Level f 0.9
+sleep 2
+
+oscsend localhost 6000 /Peer2Pan f 0.5
+sleep 2
+
 echo "=== OSC Test Complete ==="

From ecd67f16f42b8b6f5bac793360e7d31dea824884 Mon Sep 17 00:00:00 2001
From: Steven Wilson <2165238+mendeni@users.noreply.github.com>
Date: Tue, 27 Jan 2026 07:32:09 -0500
Subject: [PATCH 06/20] Update OSC BufferMinButton, RecvSyncButton to accept
 Float32 instead of Int32

---
 Source/SonobusPluginEditor.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Source/SonobusPluginEditor.cpp b/Source/SonobusPluginEditor.cpp
index 41b5dadb8..551c16fdf 100644
--- a/Source/SonobusPluginEditor.cpp
+++ b/Source/SonobusPluginEditor.cpp
@@ -1476,8 +1476,8 @@ void SonobusAudioProcessorEditor::registerAllOSCControls()
     
     // Register RecvSyncButton - triggers button click event (accepts only integer 1)
     oscManager.registerControl("/RecvSyncButton", [this](const juce::OSCMessage& message) {
-        if (message.size() > 0 && message[0].isInt32()) {
-            int value = message[0].getInt32();
+        if (message.size() > 0 && message[0].isFloat32()) {
+            int value = message[0].getFloat32();
             if (value == 1) {
                 juce::MessageManager::callAsync([this]() {
                     if (mRecvSyncButton) {
@@ -1649,8 +1649,8 @@ void SonobusAudioProcessorEditor::registerAllOSCControls()
     
     // Register BufferMinButton - triggers buffer reset button click event (accepts only integer 1)
     oscManager.registerControl("/BufferMinButton", [this](const juce::OSCMessage& message) {
-        if (message.size() > 0 && message[0].isInt32()) {
-            int value = message[0].getInt32();
+        if (message.size() > 0 && message[0].isFloat32()) {
+            int value = message[0].getFloat32();
             if (value == 1) {
                 juce::MessageManager::callAsync([this]() {
                     if (mBufferMinButton) {

From c9a91d90a0685e47b2cca5b95c9d421afa32bed4 Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Wed, 28 Jan 2026 11:06:31 -0500
Subject: [PATCH 07/20] OSC: Deduplicate peer clearing logic and fix Disconnect
 button (#21)

---
 Source/SonobusPluginEditor.cpp | 141 +++++++++++++++++++++++++--------
 1 file changed, 107 insertions(+), 34 deletions(-)

diff --git a/Source/SonobusPluginEditor.cpp b/Source/SonobusPluginEditor.cpp
index 551c16fdf..80b5ccaae 100644
--- a/Source/SonobusPluginEditor.cpp
+++ b/Source/SonobusPluginEditor.cpp
@@ -1404,6 +1404,8 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
     // Register OSC controls if OSC is enabled
     if (processor.getOSCEnabled()) {
         registerAllOSCControls();
+        // Send all OSC state on startup to ensure controllers receive complete state
+        sendAllOSCState();
     }
     
     // handles registering commands
@@ -4159,6 +4161,38 @@ void SonobusAudioProcessorEditor::sendAllOSCState()
     if (auto* param = vts.getParameter(SonobusAudioProcessor::paramSendFileAudio)) {
         oscManager.sendMessage("/FileSendButton", param->getValue() > 0.5f ? 1 : 0);
     }
+    if (mPlaybackSlider) {
+        oscManager.sendMessage("/PlaybackSlider", static_cast<float>(mPlaybackSlider->getValue()));
+    }
+    oscManager.sendMessage("/FilePlaybackPreLevel", processor.getFilePlaybackGain());
+    oscManager.sendMessage("/FileMonitorSlider", processor.getFilePlaybackMonitor());
+    
+    // Send soundboard controls
+    if (auto* param = vts.getParameter(SonobusAudioProcessor::paramSendSoundboardAudio)) {
+        oscManager.sendMessage("/SoundboardSendButton", param->getValue() > 0.5f ? 1 : 0);
+    }
+    if (processor.getSoundboardProcessor()) {
+        oscManager.sendMessage("/SoundboardLevelSlider", processor.getSoundboardProcessor()->getGain());
+        oscManager.sendMessage("/SoundboardMonitorSlider", processor.getSoundboardProcessor()->getMonitorGain());
+    }
+    
+    // Send metronome additional controls
+    oscManager.sendMessage("/MetPanSlider", processor.getMetronomePan());
+    oscManager.sendMessage("/MetMonitorSlider", processor.getMetronomeMonitor());
+    
+    // Send input reverb controls
+    if (auto* param = vts.getParameter(SonobusAudioProcessor::paramInputReverbLevel)) {
+        oscManager.sendMessage("/InputReverbLevel", param->convertFrom0to1(param->getValue()));
+    }
+    if (auto* param = vts.getParameter(SonobusAudioProcessor::paramInputReverbSize)) {
+        oscManager.sendMessage("/InputReverbSize", param->convertFrom0to1(param->getValue()));
+    }
+    if (auto* param = vts.getParameter(SonobusAudioProcessor::paramInputReverbDamping)) {
+        oscManager.sendMessage("/InputReverbDamping", param->convertFrom0to1(param->getValue()));
+    }
+    if (auto* param = vts.getParameter(SonobusAudioProcessor::paramInputReverbPreDelay)) {
+        oscManager.sendMessage("/InputReverbPreDelay", param->convertFrom0to1(param->getValue()));
+    }
     
     // Send reverb controls
     if (mReverbEnabledButton) {
@@ -4195,66 +4229,79 @@ void SonobusAudioProcessorEditor::sendAllOSCState()
     }
     oscManager.sendMessage("/OptionsRecStealth", processor.getRecordStealth() ? 1 : 0);
     
-    // Send peer controls
+    // Send peer controls for all 16 slots
+    // Send active peer states for existing peers
     int numPeers = processor.getNumberRemotePeers();
-    for (int peerIndex = 0; peerIndex < jmin(numPeers, 16); ++peerIndex) {
-        // Send username (read-only control)
+    
+    for (int peerIndex = 0; peerIndex < numPeers && peerIndex < 16; ++peerIndex) {
+        String peerNum = String(peerIndex + 1);
+        
+        // Send active peer state
         String username = processor.getRemotePeerUserName(peerIndex);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "RemotePeerUserName", username);
+        oscManager.sendMessage("/Peer" + peerNum + "RemotePeerUserName", username);
         
         // Peer mute/solo
         bool muted = !processor.getRemotePeerRecvAllow(peerIndex);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "Mute", muted ? 1 : 0);
+        oscManager.sendMessage("/Peer" + peerNum + "Mute", muted ? 1 : 0);
         
         bool soloed = processor.getRemotePeerSoloed(peerIndex);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "Solo", soloed ? 1 : 0);
+        oscManager.sendMessage("/Peer" + peerNum + "Solo", soloed ? 1 : 0);
         
         // Peer level
         float level = processor.getRemotePeerLevelGain(peerIndex);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "Level", level);
+        oscManager.sendMessage("/Peer" + peerNum + "Level", level);
+        
+        // Peer pan
+        float pan = processor.getRemotePeerChannelPan(peerIndex, 0, 0);
+        oscManager.sendMessage("/Peer" + peerNum + "Pan", pan);
         
         // Peer FX - Compressor
         SonoAudio::CompressorParams compParams;
         processor.getRemotePeerCompressorParams(peerIndex, 0, compParams);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "CompressorEnable", compParams.enabled ? 1 : 0);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "CompressorThreshold", compParams.thresholdDb);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "CompressorRatio", compParams.ratio);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "CompressorAttack", compParams.attackMs);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "CompressorRelease", compParams.releaseMs);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "CompressorMakeupGain", compParams.makeupGainDb);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "CompressorAuto", compParams.automakeupGain ? 1 : 0);
+        oscManager.sendMessage("/Peer" + peerNum + "CompressorEnable", compParams.enabled ? 1 : 0);
+        oscManager.sendMessage("/Peer" + peerNum + "CompressorThreshold", compParams.thresholdDb);
+        oscManager.sendMessage("/Peer" + peerNum + "CompressorRatio", compParams.ratio);
+        oscManager.sendMessage("/Peer" + peerNum + "CompressorAttack", compParams.attackMs);
+        oscManager.sendMessage("/Peer" + peerNum + "CompressorRelease", compParams.releaseMs);
+        oscManager.sendMessage("/Peer" + peerNum + "CompressorMakeupGain", compParams.makeupGainDb);
+        oscManager.sendMessage("/Peer" + peerNum + "CompressorAuto", compParams.automakeupGain ? 1 : 0);
         
         // Peer FX - Expander
         SonoAudio::CompressorParams expanderParams;
         processor.getRemotePeerExpanderParams(peerIndex, 0, expanderParams);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "ExpanderEnable", expanderParams.enabled ? 1 : 0);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "ExpanderNoiseFloor", expanderParams.thresholdDb);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "ExpanderRatio", expanderParams.ratio);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "ExpanderAttack", expanderParams.attackMs);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "ExpanderRelease", expanderParams.releaseMs);
+        oscManager.sendMessage("/Peer" + peerNum + "ExpanderEnable", expanderParams.enabled ? 1 : 0);
+        oscManager.sendMessage("/Peer" + peerNum + "ExpanderNoiseFloor", expanderParams.thresholdDb);
+        oscManager.sendMessage("/Peer" + peerNum + "ExpanderRatio", expanderParams.ratio);
+        oscManager.sendMessage("/Peer" + peerNum + "ExpanderAttack", expanderParams.attackMs);
+        oscManager.sendMessage("/Peer" + peerNum + "ExpanderRelease", expanderParams.releaseMs);
         
         // Peer FX - EQ
         SonoAudio::ParametricEqParams eqParams;
         processor.getRemotePeerEqParams(peerIndex, 0, eqParams);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqEnable", eqParams.enabled ? 1 : 0);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqLowShelfFreq", eqParams.lowShelfFreq);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqLowShelfGain", eqParams.lowShelfGain);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqPara1Freq", eqParams.para1Freq);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqPara1Gain", eqParams.para1Gain);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqPara1Q", eqParams.para1Q);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqHighShelfFreq", eqParams.highShelfFreq);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqHighShelfGain", eqParams.highShelfGain);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqPara2Freq", eqParams.para2Freq);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqPara2Gain", eqParams.para2Gain);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "EqPara2Q", eqParams.para2Q);
+        oscManager.sendMessage("/Peer" + peerNum + "EqEnable", eqParams.enabled ? 1 : 0);
+        oscManager.sendMessage("/Peer" + peerNum + "EqLowShelfFreq", eqParams.lowShelfFreq);
+        oscManager.sendMessage("/Peer" + peerNum + "EqLowShelfGain", eqParams.lowShelfGain);
+        oscManager.sendMessage("/Peer" + peerNum + "EqPara1Freq", eqParams.para1Freq);
+        oscManager.sendMessage("/Peer" + peerNum + "EqPara1Gain", eqParams.para1Gain);
+        oscManager.sendMessage("/Peer" + peerNum + "EqPara1Q", eqParams.para1Q);
+        oscManager.sendMessage("/Peer" + peerNum + "EqHighShelfFreq", eqParams.highShelfFreq);
+        oscManager.sendMessage("/Peer" + peerNum + "EqHighShelfGain", eqParams.highShelfGain);
+        oscManager.sendMessage("/Peer" + peerNum + "EqPara2Freq", eqParams.para2Freq);
+        oscManager.sendMessage("/Peer" + peerNum + "EqPara2Gain", eqParams.para2Gain);
+        oscManager.sendMessage("/Peer" + peerNum + "EqPara2Q", eqParams.para2Q);
         
         // Peer FX - Reverb Send
         float reverbSend = processor.getRemotePeerChannelReverbSend(peerIndex, 0);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "InputReverbSend", reverbSend);
+        oscManager.sendMessage("/Peer" + peerNum + "InputReverbSend", reverbSend);
         
         // Peer FX - Polarity Invert
         bool polarityInvert = processor.getRemotePeerPolarityInvert(peerIndex, 0);
-        oscManager.sendMessage("/Peer" + String(peerIndex + 1) + "PolarityInvert", polarityInvert ? 1 : 0);
+        oscManager.sendMessage("/Peer" + peerNum + "PolarityInvert", polarityInvert ? 1 : 0);
+    }
+    
+    // Clear empty peer slots (from numPeers to 15) to ensure pristine state
+    for (int i = numPeers; i < 16; ++i) {
+        clearPeerOSCState(i);
     }
 }
 
@@ -4332,20 +4379,25 @@ void SonobusAudioProcessorEditor::sendPeerOSCState(int peerIndex)
 
 void SonobusAudioProcessorEditor::clearPeerOSCState(int peerIndex)
 {
+    juce::Logger::writeToLog("clearPeerOSCState called for peerIndex: " + String(peerIndex));
+    
     if (!processor.getOSCEnabled() || peerIndex < 0 || peerIndex >= 16) {
+        juce::Logger::writeToLog("clearPeerOSCState early return - OSCEnabled: " + String(processor.getOSCEnabled() ? "true" : "false") + ", peerIndex: " + String(peerIndex));
         return;
     }
     
     OSCManager& oscManager = processor.getOSCManager();
     String peerNum = String(peerIndex + 1);
     
+    juce::Logger::writeToLog("Clearing OSC state for Peer" + peerNum);
+    
     // Clear username to empty string
     oscManager.sendMessage("/Peer" + peerNum + "RemotePeerUserName", "");
     
     // Clear all other peer controls to default/off states
     oscManager.sendMessage("/Peer" + peerNum + "Mute", 0);
     oscManager.sendMessage("/Peer" + peerNum + "Solo", 0);
-    oscManager.sendMessage("/Peer" + peerNum + "Level", 1.0f);
+    oscManager.sendMessage("/Peer" + peerNum + "Level", 0);
     oscManager.sendMessage("/Peer" + peerNum + "Pan", 0.0f);  // Center pan
     
     // Clear compressor
@@ -4725,17 +4777,25 @@ void SonobusAudioProcessorEditor::aooClientPeerLeft(SonobusAudioProcessor *comp,
     int peerIndex = -1;
     if (processor.getOSCEnabled()) {
         int numPeers = processor.getNumberRemotePeers();
+        juce::Logger::writeToLog("Looking for peer '" + user + "' among " + String(numPeers) + " peers for OSC clear");
         for (int i = 0; i < jmin(numPeers, 16); ++i) {
-            if (processor.getRemotePeerUserName(i) == user) {
+            String peerName = processor.getRemotePeerUserName(i);
+            juce::Logger::writeToLog("Checking peer " + String(i) + ": " + peerName);
+            if (peerName == user) {
                 peerIndex = i;
+                juce::Logger::writeToLog("Found peer '" + user + "' at index " + String(peerIndex));
                 break;
             }
         }
+        if (peerIndex < 0) {
+            juce::Logger::writeToLog("WARNING: Could not find peer '" + user + "' in peer list - OSC state will not be cleared");
+        }
     }
     
     {
         const ScopedLock sl (clientStateLock);        
         // Store the peer index in floatVal so we can clear OSC state in async handler
+        juce::Logger::writeToLog("Storing peerIndex " + String(peerIndex) + " for peer '" + user + "' in PeerLeaveEvent");
         clientEvents.add(ClientEvent(ClientEvent::PeerLeaveEvent, group, true, "", user, static_cast<float>(peerIndex)));
     }
     triggerAsyncUpdate();
@@ -5052,6 +5112,13 @@ void SonobusAudioProcessorEditor::buttonClicked (Button* buttonThatWasClicked)
             mConnectButton->setTextJustification(Justification::centredTop);
             mConnectionTimeLabel->setEnabled(true);
 
+            // Clear OSC state for all peer slots when disconnecting
+            if (processor.getOSCEnabled()) {
+                for (int i = 0; i < 16; ++i) {
+                    clearPeerOSCState(i);
+                }
+            }
+
             if (processor.getWatchPublicGroups()) {
                 processor.leaveServerGroup(processor.getCurrentJoinedGroup());
             }
@@ -9223,6 +9290,12 @@ bool SonobusAudioProcessorEditor::perform (const InvocationInfo& info) {
             DBG("got disconnect!");
             
             if (currConnected && currGroup.isNotEmpty()) {
+                // Clear OSC state for all peer slots when disconnecting
+                if (processor.getOSCEnabled()) {
+                    for (int i = 0; i < 16; ++i) {
+                        clearPeerOSCState(i);
+                    }
+                }
                 buttonClicked(mConnectButton.get());
             }
 

From 21e1e42b16ca279fb8e5f0055692957c398343ac Mon Sep 17 00:00:00 2001
From: Steven Wilson <2165238+mendeni@users.noreply.github.com>
Date: Wed, 28 Jan 2026 12:00:09 -0500
Subject: [PATCH 08/20] Only build Standalone and VST3 for macOS and Linux

---
 .github/workflows/build.yml | 13 +++----------
 1 file changed, 3 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 4d16c389c..004b2d487 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -27,22 +27,15 @@ jobs:
         if: runner.os == 'Windows'
         run: cmake -S . -B build -DJUCE_ENABLE_STANDALONE_APPLICATION:BOOL=ON -DJUCE_ASIO:BOOL=ON
 
-      - name: Configure CMake / Setup (Linux & macOS)
+      - name: Configure CMake (Linux & macOS)
         if: runner.os != 'Windows'
-        run: |
-          ./setupcmake.sh
+        run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
 
-      - name: Build (Windows)
-        if: runner.os == 'Windows'
+      - name: Build
         run: |
           cmake --build build --config Release --target SonoBusMendeni_Standalone
           cmake --build build --config Release --target SonoBusMendeni_VST3
 
-      - name: Build (Linux & macOS)
-        if: runner.os != 'Windows'
-        run: |
-          ./buildcmake.sh
-
       - name: Stage VST3 Install Script (macOS)
         if: runner.os == 'macOS'
         run: |

From d42da4bcf92c73ddc7b8cf2d755700717e50a092 Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Wed, 28 Jan 2026 17:32:40 -0500
Subject: [PATCH 09/20] Add bidirectional OSC scaling for TouchOSC slider
 synchronization (#22)

Multiply outbound slider float values by 2 and inbound by 0.5
---
 Source/OSCManager.cpp          | 3 ++-
 Source/OSCManager.h            | 8 ++++++++
 Source/SonobusPluginEditor.cpp | 8 ++++----
 3 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/Source/OSCManager.cpp b/Source/OSCManager.cpp
index 17a71075d..8b8d945f1 100644
--- a/Source/OSCManager.cpp
+++ b/Source/OSCManager.cpp
@@ -59,7 +59,8 @@ void OSCManager::sendMessage(const juce::String& address, const juce::var& value
     {
         if (value.isDouble())
         {
-            sender.send(address, static_cast<float>(value));  // Convert double to float
+            // Apply OSC_SCALE_FACTOR to float/double values
+            sender.send(address, static_cast<float>(value) * OSC_SCALE_FACTOR);
         }
         else if (value.isInt())
         {
diff --git a/Source/OSCManager.h b/Source/OSCManager.h
index 19cf21e88..07fe06d77 100644
--- a/Source/OSCManager.h
+++ b/Source/OSCManager.h
@@ -4,6 +4,14 @@
 #include <functional>
 #include <map>
 
+// Global constant for OSC message scaling factor
+// Used to scale outbound float values for TouchOSC compatibility
+constexpr float OSC_SCALE_FACTOR = 0.5f;
+
+// Inverse scale factor for incoming OSC messages
+// Used to compensate for the outbound scaling on specific controls
+constexpr float OSC_INVERSE_SCALE_FACTOR = 2.0f;
+
 class OSCManager : private juce::OSCReceiver,
                    private juce::OSCReceiver::ListenerWithOSCAddress<juce::OSCReceiver::MessageLoopCallback>
 {
diff --git a/Source/SonobusPluginEditor.cpp b/Source/SonobusPluginEditor.cpp
index 80b5ccaae..cdfe6f49d 100644
--- a/Source/SonobusPluginEditor.cpp
+++ b/Source/SonobusPluginEditor.cpp
@@ -1450,7 +1450,7 @@ void SonobusAudioProcessorEditor::registerAllOSCControls()
     // Register OutGainSlider - updates slider value with a float
     oscManager.registerControl("/OutGainSlider", [this](const juce::OSCMessage& message) {
         if (message.size() > 0 && message[0].isFloat32()) {
-            float value = message[0].getFloat32();
+            float value = message[0].getFloat32() * OSC_INVERSE_SCALE_FACTOR;
             juce::MessageManager::callAsync([this, value]() {
                 if (mOutGainSlider) {
                     mOutGainSlider->setValue(value, juce::NotificationType::sendNotificationAsync);
@@ -1531,7 +1531,7 @@ void SonobusAudioProcessorEditor::registerAllOSCControls()
     // Register DrySlider - updates slider value with a float
     oscManager.registerControl("/DrySlider", [this](const juce::OSCMessage& message) {
         if (message.size() > 0 && message[0].isFloat32()) {
-            float value = message[0].getFloat32();
+            float value = message[0].getFloat32() * OSC_INVERSE_SCALE_FACTOR;
             juce::MessageManager::callAsync([this, value]() {
                 if (mDrySlider) {
                     mDrySlider->setValue(value, juce::NotificationType::sendNotificationAsync);
@@ -3301,7 +3301,7 @@ void SonobusAudioProcessorEditor::registerAllOSCControls()
         String peerLevelAddress = "/Peer" + String(peerIndex + 1) + "Level";
         oscManager.registerControl(peerLevelAddress, [this, peerIndex](const juce::OSCMessage& message) {
             if (message.size() > 0 && message[0].isFloat32()) {
-                float level = message[0].getFloat32();
+                float level = message[0].getFloat32() * OSC_INVERSE_SCALE_FACTOR;
                 juce::MessageManager::callAsync([this, peerIndex, level]() {
                     if (peerIndex < processor.getNumberRemotePeers()) {
                         processor.setRemotePeerLevelGain(peerIndex, level);
@@ -3322,7 +3322,7 @@ void SonobusAudioProcessorEditor::registerAllOSCControls()
         String peerPanAddress = "/Peer" + String(peerIndex + 1) + "Pan";
         oscManager.registerControl(peerPanAddress, [this, peerIndex](const juce::OSCMessage& message) {
             if (message.size() > 0 && message[0].isFloat32()) {
-                float pan = message[0].getFloat32();
+                float pan = message[0].getFloat32() * OSC_INVERSE_SCALE_FACTOR;
                 juce::MessageManager::callAsync([this, peerIndex, pan]() {
                     if (peerIndex < processor.getNumberRemotePeers()) {
                         // Set pan for channel group 0, channel 0

From 9a634635c936b17b00fc562c465668cd3f45c6f5 Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Wed, 28 Jan 2026 19:59:17 -0500
Subject: [PATCH 10/20] Change Peer Mute/Solo OSC controls from int32 to
 float32 (#23)

---
 Source/PeersContainerView.cpp  |  6 +++---
 Source/SonobusPluginEditor.cpp | 24 ++++++++++++------------
 doc/OSC_COMMANDS.md            | 18 +++++++++---------
 tests/oscsend_comprehensive.sh | 16 ++++++++--------
 4 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/Source/PeersContainerView.cpp b/Source/PeersContainerView.cpp
index c92e27274..4a0016161 100644
--- a/Source/PeersContainerView.cpp
+++ b/Source/PeersContainerView.cpp
@@ -2034,7 +2034,7 @@ void PeersContainerView::buttonClicked (Button* buttonThatWasClicked)
                 
                 // Send OSC feedback for Peer Mute (only for first 16 peers)
                 if (processor.getOSCEnabled() && i < 16) {
-                    processor.getOSCManager().sendMessage("/Peer" + String(i + 1) + "Mute", pvf->recvMutedButton->getToggleState() ? 1 : 0);
+                    processor.getOSCManager().sendMessage("/Peer" + String(i + 1) + "Mute", pvf->recvMutedButton->getToggleState() ? 1.0 : 0.0);
                 }
             }
             return;
@@ -2055,7 +2055,7 @@ void PeersContainerView::buttonClicked (Button* buttonThatWasClicked)
                     // Send OSC feedback for each peer Solo state (only for first 16 peers)
                     if (processor.getOSCEnabled() && j < 16) {
                         bool soloState = buttonThatWasClicked->getToggleState() && (i == j);
-                        processor.getOSCManager().sendMessage("/Peer" + String(j + 1) + "Solo", soloState ? 1 : 0);
+                        processor.getOSCManager().sendMessage("/Peer" + String(j + 1) + "Solo", soloState ? 1.0 : 0.0);
                     }
                 }
                     
@@ -2068,7 +2068,7 @@ void PeersContainerView::buttonClicked (Button* buttonThatWasClicked)
                 
                 // Send OSC feedback for Peer Solo (only for first 16 peers)
                 if (processor.getOSCEnabled() && i < 16) {
-                    processor.getOSCManager().sendMessage("/Peer" + String(i + 1) + "Solo", buttonThatWasClicked->getToggleState() ? 1 : 0);
+                    processor.getOSCManager().sendMessage("/Peer" + String(i + 1) + "Solo", buttonThatWasClicked->getToggleState() ? 1.0 : 0.0);
                 }
                 
                 updatePeerViews();
diff --git a/Source/SonobusPluginEditor.cpp b/Source/SonobusPluginEditor.cpp
index cdfe6f49d..6c9883f8e 100644
--- a/Source/SonobusPluginEditor.cpp
+++ b/Source/SonobusPluginEditor.cpp
@@ -3208,8 +3208,8 @@ void SonobusAudioProcessorEditor::registerAllOSCControls()
         // Peer Mute - Controls receive active state
         String peerMuteAddress = "/Peer" + String(peerIndex + 1) + "Mute";
         oscManager.registerControl(peerMuteAddress, [this, peerIndex](const juce::OSCMessage& message) {
-            if (message.size() > 0 && message[0].isInt32()) {
-                bool muted = message[0].getInt32() != 0;
+            if (message.size() > 0 && message[0].isFloat32()) {
+                bool muted = message[0].getFloat32() != 0.0f;
                 juce::MessageManager::callAsync([this, peerIndex, muted]() {
                     if (peerIndex < processor.getNumberRemotePeers()) {
                         // Match UI behavior: when muting, use setRemotePeerRecvAllow to turn off receiving and allow
@@ -3225,7 +3225,7 @@ void SonobusAudioProcessorEditor::registerAllOSCControls()
                         }
                         // Send OSC feedback
                         if (processor.getOSCEnabled()) {
-                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "Mute", muted ? 1 : 0);
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "Mute", muted ? 1.0 : 0.0);
                         }
                     }
                 });
@@ -3235,8 +3235,8 @@ void SonobusAudioProcessorEditor::registerAllOSCControls()
         // Peer Solo
         String peerSoloAddress = "/Peer" + String(peerIndex + 1) + "Solo";
         oscManager.registerControl(peerSoloAddress, [this, peerIndex](const juce::OSCMessage& message) {
-            if (message.size() > 0 && message[0].isInt32()) {
-                bool soloed = message[0].getInt32() != 0;
+            if (message.size() > 0 && message[0].isFloat32()) {
+                bool soloed = message[0].getFloat32() != 0.0f;
                 juce::MessageManager::callAsync([this, peerIndex, soloed]() {
                     if (peerIndex < processor.getNumberRemotePeers()) {
                         processor.setRemotePeerSoloed(peerIndex, soloed);
@@ -3246,7 +3246,7 @@ void SonobusAudioProcessorEditor::registerAllOSCControls()
                         }
                         // Send OSC feedback
                         if (processor.getOSCEnabled()) {
-                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "Solo", soloed ? 1 : 0);
+                            processor.getOSCManager().sendMessage("/Peer" + String(peerIndex + 1) + "Solo", soloed ? 1.0 : 0.0);
                         }
                     }
                 });
@@ -4242,10 +4242,10 @@ void SonobusAudioProcessorEditor::sendAllOSCState()
         
         // Peer mute/solo
         bool muted = !processor.getRemotePeerRecvAllow(peerIndex);
-        oscManager.sendMessage("/Peer" + peerNum + "Mute", muted ? 1 : 0);
+        oscManager.sendMessage("/Peer" + peerNum + "Mute", muted ? 1.0 : 0.0);
         
         bool soloed = processor.getRemotePeerSoloed(peerIndex);
-        oscManager.sendMessage("/Peer" + peerNum + "Solo", soloed ? 1 : 0);
+        oscManager.sendMessage("/Peer" + peerNum + "Solo", soloed ? 1.0 : 0.0);
         
         // Peer level
         float level = processor.getRemotePeerLevelGain(peerIndex);
@@ -4320,10 +4320,10 @@ void SonobusAudioProcessorEditor::sendPeerOSCState(int peerIndex)
     
     // Send peer mute/solo
     bool muted = !processor.getRemotePeerRecvAllow(peerIndex);
-    oscManager.sendMessage("/Peer" + peerNum + "Mute", muted ? 1 : 0);
+    oscManager.sendMessage("/Peer" + peerNum + "Mute", muted ? 1.0 : 0.0);
     
     bool soloed = processor.getRemotePeerSoloed(peerIndex);
-    oscManager.sendMessage("/Peer" + peerNum + "Solo", soloed ? 1 : 0);
+    oscManager.sendMessage("/Peer" + peerNum + "Solo", soloed ? 1.0 : 0.0);
     
     // Send peer level
     float level = processor.getRemotePeerLevelGain(peerIndex);
@@ -4395,8 +4395,8 @@ void SonobusAudioProcessorEditor::clearPeerOSCState(int peerIndex)
     oscManager.sendMessage("/Peer" + peerNum + "RemotePeerUserName", "");
     
     // Clear all other peer controls to default/off states
-    oscManager.sendMessage("/Peer" + peerNum + "Mute", 0);
-    oscManager.sendMessage("/Peer" + peerNum + "Solo", 0);
+    oscManager.sendMessage("/Peer" + peerNum + "Mute", 0.0);
+    oscManager.sendMessage("/Peer" + peerNum + "Solo", 0.0);
     oscManager.sendMessage("/Peer" + peerNum + "Level", 0);
     oscManager.sendMessage("/Peer" + peerNum + "Pan", 0.0f);  // Center pan
     
diff --git a/doc/OSC_COMMANDS.md b/doc/OSC_COMMANDS.md
index 090e8f6b0..33ba0891b 100644
--- a/doc/OSC_COMMANDS.md
+++ b/doc/OSC_COMMANDS.md
@@ -572,7 +572,7 @@ SonoBus supports OSC control for up to 16 remote peers (connected users). Each p
 #### `/Peer[1-16]Mute`
 **Type**: Toggle Button  
 **Description**: Mutes/unmutes receiving audio from the specified peer  
-**Data Type**: Integer (0 = unmuted/receiving, 1 = muted/not receiving)  
+**Data Type**: Float (0.0 = unmuted/receiving, 1.0 = muted/not receiving)  
 **Examples**:
 - `/Peer1Mute` - Mutes/unmutes Peer 1
 - `/Peer2Mute` - Mutes/unmutes Peer 2
@@ -583,7 +583,7 @@ SonoBus supports OSC control for up to 16 remote peers (connected users). Each p
 #### `/Peer[1-16]Solo`
 **Type**: Toggle Button  
 **Description**: Solos/unsolos the specified peer  
-**Data Type**: Integer (0 = not soloed, 1 = soloed)  
+**Data Type**: Float (0.0 = not soloed, 1.0 = soloed)  
 **Examples**:
 - `/Peer1Solo` - Solos/unsolos Peer 1
 - `/Peer2Solo` - Solos/unsolos Peer 2
@@ -1083,13 +1083,13 @@ The parametric EQ provides four bands of equalization: low shelf, two parametric
 /OptionsFormatChoiceDefaultChoice 4
 
 # Mute Peer 1
-/Peer1Mute 1
+/Peer1Mute 1.0
 
 # Unmute Peer 1
-/Peer1Mute 0
+/Peer1Mute 0.0
 
 # Solo Peer 2
-/Peer2Solo 1
+/Peer2Solo 1.0
 
 # Enable compressor for Peer 1
 /Peer1CompressorEnable 1
@@ -1143,10 +1143,10 @@ client.send_message("/MetTempoSlider", 120.0)
 client.send_message("/RecordingButton", 1)
 
 # Mute Peer 1
-client.send_message("/Peer1Mute", 1)
+client.send_message("/Peer1Mute", 1.0)
 
 # Solo Peer 2
-client.send_message("/Peer2Solo", 1)
+client.send_message("/Peer2Solo", 1.0)
 
 # Enable compressor for Peer 1
 client.send_message("/Peer1CompressorEnable", 1)
@@ -1170,8 +1170,8 @@ Create controls with the following OSC addresses:
 - Fader with address `/OutGainSlider` sending float values
 - Button with address `/RecordingButton` sending 0/1
 - XY Pad with `/MetTempoSlider` on one axis
-- Toggle buttons for `/Peer1Mute`, `/Peer2Mute`, etc. sending 0/1
-- Toggle buttons for `/Peer1Solo`, `/Peer2Solo`, etc. sending 0/1
+- Toggle buttons for `/Peer1Mute`, `/Peer2Mute`, etc. sending 0.0/1.0
+- Toggle buttons for `/Peer1Solo`, `/Peer2Solo`, etc. sending 0.0/1.0
 - Faders for peer FX controls like `/Peer1CompressorThreshold`, `/Peer1EqLowShelfGain`, etc.
 
 ## Receiving OSC Messages from SonoBus
diff --git a/tests/oscsend_comprehensive.sh b/tests/oscsend_comprehensive.sh
index de21ddece..cda7b3494 100755
--- a/tests/oscsend_comprehensive.sh
+++ b/tests/oscsend_comprehensive.sh
@@ -475,14 +475,14 @@ oscsend localhost 6000 /OptionsRecMixMinusButton i 0
 sleep 2
 
 echo "=== Peer 1 Controls ==="
-oscsend localhost 6000 /Peer1Mute i 1
+oscsend localhost 6000 /Peer1Mute f 1.0
 sleep 2
-oscsend localhost 6000 /Peer1Mute i 0
+oscsend localhost 6000 /Peer1Mute f 0.0
 sleep 2
 
-oscsend localhost 6000 /Peer1Solo i 1
+oscsend localhost 6000 /Peer1Solo f 1.0
 sleep 2
-oscsend localhost 6000 /Peer1Solo i 0
+oscsend localhost 6000 /Peer1Solo f 0.0
 sleep 2
 
 echo "=== Peer 1 Utility Controls ==="
@@ -580,14 +580,14 @@ oscsend localhost 6000 /Peer1EqEnable i 0
 sleep 2
 
 echo "=== Peer 2 Controls (if connected) ==="
-oscsend localhost 6000 /Peer2Mute i 1
+oscsend localhost 6000 /Peer2Mute f 1.0
 sleep 2
-oscsend localhost 6000 /Peer2Mute i 0
+oscsend localhost 6000 /Peer2Mute f 0.0
 sleep 2
 
-oscsend localhost 6000 /Peer2Solo i 1
+oscsend localhost 6000 /Peer2Solo f 1.0
 sleep 2
-oscsend localhost 6000 /Peer2Solo i 0
+oscsend localhost 6000 /Peer2Solo f 0.0
 sleep 2
 
 oscsend localhost 6000 /Peer2InputReverbSend f 0.5

From dcaabba79ed12f86db148e3d24e10bc3efa7c59e Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Wed, 28 Jan 2026 21:02:20 -0500
Subject: [PATCH 11/20] Add recording options to OSC state synchronization
 (#24)

---
 Source/SonobusPluginEditor.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/Source/SonobusPluginEditor.cpp b/Source/SonobusPluginEditor.cpp
index 6c9883f8e..1fa2bbff7 100644
--- a/Source/SonobusPluginEditor.cpp
+++ b/Source/SonobusPluginEditor.cpp
@@ -4229,6 +4229,15 @@ void SonobusAudioProcessorEditor::sendAllOSCState()
     }
     oscManager.sendMessage("/OptionsRecStealth", processor.getRecordStealth() ? 1 : 0);
     
+    // Send recording options controls
+    uint32 recOptions = processor.getDefaultRecordingOptions();
+    oscManager.sendMessage("/OptionsRecMixButton", (recOptions & SonobusAudioProcessor::RecordMix) ? 1 : 0);
+    oscManager.sendMessage("/OptionsRecMixMinusButton", (recOptions & SonobusAudioProcessor::RecordMixMinusSelf) ? 1 : 0);
+    oscManager.sendMessage("/OptionsRecSelfButton", (recOptions & SonobusAudioProcessor::RecordSelf) ? 1 : 0);
+    oscManager.sendMessage("/OptionsRecOthersButton", (recOptions & SonobusAudioProcessor::RecordIndividualUsers) ? 1 : 0);
+    oscManager.sendMessage("/OptionsRecSelfPostFxButton", !processor.getSelfRecordingPreFX() ? 1 : 0);
+    oscManager.sendMessage("/OptionsRecSelfSilenceMutedButton", processor.getSelfRecordingSilenceWhenMuted() ? 1 : 0);
+    
     // Send peer controls for all 16 slots
     // Send active peer states for existing peers
     int numPeers = processor.getNumberRemotePeers();

From fdbfd65b8b9f4477411a8608043ff6f5d7dd9520 Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Wed, 28 Jan 2026 22:20:52 -0500
Subject: [PATCH 12/20] Fix OSC peer leave: call listeners before peer removal
 (#25)

---
 Source/SonobusPluginEditor.cpp    | 7 +++++++
 Source/SonobusPluginProcessor.cpp | 4 +++-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/Source/SonobusPluginEditor.cpp b/Source/SonobusPluginEditor.cpp
index 1fa2bbff7..ede1c4f38 100644
--- a/Source/SonobusPluginEditor.cpp
+++ b/Source/SonobusPluginEditor.cpp
@@ -7412,6 +7412,13 @@ void SonobusAudioProcessorEditor::handleAsyncUpdate()
             if (ev.success) {
                 statstr = TRANS("Left Group: ") + ev.group;
                 mChatView->addNewChatMessage(SBChatEvent(SBChatEvent::SystemType, ev.group, "", "", "", statstr));
+                
+                // Clear OSC state for all peer slots when leaving group
+                if (processor.getOSCEnabled()) {
+                    for (int i = 0; i < 16; ++i) {
+                        clearPeerOSCState(i);
+                    }
+                }
             } else {
                 // this situation is frequent but inactionable by users
                 // statstr = TRANS("Failed to leave group: ") + ev.message;
diff --git a/Source/SonobusPluginProcessor.cpp b/Source/SonobusPluginProcessor.cpp
index c0d25ac74..f5ad9f515 100644
--- a/Source/SonobusPluginProcessor.cpp
+++ b/Source/SonobusPluginProcessor.cpp
@@ -4404,6 +4404,9 @@ int32_t SonobusAudioProcessor::handleClientEvents(const aoo_event ** events, int
 
                 DBG("Peer leave group " <<  e->group << " - user " << e->user);
 
+                // Notify listeners BEFORE removing peer so they can capture peer index for OSC cleanup
+                clientListeners.call(&SonobusAudioProcessor::ClientListener::aooClientPeerLeft, this, CharPointer_UTF8 (e->group), CharPointer_UTF8 (e->user));
+
                 EndpointState * endpoint = findOrAddRawEndpoint(e->address);
                 if (endpoint) {
                     
@@ -4411,7 +4414,6 @@ int32_t SonobusAudioProcessor::handleClientEvents(const aoo_event ** events, int
                 }
                 
                 //aoo_node_remove_peer(x->x_node, gensym(e->group), gensym(e->user));
-                clientListeners.call(&SonobusAudioProcessor::ClientListener::aooClientPeerLeft, this, CharPointer_UTF8 (e->group), CharPointer_UTF8 (e->user));
 
             } else {
                 DBG("bug bad result on leave event");

From 30f5b7ba821e0841cd7614851fb57a8b67f64204 Mon Sep 17 00:00:00 2001
From: Steven Wilson <2165238+mendeni@users.noreply.github.com>
Date: Wed, 28 Jan 2026 22:23:48 -0500
Subject: [PATCH 13/20] Add TouchOSC with Control, Session, Recording pages

---
 util/SonoBusMendeni.tosc | Bin 0 -> 8324 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 util/SonoBusMendeni.tosc

diff --git a/util/SonoBusMendeni.tosc b/util/SonoBusMendeni.tosc
new file mode 100644
index 0000000000000000000000000000000000000000..4b8ee1b07d3b888653b8f60b50bd339e8240999f
GIT binary patch
literal 8324
zcmaKw2Q*ym`u1N$^b%c!gdpnZy(PNQ4Mvm@HOlC{Mv_4gqIaSjW%Lm>BKo}A=tfB}
zdI=#~@E^&0&N|<B{@=IOtaa_Z*E4%x>t6f*UC+J!vv+gMywIw-YD*^|_w}Auqb$M`
z&6EP}*;L`#ME*4P5nCrG7I#PW%29R_c4lXVOI(^KuW(oO9=sHNnH2dZb@?`-c(~X3
z_4eNQr_c*w#t_;AYuT);Bh^d&01>KjE4sMS6NUD(V8651Kh~-pN~vp4K4rKK>y*~(
z#fAo4k7sdtLij~r-Dk6W7pga@e)hT6=Y*ig>!HPul+ng^i9*bZ`LCn3^{nlYyu?qk
z@eW>h1p2INLoPp_S^ip`{`9u5e*F5^bnD5w-}?1o``4xme?(@)_0`Gj=D@k1W%~dy
z8&>*AS3pO%PL+5Fe<X{<KI!SNw&L+qEh)LTBRc!z*Nb^M=bK@d^&kPcC_mrM@Pg&=
zWmuG3n|qt7q12DlfY<svA$Oo6*QvRiP4(k_N1q1b!xZXcS10!!N+}%TQrZF~S9eIj
zm-0V<A)o5W`V<45S2hj0pViz8<8KQG?rPhAb}JaYPwwb+&<1myRavlr&N_8m?cNuc
z4PE@s#}c!NGUHrIH(mVU(wH4v3iXmJ;-wwgg;k+3D@7;*gBR}dW?|iV%N~b_wD`t`
zX8-SNDT}V(P$A3$y`cv=sR*CMPZCvO?K8eH?W$?@M&E0k4`G@m``$mCek7f+9U3QL
zT8-{KT6lhP;h>;EmUoqX(Grx@GtTW6));W$D3(z~hPnP2#5*fRK(V5c-jIWR2f_=t
zbv|%3ImraK7+qvCr7o5$<Xi`PJlw20R~!0!Z)!VDS7PTF88=_wxKmOE*`FKy39mwi
zO~a4GT(;pM@_D+wpU;Oc23qOoKedKlKMTA{S&z{u-nV_~+yVYreQ#{yVwNYMWj^4C
zDF6-1YFfGGHJ2$g4O&JELw2R3iT7tE%RhIWEPwbp7a%=SFAyq1;ea`&SOW-m)7P4?
z(+h`)k@q>2T5oaW8K#Gd&mza6>F}_ct9?g4+yq$x)O}k4-G{7QG-Rk1h~*>0!_Z^z
zJe@h+(E5}0aVznh=m+g*fZ>T<h0;f7d3k`9gUb-MVl;TuC{9!Q^LgojC0XC*lB~@2
z>4=YJmO^f>%k}vHd|)U@cTT5eceZsq-cMp0ynp3;b+8_@8m1YR`XDted+1!+UO-pL
zZ4<W5+ZtMXRiAqKR5Pvya`N<Kh}<j4@9F>`)Ah`4)+brzt9Ezffhff9BJc-jAD!W3
zub^}Fy$uh}bcI>Dh_Q^9?Z3~wvcC?_69C57USldfvmq360bA+yDuR`ZQYWbto1c=*
z@+AWDf3QPbB3y=D_gzEJPJgt_?x>BxHrYoss?W6$4z*#@d9H8;i~0G>`ngRPqWv-v
z>3|lUXThJ&6X)6JM@BrV<JX4Q(&GK--(Clwkgku+)Gafv4e#16ywmmdTS&VHa6cqp
zzuUEsbkAaIZ?Rjmrx_aZ#YjlN`p}C*B}jk7w_wMVDyoPRvsvP$i*D=1V#`aa?J}=h
z>zEa~z{g|~If@R$-3=w=7Qqs4okG@y%d<`jT^Hj6k0#M9)jNmGL6W_8mi{H%`E*d7
zhR_l>;0w58X7R`o^2Z5(JTg@j?08h<-lP$!(;IWvUE%#Bu*ba?Hiy`Cag&U&-+&v}
zQcsh!K#@$9%PI%&3|qQ%wV6E<C`#CPzpzaXeC)5OBBK}6i>UOr+h6gJGt3e{+H16J
z4Q*kb=p)Xv32Z|br_&3(mM;pw+@3siaFcD%iB-BYJrb3&c=0vj*rqmpq$DO#N6>jk
zc=H{{iEME^bj2-JlOovsoar^{kPH|m^Xoz8!nDxlmRu6frYb>^Ks9`1zauDg$w{(#
z|D8%+QOmixsay|IqoO)eAJ))u8SLkGS!?9XKey)8oUOgj67%B2q)Qf}{OQjraR_M4
z8$^eeHQ6BTn_<XVaUp2o_|Xgx{5w+F+Ew{b<)=VyE|F)v-$}0>v73MHshXUH5FPb5
z+Tt=)am9`R$IAGLfN$5WyQvqt4bxHj=MwTmbSrb`Eagxq4g7{Ox^fPO5#`3)Fw?F<
zSSmdXNMKa4*Ogn95zz|b|6)`G+h%q(jn2$S&B#bi%1DiIWVSJN1M9OduQHwaE^r+1
z$!=4~B9$XYS-lCF@5YgHFYIM(j8gjaPak?{EE$V=m(fcXRk)TY&8bGZh-F#j7bx{@
zjJ_l6Sd`bnb0K7s?vE(f-sp{}Va1+w-AEZNQ{4~o)%48qCrssHk)?ZUX?M#@w$V~0
zaO<amk;cU1VxIm(o1=U>Y0}I^6h=<&U*)~~`HAm$MSf=uE_)<Dagh6#f(#Y;Cec#s
zVcl;2g`V3QM>9S%YAoN>n=2>v=y@Z}>ju_xrRpYDl0VNRWZF_6>5hnap%f0;<>xQ+
z7UGR0OPP5O^eNM42I6^f-2qN~7yd17-<99$u}KAS0!7t14o^xbV9(CTdBE##0&pjh
zf|k;YGKAesv)zyn$P2BP4zyyxwgeBEk;$w1A@hEBVMgG7a3WHVW7HWG0S6-&T<K9x
zdd0)sHac+mZ(Ivq2f@M}c~@0~Tu9{5WqWGdd?0<|z{i@LHCDG{48L|q(j8;oMNv(G
z?v(UJf%{Hpo%K25B=m~8A>!kp;6^tX!G*CWk}-lIRVkV>K;1(NUwu=uXeV{jh<5ud
z3exg~@Vx=ELGIK9RNsn*0bkWIMn88?8m~8b^zZm$e^(RvGfJ&Z$`UTlbQDd=uYLcF
zY{_)ol9$|8K(q8i?`cNi5=m8geEKccbd-nIn3yW)?mg|N^vC1J%T}}|_{QNzb4&(A
z9po8?uYT>=sZG<U7q1l6ne`GGIKDEp_aH3#i~BM0dlXv{yI&5DO?1sq@i2r1p4O&h
zNtqS!HRIf*fw{na<+i_!9@FaK8#<C0$?HB^=`qkEAmvR+89}u~*x>LoN791Ajqci{
z44JyWCoaN;J?4QV00T!DX^OLN-DK6h!hU}HuN#53)dWwwwE6pKpKv$*3ii4@13~5u
zHe*iMnru50A)jl{P~50$c=7=>-{pX9g#>NnL=X$4=z-(*R+;ei)(OB2WlRm7^mrP$
z<lW@LE<d)%6&N^bXvm`9_Ra5g6}I~l<fg@&ZQzK_dl837NzIW%<M&1clr+zbWK+#L
zyxQt2{C2*XvfUZD|Gkyq;^$j{)^uHWAbVG>_`^Hp;9RBl*3)C1VS@A8g~Fc%=XsRt
zGvso%4=FMc%z^HVfszrV@<ewkB$kmb+^DoXdbX=m7ovw}>iH5e0(9~fDwOf-P`B|t
zrn*e{^v2zxlB~|}$Gff9bCn%O3Wf7*&#o`;7p~@ch|c{wwA}inrf?~GjvP40(^Xjh
z6q`z6-Ey^r3Zt{8y8Ia69UFR=e<j7_T1V^4HDy*%cJ^zYJ~1$ZA?)aQ|K|r_NZ|uV
z=j*6;;B-E{63-U~o!P3BsU8eTlf_F~(qgmE-(OPy9TMD^{k6ha$Xja?rS-^&C`d$-
z>+i#ilQLy`!!A+%x3>)yl{lmoHV6Y>FMg2NAj3+Sd?1rf^4j-T_X2~$3tunhsJMX%
z+L<1^F(2J-f8sXE^hYjU9K|Vu4*2cdCS*jBc%o_R`vR_}cKeBI#PM-Jih-h>la-#}
zWusT&fWHOHy#rnwwQ+SM0Kum)*h9eKH`MdYr2%p&Pm{h7S$LoPc*HZsGJ2)VZSNOi
z(ZG1WR+=BncB9USYT$I^B<W<z>0I}G70@l%y^A)cM>hP!Kb()|kdQ65;IM6)9iGK$
z9jZg~wGIJCMQW$Qcg1;eB|HmDvs07!<yi;m^Eyq0jA8E@`3fRxtt-VCD{h2=w>SDm
zD(=Zq+c2lsZUJAs$jt)CtbSy&d1p>-(__-=P-!=y6H9ATHDKa{l^*O}ehX$JgJHWf
zcG7_Ab={i;iK$V(>RMseYH1q8$I4u|@WW~xOQH0HM=@=J539S{lNbZY<{pR~Ivsxo
zC`yPNu3}uJ99FAlWg1j++bwc>1f~C8MBoNVbS`r4kOh5NtdaO5esVj^0RcaM$~6VQ
zmYiuN*{R|t-&y!8$n0MW{;X@PX)2vNdrB1-mCm6bPc5ifu#mDbxGb)fWR<C`eQqbH
zy{sz=DA5qqR%DU0%Dgqsp3ceoWJKAFKvKJFoSDD0GB;m^i+6DDi5<TtEWeV=S$oi_
zpb~o}y6(5|sEsH;jV!AyvB#uL{vb=HwcE|DOO24xH%@Nkv}@Ee#$Hi*ian#XODS|H
zsKf&qqo)ehC8m-NUkw$tsUHJVj(68vv3s#9Y3DI9FcRYucw(ZAS7krlU^Fz>Tms>F
z3mII_B-qaWCW$6q?OihnPX(^E@Cj{2P9`=7>`H2VBO9UKFDoVKwPtH8AT?_777Nt;
zCp23KIo}Xz^kk(|a<V&&bicW6uNYS@g&1wmCJHFw70eG!fA7eUu9w8=o#p*Ni;%kO
zjUel92}Fqq<%egycgGuwdeuhMoX=&+e!2B)x5o&=Hj&n5#UbbtyrBAJOc;N#AY@8>
z)&W@kI7PDh*m^W&T_VA$V*EAF@$i0t9*4}vmeae)Sa_RtV=wk4o^^T$whsIhT!z7`
z_B-eUz^6a*KR$UzmS+>~#1+0JSM`Y5Rj>!7Bv`zXZoNgGjyh83|2NL-s>sR6K@FYt
zY{+`g^kubNO^fFHJ{XHG@f@i$b&F<u(=qiK18@m^er6@E#q(2z-$V+G7da~e<E5yC
zw~4c&hqB(UOY?9}P*BftxCrH|YDK-_$5!aMBDO$ph>pt~tQD0+S=C59Iaf_W&lc&F
z!7bDlvm7qkF&jXoo(BcI%HSwCr3LGAG|;<8?2yQ;kL+_Y+-4B)oTNll+<@dJcZky!
zyAY0AV{%^_?$t_UTFc=0U_vKS{D{oJrEqhFsttA*7%vFyy5pf{(Y!P%vo$!8g4xNK
zNFgu=Kg)W*e>Z@dinBG~sQZmCk(pN69cs4cG5>P-Tv2W-BYpHQ?S5lzeue2#eMkW>
zK~_xmSc*m0lvos8)R2^|MbR6&K|DrFg@7o7U4{-1W4=IdJJ0wsgRu7#EUry36~x!V
z0d>+)A*!sRU3t!me~N7lhQN6DsSxFG0~7dtFew{?CY75{;%8f7&HVl$Gt`b4>G@NO
z7^%d^$CR1`X5|po&krpd1z5)rixn!`y6CeS64EL{^;iwd)a0mX?-me04PrD?AQbK5
zC8&tW{+43VYdk52;w4LYtzP~98Ed;@AoM+icas*~Urn*ji^GbBdkq3?NlHZ}j7ds6
zx!sAg6$cTHIzoKf9#!qhRfTg!E<pyS!^JNAktom0kJgEG#SL1H&9&>y#h6g~?_B&K
z)6{wg15*|g$ABtDg!N8JD*t`jtw>^w0isOrA&>GP-5-B9HUlR_^z)yTzi&@_=E3(Q
z5M$+&Akv<wIco~oOo<qLQUw0T;~*mCD4Kc4BYN|rJFriRBdrb!y314n1%0KF#Mfc9
zLlc)u0z+{gsZrBmT_mUaahqw^a`8{c^U`sf0g=h6OhJqKrh9%k@hIV9JM0Fm7{i*H
z%KT*poPUU)t(QLx8wJ??u3*uBRj`Oy>g-**g^as;^}R}fX9?K%=H?pJqK4#bH`O~L
z-lR1^>=uE4VatO_6^Q+-)H@P{T_joDTx*K87mjslfYA1ehTSfwo()15%^~y$x&7!r
zEjF5($TNWAE+ZzNT|n+@iE^wYHe|M~QE8)Jy(LM%N5c8@-Knry^buwq8l@o5l%5i=
z7YH)A0uf?9t`Wa6*xW`z6k!zHsHv+vK`C%0fm2%sm%55`@7k#5UEB$w;tCrU_gBsF
z`{~rd+WaDRZs6IhxBLFUGg66}R_dMIjT%3^o!!oVll%tM(_a?LTbn$dl%-Tp5e4~$
zxBF;A+nKD~=zm7EKX;p9`Xj9@Kc~9dF{GrQWSN2juCA6#j7|ZL@b4RC2%cB;pY98+
zQCCxudb8G<Z64mP@YfH1m;(O}0;!p=eyRE*`iZ_N!FDL(!rweTtc0w+TMsxjCN8Hn
zdnAbI6D7AGD@3g<0D9W|8ILlLD^NZVF<)<v4)Fvi{HT|}!MxVwZ))Q5^;`A5fF!ty
zXCG+JM=>>LBb%jW=N3|@X6MZ<Icf;=OdYke-J}J-g0><US!jxl37)1p>6`q>{w@E6
zMs(fan27!qD^JC9le0I4)zF(2a(4V=e%MUGCd}4<B@6+q^4nrTbKI^FcXeyhp;nqk
z0NH7Dxgf7DUC?vmXV9!i^@n#Sp4ek1dEQtQx!Pj}NEWF^21OtcH?fw{TOF+=OK`kk
z37jRK?_|MvOPvyb#82)!ggXdbbIS5?X#wh{)bw(n^Q##_N4VQprqkPh1WwfP`j-~b
zbZt7femspJs9+(3%I+<bJrH|{SSA2*Tq$F$%Wr`=RuAw>fPzM^U{q8`T5Ud2Ada0*
zWND*$j@X396hPYfsUDd_&(m#B;~ViX&Zhk>Qh}Vq(#j4#E(u=7Bcw>BI7!}Np2qsr
zH5u%ZMu5ZQzgJ@afQ``QN+oY&@B+F*TDZW#A>`t0Z|~fu0%e*!H0ddowJ1k7_PFAy
zIK-&lx6UyOSddlMzxG+)L2}slzJu3_7feyJ*vn#y;o^(az^^u6_LA=r>u>!h#_?^0
z?mQcd;IU}A+rx3mlxH8~0kOD+WknIL4i;^R^$rD!uMJt3W|r_~pFq#^6-%CfP<&TD
z3PHWbLhm2;5z=mHj3`4R$`ltDO*cc!7>jwleXf2kmy1(xY1-CMF^G2r7JhqSMliUH
z&CCS{;Qr&3$JNK4H<@|Ir2_PZ$7f{!tsaNm##SaaGppOIhkj>f=6_@+Q9l4a_mTg}
z$s!q2N`)(ki6;WXi~h{L@QnuK_cgh<&*|F@oWenK%gK<C7wOr{GC>uLL?Ry==HpSG
z0K4st<kamx+Q?-7Vml!6o!mYb|4HjhHOCB8UA9~j>X1?s+0ieMxZ)fb;K)e3mHqz)
zC~LXi*EI<hKbNZDc0CmDf=2bK0V3{6U~#@D<t8nP_cuoCARO&fnP-=U%zZZEdei?4
zL&-~TouTS%%8CDlPzw<E4MG9`AA~}in*<eK)K{tL8oo%YQ-Nmcvtlt%$@7LdUlA)4
zg}HBu$qb-f?Ts!z#ldD2zuoN^AX-Wio;jA?Q~rZbtVI_yjcR4p(07tcG`KpOlBL)+
z?m#b_Mr{7zVq>Vt1^ta?WX96VGXJ0QIk)^SpAoCQCM09d(}qIU33&<ss&7_;;By!$
zLdbT`)s->?(0kHO_dw6TDK@9`114fg66$-P?yTm7^j%Q*e3oM^^B3;{tGm_q6<Mob
za$kC>AH2=kkh^99?4MBTPon-J!J)(DyJbQ+hqz;PV93!=F&B}FU*>(!(DRAe<KpHq
z)5rLFIEH`GCL(rUMkiGRf^vI}VRA6QdLja@;?s=tOkZQpz@nsOeg-do%kz`7zhN2-
zaI+5rP}H_m!Uh)?S#-`mV4X?P4{|^}^6kx|iueI<NWLk4q{Iq#AGECa+MD%JUc)hI
zJT0V^#cF^9Vv+TiCJ3MPx3L;ZD^^D|@TCg)1eecg1BZv1AjKR-r|0O}K=<3(V`vdX
z=EL%8>8$|7bCAWJnomGlgP8a0El<3*f`o?R7A>FVS^}0yOz8CYG62ZpCcG_JtbJw$
ze<mU#o_0_$-k6)aF&FW_o6}uAk){dPeTlL1OAzU-)112t>yo3gf|<SYJ|j`I1^2^c
z-C}ouYW2K$6tkJ-sg}dW^;XGnk(+Hsp=dYPA;m-&mmqO0idvP?wPVU)sFSE?G1jh!
zcVv3e;#c6blggQuveZu|<Djvo5U#Q0SdE=Z|4K(QE|2iU!u;-!cP#BS6FRQiC=dD^
z9@ZVQ0^OVj!iWp*O`GHB^MqKoyyH3+Qkk1mu&ze=Y~X(&#nbV{<N}NZurnxbi8ub=
zcshb72h3its=2M<-^~1tJE9mn1WE3n?%@V!m6P9~n)Clewf1-B-OqkSY2fwneVxuG
z819mGXA}N^z+B?H1x2u$eJD5Hh{UA9X@_iBn8!FzNSY|v-`mja&gYn=c={i2!9=%P
z-p^G1*Vs9S9XmDW)$5*p!H%73kFjH?H5bSBi!7EBm%#Kxo6HD!g#PA%Ynt`5HqyYM
zE2GU8M3!s|m1UNR+eehl{cO)3Yaw01vRvxF@3v~4TMzK-I)aIxdKP$vb|zBuNqtVF
z{+$X|nmV#l73-K%uiK_k^~;qDUQ?(KcZZ|vr!bYASXr*b^8ZFWkF>IVUJh^Z07LV1
zmjt!2^xyqZpNjb>78>3E6(Ii+3l_7Mv`W)6YnAuW*%(AHLK`9F{Md%{41Bu(uBT>b
zb_`64?Z6^79c(9Jk^cK7cNXw+%8&+3P|y!T&SFW#Rum8S*<bx>1$GXPWyO#0v*oDi
z?-r0SI>{q9I9a-VqX}9yu>+77(gAHP(^EpM2+mznMpWrgmrp3nf(~dO^6kJ*+etp>
zMu(M|^IXW&AGFdK{-kU23a$<|qkmj1^C1y^!uTJ}Qp~T%_;YQ<wO}cT_ihF`wkr(N
z{4~%DP6~!;+pDxmMf{U?<ycr_TjiuRLd_>*>ju_ahYu={;q^@ham8O1FWvJkP;~T8
z{ZREetmm6H#&)w_d>|)4RGD7*#F)$nw{adySmXWZrdcw}pS&!Fy`uaFG&S!VARL|6
zTW7_~*`r*REI4|b<YhaFh?l_Eg^e$XKj4=A#lsFk<IqYdaBzJ~Jq$4^1NgyPvNh*i
zPq^}1%pX;outQ+jK6c#+SMzCJ5|b@Q8m3{V8pAY#rxtVp^oK4zy}x;g<;)Ea8~$$|
zMgeSLPZps^k14IBW-L}oYgQ8xC9406$IY{M{r4>J4O_^0nv3{9pyprj|F-v%SOXpL
z7{l(*pxd>|pyDlrrzSxo!E942;;oNcMPm`#(R}p_HtG4}+eV@ga!s?;rNcY=i1s;$
znV97)uBs{nqGBSBA%!K{LM4_dAvpG%f1rZk$J6?)&&Qut4&H8`Z4>PI(4=H)0#}%v
z$LdV_$B|&UU`u(|e1Zx0Y3`%7)fX}h@O-sTqyWtHfr;<g@WCK_sW#I2ttxw1|31qe
zx-{@BC&hug+v6@0IVjCj1p`~t+hjMtUea>j%d$5UjCI>*Epa*X4sK~(SuWX{rrr;L
zs>!ij8S^6!1-8lqQHdIpB5xDP_<#sHw&&~6eu@H5)&fOzJ~6~z5uNg0RC|cH;jrTU
zL}4jDZGjHDCw~Gw;TZ26C(Z9OXS&@$?|hpXvL|17S-ZdJY*TCC%<D>1bdjJsWuL;{
zXD8LS_#k%Ao^WO3fz|@yL(Z{Xf3}ivb+2+(K0IWnaE+F8Mty0}$cu#eNL3G2;lic+
z-QJ?P!(il?ztDN&Vn&39MCitO1hc<X%R%92f%QUtbmMdVTGtqlMfgS8{Cg#wEL?GX
zm*%`lni_5^P-kkngFz>Y366}n)+5j9ZAI71exs0IWe%aX6{q@1p~-)3A09H<zhQi?
znttcEv|~r#G0GvX(bzUdDOYvCnpIMQEWJ&Ja*&xj8<h~dwR-paC`aBqKWNsO<%W$9
zq-jKQZzoMk)BH$|Z2slLK>oD<ED!-xi#}GO`S{shr9_nBi@Mt<)j*3x!6CgNg4*Dg
zruQ$OXQz2Q>kVLBx5FMR<{oSH1`vo3X9eopIs=DeWYK<%>$^xvx0boxhbwJEckdLo
z#U2U|BDwZG3fm&Hz@FQ09mZ$rg@7ITn>DU&&3E4Qj_W7SOl=@f(Sq!CG%xNw?8kY>
zq)G#CB^UL*En2==Q=l}Y?3EGRBp=Id{94G0lwtgCZ&6duSmcwW=n8)+g9GNm;0<V^
z_c{>OOK0M%FXM!2jO(0_de9uC7gusmTPo926tf{RICi$ECe^Ynm*jawi5zoH_G25F
zHmQO8>8#eVDJAJ72aAA7x(S68V<{j0mcU7oJB6&#3G{300_TWLN@pn(Tif_XNxuHk
zHmU@7)^Cbk&^MZBqO`I76^zm$#{%|qC8<}iju6{-C~f9Ng`n~dV#+64KPT2&G{)U^
zh{mgac51`GA8Ew*n1S;48=U8Jis`MZxo7AXg$7@`Q~M9!z|q@MDp?_Wat|NC&`sqH
zC3S&@HcEn<ndyc_Fm+Hu37fXcd2F<I$BBNzUf@U(n_Nxwk!duajc&BLaopA~6L@<)
zD>T}>P`X<Wpwvu?5l%)=>Fp^HSOoi;3lQ@mHNsU~*u0~87<zWmT=0CMXfzE1`+=V7
z+Uj1Khk36DW1rohgP=(f#y;j5$vx8;7fYmb0z|03Okw3?OOK@M7sYOMz{BR)RpCVR
xl=>c&UN&}7?oK|T8upVm3z-t5#A%}Bm_HR~pZ|g`=Q28NVD=iXa)H+7e*kxaNNE57

literal 0
HcmV?d00001


From 34b9fb531213ca41500e3e7965dee3a549f4916d Mon Sep 17 00:00:00 2001
From: Steven Wilson <2165238+mendeni@users.noreply.github.com>
Date: Wed, 28 Jan 2026 22:59:34 -0500
Subject: [PATCH 14/20] Verbose copy of VST3 for easier debugging

---
 util/install-macos-vst3.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/util/install-macos-vst3.sh b/util/install-macos-vst3.sh
index 644576b3c..eaaf70bb9 100755
--- a/util/install-macos-vst3.sh
+++ b/util/install-macos-vst3.sh
@@ -22,7 +22,7 @@ if [ ! -d 'VST3' ]; then
   exit 2
 fi
 
-cd VST3 && cp -a * $TARGET
+cd VST3 && cp -av * $TARGET
 
 codesign --force --deep --sign - $TARGET/SonoBusMendeni.vst3/Contents/MacOS/SonoBusMendeni || exit 3
 

From 35b3976ba9d8338224f24b7ff3f4e3a045a57b6a Mon Sep 17 00:00:00 2001
From: Steven Wilson <2165238+mendeni@users.noreply.github.com>
Date: Wed, 28 Jan 2026 23:16:40 -0500
Subject: [PATCH 15/20] Add SonoBusMendeni.tosc to build artefacts

---
 .github/workflows/build.yml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 004b2d487..79aa9b394 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -36,6 +36,10 @@ jobs:
           cmake --build build --config Release --target SonoBusMendeni_Standalone
           cmake --build build --config Release --target SonoBusMendeni_VST3
 
+      - name: Stage TouchOSC
+        run: |
+           cp -a util/SonoBusMendeni.tosc build/SonoBusMendeni_artefacts/Release
+
       - name: Stage VST3 Install Script (macOS)
         if: runner.os == 'macOS'
         run: |

From 527c8f770eef3f0b44db69b84ea2cf8f1263d7c6 Mon Sep 17 00:00:00 2001
From: Steven Wilson <2165238+mendeni@users.noreply.github.com>
Date: Wed, 28 Jan 2026 23:27:00 -0500
Subject: [PATCH 16/20] Fix cp SonoBusMendeni.tosc in build artefacts

---
 .github/workflows/build.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 79aa9b394..51a4779fc 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -38,12 +38,12 @@ jobs:
 
       - name: Stage TouchOSC
         run: |
-           cp -a util/SonoBusMendeni.tosc build/SonoBusMendeni_artefacts/Release
+           cp util/SonoBusMendeni.tosc build/SonoBusMendeni_artefacts/Release
 
       - name: Stage VST3 Install Script (macOS)
         if: runner.os == 'macOS'
         run: |
-           cp -a util/install-macos-vst3.sh build/SonoBusMendeni_artefacts/Release
+           cp util/install-macos-vst3.sh build/SonoBusMendeni_artefacts/Release
 
       - name: Upload Sonobus artifacts (Windows & Linux)
         if: runner.os != 'macOS'

From bb6e3e8fbf56381f85aa015b2a3c4abb17d5b995 Mon Sep 17 00:00:00 2001
From: Steven Wilson <2165238+mendeni@users.noreply.github.com>
Date: Wed, 28 Jan 2026 23:44:57 -0500
Subject: [PATCH 17/20] Include SonoBusMendeni.tosc in build artefact upload

---
 .github/workflows/build.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 51a4779fc..e8be296f6 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -53,6 +53,7 @@ jobs:
           path: |
             build/SonoBusMendeni_artefacts/Release/Standalone
             build/SonoBusMendeni_artefacts/Release/VST3
+            build/SonoBusMendeni_artefacts/Release/SonoBusMendeni.tosc
 
       - name: Upload Sonobus artifacts
         if: runner.os == 'macOS'

From b7365f89803e55edd092f18c604da7a2508e5454 Mon Sep 17 00:00:00 2001
From: Steven Wilson <2165238+mendeni@users.noreply.github.com>
Date: Thu, 29 Jan 2026 00:23:52 -0500
Subject: [PATCH 18/20] Include SonoBusMendeni.tosc in macOS artefact upload

---
 .github/workflows/build.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index e8be296f6..8d1d26d26 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -64,3 +64,4 @@ jobs:
             build/SonoBusMendeni_artefacts/Release/Standalone
             build/SonoBusMendeni_artefacts/Release/VST3
             build/SonoBusMendeni_artefacts/Release/install-macos-vst3.sh
+            build/SonoBusMendeni_artefacts/Release/SonoBusMendeni.tosc

From 2d12cf72c21c1d81faea66949e7c54ff40616314 Mon Sep 17 00:00:00 2001
From: Steven Wilson <2165238+mendeni@users.noreply.github.com>
Date: Thu, 29 Jan 2026 08:38:28 -0500
Subject: [PATCH 19/20] Change mMaxRecvPaddingMs default from 2.0 to 0.0

---
 Source/SonobusPluginProcessor.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Source/SonobusPluginProcessor.h b/Source/SonobusPluginProcessor.h
index 43a18fccd..1cb95386b 100644
--- a/Source/SonobusPluginProcessor.h
+++ b/Source/SonobusPluginProcessor.h
@@ -1022,7 +1022,7 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
     Atomic<bool>   mSyncMetToHost  { false };
     Atomic<bool>   mSyncMetStartToPlayback  { false };
     Atomic<bool>   mReconnectAfterServerLoss  { true };
-    Atomic<float>   mMaxRecvPaddingMs  { 2.0f };
+    Atomic<float>   mMaxRecvPaddingMs  { 0.0f };
 
     Atomic<float>   mInputReverbLevel  { 1.0f };
     Atomic<float>   mInputReverbSize  { 0.15f };

From 775b63c77b82ebe6b7778bf9af2e304f59978616 Mon Sep 17 00:00:00 2001
From: Steven Wilson <2165238+mendeni@users.noreply.github.com>
Date: Thu, 29 Jan 2026 11:02:53 -0500
Subject: [PATCH 20/20] Comment out juce logging for most OSC operations

---
 Source/OSCManager.cpp          | 6 +++---
 Source/SonobusPluginEditor.cpp | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Source/OSCManager.cpp b/Source/OSCManager.cpp
index 8b8d945f1..4702c42c1 100644
--- a/Source/OSCManager.cpp
+++ b/Source/OSCManager.cpp
@@ -87,7 +87,7 @@ void OSCManager::registerControl(const juce::String& address, ControlCallback ca
     controlRegistry[address] = callback;
     // Also register as a listener for this OSC address pattern
     addListener(this, address);
-    juce::Logger::writeToLog("Registered control for OSC address: " + address);
+    // juce::Logger::writeToLog("Registered control for OSC address: " + address);
 }
 
 // Unregister Control
@@ -99,7 +99,7 @@ void OSCManager::unregisterControl(const juce::String& address)
         controlRegistry.erase(it);
         // Note: JUCE doesn't provide a way to remove a specific listener,
         // but the callback will no longer be called since it's removed from the registry
-        juce::Logger::writeToLog("Unregistered control for OSC address: " + address);
+        // juce::Logger::writeToLog("Unregistered control for OSC address: " + address);
     }
 }
 
@@ -107,7 +107,7 @@ void OSCManager::unregisterControl(const juce::String& address)
 void OSCManager::oscMessageReceived(const juce::OSCMessage& message)
 {
     juce::String address = message.getAddressPattern().toString();
-    juce::Logger::writeToLog("Incoming OSC message: " + address);
+    // juce::Logger::writeToLog("Incoming OSC message: " + address);
     
     // Check if a callback is registered for this address
     auto it = controlRegistry.find(address);
diff --git a/Source/SonobusPluginEditor.cpp b/Source/SonobusPluginEditor.cpp
index ede1c4f38..2ea6e5e76 100644
--- a/Source/SonobusPluginEditor.cpp
+++ b/Source/SonobusPluginEditor.cpp
@@ -4388,7 +4388,7 @@ void SonobusAudioProcessorEditor::sendPeerOSCState(int peerIndex)
 
 void SonobusAudioProcessorEditor::clearPeerOSCState(int peerIndex)
 {
-    juce::Logger::writeToLog("clearPeerOSCState called for peerIndex: " + String(peerIndex));
+    // juce::Logger::writeToLog("clearPeerOSCState called for peerIndex: " + String(peerIndex));
     
     if (!processor.getOSCEnabled() || peerIndex < 0 || peerIndex >= 16) {
         juce::Logger::writeToLog("clearPeerOSCState early return - OSCEnabled: " + String(processor.getOSCEnabled() ? "true" : "false") + ", peerIndex: " + String(peerIndex));
@@ -4398,7 +4398,7 @@ void SonobusAudioProcessorEditor::clearPeerOSCState(int peerIndex)
     OSCManager& oscManager = processor.getOSCManager();
     String peerNum = String(peerIndex + 1);
     
-    juce::Logger::writeToLog("Clearing OSC state for Peer" + peerNum);
+    // juce::Logger::writeToLog("Clearing OSC state for Peer" + peerNum);
     
     // Clear username to empty string
     oscManager.sendMessage("/Peer" + peerNum + "RemotePeerUserName", "");