diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 4d16c389c..8d1d26d26 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -27,26 +27,23 @@ 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'
+      - name: Stage TouchOSC
         run: |
-          ./buildcmake.sh
+           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'
@@ -56,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'
@@ -66,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
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4fa4de43a..f03867e45 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/ChannelGroupsView.cpp b/Source/ChannelGroupsView.cpp
index 5a7bd6172..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);
@@ -264,6 +275,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);
     }
 
 }
@@ -279,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);
@@ -289,6 +318,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);
     }
 }
 
@@ -303,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);
 
@@ -312,6 +363,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);
     }
 }
 
@@ -326,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);
@@ -337,6 +406,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);
     }
 }
 
@@ -344,10 +416,18 @@ 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
         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 +583,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 +695,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 +740,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 +776,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 +1065,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 +1077,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 +1800,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 +1881,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 +1893,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 +1951,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 +1963,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 +3657,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 +3691,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 +3702,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
@@ -4758,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()) {
@@ -4766,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;
         }
@@ -4815,10 +4970,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 +4990,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/OSCManager.cpp b/Source/OSCManager.cpp
new file mode 100644
index 000000000..4702c42c1
--- /dev/null
+++ b/Source/OSCManager.cpp
@@ -0,0 +1,123 @@
+#include "OSCManager.h"
+
+OSCManager::OSCManager()
+{
+    // OSCManager object created, but not initialized until OSC is enabled
+}
+
+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;
+    }
+
+    // Legacy listener - keeping for backward compatibility
+    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;
+}
+
+// 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)
+{
+    if (senderConnected)
+    {
+        if (value.isDouble())
+        {
+            // Apply OSC_SCALE_FACTOR to float/double values
+            sender.send(address, static_cast<float>(value) * OSC_SCALE_FACTOR);
+        }
+        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);
+    }
+}
+
+// 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::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
+    {
+        juce::Logger::writeToLog("No handler registered for OSC address: " + address);
+    }
+}
diff --git a/Source/OSCManager.h b/Source/OSCManager.h
new file mode 100644
index 000000000..07fe06d77
--- /dev/null
+++ b/Source/OSCManager.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <juce_osc/juce_osc.h>
+#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>
+{
+public:
+    OSCManager();
+    ~OSCManager();
+
+    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
+    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.cpp b/Source/OptionsView.cpp
index 75e8062bb..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"
@@ -334,6 +335,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."));
@@ -367,6 +373,50 @@ 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"));
+
+    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);
+    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 +457,16 @@ 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(mOSCSendStateOnStartButton.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 +742,24 @@ 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);
+    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);
+    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 +860,41 @@ 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));
+    
+    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));
+    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 +974,19 @@ 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, 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));
+    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 +1203,42 @@ void OptionsView::textEditorFocusLost (TextEditor& ed)
         int port = mOptionsUdpPortEditor->getText().getIntValue();
         changeUdpPort(port);
     }
+    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();
+        // Validate port range (1-65535)
+        if (port < 1 || port > 65535) {
+            port = 6001; // Reset to default
+            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();
+        // Validate port range (1-65535)
+        if (port < 1 || port > 65535) {
+            port = 6000; // Reset to default
+            mOSCReceivePortEditor->setText(String(port), dontSendNotification);
+        }
+        processor.setOSCReceivePort(port);
+        
+        // Send OSC message for OSCReceivePort change
+        if (processor.getOSCEnabled()) {
+            processor.getOSCManager().sendMessage("/OSCReceivePort", port);
+        }
+    }
 }
 
 void OptionsView::changeUdpPort(int port)
@@ -1086,6 +1248,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);
 
@@ -1122,6 +1289,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()
@@ -1141,21 +1313,85 @@ 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());
     }
     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
+        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 == mOSCSendStateOnStartButton.get()) {
+        bool enabled = mOSCSendStateOnStartButton->getToggleState();
+        processor.setOSCSendStateOnStart(enabled);
+        
+        // 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()) {
@@ -1164,6 +1400,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()) {
 
@@ -1171,6 +1412,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()) {
 
@@ -1195,6 +1441,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();
@@ -1205,6 +1456,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();
@@ -1212,6 +1468,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 b1fbdee24..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,
@@ -68,6 +70,38 @@ public MultiTimer
 
     void showWarnings();
 
+    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; };
@@ -153,6 +187,16 @@ public MultiTimer
     std::unique_ptr<Label> mOptionsLanguageLabel;
     std::unique_ptr<ToggleButton> mOptionsUnivFontButton;
 
+    // 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;
+    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;
@@ -191,6 +235,11 @@ public MultiTimer
     FlexBox optionsAutoDropThreshBox;
     FlexBox optionsMaxRecvPaddingBox;
     FlexBox optionsPluginDefaultBox;
+    FlexBox optionsOSCEnabledBox;
+    FlexBox optionsOSCSendStateOnStartBox;
+    FlexBox optionsOSCTargetIPBox;
+    FlexBox optionsOSCTargetPortBox;
+    FlexBox optionsOSCReceivePortBox;
 
     FlexBox recOptionsBox;
     FlexBox optionsRecordFormatBox;
diff --git a/Source/PeersContainerView.cpp b/Source/PeersContainerView.cpp
index d1023b9b0..4a0016161 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 : 0.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 : 0.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 : 0.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 bf0e727d1..2ea6e5e76 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"
 
@@ -702,6 +703,31 @@ 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);
+    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");
@@ -1125,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);
@@ -1331,73 +1363,3093 @@ 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
+    // OSC controls are registered via registerAllOSCControls() when OSC is enabled
+    
+    // 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
+    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
+    oscManager.registerControl("/OutGainSlider", [this](const juce::OSCMessage& message) {
+        if (message.size() > 0 && message[0].isFloat32()) {
+            float value = message[0].getFloat32() * OSC_INVERSE_SCALE_FACTOR;
+            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].isFloat32()) {
+            int value = message[0].getFloat32();
+            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() * OSC_INVERSE_SCALE_FACTOR;
+            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].isFloat32()) {
+            int value = message[0].getFloat32();
+            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();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // 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();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // 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();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // 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();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // 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();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // 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();
+                        }
+                    }
+                });
+            }
+        });
+        
+        // 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();
+                        }
+                    }
+                });
+            }
+        });
+    }
+
+    // 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].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
+                        // 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 : 0.0);
+                        }
+                    }
+                });
+            }
+        });
+        
+        // Peer Solo
+        String peerSoloAddress = "/Peer" + String(peerIndex + 1) + "Solo";
+        oscManager.registerControl(peerSoloAddress, [this, peerIndex](const juce::OSCMessage& message) {
+            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);
+                        // 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 : 0.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() * OSC_INVERSE_SCALE_FACTOR;
+                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() * OSC_INVERSE_SCALE_FACTOR;
+                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);
+                        }
+                    }
+                });
+            }
+        });
         
-        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
+        // 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);
+                        }
+                    }
+                });
+            }
+        });
+    }
 
-        // look for link in clipboard        
-        if (mConnectView->attemptToPasteConnectionFromClipboard()) {
-            // show connect immediately
-            showConnectPopup(true);
-            // switch to group page
-            mConnectView->showPrivateGroupTab();
+    
+    mOSCControlsRegistered = true;
+}
 
-            updateServerStatusLabel(TRANS("Filled in Group information from clipboard! Press 'Connect to Group' to join..."), false);
-        }
+void SonobusAudioProcessorEditor::unregisterAllOSCControls()
+{
+    if (!mOSCControlsRegistered) {
+        return; // Not registered
+    }
+    
+    OSCManager& oscManager = processor.getOSCManager();
+    oscManager.unregisterControl("/OutGainSlider");
+    oscManager.unregisterControl("/MainMuteButton");
+    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");
+    }
+    
+    // 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);
+    }
+    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) {
+        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 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();
+    
+    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" + peerNum + "RemotePeerUserName", username);
         
-        // check for update!
-        // LatestVersionCheckerAndUpdater::getInstance()->checkForNewVersion (false);
+        // Peer mute/solo
+        bool muted = !processor.getRemotePeerRecvAllow(peerIndex);
+        oscManager.sendMessage("/Peer" + peerNum + "Mute", muted ? 1.0 : 0.0);
         
-    } else  {
-        setResizable(true, true);    
+        bool soloed = processor.getRemotePeerSoloed(peerIndex);
+        oscManager.sendMessage("/Peer" + peerNum + "Solo", soloed ? 1.0 : 0.0);
+        
+        // Peer level
+        float level = processor.getRemotePeerLevelGain(peerIndex);
+        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" + 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" + 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" + 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" + peerNum + "InputReverbSend", reverbSend);
+        
+        // Peer FX - Polarity Invert
+        bool polarityInvert = processor.getRemotePeerPolarityInvert(peerIndex, 0);
+        oscManager.sendMessage("/Peer" + peerNum + "PolarityInvert", polarityInvert ? 1 : 0);
     }
     
-    processor.addClientListener(this);
-    processor.getTransportSource().addChangeListener (this);
+    // Clear empty peer slots (from numPeers to 15) to ensure pristine state
+    for (int i = numPeers; i < 16; ++i) {
+        clearPeerOSCState(i);
+    }
+}
 
-    // handles registering commands
-    updateUseKeybindings();
-        
-    commandManager.commandStatusChanged();
+void SonobusAudioProcessorEditor::sendPeerOSCState(int peerIndex)
+{
+    if (!processor.getOSCEnabled() || peerIndex < 0 || peerIndex >= processor.getNumberRemotePeers()) {
+        return;
+    }
     
-    setWantsKeyboardFocus(true);
+    OSCManager& oscManager = processor.getOSCManager();
+    String peerNum = String(peerIndex + 1);
     
-    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());
-
+    // 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 : 0.0);
+    
+    bool soloed = processor.getRemotePeerSoloed(peerIndex);
+    oscManager.sendMessage("/Peer" + peerNum + "Solo", soloed ? 1.0 : 0.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);
+}
 
-    // to make sure transport area is initialized with the current state
-    if (updateTransportWithURL(processor.getCurrentLoadedTransportURL())) {
-        processor.getTransportSource().sendChangeMessage();
+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.0);
+    oscManager.sendMessage("/Peer" + peerNum + "Solo", 0.0);
+    oscManager.sendMessage("/Peer" + peerNum + "Level", 0);
+    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
@@ -1425,6 +4477,31 @@ 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);
+    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);
 
 
     
@@ -1704,9 +4781,31 @@ 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();
+        juce::Logger::writeToLog("Looking for peer '" + user + "' among " + String(numPeers) + " peers for OSC clear");
+        for (int i = 0; i < jmin(numPeers, 16); ++i) {
+            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);        
-        clientEvents.add(ClientEvent(ClientEvent::PeerLeaveEvent, group, true, "", user));
+        // 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();
 
@@ -2022,6 +5121,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());
             }
@@ -2080,10 +5186,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;
@@ -2110,6 +5221,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
@@ -2119,6 +5235,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) {
@@ -2146,6 +5267,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
@@ -2370,6 +5496,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) {
@@ -3344,6 +6475,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);
+            }
         }
     }
 }
@@ -3361,6 +6497,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()) {
@@ -3840,14 +6981,52 @@ void SonobusAudioProcessorEditor::parameterChanged (const String& pname, float n
         }
         triggerAsyncUpdate();
     }
-    else if (pname == SonobusAudioProcessor::paramMainRecvMute) {
+    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::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::paramMetEnabled) {
+    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, ""));
@@ -3855,13 +7034,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, ""));
@@ -3869,6 +7092,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, ""));
@@ -3883,12 +7121,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);
@@ -4098,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;
@@ -4130,10 +7451,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) {
@@ -4143,6 +7475,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);
@@ -5967,6 +9306,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());
             }
 
@@ -6140,4 +9485,3 @@ void SonobusAudioProcessorEditor::SonobusMenuBarModel::menuItemSelected (int men
     }
 #endif
 }
-
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 240e4fb4a..f5ad9f515 100644
--- a/Source/SonobusPluginProcessor.cpp
+++ b/Source/SonobusPluginProcessor.cpp
@@ -98,6 +98,11 @@ static String recordStealthKey("RecordStealth");
 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");
 static String sliderSnapKey("SliderSnapToMouse");
 static String disableShortcutsKey("DisableKeyShortcuts");
 static String peerDisplayModeKey("PeerDisplayMode");
@@ -842,6 +847,21 @@ mState (*this, &mUndoManager, "SonoBusAoO",
     
     initializeAoo();
 
+    // 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 with configurable target
+        if (!oscManager.initializeSender(mOSCTargetIPAddress, mOSCTargetPort))
+        {
+            juce::Logger::writeToLog("Failed to initialize OSC Sender to " + mOSCTargetIPAddress + ":" + juce::String(mOSCTargetPort));
+        }
+    }
+
     mFreshInit = false; // need to ensure this before loaddefaultpluginstate
 
     if (isplugin) {
@@ -4384,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) {
                     
@@ -4391,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");
@@ -8439,6 +8461,60 @@ AudioProcessorValueTreeState& SonobusAudioProcessor::getValueTreeState()
     return mState;
 }
 
+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);
+        
+        // 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();
+    }
+}
+
+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);
@@ -8545,6 +8621,13 @@ void SonobusAudioProcessor::getStateInformationWithOptions(MemoryBlock& destData
     }
     extraTree.setProperty(defRecordDirURLKey, mDefaultRecordDir.toString(false), nullptr);
 
+    // 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);
+
     extraTree.setProperty(lastBrowseDirKey, mLastBrowseDir, nullptr);
     extraTree.setProperty(sliderSnapKey, mSliderSnapToMouse, nullptr);
     extraTree.setProperty(disableShortcutsKey, mDisableKeyboardShortcuts, nullptr);
@@ -8687,6 +8770,19 @@ void SonobusAudioProcessor::setStateInformationWithOptions (const void* data, in
 
             setRecordFinishOpens(extraTree.getProperty(recordFinishOpenKey, mRecordFinishOpens));
             setRecordStealth(extraTree.getProperty(recordStealthKey, mRecordStealth));
+            
+            // 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);
+            
+            // 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 34977537e..1cb95386b 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 {
@@ -234,6 +236,8 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
     bool loadDefaultPluginSettings();
     
     AudioProcessorValueTreeState& getValueTreeState();
+    
+    OSCManager& getOSCManager();
 
     static String paramInGain;
     static String paramInMonitorMonoPan;
@@ -779,6 +783,22 @@ 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);
+    
+    bool getOSCSendStateOnStart() const { return mOSCSendStateOnStart; }
+    void setOSCSendStateOnStart(bool enabled) { mOSCSendStateOnStart = 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; }
@@ -837,6 +857,8 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
 private:
     //==============================================================================
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (SonobusAudioProcessor)
+
+    OSCManager oscManager;
     
     struct PeerStateCache
     {
@@ -1000,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 };
@@ -1225,6 +1247,13 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
     bool mRecordFinishOpens = true;
     bool mRecordStealth = false;
     URL mDefaultRecordDir;
+    
+    // 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;
     String mLastError;
     int mSelfRecordChannels = 2;
     int mActiveInputChannels = 2;
diff --git a/doc/OSC_COMMANDS.md b/doc/OSC_COMMANDS.md
new file mode 100644
index 000000000..33ba0891b
--- /dev/null
+++ b/doc/OSC_COMMANDS.md
@@ -0,0 +1,1223 @@
+# 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)
+
+## 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**: Float (0.0 = unmuted/receiving, 1.0 = 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**: Float (0.0 = not soloed, 1.0 = 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
+
+#### `/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
+
+# Mute Peer 1
+/Peer1Mute 1.0
+
+# Unmute Peer 1
+/Peer1Mute 0.0
+
+# Solo Peer 2
+/Peer2Solo 1.0
+
+# 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
+
+```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)
+
+# Mute Peer 1
+client.send_message("/Peer1Mute", 1.0)
+
+# Solo Peer 2
+client.send_message("/Peer2Solo", 1.0)
+
+# 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
+
+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
+- 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
+
+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_comprehensive.sh b/tests/oscsend_comprehensive.sh
new file mode 100755
index 000000000..cda7b3494
--- /dev/null
+++ b/tests/oscsend_comprehensive.sh
@@ -0,0 +1,604 @@
+#!/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 "=== Peer 1 Controls ==="
+oscsend localhost 6000 /Peer1Mute f 1.0
+sleep 2
+oscsend localhost 6000 /Peer1Mute f 0.0
+sleep 2
+
+oscsend localhost 6000 /Peer1Solo f 1.0
+sleep 2
+oscsend localhost 6000 /Peer1Solo f 0.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 f 1.0
+sleep 2
+oscsend localhost 6000 /Peer2Mute f 0.0
+sleep 2
+
+oscsend localhost 6000 /Peer2Solo f 1.0
+sleep 2
+oscsend localhost 6000 /Peer2Solo f 0.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 ==="
diff --git a/util/SonoBusMendeni.tosc b/util/SonoBusMendeni.tosc
new file mode 100644
index 000000000..4b8ee1b07
Binary files /dev/null and b/util/SonoBusMendeni.tosc differ
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