diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
new file mode 100644
index 000000000..077f7bddd
--- /dev/null
+++ b/.github/workflows/build.yml
@@ -0,0 +1,98 @@
+name: Build SonoBus
+
+on:
+  push:
+    branches: [ main ]
+    tags: [ 'v*' ]
+  pull_request:
+    branches: [ main ]
+
+permissions:
+  contents: write
+
+jobs:
+  build:
+    name: Build ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-14, windows-latest]
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - name: Install dependencies (Linux)
+      if: runner.os == 'Linux'
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y libjack-jackd2-dev libopus-dev opus-tools libasound2-dev libx11-dev libxext-dev libxinerama-dev libxrandr-dev libxcursor-dev libgl-dev libfreetype6-dev libcurl4-openssl-dev
+
+    - name: Download ASIO SDK
+      if: runner.os == 'Windows'
+      shell: pwsh
+      run: |
+        curl -L -o asiosdk.zip https://www.steinberg.net/asiosdk -H "User-Agent: Mozilla/5.0"
+        Expand-Archive asiosdk.zip -DestinationPath asiosdk_ext
+        $asiodir = Get-ChildItem -Path asiosdk_ext -Directory | Select-Object -First 1
+        Move-Item $asiodir.FullName ./asiosdk
+
+    - name: Setup CMake
+      run: |
+        if [ "${{ runner.os }}" == "Windows" ]; then
+          cmake -B build -DCMAKE_BUILD_TYPE=Release "-DASIO_SDK_PATH=${{ github.workspace }}/asiosdk"
+        else
+          cmake -B build -DCMAKE_BUILD_TYPE=Release
+        fi
+      shell: bash
+
+    - name: Build
+      run: cmake --build build --config Release --parallel 4
+
+    - name: Zip Artifacts (Windows)
+      if: runner.os == 'Windows'
+      shell: pwsh
+      run: |
+        Compress-Archive -Path build/SonoBus_artefacts/Release/* -DestinationPath SonoBus-Windows.zip
+
+    - name: Zip Artifacts (macOS)
+      if: runner.os == 'macOS'
+      run: |
+        zip -r SonoBus-macOS.zip build/SonoBus_artefacts/Release/*
+
+    - name: Zip Artifacts (Linux)
+      if: runner.os == 'Linux'
+      run: |
+        zip -r SonoBus-Linux.zip build/SonoBus_artefacts/Release/*
+
+    - name: Upload Artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: SonoBus-${{ runner.os }}
+        path: SonoBus-*.zip
+        if-no-files-found: error
+
+  release:
+    name: Create Release
+    if: startsWith(github.ref, 'refs/tags/')
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts
+          merge-multiple: true
+
+      - name: Create Release
+        id: create_release
+        uses: softprops/action-gh-release@v1
+        with:
+          files: artifacts/*.zip
+          draft: false
+          prerelease: false
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/CMakeLists.txt b/CMakeLists.txt
index a8e35c0ec..5bb235ca1 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -209,7 +209,10 @@ function(sono_add_custom_plugin_target target_name product_name formats is_instr
         list (APPEND LIB_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/deps/mac/lib)
         list (APPEND PlatSourceFiles  Source/CrossPlatformUtilsMac.mm)
     elseif (WIN32)
-        list (APPEND HEADER_INCLUDES deps/windows ../asiosdk/common)
+        if (NOT ASIO_SDK_PATH)
+            set(ASIO_SDK_PATH "C:/SDKs/ASIOSDK")
+        endif()
+        list (APPEND HEADER_INCLUDES deps/windows ${ASIO_SDK_PATH}/common)
         list (APPEND PlatSourceFiles  Source/CrossPlatformUtilsWindows.cpp)
 
 	message (STATUS "Win generator platform is: ${CMAKE_VS_PLATFORM_NAME}" )
diff --git a/Source/ChannelGroupsView.cpp b/Source/ChannelGroupsView.cpp
index 5a7bd6172..ca3b51b45 100644
--- a/Source/ChannelGroupsView.cpp
+++ b/Source/ChannelGroupsView.cpp
@@ -2,6 +2,7 @@
 // Copyright (C) 2020 Jesse Chappell
 
 #include "ChannelGroupsView.h"
+#include "SonobusPluginEditor.h"
 
 
 using namespace SonoAudio;
@@ -423,7 +424,8 @@ void ChannelGroupEffectsView::effectsHeaderClicked(EffectsBaseView *comp)
 }
 
 
-#pragma ChannelGroupMonitorEffectsView
+// --------------------------------------------
+// ChannelGroupMonitorEffectsView
 
 ChannelGroupMonitorEffectsView::ChannelGroupMonitorEffectsView(SonobusAudioProcessor& proc, bool peermode)
 : Component(), peerMode(peermode), processor(proc)
@@ -514,9 +516,10 @@ void ChannelGroupMonitorEffectsView::updateStateForInput()
             reverbSendView->getHeaderComponent()->setVisible(false);
         }
     }
-    else if (groupIndex == -2) {
+    else if (groupIndex <= -100) {
         // file playback
-        if (processor.getFilePlaybackMonitorDelayParams(monDelayParams)) {
+        int fidx = -(groupIndex + 100);
+        if (processor.getFilePlaybackMonitorDelayParams(fidx, monDelayParams)) {
             delayView->updateParams(monDelayParams);
         }
 
@@ -641,10 +644,11 @@ void ChannelGroupMonitorEffectsView::monitorDelayParamsChanged(MonitorDelayView
             processor.getMetronomeMonitorDelayParams(eparam);
             wason = eparam.enabled;
             processor.setMetronomeMonitorDelayParams(params);
-        } else if (groupIndex == -2) {
-            processor.getFilePlaybackMonitorDelayParams(eparam);
+        } else if (groupIndex <= -100) {
+            int fidx = -(groupIndex + 100);
+            processor.getFilePlaybackMonitorDelayParams(fidx, eparam);
             wason = eparam.enabled;
-            processor.setFilePlaybackMonitorDelayParams(params);
+            processor.setFilePlaybackMonitorDelayParams(fidx, params);
         } else if (groupIndex == -3) {
             eparam = processor.getSoundboardProcessor()->getMonitorDelayParams();
             wason = eparam.enabled;
@@ -671,10 +675,12 @@ void ChannelGroupMonitorEffectsView::monitorDelayParamsChanged(MonitorDelayView
                 processor.setMetronomeMonitorDelayParams(eparam);
             }
 
-            processor.getFilePlaybackMonitorDelayParams(eparam);
-            if (eparam.delayTimeMs != deltimems) {
-                eparam.delayTimeMs = deltimems;
-                processor.setFilePlaybackMonitorDelayParams(eparam);
+            for (int fidx=0; fidx < processor.getFilePlaybackGroupCount(); ++fidx) {
+                processor.getFilePlaybackMonitorDelayParams(fidx, eparam);
+                if (eparam.delayTimeMs != deltimems) {
+                    eparam.delayTimeMs = deltimems;
+                    processor.setFilePlaybackMonitorDelayParams(fidx, eparam);
+                }
             }
 
             eparam = processor.getSoundboardProcessor()->getMonitorDelayParams();
@@ -712,10 +718,11 @@ void ChannelGroupMonitorEffectsView::effectsHeaderClicked(EffectsBaseView *comp)
                     processor.getMetronomeMonitorDelayParams(params);
                     params.enabled = !params.enabled;
                     processor.setMetronomeMonitorDelayParams(params);
-                } else if (groupIndex == -2) {
-                    processor.getFilePlaybackMonitorDelayParams(params);
+                } else if (groupIndex <= -100) {
+                    int fidx = -(groupIndex + 100);
+                    processor.getFilePlaybackMonitorDelayParams(fidx, params);
                     params.enabled = !params.enabled;
-                    processor.setFilePlaybackMonitorDelayParams(params);
+                    processor.setFilePlaybackMonitorDelayParams(fidx, params);
                 }
                 else if (groupIndex == -3) {
                     params = processor.getSoundboardProcessor()->getMonitorDelayParams();
@@ -735,7 +742,8 @@ void ChannelGroupMonitorEffectsView::effectsHeaderClicked(EffectsBaseView *comp)
     }
 }
 
-#pragma ChannelGroupReverbEffectsView
+// --------------------------------------------
+// ChannelGroupReverbEffectsView
 
 ChannelGroupReverbEffectsView::ChannelGroupReverbEffectsView(SonobusAudioProcessor& proc)
 : Component(), processor(proc)
@@ -839,7 +847,8 @@ void ChannelGroupReverbEffectsView::effectsHeaderClicked(EffectsBaseView *comp)
 }
 
 
-#pragma ChannelGroupView
+// --------------------------------------------
+// ChannelGroupView
 
 
 ChannelGroupView::ChannelGroupView() : smallLnf(12), medLnf(14), sonoSliderLNF(12), panSliderLNF(12)
@@ -893,9 +902,18 @@ void ChannelGroupView::paint(Graphics& g)
 
 void ChannelGroupView::resized()
 {
-    
     mainbox.performLayout(getLocalBounds());
     
+    for (auto& item : mainbox.items) {
+        if (item.associatedFlexBox == &maincontentbox) {
+            maincontentbox.performLayout(item.currentBounds.toNearestInt());
+            for (auto& subitem : maincontentbox.items) {
+                if (subitem.associatedFlexBox == &inbox) inbox.performLayout(subitem.currentBounds.toNearestInt());
+                else if (subitem.associatedFlexBox == &monbox) monbox.performLayout(subitem.currentBounds.toNearestInt());
+            }
+        }
+    }
+
     if (panLabel) {
         panLabel->setBounds(panSlider->getBounds().removeFromTop(16).translated(0, -2));
     }
@@ -917,6 +935,7 @@ void ChannelGroupView::resized()
 ChannelGroupsView::ChannelGroupsView(SonobusAudioProcessor& proc, bool peerMode, int peerIndex)
  : Component("pcv"),  addLnf(20), processor(proc), mPeerMode(peerMode), mPeerIndex(peerIndex)
 {
+    processor.addMidiLearnListener(this);
     mutedTextColor = Colour::fromFloatRGBA(0.8, 0.5, 0.2, 1.0);
     regularTextColor = Colour(0xa0eeeeee);; //Colour(0xc0eeeeee);
     dimTextColor = Colour(0xa0aaaaaa); //Colour(0xc0aaaaaa);
@@ -932,11 +951,14 @@ ChannelGroupsView::ChannelGroupsView(SonobusAudioProcessor& proc, bool peerMode,
     //bgColor = Colour::fromFloatRGBA(0.045f, 0.045f, 0.05f, 1.0f);
     bgColor = Colour::fromFloatRGBA(0.08f, 0.045f, 0.08f, 1.0f);
 
-    mInGainSlider     = std::make_unique<Slider>(Slider::LinearHorizontal,  Slider::TextBoxAbove);
+    mInGainSlider     = std::make_unique<SonoSlider>(Slider::LinearHorizontal,  Slider::TextBoxAbove);
+
     mInGainSlider->setName("ingain");
     mInGainSlider->setSliderSnapsToMousePosition(processor.getSlidersSnapToMousePosition());
     mInGainSlider->setTextBoxIsEditable(true);
-    mInGainSlider->setScrollWheelEnabled(false);
+    mInGainSlider->setScrollWheelEnabled(true);
+    mInGainSlider->addMouseListener(this, false);
+
 
     mAddButton = std::make_unique<TextButton>("+");
     mAddButton->setTitle(TRANS("Add Input Group"));
@@ -999,11 +1021,73 @@ ChannelGroupsView::ChannelGroupsView(SonobusAudioProcessor& proc, bool peerMode,
 
 ChannelGroupsView::~ChannelGroupsView()
 {
+    processor.removeMidiLearnListener(this);
     if (mEffectsView) {
         mEffectsView->removeListener(this);
     }
 }
 
+// Called on the message thread whenever a MIDI mapping changes
+void ChannelGroupsView::midiMappingChanged()
+{
+    // Refresh button labels to reflect new mapping status
+    MessageManager::callAsync([this]() {
+        updateChannelViews();
+    });
+}
+
+void ChannelGroupsView::showFileStemMidiMenu(Component* source,
+                                              SonobusAudioProcessor::MidiTargetType type,
+                                              int stemIdx)
+{
+    using MidiTargetType = SonobusAudioProcessor::MidiTargetType;
+
+    int ccNum = -1, midiCh = 0;
+    bool hasMapped = processor.getMidiMapping(type, stemIdx, ccNum, midiCh);
+
+    String controlName;
+    switch (type) {
+        case MidiTargetType::MidiTarget_FileStemGain: controlName = "Fader " + String(stemIdx+1); break;
+        case MidiTargetType::MidiTarget_FileStemMute: controlName = "Mute " + String(stemIdx+1);  break;
+        case MidiTargetType::MidiTarget_FileStemSolo: controlName = "Solo " + String(stemIdx+1);  break;
+        case MidiTargetType::MidiTarget_MetronomeLevel: controlName = TRANS("Metronome Level"); break;
+        case MidiTargetType::MidiTarget_SoundboardLevel: controlName = TRANS("Soundboard Level"); break;
+        case MidiTargetType::MidiTarget_MonitorLevel: controlName = TRANS("Monitor Level"); break;
+        case MidiTargetType::MidiTarget_FileStemMonitor: controlName = (stemIdx == 0 ? TRANS("Full Mix Monitor") : "Monitor " + String(stemIdx+1)); break;
+        case MidiTargetType::MidiTarget_InputGain: controlName = TRANS("In Level"); break;
+        case MidiTargetType::MidiTarget_InputMute: controlName = TRANS("In Mute"); break;
+        default: controlName = TRANS("Control"); break;
+    }
+
+    PopupMenu m;
+    if (processor.isMidiLearning() &&
+        processor.getMidiLearnTargetType() == type &&
+        processor.getMidiLearnTargetData() == stemIdx) {
+        m.addItem(1, String(TRANS("Cancel MIDI Learn")), true, false);
+    } else {
+        m.addItem(1, String(TRANS("MIDI Learn: ")) + controlName, true, false);
+    }
+
+    String forgetText = TRANS("MIDI Forget");
+    if (hasMapped) forgetText += " (CC " + String(ccNum) + ", Ch " + String(midiCh) + ")";
+    m.addItem(2, forgetText, hasMapped, false);
+
+
+    m.showMenuAsync(PopupMenu::Options().withMousePosition(),
+        [this, type, stemIdx, hasMapped](int result) {
+            if (result == 1) {
+                if (processor.isMidiLearning()) {
+                    processor.stopMidiLearn();
+                } else {
+                    processor.startMidiLearn(type, stemIdx);
+                }
+            } else if (result == 2 && hasMapped) {
+                processor.clearMidiMapping(type, stemIdx);
+            }
+        });
+
+}
+
 void ChannelGroupsView::configLevelSlider(Slider * slider, bool monmode)
 {
     //slider->setTextValueSuffix(" dB");
@@ -1025,8 +1109,10 @@ void ChannelGroupsView::configLevelSlider(Slider * slider, bool monmode)
     slider->setDoubleClickReturnValue(true, 1.0);
     slider->setTextBoxIsEditable(true);
     slider->setSliderSnapsToMousePosition(processor.getSlidersSnapToMousePosition());
-    slider->setScrollWheelEnabled(false);
+    slider->setScrollWheelEnabled(true);
+    slider->addMouseListener(this, false);
     slider->setWantsKeyboardFocus(true);
+
     slider->valueFromTextFunction = [](const String& s) -> float { return Decibels::decibelsToGain(s.getFloatValue()); };
 
     if (mPeerMode) {
@@ -1143,10 +1229,22 @@ void ChannelGroupsView::resized()
         mMainChannelView->resized();
     }
 
-    if (mMetChannelView && mMetChannelView->isVisible()) {
-        // resize bg border
-        auto mfbounds = Rectangle<int>(mMetChannelView->getX() - 3, mMetChannelView->getY(), mMetChannelView->getWidth() + 6, mSoundboardChannelView->getBottom() - mMetChannelView->getY() + 4);
-        mMetFileBg->setRectangle (mfbounds.toFloat());
+    if (!mPeerMode) {
+        if (mMetChannelView && mMetChannelView->isVisible()) {
+            mMetChannelView->resized();
+        }
+        for (auto v : mFileChannelViews) {
+            if (v && v->isVisible()) v->resized();
+        }
+        if (mSoundboardChannelView && mSoundboardChannelView->isVisible()) {
+            mSoundboardChannelView->resized();
+        }
+
+        if (mMetChannelView && mMetChannelView->isVisible()) {
+            // resize bg border
+            auto mfbounds = Rectangle<int>(mMetChannelView->getX() - 3, mMetChannelView->getY(), mMetChannelView->getWidth() + 6, mSoundboardChannelView->getBottom() - mMetChannelView->getY() + 4);
+            mMetFileBg->setRectangle (mfbounds.toFloat());
+        }
     }
 
     Component* dw = nullptr; // this->findParentComponentOfClass<DocumentWindow>();    
@@ -1308,14 +1406,16 @@ ChannelGroupView * ChannelGroupsView::createChannelGroupView(bool first)
     pvf->chanLabel->setJustificationType(Justification::centredLeft);
 
     
-    pvf->levelSlider     = std::make_unique<Slider>(Slider::LinearHorizontal,  Slider::TextBoxRight);
+    pvf->levelSlider     = std::make_unique<SonoSlider>(Slider::LinearHorizontal,  Slider::TextBoxRight);
+
     pvf->levelSlider->setName("level");
     pvf->levelSlider->addListener(this);
 
     configLevelSlider(pvf->levelSlider.get(), false);
     pvf->levelSlider->setLookAndFeel(&pvf->sonoSliderLNF);
 
-    pvf->monitorSlider     = std::make_unique<Slider>(Slider::RotaryHorizontalVerticalDrag,  Slider::TextBoxRight);
+    pvf->monitorSlider     = std::make_unique<SonoSlider>(Slider::RotaryHorizontalVerticalDrag,  Slider::TextBoxRight);
+
     pvf->monitorSlider->setName("monitor");
     pvf->monitorSlider->addListener(this);
 
@@ -1330,7 +1430,8 @@ ChannelGroupView * ChannelGroupsView::createChannelGroupView(bool first)
     pvf->panLabel->setJustificationType(Justification::centredTop);
     pvf->panLabel->setAccessible(false);
 
-    pvf->panSlider     = std::make_unique<Slider>(Slider::LinearHorizontal,  Slider::NoTextBox);
+    pvf->panSlider     = std::make_unique<SonoSlider>(Slider::LinearHorizontal,  Slider::NoTextBox);
+
     //pvf->panSlider->setTextBoxStyle(Slider::TextBoxAbove, true, 60, 12);
     pvf->panSlider->setTitle(TRANS("Pan"));
     pvf->panSlider->setName(first ? "firstpan1": "pan1");
@@ -1341,10 +1442,12 @@ ChannelGroupView * ChannelGroupsView::createChannelGroupView(bool first)
     pvf->panSlider->setDoubleClickReturnValue(true, 0.0);
     pvf->panSlider->setTextBoxIsEditable(true);
     pvf->panSlider->setSliderSnapsToMousePosition(false);
-    pvf->panSlider->setScrollWheelEnabled(false);
+    pvf->panSlider->setScrollWheelEnabled(true);
+    pvf->panSlider->addMouseListener(this, false);
     pvf->panSlider->setMouseDragSensitivity(100);
     pvf->panSlider->setWantsKeyboardFocus(true);
 
+
     pvf->panSlider->textFromValueFunction =  [](double v) -> String { if (fabs(v) < 0.01) return String(TRANS("Pan: Center")); return String(TRANS("Pan: ")) +  String((int)rint(abs(v*100.0f))) + ((v > 0 ? "% R" : "% L")) ; };
     pvf->panSlider->valueFromTextFunction =  [](const String& s) -> double { return s.getDoubleValue()*1e-2f; };
     pvf->panSlider->setValue(0.1, dontSendNotification);
@@ -1352,7 +1455,24 @@ ChannelGroupView * ChannelGroupsView::createChannelGroupView(bool first)
     pvf->panSlider->setLookAndFeel(&pvf->panSliderLNF);
     pvf->singlePanner = true;
 
+    pvf->moggButton = std::make_unique<TextButton>("MOGG");
+    pvf->moggButton->addListener(this);
+    pvf->moggButton->setTooltip(TRANS("Open MOGG multitrack mixer"));
+    pvf->moggButton->setColour(TextButton::buttonColourId,  Colour(0xFF6C2E8C));
+    pvf->moggButton->setColour(TextButton::buttonOnColourId, Colour(0xFF8E3EB5));
+    pvf->moggButton->setColour(TextButton::textColourOffId, Colours::white);
+    pvf->moggButton->setColour(TextButton::textColourOnId, Colours::white);
+    pvf->moggButton->setConnectedEdges(Button::ConnectedOnLeft | Button::ConnectedOnRight | Button::ConnectedOnTop | Button::ConnectedOnBottom);
+
+    pvf->midiButton = std::make_unique<TextButton>("MIDI");
+    pvf->midiButton->addListener(this);
+    pvf->midiButton->setClickingTogglesState(true);
+    pvf->midiButton->setTooltip(TRANS("Relay MIDI data to this peer"));
+    pvf->midiButton->setColour(TextButton::buttonOnColourId, Colours::orange);
+
     std::unique_ptr<Drawable> destimg(Drawable::createFromImageData(BinaryData::chevron_forward_svg, BinaryData::chevron_forward_svgSize));
+
+
     std::unique_ptr<Drawable> linkimg(Drawable::createFromImageData(BinaryData::link_svg, BinaryData::link_svgSize));
     std::unique_ptr<Drawable> trirightimg(Drawable::createFromImageData(BinaryData::expand_arrow_inactive_svg, BinaryData::expand_arrow_inactive_svgSize));
     std::unique_ptr<Drawable> triimg(Drawable::createFromImageData(BinaryData::expand_arrow_active_svg, BinaryData::expand_arrow_active_svgSize));
@@ -1506,9 +1626,7 @@ void ChannelGroupsView::setMetersActive(bool flag)
     if (mMetChannelView) {
         mMetChannelView->meter->setRefreshRateHz(rate);
     }
-    if (mFileChannelView) {
-        mFileChannelView->meter->setRefreshRateHz(rate);
-    }
+    for (auto v : mFileChannelViews) { v->meter->setRefreshRateHz(rate); }
     if (mSoundboardChannelView) {
         mSoundboardChannelView->meter->setRefreshRateHz(rate);
     }
@@ -1706,83 +1824,82 @@ void ChannelGroupsView::rebuildChannelViews(bool notify)
 
         }
 
-        if (!mFileChannelView) {
-            mFileChannelView.reset(createChannelGroupView(true));
-            mFileChannelView->nameLabel->setEditable(false);
-            mFileChannelView->nameLabel->setText(TRANS("File Playback"), dontSendNotification);
-            mFileChannelView->nameLabel->setColour(Label::backgroundColourId, Colours::transparentBlack);
-            mFileChannelView->nameLabel->setColour(Label::outlineColourId, Colours::transparentBlack);
-            //mFileChannelView->nameLabel->setColour(TextEditor::backgroundColourId, Colours::transparentBlack);
-            //mFileChannelView->nameLabel->setColour(TextEditor::outlineColourId, Colours::transparentBlack);
-            //mFileChannelView->nameLabel->setReadOnly(true);
+                int fpgCnt = processor.getFilePlaybackGroupCount();
+        while (mFileChannelViews.size() > fpgCnt) {
+            mFileChannelViews.removeLast();
+        }
+        while (mFileChannelViews.size() < fpgCnt) {
+            int idx = mFileChannelViews.size();
+            auto v = createChannelGroupView(true);
+            mFileChannelViews.add(v);
+            
+            v->nameLabel->setEditable(false);
+            String fname = processor.getFilePlaybackChannelGroupName(idx);
+            if (fname.isEmpty()) fname = fpgCnt == 1 ? TRANS("File Playback") : TRANS("File pb ") + String(idx+1);
+            v->nameLabel->setText(fname, dontSendNotification);
+            v->nameLabel->setColour(Label::backgroundColourId, Colours::transparentBlack);
+            v->nameLabel->setColour(Label::outlineColourId, Colours::transparentBlack);
+
+            if (idx == 0) {
+                v->linkButton->setClickingTogglesState(true);
+                std::unique_ptr<Drawable> grpimg(Drawable::createFromImageData(BinaryData::send_group_small_svg, BinaryData::send_group_small_svgSize));
+                v->linkButton->setTitle(TRANS("Send File Playback"));
+                v->linkButton->setImages(grpimg.get());
+                v->linkButton->setClickingTogglesState(true);
+                mFileSendAttachment = std::make_unique<AudioProcessorValueTreeState::ButtonAttachment> (processor.getValueTreeState(), SonobusAudioProcessor::paramSendFileAudio, *v->linkButton);
+                v->linkButton->setButtonStyle(DrawableButton::ButtonStyle::ImageOnButtonBackground);
+                v->linkButton->setForegroundImageRatio(1.0f);
+                v->linkButton->setColour(TextButton::buttonOnColourId, Colour::fromFloatRGBA(0.2, 0.5, 0.7, 0.65));
+                v->linkButton->setColour(TextButton::buttonColourId, Colours::transparentBlack);
+                v->linkButton->setTooltip(TRANS("Send File Playback to All"));
+            } else {
+                v->linkButton->setVisible(false);
+            }
 
-            mFileChannelView->linkButton->setClickingTogglesState(true);
-            std::unique_ptr<Drawable> grpimg(Drawable::createFromImageData(BinaryData::send_group_small_svg, BinaryData::send_group_small_svgSize));
-            mFileChannelView->linkButton->setTitle(TRANS("Send File Playback"));
-            mFileChannelView->linkButton->setImages(grpimg.get());
-            mFileChannelView->linkButton->setClickingTogglesState(true);
-            mFileSendAttachment = std::make_unique<AudioProcessorValueTreeState::ButtonAttachment> (processor.getValueTreeState(), SonobusAudioProcessor::paramSendFileAudio, *mFileChannelView->linkButton);
-            mFileChannelView->linkButton->setButtonStyle(DrawableButton::ButtonStyle::ImageOnButtonBackground);
-            mFileChannelView->linkButton->setForegroundImageRatio(1.0f);
-            mFileChannelView->linkButton->setColour(TextButton::buttonOnColourId, Colour::fromFloatRGBA(0.2, 0.5, 0.7, 0.65));
-            mFileChannelView->linkButton->setColour(TextButton::buttonColourId, Colours::transparentBlack);
-            mFileChannelView->linkButton->setTooltip(TRANS("Send File Playback to All"));
-
-
-            mFileChannelView->soloButton->onClick = [this]() {
+            v->soloButton->onClick = [this, idx]() {
+                processor.setFilePlaybackSoloed(idx, mFileChannelViews[idx]->soloButton->getToggleState());
             };
 
-            mFileChannelView->muteButton->onClick = [this]() {
+            v->muteButton->onClick = [this, idx]() {
+                processor.setFilePlaybackMuted(idx, mFileChannelViews[idx]->muteButton->getToggleState());
             };
 
-
-            mFileChannelView->fxButton->onClick = [this]() {
-                /*
-                if (!effectsCalloutBox) {
-                    showEffects(0, true, mFileChannelView->fxButton.get());
-                } else {
-                    showEffects(0, false);
-                }
-                 */
+            v->fxButton->onClick = [this]() {
             };
 
-            mFileChannelView->monfxButton->onClick = [this]() {
+            v->monfxButton->onClick = [this, idx]() {
                 if (!monEffectsCalloutBox) {
-                    showMonitorEffects(-2, true, mFileChannelView->monfxButton.get());
+                    showMonitorEffects(-100 - idx, true, mFileChannelViews[idx]->monfxButton.get());
                 } else {
-                    showMonitorEffects(-2, false);
+                    showMonitorEffects(-100 - idx, false);
                 }
             };
 
-            mFileChannelView->destButton->onClick = [this]() {
-                // when shown it will be for the first one
-                showDestSelectionMenu(mFileChannelView->destButton.get(), -2);
+            v->destButton->onClick = [this, idx]() {
+                showDestSelectionMenu(mFileChannelViews[idx]->destButton.get(), -100 - idx);
             };
 
-            mFileChannelView->levelSlider->onValueChange = [this]() {
-                processor.setFilePlaybackGain(mFileChannelView->levelSlider->getValue());
+            v->levelSlider->onValueChange = [this, idx]() {
+                processor.setFilePlaybackGain(idx, mFileChannelViews[idx]->levelSlider->getValue());
             };
+            // Right-click on fader is handled via ChannelGroupsView::mouseDown
 
-            //mFileChannelView->panSlider->onValueChange = [this]() {
-            //    processor.setFilePlaybackPan(mFileChannelView->panSlider->getValue());
-            //};
-
-            mFileChannelView->monitorSlider->onValueChange = [this]() {
-                processor.setFilePlaybackMonitor(mFileChannelView->monitorSlider->getValue());
+            v->monitorSlider->onValueChange = [this, idx]() {
+                processor.setFilePlaybackMonitor(idx, mFileChannelViews[idx]->monitorSlider->getValue());
             };
 
-            setupChildren(mFileChannelView.get());
-
-            mFileChannelView->muteButton->setVisible(false);
-            mFileChannelView->soloButton->setVisible(false);
-            mFileChannelView->fxButton->setVisible(false);
-            mFileChannelView->panSlider->setVisible(false);
+            // Right-click MIDI learn on mute & solo (override their onClick with right-click detection via mouseDown)
+            // We use a lambda approach via a helper CustomButton subclass; simplest is to store index and re-use mouseDown.
+            // We will handle this in ChannelGroupsView::mouseDown by checking the component pointer.
 
-            mFileChannelView->premeter->setVisible(false);
-            mFileChannelView->premeter->setRefreshRateHz(0);
-            //mFileChannelView->premeter->setVisible(false);
-            //mFileChannelView->premeter->setRefreshRateHz(0);
+            setupChildren(v);
 
+            v->muteButton->setVisible(true);
+            v->soloButton->setVisible(true);
+            v->fxButton->setVisible(false);
+            v->panSlider->setVisible(false);
+            v->premeter->setVisible(false);
+            v->premeter->setRefreshRateHz(0);
         }
         if (!mSoundboardChannelView) {
             mSoundboardChannelView.reset(createChannelGroupView(true));
@@ -1881,6 +1998,10 @@ void ChannelGroupsView::setupChildren(ChannelGroupView * pvf)
     pvf->addAndMakeVisible(pvf->soloButton.get());
     pvf->addAndMakeVisible(pvf->levelSlider.get());
     pvf->addChildComponent(pvf->monitorSlider.get());
+    // Allow this ChannelGroupsView to see mouse events on child controls (for right-click MIDI learn)
+    pvf->levelSlider->addMouseListener(this, false);
+    pvf->muteButton->addMouseListener(this, false);
+    pvf->soloButton->addMouseListener(this, false);
     //pvf->addAndMakeVisible(pvf->levelLabel.get());
     pvf->addAndMakeVisible(pvf->panLabel.get());
     pvf->addAndMakeVisible(pvf->nameLabel.get());
@@ -1896,6 +2017,8 @@ void ChannelGroupsView::setupChildren(ChannelGroupView * pvf)
     pvf->addAndMakeVisible(pvf->monfxButton.get());
 
     pvf->addAndMakeVisible(pvf->panSlider.get());
+    pvf->addChildComponent(pvf->moggButton.get());
+    pvf->moggButton->addMouseListener(this, false);
 
     pvf->panSlider->setPopupDisplayEnabled(true, true, dw);
 
@@ -2058,6 +2181,16 @@ void ChannelGroupsView::updateLayoutForRemotePeer(bool notify)
                 pvf->inbox.items.add(FlexItem(5, 3));
                 pvf->inbox.items.add(FlexItem(mutebuttwidth, minitemheight, *pvf->fxButton).withMargin(0).withFlex(0));
 
+                if (i < 0 && processor.getRemotePeerIsMogg(mPeerIndex)) {
+                    pvf->inbox.items.add(FlexItem(5, 3));
+                    pvf->inbox.items.add(FlexItem(50, minitemheight, *pvf->moggButton).withMargin(0).withFlex(0));
+                }
+            }
+            else {
+                 if (i < 0 && processor.getRemotePeerIsMogg(mPeerIndex)) {
+                    pvf->inbox.items.add(FlexItem(3, 3));
+                    pvf->inbox.items.add(FlexItem(50, minitemheight, *pvf->moggButton).withMargin(0).withFlex(0));
+                }
             }
             pvf->inbox.items.add(FlexItem(3, 3));
             pvf->inbox.items.add(FlexItem(minSliderWidth, minitemheight, *pvf->levelSlider).withMargin(0).withFlex(1));
@@ -2359,8 +2492,8 @@ void ChannelGroupsView::updateLayoutForInput(bool notify)
     channelsBox.items.add(FlexItem(8, bgaph).withMargin(0));
     peersheight += addrowheight + gaph + bgaph;
 
-    // all the inputs, plus three extra (met and file playback and soundboard)
-    for (int i =  0; i < mChannelViews.size() + 3; ++i, ++chi) {
+    // all the inputs, plus (1 for met, mFileChannelViews.size() for files, 1 for soundboard)
+    for (int i = 0; i < (int)mChannelViews.size() + (int)mFileChannelViews.size() + 2; ++i, ++chi) {
         if (i==0) {
             chi = 0; // ensure this
         }
@@ -2386,25 +2519,24 @@ void ChannelGroupsView::updateLayoutForInput(bool notify)
 
         bool ismetorfileorsoundboard = false;
 
-        ChannelGroupView * pvf;
-        if (i == mChannelViews.size()) {
+        ChannelGroupView * pvf = nullptr;
+        if (i < mChannelViews.size()) {
+            pvf = mChannelViews.getUnchecked(i);
+        } else if (i == mChannelViews.size()) {
             pvf = mMetChannelView.get();
             ismetorfileorsoundboard = true;
-        } else if (i == mChannelViews.size() + 1) {
-            pvf = mFileChannelView.get();
-            auto numfilechan = processor.getFilePlaybackMeterSource().getNumChannels();
-            mainmeterwidth = numfilechan * (numfilechan > 2 ? 6 : meterwidth);
+        } else if (i < mChannelViews.size() + 1 + mFileChannelViews.size()) {
+            int fidx = i - ((int)mChannelViews.size() + 1);
+            pvf = mFileChannelViews[fidx];
             ismetorfileorsoundboard = true;
-        }
-        else if (i > mChannelViews.size()) {
+        } else {
             pvf = mSoundboardChannelView.get();
             auto numsoundboardchan = processor.getSoundboardProcessor()->getMeterSource().getNumChannels();
             mainmeterwidth = numsoundboardchan * (numsoundboardchan > 2 ? 6 : meterwidth);
             ismetorfileorsoundboard = true;
         }
-        else {
-            pvf = mChannelViews.getUnchecked(i);
-        }
+
+        if (pvf == nullptr) continue;
 
         //pvf->updateLayout();
         bool viewexpanded = true;
@@ -2522,8 +2654,9 @@ void ChannelGroupsView::updateLayoutForInput(bool notify)
 
                 pvf->monbox.items.add(FlexItem(monsliderwidth, minitemheight, *pvf->monitorSlider).withMargin(0).withFlex(0));
                 pvf->monbox.items.add(FlexItem(2, 3));
-                pvf->monbox.items.add(FlexItem(mutebuttwidth, minitemheight, *pvf->monfxButton).withMargin(0).withFlex(0));
-                pvf->monbox.items.add(FlexItem(2, 3));
+                pvf->monbox.items.add(FlexItem(mutebuttwidth, minitemheight, *pvf->soloButton).withMargin(2).withFlex(0));
+                pvf->monbox.items.add(FlexItem(mutebuttwidth, minitemheight, *pvf->midiButton).withMargin(2).withFlex(0));
+                pvf->monbox.items.add(FlexItem(mutebuttwidth, minitemheight, *pvf->moggButton).withMargin(2).withFlex(0));
 
                 if (destbuttvisible) {
                     pvf->monbox.items.add(FlexItem(destbuttwidth, minitemheight, *pvf->destButton).withMargin(0).withFlex(0));
@@ -2603,7 +2736,7 @@ void ChannelGroupsView::updateLayoutForInput(bool notify)
                 peersheight += mbh + 2;
             }
 
-            if (i < mChannelViews.size()+2) {
+            if (i < (int)mChannelViews.size() + (int)mFileChannelViews.size() + 1) {
                 channelsBox.items.add(FlexItem(3, 4));
                 peersheight += 4;
             }
@@ -2665,10 +2798,10 @@ void ChannelGroupsView::applyToAllSliders(std::function<void(Slider *)> & routin
         routine(mMainChannelView->monitorSlider.get());
     }
 
-    if (mFileChannelView) {
-        routine(mFileChannelView->levelSlider.get());
-        routine(mFileChannelView->panSlider.get());
-        routine(mFileChannelView->monitorSlider.get());
+    for (auto v : mFileChannelViews) {
+        routine(v->levelSlider.get());
+        routine(v->panSlider.get());
+        routine(v->monitorSlider.get());
     }
 
     if (mMetChannelView) {
@@ -2750,32 +2883,37 @@ void ChannelGroupsView::updateInputModeChannelViews(int specific)
 
     }
 
-    if (mFileChannelView) {
+    for (int i=0; i < mFileChannelViews.size(); i++) {
+        auto v = mFileChannelViews[i];
+        
+        String fname = processor.getFilePlaybackChannelGroupName(i);
+        if (fname.isNotEmpty()) v->nameLabel->setText(fname, dontSendNotification);
+
         String desttext;
         int destcnt, deststart;
-        processor.getFilePlaybackDestStartAndCount(deststart, destcnt);
+        processor.getFilePlaybackDestStartAndCount(i, deststart, destcnt);
         if (destcnt == 1) {
             desttext << deststart + 1;
         } else {
             desttext << deststart + 1 << "-" << deststart+destcnt;
         }
-        mFileChannelView->destButton->setButtonText(desttext);
-        mFileChannelView->monitorSlider->setVisible(true);
-        mFileChannelView->monitorSlider->setValue(processor.getFilePlaybackMonitor(), dontSendNotification);
-        mFileChannelView->levelSlider->setValue(processor.getFilePlaybackGain(), dontSendNotification);
-        mFileChannelView->panSlider->setVisible(false);
-        mFileChannelView->panLabel->setVisible(false);
-        //mFileChannelView->panSlider->setValue(processor.getFilPlaybackPan(), dontSendNotification);
-        mFileChannelView->showDivider = true;
-        mFileChannelView->nameEditor->setVisible(false);
+        v->destButton->setButtonText(desttext);
+        v->monitorSlider->setVisible(true);
+        v->monitorSlider->setValue(processor.getFilePlaybackMonitor(i), dontSendNotification);
+        v->levelSlider->setValue(processor.getFilePlaybackGain(i), dontSendNotification);
+        v->muteButton->setToggleState(processor.getFilePlaybackMuted(i), dontSendNotification);
+        v->soloButton->setToggleState(processor.getFilePlaybackSoloed(i), dontSendNotification);
+        v->panSlider->setVisible(false);
+        v->panLabel->setVisible(false);
+        v->showDivider = true;
+        v->nameEditor->setVisible(false);
 
-        mFileChannelView->meter->setMeterSource (&processor.getFilePlaybackMeterSource());
-        mFileChannelView->meter->setSelectedChannel(0);
+        v->meter->setMeterSource (&processor.getFilePlaybackMeterSource());
+        v->meter->setSelectedChannel(i);
 
         SonoAudio::DelayParams eparams;
-        processor.getFilePlaybackMonitorDelayParams(eparams);
-        mFileChannelView->monfxButton->setToggleState(eparams.enabled, dontSendNotification);
-
+        processor.getFilePlaybackMonitorDelayParams(i, eparams);
+        v->monfxButton->setToggleState(eparams.enabled, dontSendNotification);
     }
 
     if (mSoundboardChannelView) {
@@ -2982,6 +3120,9 @@ void ChannelGroupsView::updatePeerModeChannelViews(int specific)
     String username = processor.getRemotePeerUserName(mPeerIndex);
 
     mMainChannelView->nameLabel->setText(username, dontSendNotification);
+    
+    bool isMogg = processor.getRemotePeerIsMogg(mPeerIndex);
+    mMainChannelView->moggButton->setVisible(isMogg);
     if (username.length() > 32) {
         mMainChannelView->nameLabel->setTooltip(username);
     } else {
@@ -3017,6 +3158,8 @@ void ChannelGroupsView::updatePeerModeChannelViews(int specific)
 
     mMainChannelView->muteButton->setToggleState(mainmuted , dontSendNotification);
     mMainChannelView->soloButton->setToggleState(mainsoloed , dontSendNotification);
+    mMainChannelView->midiButton->setToggleState(processor.getRemotePeerMidiRelay(mPeerIndex), dontSendNotification);
+
 
     if (!mMainChannelView->levelSlider->isMouseOverOrDragging()) {
         mMainChannelView->levelSlider->setValue(processor.getRemotePeerLevelGain(mPeerIndex), dontSendNotification);
@@ -3297,7 +3440,7 @@ void ChannelGroupsView::updateMonDelayButton()
     processor.getMetronomeMonitorDelayParams(metparams);
 
     DelayParams fileparams;
-    processor.getFilePlaybackMonitorDelayParams(fileparams);
+    processor.getFilePlaybackMonitorDelayParams(0, fileparams);
 
     DelayParams sbparams = processor.getSoundboardProcessor()->getMonitorDelayParams();
 
@@ -3328,7 +3471,7 @@ void ChannelGroupsView::toggleAllMonitorDelay()
     processor.getMetronomeMonitorDelayParams(metparams);
 
     DelayParams fileparams;
-    processor.getFilePlaybackMonitorDelayParams(fileparams);
+    processor.getFilePlaybackMonitorDelayParams(0, fileparams);
 
     DelayParams sbparams = processor.getSoundboardProcessor()->getMonitorDelayParams();
 
@@ -3352,7 +3495,9 @@ void ChannelGroupsView::toggleAllMonitorDelay()
     processor.setMetronomeMonitorDelayParams(metparams);
 
     fileparams.enabled = !doDisable;
-    processor.setFilePlaybackMonitorDelayParams(fileparams);
+    for (int fi=0; fi < processor.getFilePlaybackGroupCount(); ++fi) {
+        processor.setFilePlaybackMonitorDelayParams(fi, fileparams);
+    }
 
     sbparams.enabled = !doDisable;
     processor.getSoundboardProcessor()->setMonitorDelayParams(sbparams);
@@ -3396,6 +3541,7 @@ void ChannelGroupsView::buttonClicked (Button* buttonThatWasClicked)
                 // see if any are muted
                 bool anysubmute = false;
                 bool allsubmute = true;
+                int changroups = processor.getRemotePeerChannelGroupCount(mPeerIndex);
                 for (int gi=0; gi < changroups; ++gi) {
                     if (processor.getRemotePeerChannelMuted(mPeerIndex, gi)) {
                         anysubmute = true;
@@ -3418,19 +3564,33 @@ void ChannelGroupsView::buttonClicked (Button* buttonThatWasClicked)
                 break;
             }
             else if (pvf->linkButton.get() == buttonThatWasClicked) {
-                //processor.setRemotePeerChannelMuted (mPeerIndex, changroup, buttonThatWasClicked->getToggleState());
-                //updateChannelViews();
-
                 showChangePeerChannelsLayout(i, buttonThatWasClicked);
-
                 break;
             }
             else if (pvf->destButton.get() == buttonThatWasClicked) {
-                //processor.setRemotePeerChannelMuted (mPeerIndex, changroup, buttonThatWasClicked->getToggleState());
-                //updateChannelViews();
-
                 showDestSelectionMenu(buttonThatWasClicked, i);
+                break;
+            }
+            else if (pvf->moggButton.get() == buttonThatWasClicked) {
+                // Open remote MOGG mixer
+                SonobusAudioProcessorEditor* editor = nullptr;
+                
+                // Walk up the component tree to find the main editor
+                Component* c = this;
+                while (c != nullptr) {
+                    if (auto* e = dynamic_cast<SonobusAudioProcessorEditor*>(c)) {
+                        editor = e;
+                        break;
+                    }
+                    c = c->getParentComponent();
+                }
 
+                if (editor) {
+                    DBG("Opening MOGG Mixer for peer " << mPeerIndex);
+                    editor->showMoggMixer(mPeerIndex);
+                } else {
+                    DBG("Could NOT find SonobusAudioProcessorEditor for MOGG button click!");
+                }
                 break;
             }
             else if (pvf->soloButton.get() == buttonThatWasClicked) {
@@ -4351,7 +4511,56 @@ bool ChannelGroupsView::isDraggable(Component * comp) const
 
 void ChannelGroupsView::mouseDown (const MouseEvent& event)
 {
+    if (event.mods.isRightButtonDown()) {
+        auto * comp = event.eventComponent;
+        ChannelGroupView * pvf = nullptr;
+        int group = -1;
+        
+        if (mMainChannelView && (comp == mMainChannelView.get() || mMainChannelView->isParentOf(comp))) {
+            pvf = mMainChannelView.get();
+            group = -1;
+        } else {
+            for (int i=0; i < mChannelViews.size(); ++i) {
+                if (comp->isParentOf(mChannelViews[i]) || comp == mChannelViews[i]) {
+                    pvf = mChannelViews[i];
+                    group = i;
+                    break;
+                }
+            }
+            if (!pvf) {
+                if (mMetChannelView && (comp == mMetChannelView.get() || mMetChannelView->isParentOf(comp))) {
+                    pvf = mMetChannelView.get();
+                    group = -2;
+                } else if (mSoundboardChannelView && (comp == mSoundboardChannelView.get() || mSoundboardChannelView->isParentOf(comp))) {
+                    pvf = mSoundboardChannelView.get();
+                    group = -3;
+                }
+            }
+        }
+
+        if (pvf) {
+            SonobusAudioProcessor::MidiTargetType type = SonobusAudioProcessor::MidiTarget_None;
+            int data = (group >= 0 && mPeerMode) ? mPeerIndex : group;
+
+            if (comp == pvf->levelSlider.get()) {
+                if (group == -2) type = SonobusAudioProcessor::MidiTarget_MetronomeLevel;
+                else if (group == -3) type = SonobusAudioProcessor::MidiTarget_SoundboardLevel;
+                else type = mPeerMode ? SonobusAudioProcessor::MidiTarget_PeerLevel : SonobusAudioProcessor::MidiTarget_InputGain;
+            }
+            else if (comp == pvf->panSlider.get()) type = SonobusAudioProcessor::MidiTarget_PeerPan;
+            else if (comp == pvf->monitorSlider.get()) type = SonobusAudioProcessor::MidiTarget_MonitorLevel;
+            else if (comp == pvf->muteButton.get()) type = mPeerMode ? SonobusAudioProcessor::MidiTarget_PeerMute : SonobusAudioProcessor::MidiTarget_InputMute;
+
+            if (type != SonobusAudioProcessor::MidiTarget_None) {
+                showFileStemMidiMenu(comp, type, data);
+                return;
+            }
+        }
+    }
+
+
     if (mMainChannelView) {
+
         if (event.eventComponent == mMainChannelView->meter.get()) {
             clearClipIndicators();
             return;
@@ -4364,11 +4573,34 @@ void ChannelGroupsView::mouseDown (const MouseEvent& event)
             return;
         }
     }
-    if (mFileChannelView) {
-        if (event.eventComponent == mFileChannelView->meter.get()) {
+    for (int fv=0; fv < mFileChannelViews.size(); ++fv) {
+        auto v = mFileChannelViews[fv];
+        if (event.eventComponent == v->meter.get()) {
             clearClipIndicators();
             return;
         }
+        if (event.mods.isRightButtonDown()) {
+            if (event.eventComponent == v->muteButton.get()) {
+                showFileStemMidiMenu(v->muteButton.get(),
+                    SonobusAudioProcessor::MidiTarget_FileStemMute, fv);
+                return;
+            }
+            if (event.eventComponent == v->soloButton.get()) {
+                showFileStemMidiMenu(v->soloButton.get(),
+                    SonobusAudioProcessor::MidiTarget_FileStemSolo, fv);
+                return;
+            }
+            if (event.eventComponent == v->levelSlider.get()) {
+                showFileStemMidiMenu(v->levelSlider.get(),
+                    SonobusAudioProcessor::MidiTarget_FileStemGain, fv);
+                return;
+            }
+            if (event.eventComponent == v->monitorSlider.get()) {
+                showFileStemMidiMenu(v->monitorSlider.get(),
+                    SonobusAudioProcessor::MidiTarget_FileStemMonitor, fv);
+                return;
+            }
+        }
     }
     if (mSoundboardChannelView) {
         if (event.eventComponent == mSoundboardChannelView->meter.get()) {
@@ -4518,11 +4750,11 @@ void ChannelGroupsView::clearClipIndicators()
         mMetChannelView->meter->clearMaxLevelDisplay(-1);
     }
 
-    if (mFileChannelView) {
-        mFileChannelView->premeter->clearClipIndicator();
-        mFileChannelView->premeter->clearMaxLevelDisplay(-1);
-        mFileChannelView->meter->clearClipIndicator();
-        mFileChannelView->meter->clearMaxLevelDisplay(-1);
+    for (auto v : mFileChannelViews) {
+        v->premeter->clearClipIndicator();
+        v->premeter->clearMaxLevelDisplay(-1);
+        v->meter->clearClipIndicator();
+        v->meter->clearMaxLevelDisplay(-1);
     }
 
     if (mSoundboardChannelView) {
@@ -4545,8 +4777,14 @@ void ChannelGroupsView::showDestSelectionMenu(Component * source, int index)
     if (index == -1) {
         pvf = mMetChannelView.get();
         ismet = true;
-    } else if (index == -2) {
-        pvf = mFileChannelView.get();
+    } else if (index <= -100) {
+        // index mapping: -100 - fileindex
+        int fileIdx = -(index + 100);
+        if (fileIdx >= 0 && fileIdx < mFileChannelViews.size()) {
+            pvf = mFileChannelViews[fileIdx];
+        } else {
+            pvf = mFileChannelViews[0];
+        }
         isfile = true;
     } else if (index == -3) {
         pvf = mSoundboardChannelView.get();
@@ -4580,7 +4818,8 @@ void ChannelGroupsView::showDestSelectionMenu(Component * source, int index)
             processor.getMetronomeChannelDestStartAndCount(destst, destcnt);
         }
         else if (isfile) {
-            processor.getFilePlaybackDestStartAndCount(destst, destcnt);
+            int fidx = -(index + 100);
+            processor.getFilePlaybackDestStartAndCount(fidx, destst, destcnt);
             chcnt = processor.getFilePlaybackMeterSource().getNumChannels();
             maxchcnt = chcnt;
             chcnt = jmin(2, chcnt, totalouts);
@@ -4686,7 +4925,8 @@ void ChannelGroupsView::showDestSelectionMenu(Component * source, int index)
             safeThis->processor.setMetronomeChannelDestStartAndCount(dclitem->startIndex, dclitem->count);
         }
         else if (isfile) {
-            safeThis->processor.setFilePlaybackDestStartAndCount(dclitem->startIndex, dclitem->count);
+            int fidx = -(changroup + 100);
+            safeThis->processor.setFilePlaybackDestStartAndCount(fidx, dclitem->startIndex, dclitem->count);
         }
         else if (issoundboard) {
             safeThis->processor.getSoundboardProcessor()->setDestStartAndCount(dclitem->startIndex, dclitem->count);
diff --git a/Source/ChannelGroupsView.h b/Source/ChannelGroupsView.h
index f3fe3bb3a..51beaef08 100644
--- a/Source/ChannelGroupsView.h
+++ b/Source/ChannelGroupsView.h
@@ -8,6 +8,8 @@
 
 #include "SonobusPluginProcessor.h"
 #include "SonoLookAndFeel.h"
+#include "SonoSlider.h"
+
 #include "SonoChoiceButton.h"
 #include "SonoDrawableButton.h"
 #include "GenericItemChooser.h"
@@ -255,12 +257,16 @@ class ChannelGroupView : public Component {
     std::unique_ptr<TextButton> soloButton;
     std::unique_ptr<TextButton> fxButton;
     std::unique_ptr<TextButton> monfxButton;
+    std::unique_ptr<TextButton> moggButton;
+    std::unique_ptr<TextButton> midiButton;
     std::unique_ptr<Label>  chanLabel;
+
     std::unique_ptr<Label>  levelLabel;
-    std::unique_ptr<Slider> levelSlider;
-    std::unique_ptr<Slider> monitorSlider;
+    std::unique_ptr<SonoSlider> levelSlider;
+    std::unique_ptr<SonoSlider> monitorSlider;
     std::unique_ptr<Label>  panLabel;
-    std::unique_ptr<Slider> panSlider;
+    std::unique_ptr<SonoSlider> panSlider;
+
     std::unique_ptr<SonoDrawableButton> linkButton;
     std::unique_ptr<SonoDrawableButton> monoButton;
     std::unique_ptr<SonoDrawableButton> destButton;
@@ -300,6 +306,7 @@ public SonoChoiceButton::Listener,
 public GenericItemChooser::Listener,
 public ChannelGroupEffectsView::Listener,
 public ChannelGroupMonitorEffectsView::Listener,
+public SonobusAudioProcessor::MidiLearnListener,
 public MultiTimer
 {
 public:
@@ -411,6 +418,10 @@ public MultiTimer
     void showMonitorEffects(int index, bool flag, Component * fromView=nullptr);
     void showInputReverbView(bool flag, Component * fromView=nullptr);
 
+    // MIDI learn context menu for a specific stem control
+    void showFileStemMidiMenu(Component* source, SonobusAudioProcessor::MidiTargetType type, int stemIdx);
+    void midiMappingChanged() override; // from MidiLearnListener
+
     int getChanGroupFromIndex(int index);
     juce::Rectangle<int> getBoundsForChanGroup(int chgroup);
     int getChanGroupForPoint(Point<int> pos, bool inbetween);
@@ -424,7 +435,7 @@ public MultiTimer
     OwnedArray<ChannelGroupView> mChannelViews;
     std::unique_ptr<ChannelGroupView> mMainChannelView; // used for peers
 
-    std::unique_ptr<ChannelGroupView> mFileChannelView; // used for input
+    juce::OwnedArray<ChannelGroupView> mFileChannelViews; // used for input
     std::unique_ptr<ChannelGroupView> mMetChannelView; // used for input
     std::unique_ptr<ChannelGroupView> mSoundboardChannelView; // used for init
 
@@ -435,8 +446,9 @@ public MultiTimer
 
 
 
-    std::unique_ptr<Slider> mInGainSlider;
+    std::unique_ptr<SonoSlider> mInGainSlider;
     std::unique_ptr<TextButton> mAddButton;
+
     std::unique_ptr<TextButton> mClearButton;
     std::unique_ptr<TextButton> mInReverbButton;
     std::unique_ptr<TextButton> mMonDelayButton;
diff --git a/Source/MoggMixerView.h b/Source/MoggMixerView.h
new file mode 100644
index 000000000..1512d9d80
--- /dev/null
+++ b/Source/MoggMixerView.h
@@ -0,0 +1,394 @@
+// SPDX-License-Identifier: GPLv3-or-later WITH Appstore-exception
+// Mogg Mixer Window – per-stem fader / mute / solo / colour panel
+
+#pragma once
+
+#include "JuceHeader.h"
+#include "SonobusPluginProcessor.h"
+#include "SonoLookAndFeel.h"
+
+// Palette of distinct stem colours  (can be changed by the user)
+static const Colour kStemColours[] = {
+    Colour(0xFF4FC3F7), // sky blue
+    Colour(0xFFAED581), // light green
+    Colour(0xFFFFB74D), // amber
+    Colour(0xFFF48FB1), // pink
+    Colour(0xFFCE93D8), // lavender
+    Colour(0xFF80DEEA), // cyan
+    Colour(0xFFFFCC02), // yellow
+    Colour(0xFFFF8A65), // deep orange
+};
+static const int kNumStemColours = (int)(sizeof(kStemColours)/sizeof(kStemColours[0]));
+
+// ============================================================================
+class MoggMixerComponent  : public Component,
+                             public Timer,
+                             public SonobusAudioProcessor::MidiLearnListener
+{
+public:
+    int remotePeerIndex = -1; // -1 means local file playback
+
+    // -------------------------------------------------------------------------
+    struct StemStrip : public Component
+    {
+        StemStrip(int idx_, SonobusAudioProcessor& proc_, MoggMixerComponent* parent_)
+            : idx(idx_), processor(proc_), parent(parent_)
+        {
+            colour = kStemColours[idx % kNumStemColours];
+            bool isRemote = parent->remotePeerIndex >= 0;
+
+            // Label
+            String name;
+            if (isRemote) 
+                name = processor.getRemotePeerChannelGroupName(parent->remotePeerIndex, idx);
+            else {
+                // For local, use our predefined stem names ("Full Mix", "Stem 1", etc)
+                name = processor.getFilePlaybackChannelGroupName(idx);
+            }
+
+            if (name.isEmpty()) name = "Track " + String(idx+1);
+
+            nameLabel.setText(name, dontSendNotification);
+            nameLabel.setJustificationType(Justification::centred);
+            nameLabel.setFont(Font(11.0f, Font::bold));
+            nameLabel.setColour(Label::textColourId, Colours::white);
+            addAndMakeVisible(nameLabel);
+
+            // Colour swatch (click to cycle colour)
+            colourSwatch.setTooltip("Click to change track colour");
+            colourSwatch.onClick = [this] { cycleColour(); };
+            addAndMakeVisible(colourSwatch);
+
+            // Fader  (vertical)
+            fader.setSliderStyle(Slider::LinearBarVertical);
+            fader.setRange(0.0, 2.0, 0.0);
+            fader.setSkewFactor(0.5f);
+            fader.setTextBoxStyle(Slider::NoTextBox, false, 0, 0);
+            fader.setPopupDisplayEnabled(true, false, nullptr);
+            fader.textFromValueFunction = [](double v) {
+                return Decibels::toString(Decibels::gainToDecibels((float)v, -60.0f), 1);
+            };
+            fader.valueFromTextFunction = [](const String& s) -> double {
+                return Decibels::decibelsToGain(s.getDoubleValue());
+            };
+            fader.onValueChange = [this] {
+                if (parent->remotePeerIndex >= 0)
+                    processor.setRemotePeerChannelGain(parent->remotePeerIndex, idx, (float)fader.getValue());
+                else
+                    processor.setFilePlaybackGain(idx, (float)fader.getValue());
+            };
+            
+            float startGain = isRemote ? processor.getRemotePeerChannelGain(parent->remotePeerIndex, idx)
+                                       : processor.getFilePlaybackGain(idx);
+            fader.setValue(startGain, dontSendNotification);
+            addAndMakeVisible(fader);
+
+            // Mute
+            muteBtn.setButtonText("M");
+            muteBtn.setClickingTogglesState(true);
+            muteBtn.setColour(TextButton::buttonOnColourId,  Colour(0xFFCC5500));
+            muteBtn.setColour(TextButton::buttonColourId,    Colour(0xFF444444));
+            muteBtn.setColour(TextButton::textColourOnId,    Colours::white);
+            muteBtn.setColour(TextButton::textColourOffId,   Colour(0xFFAAAAAA));
+            muteBtn.onStateChange = [this] {
+                if (parent->remotePeerIndex >= 0)
+                    processor.setRemotePeerChannelMuted(parent->remotePeerIndex, idx, muteBtn.getToggleState());
+                else
+                    processor.setFilePlaybackMuted(idx, muteBtn.getToggleState());
+            };
+            
+            bool startMute = isRemote ? processor.getRemotePeerChannelMuted(parent->remotePeerIndex, idx)
+                                      : processor.getFilePlaybackMuted(idx);
+            muteBtn.setToggleState(startMute, dontSendNotification);
+            muteBtn.setTooltip("Mute track " + String(idx+1) + " (right-click for MIDI learn)");
+            addAndMakeVisible(muteBtn);
+
+            // Solo
+            soloBtn.setButtonText("S");
+            soloBtn.setClickingTogglesState(true);
+            soloBtn.setColour(TextButton::buttonOnColourId,  Colour(0xFFDDCC00));
+            soloBtn.setColour(TextButton::buttonColourId,    Colour(0xFF444444));
+            soloBtn.setColour(TextButton::textColourOnId,    Colours::black);
+            soloBtn.setColour(TextButton::textColourOffId,   Colour(0xFFAAAAAA));
+            soloBtn.onStateChange = [this] {
+                if (parent->remotePeerIndex >= 0)
+                    processor.setRemotePeerChannelSoloed(parent->remotePeerIndex, idx, soloBtn.getToggleState());
+                else
+                    processor.setFilePlaybackSoloed(idx, soloBtn.getToggleState());
+            };
+            
+            bool startSolo = isRemote ? processor.getRemotePeerChannelSoloed(parent->remotePeerIndex, idx)
+                                      : processor.getFilePlaybackSoloed(idx);
+            soloBtn.setToggleState(startSolo, dontSendNotification);
+            soloBtn.setTooltip("Solo track " + String(idx+1) + " (right-click for MIDI learn)");
+            addAndMakeVisible(soloBtn);
+
+            // dB readout label
+            dbLabel.setFont(Font(9.0f));
+            dbLabel.setJustificationType(Justification::centred);
+            dbLabel.setColour(Label::textColourId, Colour(0xFF88CCFF));
+            addAndMakeVisible(dbLabel);
+
+            refreshDbLabel();
+
+            // Right-click for MIDI learn
+            fader.addMouseListener(this, false);
+            muteBtn.addMouseListener(this, false);
+            soloBtn.addMouseListener(this, false);
+
+            meter.setMeterSource(&processor.getMoggStemMeterSource(isRemote ? parent->remotePeerIndex : -1, idx));
+            addAndMakeVisible(meter);
+        }
+
+        void mouseDown(const MouseEvent& e) override
+        {
+            if (e.mods.isRightButtonDown()) {
+                if (e.eventComponent == &fader) {
+                    parent->showMidiMenu(&fader, SonobusAudioProcessor::MidiTarget_FileStemGain, idx);
+                } else if (e.eventComponent == &muteBtn) {
+                    parent->showMidiMenu(&muteBtn, SonobusAudioProcessor::MidiTarget_FileStemMute, idx);
+                } else if (e.eventComponent == &soloBtn) {
+                    parent->showMidiMenu(&soloBtn, SonobusAudioProcessor::MidiTarget_FileStemSolo, idx);
+                }
+            }
+        }
+
+        void cycleColour()
+        {
+            // Find next colour in palette
+            for (int i=0; i<kNumStemColours; ++i) {
+                if (kStemColours[i] == colour) {
+                    colour = kStemColours[(i+1) % kNumStemColours];
+                    repaint();
+                    return;
+                }
+            }
+            colour = kStemColours[0];
+            repaint();
+        }
+
+        void refreshDbLabel()
+        {
+            float g = (parent->remotePeerIndex >= 0) ? processor.getRemotePeerChannelGain(parent->remotePeerIndex, idx)
+                                                     : processor.getFilePlaybackGain(idx);
+            if (g <= 0.0f)
+                dbLabel.setText("-inf", dontSendNotification);
+            else
+                dbLabel.setText(Decibels::toString(Decibels::gainToDecibels(g, -60.0f), 1),
+                                dontSendNotification);
+        }
+
+        void paint(Graphics& g) override
+        {
+            auto b = getLocalBounds().reduced(2);
+            // Background strip
+            g.setColour(Colour(0xFF282830));
+            g.fillRoundedRectangle(b.toFloat(), 6.0f);
+
+            // Colour accent bar at top
+            g.setColour(colour);
+            g.fillRoundedRectangle(b.removeFromTop(6).toFloat(), 3.0f);
+        }
+
+        void resized() override
+        {
+            auto b = getLocalBounds().reduced(4);
+            b.removeFromTop(8); // accent bar
+            nameLabel.setBounds(b.removeFromTop(18));
+            colourSwatch.setBounds(b.removeFromTop(14).reduced(20,2));
+            b.removeFromTop(4);
+            soloBtn.setBounds(b.removeFromTop(22).reduced(4,0));
+            muteBtn.setBounds(b.removeFromTop(22).reduced(4,0));
+            b.removeFromTop(4);
+            dbLabel.setBounds(b.removeFromTop(14));
+            meter.setBounds(b.removeFromRight(15).reduced(2, 4));
+            fader.setBounds(b.reduced(2,4));
+        }
+
+        int idx;
+        SonobusAudioProcessor& processor;
+        Colour colour;
+        Label nameLabel;
+        TextButton colourSwatch { "" };   // clickable swatch
+        Slider fader;
+        TextButton muteBtn, soloBtn;
+        Label dbLabel;
+        MoggMixerComponent* parent;
+
+        foleys::LevelMeter meter;
+        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(StemStrip)
+    };
+
+    // -------------------------------------------------------------------------
+    MoggMixerComponent(SonobusAudioProcessor& proc, int remoteIdx = -1)
+        : processor(proc), remotePeerIndex(remoteIdx)
+    {
+        setName(remotePeerIndex >= 0 ? "Remote MOGG Mixer" : "MOGG Stem Mixer");
+        processor.addMidiLearnListener(this);
+        rebuild();
+    }
+
+    ~MoggMixerComponent() override 
+    { 
+        processor.removeMidiLearnListener(this);
+        stopTimer(); 
+    }
+
+    int getRemotePeerIndex() const { return remotePeerIndex; }
+
+    void midiMappingChanged() override { /* refresh if we held state */ }
+
+    void showMidiMenu(Component* source, SonobusAudioProcessor::MidiTargetType type, int stemIdx)
+    {
+        if (remotePeerIndex >= 0) return; // No MIDI learn for remote peers for now
+
+        int ccNum = -1, midiCh = 0;
+        bool hasMapped = processor.getMidiMapping(type, stemIdx, ccNum, midiCh);
+
+        PopupMenu m;
+        if (processor.isMidiLearning() && 
+            processor.getMidiLearnTargetType() == type && 
+            processor.getMidiLearnTargetData() == stemIdx) 
+        {
+            m.addItem(1, TRANS("Cancel MIDI Learn"));
+        } else {
+            m.addItem(1, TRANS("MIDI Learn"));
+        }
+
+        if (hasMapped) {
+            m.addItem(2, TRANS("Clear MIDI Assignment") + " (CC " + String(ccNum) + ")");
+        }
+
+        m.showMenuAsync(PopupMenu::Options().withTargetComponent(source),
+            [this, type, stemIdx, hasMapped](int result) {
+                if (result == 1) {
+                    if (processor.isMidiLearning()) processor.stopMidiLearn();
+                    else processor.startMidiLearn(type, stemIdx);
+                } else if (result == 2 && hasMapped) {
+                    processor.clearMidiMapping(type, stemIdx);
+                }
+            });
+    }
+
+    void rebuild()
+    {
+        strips.clear();
+        int n = (remotePeerIndex >= 0) ? processor.getRemotePeerMoggStemCount(remotePeerIndex)
+                                       : processor.getFilePlaybackGroupCount();
+        for (int i=0; i<n; ++i) {
+            auto* s = new StemStrip(i, processor, this);
+            addAndMakeVisible(s);
+            strips.add(s);
+        }
+        startTimerHz(15);
+        resized();
+    }
+
+    int getIdealWidth()  const { return jmax(400, strips.size() * (kStripW + kGap) + kGap*2); }
+    int getIdealHeight() const { return 320; }
+
+    void resized() override
+    {
+        int x = kGap;
+        for (auto* s : strips) {
+            s->setBounds(x, kGap, kStripW, getHeight() - kGap*2);
+            x += kStripW + kGap;
+        }
+    }
+
+    void paint(Graphics& g) override
+    {
+        g.fillAll(Colour(0xFF1A1A22));
+        g.setColour(Colour(0xFF333344));
+        g.drawRect(getLocalBounds(), 1);
+
+        if (strips.isEmpty()) {
+            g.setColour(Colours::grey);
+            g.setFont(14.0f);
+            g.drawText(remotePeerIndex >= 0 ? "Peer is not sending multitrack" : "No multitrack file loaded", 
+                       getLocalBounds(), Justification::centred, true);
+        }
+    }
+
+    void timerCallback() override
+    {
+        // Sync UI state from processor
+        int n = (remotePeerIndex >= 0) ? processor.getRemotePeerMoggStemCount(remotePeerIndex)
+                                       : processor.getFilePlaybackGroupCount();
+        if (n != strips.size()) { rebuild(); return; }
+
+        for (auto* s : strips) {
+            float g = (remotePeerIndex >= 0) ? processor.getRemotePeerChannelGain(remotePeerIndex, s->idx)
+                                             : processor.getFilePlaybackGain(s->idx);
+            if (std::abs((float)s->fader.getValue() - g) > 0.001f)
+                s->fader.setValue(g, dontSendNotification);
+
+            bool muted  = (remotePeerIndex >= 0) ? processor.getRemotePeerChannelMuted(remotePeerIndex, s->idx)
+                                                 : processor.getFilePlaybackMuted(s->idx);
+            bool soloed = (remotePeerIndex >= 0) ? processor.getRemotePeerChannelSoloed(remotePeerIndex, s->idx)
+                                                 : processor.getFilePlaybackSoloed(s->idx);
+            if (s->muteBtn.getToggleState() != muted)
+                s->muteBtn.setToggleState(muted, dontSendNotification);
+            if (s->soloBtn.getToggleState() != soloed)
+                s->soloBtn.setToggleState(soloed, dontSendNotification);
+
+            s->refreshDbLabel();
+        }
+    }
+
+private:
+    static constexpr int kStripW = 72;
+    static constexpr int kGap    = 6;
+
+    SonobusAudioProcessor& processor;
+    OwnedArray<StemStrip> strips;
+
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(MoggMixerComponent)
+};
+
+// ============================================================================
+// Floating DialogWindow that hosts the mixer
+class MoggMixerWindow : public DocumentWindow
+{
+public:
+    MoggMixerWindow(SonobusAudioProcessor& proc, Component* centreRelativeTo, int remoteIdx = -1)
+        : DocumentWindow(remoteIdx >= 0 ? "Remote MOGG Mixer" : "MOGG Stem Mixer",
+                         Colour(0xFF1A1A22),
+                         DocumentWindow::closeButton | DocumentWindow::minimiseButton)
+    {
+        mixer = std::make_unique<MoggMixerComponent>(proc, remoteIdx);
+        setUsingNativeTitleBar(false);
+        setContentNonOwned(mixer.get(), true);
+        setResizable(true, false);
+
+        int w = mixer->getIdealWidth();
+        int h = mixer->getIdealHeight() + getTitleBarHeight() + 4;
+        setSize(w, h);
+
+        if (centreRelativeTo)
+            centreAroundComponent(centreRelativeTo, w, h);
+
+        setVisible(true);
+        setAlwaysOnTop(true);
+        
+        DBG("MoggMixerWindow created for peer index: " << remoteIdx);
+    }
+
+    MoggMixerComponent* getMixer() const { return mixer.get(); }
+
+
+    void closeButtonPressed() override
+    {
+        setVisible(false);
+        // Caller holds the unique_ptr — it'll delete us when ready
+        if (onClosed) onClosed();
+    }
+
+    std::function<void()> onClosed;
+
+    MoggMixerComponent* getMixer() { return mixer.get(); }
+
+private:
+    std::unique_ptr<MoggMixerComponent> mixer;
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(MoggMixerWindow)
+};
diff --git a/Source/OptionsView.cpp b/Source/OptionsView.cpp
index 762c26385..a189a0052 100644
--- a/Source/OptionsView.cpp
+++ b/Source/OptionsView.cpp
@@ -149,7 +149,40 @@ OptionsView::OptionsView(SonobusAudioProcessor& proc, std::function<AudioDeviceM
 
     mOptionsFormatChoiceStaticLabel = std::make_unique<Label>("", TRANS("Default Send Quality:"));
     configLabel(mOptionsFormatChoiceStaticLabel.get(), false);
-    mOptionsFormatChoiceStaticLabel->setJustificationType(Justification::centredRight);
+    mOptionsFormatChoiceStaticLabel->setJustificationType(Justification::centredLeft);
+    mOptionsFormatChoiceStaticLabel->setAccessible(false);
+
+    // MIDI Options
+    mMidiOptionsViewport = std::make_unique<Viewport>();
+    mMidiOptionsComponent = std::make_unique<Component>();
+
+    mMidiRelayDeviceLabel = std::make_unique<Label>("", TRANS("MIDI Relay Input Device:"));
+    configLabel(mMidiRelayDeviceLabel.get(), false);
+    mMidiRelayDeviceChoice = std::make_unique<SonoChoiceButton>();
+    mMidiRelayDeviceChoice->addChoiceListener(this);
+
+    mMidiLearnDeviceLabel = std::make_unique<Label>("", TRANS("MIDI Learn Input Device:"));
+    configLabel(mMidiLearnDeviceLabel.get(), false);
+    mMidiLearnDeviceChoice = std::make_unique<SonoChoiceButton>();
+    mMidiLearnDeviceChoice->addChoiceListener(this);
+
+    auto devices = MidiInput::getAvailableDevices();
+    mMidiRelayDeviceChoice->addItem(TRANS("None"), 0);
+    mMidiLearnDeviceChoice->addItem(TRANS("None"), 0);
+    int di = 1;
+    for (auto& d : devices) {
+        mMidiRelayDeviceChoice->addItem(d.name, di);
+        mMidiLearnDeviceChoice->addItem(d.name, di);
+        di++;
+    }
+
+    mMidiOptionsComponent->addAndMakeVisible(mMidiRelayDeviceLabel.get());
+    mMidiOptionsComponent->addAndMakeVisible(mMidiRelayDeviceChoice.get());
+    mMidiOptionsComponent->addAndMakeVisible(mMidiLearnDeviceLabel.get());
+    mMidiOptionsComponent->addAndMakeVisible(mMidiLearnDeviceChoice.get());
+
+    mMidiOptionsViewport->setScrollBarsShown(true, false);
+    mMidiOptionsViewport->setViewedComponent (mMidiOptionsComponent.get(), false);
 
 
     mOptionsLanguageChoice = std::make_unique<SonoChoiceButton>();
@@ -226,6 +259,7 @@ OptionsView::OptionsView(SonobusAudioProcessor& proc, std::function<AudioDeviceM
     mRecFormatChoice->addItem(TRANS("FLAC"), SonobusAudioProcessor::FileFormatFLAC);
     mRecFormatChoice->addItem(TRANS("WAV"), SonobusAudioProcessor::FileFormatWAV);
     mRecFormatChoice->addItem(TRANS("OGG"), SonobusAudioProcessor::FileFormatOGG);
+    mRecFormatChoice->addItem(TRANS("MOGG"), SonobusAudioProcessor::FileFormatMOGG);
 
     mRecBitsChoice = std::make_unique<SonoChoiceButton>();
     mRecBitsChoice->addChoiceListener(this);
@@ -500,6 +534,8 @@ OptionsView::OptionsView(SonobusAudioProcessor& proc, std::function<AudioDeviceM
     mRecordOptionsViewport->setViewedComponent(mRecOptionsComponent.get(), false);
 
     mSettingsTab->addTab(TRANS("RECORDING"),Colour::fromFloatRGBA(0.1, 0.1, 0.1, 1.0), mRecordOptionsViewport.get(), false);
+    mSettingsTab->addTab(TRANS("MIDI"), Colour::fromFloatRGBA(0.1, 0.1, 0.1, 1.0), mMidiOptionsViewport.get(), false);
+
 
     setFocusContainerType(FocusContainerType::keyboardFocusContainer);
 
@@ -599,6 +635,18 @@ void OptionsView::updateState(bool ignorecheck)
 
     mOptionsAutoDropThreshSlider->setValue(1 / jmax(0.001f, processor.getAutoresizeBufferDropRateThreshold()), dontSendNotification);
 
+    // MIDI state
+    auto devs = MidiInput::getAvailableDevices();
+    int relayIndex = 0;
+    int learnIndex = 0;
+    for (int i=0; i < devs.size(); ++i) {
+        if (devs[i].name == processor.getMidiRelayDevice()) relayIndex = i + 1;
+        if (devs[i].name == processor.getMidiLearnDevice()) learnIndex = i + 1;
+    }
+    mMidiRelayDeviceChoice->setSelectedItemIndex(relayIndex, dontSendNotification);
+    mMidiLearnDeviceChoice->setSelectedItemIndex(learnIndex, dontSendNotification);
+
+
     int port = processor.getUseSpecificUdpPort();
     if (port > 0) {
         mOptionsUdpPortEditor->setText(String::formatted("%d", port), dontSendNotification);
@@ -909,7 +957,24 @@ void OptionsView::updateLayout()
     optionsRecordFinishBox.items.add(FlexItem(minButtonWidth, minpassheight, *mOptionsRecFinishOpenButton).withMargin(0).withFlex(1));
 
 
+    midiRelayBox.items.clear();
+    midiRelayBox.flexDirection = FlexBox::Direction::row;
+    midiRelayBox.items.add(FlexItem(160, minitemheight, *mMidiRelayDeviceLabel).withMargin(2).withFlex(0));
+    midiRelayBox.items.add(FlexItem(minitemheight, minitemheight, *mMidiRelayDeviceChoice).withMargin(2).withFlex(1.0));
+
+    midiLearnBox.items.clear();
+    midiLearnBox.flexDirection = FlexBox::Direction::row;
+    midiLearnBox.items.add(FlexItem(160, minitemheight, *mMidiLearnDeviceLabel).withMargin(2).withFlex(0));
+    midiLearnBox.items.add(FlexItem(minitemheight, minitemheight, *mMidiLearnDeviceChoice).withMargin(2).withFlex(1.0));
+
+    midiOptionsBox.items.clear();
+    midiOptionsBox.flexDirection = FlexBox::Direction::column;
+    midiOptionsBox.items.add(FlexItem(100, minitemheight, midiRelayBox).withMargin(2).withFlex(0));
+    midiOptionsBox.items.add(FlexItem(100, minitemheight, midiLearnBox).withMargin(2).withFlex(0));
+
+
     recOptionsBox.items.clear();
+
     recOptionsBox.flexDirection = FlexBox::Direction::column;
     recOptionsBox.items.add(FlexItem(4, 6));
 //#if !(JUCE_IOS || JUCE_ANDROID)
@@ -952,11 +1017,14 @@ void OptionsView::resized()  {
     }
     mOptionsComponent->setBounds(Rectangle<int>(0,0,innerbounds.getWidth() - 10, minOptionsHeight));
     mRecOptionsComponent->setBounds(Rectangle<int>(0,0,innerbounds.getWidth() - 10, minRecOptionsHeight));
+    mMidiOptionsComponent->setBounds(Rectangle<int>(0,0,innerbounds.getWidth() - 10, 100));
 
 
 
     optionsBox.performLayout(mOptionsComponent->getLocalBounds());
     recOptionsBox.performLayout(mRecOptionsComponent->getLocalBounds());
+    midiOptionsBox.performLayout(mMidiOptionsComponent->getLocalBounds());
+
 
     mOptionsAutosizeStaticLabel->setBounds(mBufferTimeSlider->getBounds().removeFromLeft(mBufferTimeSlider->getWidth()*0.75));
 
@@ -1232,6 +1300,13 @@ void OptionsView::choiceButtonSelected(SonoChoiceButton *comp, int index, int id
     else if (comp == mRecBitsChoice.get()) {
         processor.setDefaultRecordingBitsPerSample(ident);
     }
+    else if (comp == mMidiRelayDeviceChoice.get()) {
+        processor.setMidiRelayDevice(ident == 0 ? "" : comp->getItemText(index));
+    }
+    else if (comp == mMidiLearnDeviceChoice.get()) {
+        processor.setMidiLearnDevice(ident == 0 ? "" : comp->getItemText(index));
+    }
+
     else if (comp == mOptionsLanguageChoice.get()) {
         String code = codes[ident];
         //app->mainConfig.languageOverrideCode =  codes[comp->getRowId()].toStdString();
diff --git a/Source/OptionsView.h b/Source/OptionsView.h
index 29bcbf05c..573ddfe78 100644
--- a/Source/OptionsView.h
+++ b/Source/OptionsView.h
@@ -103,10 +103,13 @@ public MultiTimer
     std::unique_ptr<Viewport> mAudioOptionsViewport;
     std::unique_ptr<Viewport> mOtherOptionsViewport;
     std::unique_ptr<Viewport> mRecordOptionsViewport;
+    std::unique_ptr<Viewport> mMidiOptionsViewport;
 
 
     std::unique_ptr<Component> mOptionsComponent;
     std::unique_ptr<Component> mRecOptionsComponent;
+    std::unique_ptr<Component> mMidiOptionsComponent;
+
 
     int minOptionsHeight = 0;
     int minRecOptionsHeight = 0;
@@ -150,6 +153,12 @@ public MultiTimer
     std::unique_ptr<Label> mOptionsLanguageLabel;
     std::unique_ptr<ToggleButton> mOptionsUnivFontButton;
 
+    std::unique_ptr<SonoChoiceButton> mMidiRelayDeviceChoice;
+    std::unique_ptr<SonoChoiceButton> mMidiLearnDeviceChoice;
+    std::unique_ptr<Label> mMidiRelayDeviceLabel;
+    std::unique_ptr<Label> mMidiLearnDeviceLabel;
+
+
 
     std::unique_ptr<Label> mOptionsRecFilesStaticLabel;
     std::unique_ptr<ToggleButton> mOptionsRecMixButton;
@@ -187,6 +196,11 @@ public MultiTimer
     FlexBox optionsAutoDropThreshBox;
     FlexBox optionsPluginDefaultBox;
 
+    FlexBox midiOptionsBox;
+    FlexBox midiRelayBox;
+    FlexBox midiLearnBox;
+
+
     FlexBox recOptionsBox;
     FlexBox optionsRecordFormatBox;
     FlexBox optionsRecMixBox;
diff --git a/Source/PeersContainerView.cpp b/Source/PeersContainerView.cpp
index d1023b9b0..698c043a0 100644
--- a/Source/PeersContainerView.cpp
+++ b/Source/PeersContainerView.cpp
@@ -163,8 +163,8 @@ void PeerViewInfo::resized()
     }
 }
 
-/// --------------------------------------------
-#pragma PendingPeerViewInfo
+// --------------------------------------------
+// PendingPeerViewInfo
 
 
 PendingPeerViewInfo::PendingPeerViewInfo()
@@ -431,9 +431,13 @@ PeerViewInfo * PeersContainerView::createPeerViewInfo()
     pvf->staticAddrLabel->setFont(13);
     
     
-    pvf->sendMutedButton = std::make_unique<ToggleButton>(TRANS("Disable Sending"));
+    pvf->sendMutedButton = std::make_unique<ToggleButton>(TRANS("Disable Sending Audio"));
     pvf->sendMutedButton->addListener(this);
 
+    pvf->midiRelayButton = std::make_unique<ToggleButton>(TRANS("Send MIDI"));
+    pvf->midiRelayButton->addListener(this);
+    pvf->midiRelayButton->setTooltip(TRANS("Enable relaying MIDI from your selected MIDI relay input to this user."));
+
     pvf->recvMutedButton = std::make_unique<TextButton>(TRANS("MUTE"));
     pvf->recvMutedButton->addListener(this);
     pvf->recvMutedButton->setLookAndFeel(&pvf->medLnf);
@@ -895,6 +899,7 @@ void PeersContainerView::rebuildPeerViews()
         pvf->sendOptionsContainer->addAndMakeVisible(pvf->changeAllFormatButton.get());
         pvf->sendOptionsContainer->addAndMakeVisible(pvf->staticFormatChoiceLabel.get());
         pvf->sendOptionsContainer->addAndMakeVisible(pvf->sendMutedButton.get());
+        pvf->sendOptionsContainer->addAndMakeVisible(pvf->midiRelayButton.get());
         pvf->sendOptionsContainer->addAndMakeVisible(pvf->optionsRemoveButton.get());
         pvf->sendOptionsContainer->addAndMakeVisible(pvf->optionsBlockButton.get());
 
@@ -982,10 +987,18 @@ void PeersContainerView::updatePeerOrdering()
 
     for (int i=0; i < processor.getNumberRemotePeers(); ++i) {
         String username = processor.getRemotePeerUserName(i);
+        // Use a more unique key to avoid same-name collisions during sorting
+        String uniqueKey = username + "_" + String(i);
+
+        auto found = mPeerPriorityOrdering.find(uniqueKey);
+        if (found == mPeerPriorityOrdering.end()) {
+             // also check by pure name for legacy/compatibility
+             found = mPeerPriorityOrdering.find(username);
+        }
 
-        auto found = mPeerPriorityOrdering.find(username);
         if (found != mPeerPriorityOrdering.end()) {
-            priorityIndexes[found->second] = i;
+            // Use index as tie-breaker if priorities same
+            priorityIndexes[(found->second << 16) | (i & 0xFFFF)] = i;
         }
     }
 
@@ -1195,6 +1208,11 @@ void PeersContainerView::updateLayout()
         pvf->optionsSendMutedBox.items.add(FlexItem(3, 12));
         pvf->optionsSendMutedBox.items.add(FlexItem(minSmallButtonWidth, minitemheight, *pvf->optionsBlockButton).withMargin(0).withFlex(0));
 
+        pvf->optionsMidiRelayBox.items.clear();
+        pvf->optionsMidiRelayBox.flexDirection = FlexBox::Direction::row;
+        pvf->optionsMidiRelayBox.items.add(FlexItem(5, 12));
+        pvf->optionsMidiRelayBox.items.add(FlexItem(100, minitemheight, *pvf->midiRelayButton).withMargin(0).withFlex(1));
+
         
         pvf->optionsChangeAllQualBox.items.clear();
         pvf->optionsChangeAllQualBox.flexDirection = FlexBox::Direction::row;
@@ -1234,6 +1252,8 @@ void PeersContainerView::updateLayout()
         pvf->sendOptionsBox.items.add(FlexItem(100, minitemheight-10,  pvf->optionsChangeAllQualBox).withMargin(2).withFlex(0));
         pvf->sendOptionsBox.items.add(FlexItem(4, 4));
         pvf->sendOptionsBox.items.add(FlexItem(100, minitemheight, pvf->optionsSendMutedBox).withMargin(0).withFlex(0));
+        pvf->sendOptionsBox.items.add(FlexItem(4, 4));
+        pvf->sendOptionsBox.items.add(FlexItem(100, minitemheight, pvf->optionsMidiRelayBox).withMargin(0).withFlex(0));
 
 
         pvf->recvbox.items.clear();
@@ -1753,6 +1773,8 @@ void PeersContainerView::updatePeerViews(int specific)
         pvf->changeAllFormatButton->setToggleState(processor.getChangingDefaultAudioCodecSetsExisting(), dontSendNotification);
 
         pvf->changeAllRecvFormatButton->setToggleState(processor.getChangingDefaultRecvAudioCodecSetsExisting(), dontSendNotification);
+        pvf->midiRelayButton->setToggleState(processor.getRemotePeerMidiRelay(i), dontSendNotification);
+        pvf->sendMutedButton->setToggleState(!processor.getRemotePeerSendAllow(i), dontSendNotification);
 
         pvf->sendActualBitrateLabel->setText(sendtext, dontSendNotification);
         pvf->recvActualBitrateLabel->setText(recvtext, dontSendNotification);
@@ -1854,7 +1876,13 @@ void PeersContainerView::updatePeerViews(int specific)
         
         if (pinfo.second.failed) {
             if (pinfo.second.blocked) {
-                ppvf->messageLabel->setText(TRANS("User BLOCKED from address: ") + pinfo.second.address, dontSendNotification);
+                String maskedAddr = pinfo.second.address;
+                StringArray parts;
+                parts.addTokens(maskedAddr, ".", "");
+                if (parts.size() == 4) {
+                    maskedAddr = parts[0] + "." + parts[1] + ".x.x";
+                }
+                ppvf->messageLabel->setText(TRANS("User BLOCKED from address: ") + maskedAddr, dontSendNotification);
                 ppvf->removeButton->setVisible(true);
                 ppvf->unblockButton->setVisible(true);
             }
@@ -2017,6 +2045,10 @@ void PeersContainerView::buttonClicked (Button* buttonThatWasClicked)
             }
             return;
         }
+        else if (pvf->midiRelayButton.get() == buttonThatWasClicked) {
+            processor.setRemotePeerMidiRelay(i, pvf->midiRelayButton->getToggleState());
+            return;
+        }
         else if (pvf->recvMutedButton.get() == buttonThatWasClicked) {
             if (!connected && !isGroupPeer) {
                 String hostname;
@@ -2271,7 +2303,7 @@ void PeersContainerView::showSendOptions(int dindex, bool flag, Component * from
 #if JUCE_IOS || JUCE_ANDROID
         const int defHeight = 144;
 #else
-        const int defHeight = 116;
+        const int defHeight = 144;
 #endif
         
         
diff --git a/Source/PeersContainerView.h b/Source/PeersContainerView.h
index fde8c8356..668d15789 100644
--- a/Source/PeersContainerView.h
+++ b/Source/PeersContainerView.h
@@ -40,6 +40,7 @@ class PeerViewInfo : public Component{
     std::unique_ptr<TextEditor> addrLabel;
     std::unique_ptr<Label> staticAddrLabel;
     std::unique_ptr<ToggleButton> sendMutedButton;
+    std::unique_ptr<ToggleButton> midiRelayButton;
     std::unique_ptr<TextButton> recvMutedButton;
     std::unique_ptr<TextButton> recvSoloButton;
     std::unique_ptr<SonoDrawableButton> latActiveButton;
@@ -132,6 +133,7 @@ class PeerViewInfo : public Component{
     FlexBox optionsSendQualBox;
     FlexBox optionsChangeAllQualBox;
     FlexBox optionsSendMutedBox;
+    FlexBox optionsMidiRelayBox;
     
     
     FlexBox effectsBox;
diff --git a/Source/SonoLookAndFeel.cpp b/Source/SonoLookAndFeel.cpp
index a8b36018a..bd6d158a8 100644
--- a/Source/SonoLookAndFeel.cpp
+++ b/Source/SonoLookAndFeel.cpp
@@ -1046,26 +1046,30 @@ void SonoLookAndFeel::drawRotarySlider (Graphics& g, int x, int y, int width, in
     
     if (slider.isEnabled())
     {
-        Path valueArc;
-        valueArc.addCentredArc (bounds.getCentreX(),
-                                bounds.getCentreY(),
-                                arcRadius,
-                                arcRadius,
-                                0.0f,
-                                rotStartAngle,
-                                toAngle,
-                                true);
+        // Draw proper knob body
+        g.setColour (outline.darker (0.2f));
+        g.fillEllipse (bounds.getCentreX() - arcRadius, bounds.getCentreY() - arcRadius, arcRadius * 2, arcRadius * 2);
         
-        g.setColour (fill);
-        g.strokePath (valueArc, PathStrokeType (lineW, PathStrokeType::curved, PathStrokeType::rounded));
+        // Draw indicator pointer
+        Path p;
+        p.addRoundedRectangle (-lineW * 0.4f, -arcRadius, lineW * 0.8f, arcRadius * 0.6f, 1.0f);
+        
+        auto pointerColor = fill;
+        if (slider.getName().containsIgnoreCase("monitor") || slider.getName().containsIgnoreCase("mon"))
+             pointerColor = Colour (0xffff9900);
+             
+        g.setColour (pointerColor);
+        g.fillPath (p, AffineTransform::rotation (toAngle).translated (bounds.getCentre()));
     }
+
     
-    const auto thumbWidth = lineW ; // * 1.5f;
-    const Point<float> thumbPoint (bounds.getCentreX() + arcRadius * std::cos (toAngle - MathConstants<float>::pi * 0.5f),
-                                   bounds.getCentreY() + arcRadius * std::sin (toAngle - MathConstants<float>::pi * 0.5f));
+    // remove the old thumb "dot" since we have a pointer now
+    //const auto thumbWidth = lineW ; // * 1.5f;
+    //const Point<float> thumbPoint (bounds.getCentreX() + arcRadius * std::cos (toAngle - MathConstants<float>::pi * 0.5f),
+    //                               bounds.getCentreY() + arcRadius * std::sin (toAngle - MathConstants<float>::pi * 0.5f));
     
-    g.setColour (findColour (Slider::thumbColourId));
-    g.fillEllipse (Rectangle<float> (thumbWidth, thumbWidth).withCentre (thumbPoint));
+    //g.setColour (findColour (Slider::thumbColourId));
+    //g.fillEllipse (Rectangle<float> (thumbWidth, thumbWidth).withCentre (thumbPoint));
 }
 
 //==============================================================================
@@ -1252,9 +1256,19 @@ void SonoLookAndFeel::drawLinearSlider (Graphics& g, int x, int y, int width, in
         
         if (! isTwoVal)
         {
-            g.setColour (slider.findColour (Slider::thumbColourId));
-            g.fillEllipse (Rectangle<float> (static_cast<float> (thumbWidth), static_cast<float> (thumbWidth)).withCentre (isThreeVal ? thumbPoint : maxPoint));
+            auto thumbColor = slider.findColour (Slider::thumbColourId);
+            if (slider.getName().containsIgnoreCase("monitor") || slider.getName().containsIgnoreCase("mon"))
+                thumbColor = Colour (0xffff9900);
+            
+            g.setColour (thumbColor);
+            
+            // Use a rectangular fader button instead of a dot
+            float fw = thumbWidth * 2.0f;
+            float fh = thumbWidth * 0.8f;
+            if (slider.isVertical()) std::swap(fw, fh);
+            g.fillRoundedRectangle (Rectangle<float> (fw, fh).withCentre (isThreeVal ? thumbPoint : maxPoint), 2.0f);
         }
+
         
         if (isTwoVal || isThreeVal)
         {
diff --git a/Source/SonoSlider.h b/Source/SonoSlider.h
new file mode 100644
index 000000000..9a99ffec6
--- /dev/null
+++ b/Source/SonoSlider.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include "JuceHeader.h"
+
+class SonoSlider : public Slider
+{
+public:
+    SonoSlider(const String& name = String()) : Slider(name) {}
+    SonoSlider(SliderStyle style, TextEntryBoxPosition textBoxPos) : Slider(style, textBoxPos) {}
+    
+    void mouseDown(const MouseEvent& event) override {
+        if (event.mods.isRightButtonDown()) {
+            // Ignore right-click to reserve it for MIDI Learn
+        } else {
+            Slider::mouseDown(event);
+        }
+    }
+    
+    void mouseDrag(const MouseEvent& event) override {
+        if (event.mods.isRightButtonDown()) {
+            // Ignore right-click drag
+        } else {
+            Slider::mouseDrag(event);
+        }
+    }
+
+    void mouseUp(const MouseEvent& event) override {
+        if (event.mods.isRightButtonDown()) {
+            // Ignore right-click up
+        } else {
+            Slider::mouseUp(event);
+        }
+    }
+};
diff --git a/Source/SonobusPluginEditor.cpp b/Source/SonobusPluginEditor.cpp
index e4c60bbbc..4368ca6e3 100644
--- a/Source/SonobusPluginEditor.cpp
+++ b/Source/SonobusPluginEditor.cpp
@@ -423,7 +423,8 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
     mPeerLayoutMinimalButton->setRadioGroupId(PeerLayoutRadioGroupId);
 
 
-    mInGainSlider     = std::make_unique<Slider>(Slider::LinearHorizontal,  Slider::TextBoxAbove);
+    mInGainSlider     = std::make_unique<SonoSlider>(Slider::LinearHorizontal,  Slider::TextBoxAbove);
+
     mInGainSlider->setName("ingain");
     mInGainSlider->setTitle(TRANS("In Level"));
     mInGainSlider->setSliderSnapsToMousePosition(processor.getSlidersSnapToMousePosition());
@@ -539,6 +540,7 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
     std::unique_ptr<Drawable> metimg(Drawable::createFromImageData(BinaryData::met_svg, BinaryData::met_svgSize));
     mMetEnableButton->setImages(metimg.get(), nullptr, nullptr, nullptr, nullptr);
     mMetEnableButton->addListener(this);
+    mMetEnableButton->addMouseListener(this, false);
     mMetEnableButton->setClickingTogglesState(true);
     mMetEnableButton->setColour(TextButton::buttonOnColourId, Colour::fromFloatRGBA(0.2, 0.2, 0.2, 0.7));
     mMetEnableButton->setColour(TextButton::buttonColourId, Colours::transparentBlack);
@@ -556,7 +558,8 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
     mMetConfigButton->setTooltip(metoptstr);
     mMetConfigButton->setTitle(metoptstr);
 
-    mMetTempoSlider     = std::make_unique<Slider>(Slider::RotaryHorizontalVerticalDrag,  Slider::TextBoxAbove);
+    mMetTempoSlider     = std::make_unique<SonoSlider>(Slider::RotaryHorizontalVerticalDrag,  Slider::TextBoxAbove);
+
     mMetTempoSlider->setName("mettempo");
     mMetTempoSlider->setTitle(TRANS("Tempo"));
     mMetTempoSlider->setSliderSnapsToMousePosition(false);
@@ -567,7 +570,8 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
     mMetTempoSlider->setWantsKeyboardFocus(true);
 
     
-    mMetLevelSlider     = std::make_unique<Slider>(Slider::RotaryHorizontalVerticalDrag,  Slider::NoTextBox);
+    mMetLevelSlider     = std::make_unique<SonoSlider>(Slider::RotaryHorizontalVerticalDrag,  Slider::NoTextBox);
+
     mMetLevelSlider->setName("metvol");
     mMetLevelSlider->setTitle(TRANS("Metronome Level"));
     mMetLevelSlider->setSliderSnapsToMousePosition(false);
@@ -618,13 +622,16 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
     mMetSyncFileButton->setTooltip(TRANS("Synchronize metronome start with file playback"));
 
     
-    mDrySlider     = std::make_unique<Slider>(Slider::LinearHorizontal,  Slider::TextBoxAbove);
-    mDrySlider->setName("dry");
+    mDrySlider     = std::make_unique<SonoSlider>(Slider::LinearHorizontal,  Slider::TextBoxAbove);
+
+    mDrySlider->setName("monitor_level");
+
     mDrySlider->setTitle(TRANS("Monitor"));
     mDrySlider->setSliderSnapsToMousePosition(processor.getSlidersSnapToMousePosition());
     mDrySlider->setScrollWheelEnabled(false);
 
-    mOutGainSlider     = std::make_unique<Slider>(Slider::LinearHorizontal,  Slider::TextBoxRight);
+    mOutGainSlider     = std::make_unique<SonoSlider>(Slider::LinearHorizontal,  Slider::TextBoxRight);
+
     mOutGainSlider->setName("wet");
     mOutGainSlider->setTitle(TRANS("Out Level"));
     mOutGainSlider->setSliderSnapsToMousePosition(processor.getSlidersSnapToMousePosition());
@@ -632,6 +639,7 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
 
     configLevelSlider(mInGainSlider.get());
     configLevelSlider(mDrySlider.get());
+    mDrySlider->setColour(Slider::thumbColourId, Colour::fromFloatRGBA(0.9f, 0.4f, 0.1f, 1.0f));
     configLevelSlider(mOutGainSlider.get());
 
     mOutGainSlider->setTextBoxIsEditable(true);
@@ -810,9 +818,9 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
     mMainContainer->addChildComponent(mInputChannelsContainer.get());
     mInputChannelsContainer->addListener(this);
 
-    //mInputChannelsViewport = std::make_unique<Viewport>();
-    //mInputChannelsViewport->setViewedComponent(mInputChannelsContainer.get(), false);
-    //mMainContainer->addChildComponent(mInputChannelsViewport.get());
+    mInputChannelsViewport = std::make_unique<Viewport>();
+    mInputChannelsViewport->setViewedComponent(mInputChannelsContainer.get(), false);
+    mMainContainer->addAndMakeVisible(mInputChannelsViewport.get());
 
     mChatView = std::make_unique<ChatView>(processor, currConnectionInfo);
     mChatView->setVisible(false);
@@ -899,6 +907,7 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
     std::unique_ptr<Drawable> backimg(Drawable::createFromImageData(BinaryData::reset_buffer_icon_svg, BinaryData::reset_buffer_icon_svgSize));
     mBufferMinButton->setImages(backimg.get());
     mBufferMinButton->addListener(this);
+    mBufferMinButton->addMouseListener(this, false);
     mBufferMinButton->setTooltip(TRANS("Resets jitter buffer to the minimum for all."));
     mBufferMinButton->setTitle(TRANS("Reset All Jitter Buffers"));
     mBufferMinButton->setAlpha(0.8f);
@@ -964,6 +973,7 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
     mReverbEnabledButton->setColour(DrawableButton::backgroundColourId, Colours::transparentBlack);
     mReverbEnabledButton->setColour(DrawableButton::backgroundOnColourId, Colours::transparentBlack);    
     mReverbEnabledButton->addListener(this);
+    mReverbEnabledButton->addMouseListener(this, false);
     mReverbEnabledButton->setTitle(TRANS("Reverb Enabled"));
     mReverbEnableAttachment = std::make_unique<AudioProcessorValueTreeState::ButtonAttachment> (p.getValueTreeState(), SonobusAudioProcessor::paramMainReverbEnabled, *mReverbEnabledButton);
 
@@ -977,7 +987,8 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
     mReverbModelChoice->addItem(TRANS("Zita"), SonobusAudioProcessor::ReverbModelZita);
 
     
-    mReverbSizeSlider     = std::make_unique<Slider>(Slider::RotaryHorizontalVerticalDrag,  Slider::NoTextBox);
+    mReverbSizeSlider     = std::make_unique<SonoSlider>(Slider::RotaryHorizontalVerticalDrag,  Slider::NoTextBox);
+
     mReverbSizeSlider->setName("revsize");
     mReverbSizeSlider->setTitle(TRANS("Size"));
     mReverbSizeSlider->setSliderSnapsToMousePosition(false);
@@ -989,7 +1000,8 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
 
     mReverbSizeAttachment = std::make_unique<AudioProcessorValueTreeState::SliderAttachment> (p.getValueTreeState(), SonobusAudioProcessor::paramMainReverbSize, *mReverbSizeSlider);
 
-    mReverbLevelSlider     = std::make_unique<Slider>(Slider::RotaryHorizontalVerticalDrag,  Slider::NoTextBox);
+    mReverbLevelSlider     = std::make_unique<SonoSlider>(Slider::RotaryHorizontalVerticalDrag,  Slider::NoTextBox);
+
     mReverbLevelSlider->setName("revlevel");
     mReverbLevelSlider->setTitle(TRANS("Level"));
     mReverbLevelSlider->setSliderSnapsToMousePosition(false);
@@ -1001,7 +1013,8 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
 
     mReverbLevelAttachment = std::make_unique<AudioProcessorValueTreeState::SliderAttachment> (p.getValueTreeState(), SonobusAudioProcessor::paramMainReverbLevel, *mReverbLevelSlider);
 
-    mReverbDampingSlider     = std::make_unique<Slider>(Slider::RotaryHorizontalVerticalDrag,  Slider::NoTextBox);
+    mReverbDampingSlider     = std::make_unique<SonoSlider>(Slider::RotaryHorizontalVerticalDrag,  Slider::NoTextBox);
+
     mReverbDampingSlider->setName("revdamp");
     mReverbDampingSlider->setTitle(TRANS("Damping"));
     mReverbDampingSlider->setSliderSnapsToMousePosition(false);
@@ -1013,7 +1026,8 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
 
     mReverbDampingAttachment = std::make_unique<AudioProcessorValueTreeState::SliderAttachment> (p.getValueTreeState(), SonobusAudioProcessor::paramMainReverbDamping, *mReverbDampingSlider);
 
-    mReverbPreDelaySlider     = std::make_unique<Slider>(Slider::RotaryHorizontalVerticalDrag,  Slider::NoTextBox);
+    mReverbPreDelaySlider     = std::make_unique<SonoSlider>(Slider::RotaryHorizontalVerticalDrag,  Slider::NoTextBox);
+
     mReverbPreDelaySlider->setName("revpredel");
     mReverbPreDelaySlider->setTitle(TRANS("Pre-Delay"));
     mReverbPreDelaySlider->setSliderSnapsToMousePosition(false);
@@ -1039,6 +1053,7 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
         std::unique_ptr<Drawable> recselimg(Drawable::createFromImageData(BinaryData::record_active_alt_svg, BinaryData::record_active_alt_svgSize));
         mRecordingButton->setImages(recimg.get(), nullptr, nullptr, nullptr, recselimg.get());
         mRecordingButton->addListener(this);
+        mRecordingButton->addMouseListener(this, false);
         mRecordingButton->setColour(DrawableButton::backgroundOnColourId, Colours::transparentBlack);
         mRecordingButton->setTooltip(TRANS("Start/Stop recording audio to file"));
         mRecordingButton->setTitle(TRANS("Record"));
@@ -1064,6 +1079,7 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
         mPlayButton->setImages(playimg.get(), nullptr, nullptr, nullptr, pauseimg.get());
         mPlayButton->setClickingTogglesState(true);
         mPlayButton->addListener(this);
+        mPlayButton->addMouseListener(this, false);
         mPlayButton->setColour(DrawableButton::backgroundOnColourId, Colours::transparentBlack);
         mPlayButton->setColour(DrawableButton::backgroundColourId, Colours::transparentBlack);
         mPlayButton->setTitle(TRANS("Play"));
@@ -1083,6 +1099,7 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
         mLoopButton->setImages(loopimg.get(), nullptr, nullptr, nullptr, nullptr);
         mLoopButton->setClickingTogglesState(true);
         mLoopButton->addListener(this);
+        mLoopButton->addMouseListener(this, false);
         mLoopButton->setColour(DrawableButton::backgroundOnColourId, Colour::fromFloatRGBA(0.6, 0.3, 0.6, 0.5));
         mLoopButton->setColour(DrawableButton::backgroundColourId, Colours::transparentBlack);
         mLoopButton->setTooltip(TRANS("Toggle loop range"));
@@ -1099,7 +1116,8 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
         mWaveformThumbnail->addChangeListener (this);
         mWaveformThumbnail->setFollowsTransport(false);
         
-        mPlaybackSlider     = std::make_unique<Slider>(Slider::RotaryHorizontalVerticalDrag,  Slider::TextBoxRight);
+        mPlaybackSlider     = std::make_unique<SonoSlider>(Slider::RotaryHorizontalVerticalDrag,  Slider::TextBoxRight);
+
         mPlaybackSlider->setRange(0.0, 2.0, 0.0);
         mPlaybackSlider->setSkewFactor(0.5);
         mPlaybackSlider->setName("plevel");
@@ -1109,12 +1127,13 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
         mPlaybackSlider->setTextBoxIsEditable(false);
         mPlaybackSlider->setScrollWheelEnabled(false);
         configKnobSlider(mPlaybackSlider.get());
+        mPlaybackSlider->setColour(Slider::thumbColourId, Colour::fromFloatRGBA(0.9f, 0.4f, 0.1f, 1.0f));
         mPlaybackSlider->setMouseDragSensitivity(80);
         mPlaybackSlider->setTextBoxStyle(Slider::NoTextBox, true, 60, 14);
         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(0, mPlaybackSlider->getValue()); };
         mPlaybackSlider->setWantsKeyboardFocus(true);
 
         mFileSendAudioButton = std::make_unique<SonoDrawableButton>("sendmute", DrawableButton::ButtonStyle::ImageFitted);
@@ -1140,6 +1159,18 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
         mFileMenuButton->setTooltip(filemenstr);
         mFileMenuButton->setTitle(filemenstr);
 
+        // Mogg stem mixer button
+        mMoggMixerButton = std::make_unique<SonoDrawableButton>("moggmix", DrawableButton::ButtonStyle::ImageOnButtonBackground);
+        std::unique_ptr<Drawable> mixerimg(Drawable::createFromImageData(BinaryData::dots_svg, BinaryData::dots_svgSize));
+        mMoggMixerButton->setImages(mixerimg.get(), nullptr, nullptr, nullptr, nullptr);
+        mMoggMixerButton->setClickingTogglesState(true);
+        mMoggMixerButton->setColour(DrawableButton::backgroundOnColourId, Colour::fromFloatRGBA(0.2f, 0.5f, 0.9f, 0.7f));
+        mMoggMixerButton->setColour(DrawableButton::backgroundColourId,    Colours::transparentBlack);
+        mMoggMixerButton->setTooltip(TRANS("Open MOGG Stem Mixer"));
+        mMoggMixerButton->setTitle(TRANS("MOGG"));
+        mMoggMixerButton->addListener(this);
+        mMoggMixerButton->setVisible(false);
+
         
     }
     
@@ -1242,6 +1273,7 @@ SonobusAudioProcessorEditor::SonobusAudioProcessorEditor (SonobusAudioProcessor&
         mTopLevelContainer->addChildComponent(mPlaybackSlider.get());
         mTopLevelContainer->addChildComponent(mFileSendAudioButton.get());
         mTopLevelContainer->addChildComponent(mFileMenuButton.get());
+        mTopLevelContainer->addChildComponent(mMoggMixerButton.get());
     }
 
 
@@ -1542,7 +1574,9 @@ void SonobusAudioProcessorEditor::configKnobSlider(Slider * slider)
     slider->setSliderStyle(Slider::SliderStyle::RotaryHorizontalVerticalDrag);
     slider->setTextBoxStyle(Slider::TextBoxAbove, true, 60, 14);
     slider->setMouseDragSensitivity(128);
-    slider->setScrollWheelEnabled(false);
+    slider->setScrollWheelEnabled(true);
+    slider->addMouseListener(this, false);
+
     //slider->setPopupDisplayEnabled(true, false, this);
     slider->setColour(Slider::textBoxBackgroundColourId, Colours::transparentBlack);
     slider->setColour(Slider::textBoxOutlineColourId, Colours::transparentBlack);
@@ -1560,7 +1594,9 @@ void SonobusAudioProcessorEditor::configLevelSlider(Slider * slider)
     slider->setSliderStyle(Slider::SliderStyle::LinearHorizontal);
     slider->setTextBoxStyle(Slider::TextBoxAbove, true, 50, 14);
     slider->setMouseDragSensitivity(128);
-    slider->setScrollWheelEnabled(false);
+    slider->setScrollWheelEnabled(true);
+    slider->addMouseListener(this, false);
+
     //slider->setPopupDisplayEnabled(true, false, this);
     slider->setColour(Slider::textBoxBackgroundColourId, Colours::transparentBlack);
     slider->setColour(Slider::textBoxOutlineColourId, Colours::transparentBlack);
@@ -1827,6 +1863,7 @@ void SonobusAudioProcessorEditor::updateOptionsState(bool ignorecheck)
 void SonobusAudioProcessorEditor::updateTransportState()
 {
     if (mPlayButton) {
+        bool isMultitrack = processor.getFilePlaybackGroupCount() > 1;
         if (!mCurrentAudioFile.isEmpty()) {
 
             mPlayButton->setVisible(true);
@@ -1838,6 +1875,14 @@ void SonobusAudioProcessorEditor::updateTransportState()
             mFileSendAudioButton->setVisible(true);
             mFileMenuButton->setVisible(true);
             mFileAreaBg->setVisible(true);
+            mMoggMixerButton->setVisible(isMultitrack);
+
+            // Rebuild mixer if stem count changed
+            if (mMoggMixerWindow && mMoggMixerWindow->isVisible()) {
+                if (mMoggMixerWindow->getMixer()) {
+                    mMoggMixerWindow->getMixer()->rebuild();
+                }
+            }
         } else {
             mPlayButton->setVisible(false);
             mLoopButton->setVisible(false);
@@ -1848,11 +1893,17 @@ void SonobusAudioProcessorEditor::updateTransportState()
             mFileSendAudioButton->setVisible(false);
             mFileMenuButton->setVisible(false);
             mFileAreaBg->setVisible(false);
+            mMoggMixerButton->setVisible(false);
+            // Close mixer if open and it's THE LOCAL ONE
+            if (mMoggMixerWindow && mMoggMixerWindow->getMixer() && mMoggMixerWindow->getMixer()->getRemotePeerIndex() == -1) {
+                mMoggMixerWindow->setVisible(false);
+                mMoggMixerWindow.reset();
+            }
         }
 
         mPlayButton->setToggleState(processor.getTransportSource().isPlaying(), dontSendNotification);
 
-        mPlaybackSlider->setValue(processor.getFilePlaybackGain(), dontSendNotification);
+        mPlaybackSlider->setValue(processor.getFilePlaybackGain(0), dontSendNotification);
         
     }
 }
@@ -2401,6 +2452,22 @@ void SonobusAudioProcessorEditor::buttonClicked (Button* buttonThatWasClicked)
         // show file extra menu
         showFilePopupMenu(mFileMenuButton.get());
     }
+    else if (buttonThatWasClicked == mMoggMixerButton.get()) {
+        bool wantOpen = mMoggMixerButton->getToggleState();
+        if (wantOpen) {
+            showMoggMixer(-1);
+            if (mMoggMixerWindow) {
+                mMoggMixerWindow->onClosed = [this] {
+                    mMoggMixerButton->setToggleState(false, dontSendNotification);
+                    mMoggMixerWindow.reset();
+                };
+            }
+        } else {
+            if (mMoggMixerWindow) {
+                mMoggMixerWindow.reset();
+            }
+        }
+    }
 
     
     else {
@@ -2507,9 +2574,9 @@ void SonobusAudioProcessorEditor::openFileBrowser()
     mFileChooser.reset(new FileChooser(TRANS("Choose an audio file to open..."),
                                        mCurrOpenDir,
 #if (JUCE_IOS || JUCE_MAC)
-                                       "*.wav;*.flac;*.aif;*.ogg;*.mp3;*.m4a;*.caf",
+                                       "*.wav;*.flac;*.aif;*.ogg;*.mp3;*.m4a;*.caf;*.mogg;*.m0gg",
 #else
-                                       "*.wav;*.flac;*.aif;*.ogg;*.mp3",
+                                       "*.wav;*.flac;*.aif;*.ogg;*.mp3;*.mogg;*.m0gg",
 #endif
                                        true, false, getTopLevelComponent()));
     
@@ -3204,6 +3271,28 @@ void SonobusAudioProcessorEditor::showConnectPopup(bool flag)
     }
 }
 
+void SonobusAudioProcessorEditor::showMoggMixer(int peerIndex)
+{
+    // If the window is already open for this specific peer, just bring it to front
+    if (mMoggMixerWindow != nullptr && mMoggMixerWindow->getMixer() && mMoggMixerWindow->getMixer()->getRemotePeerIndex() == peerIndex) {
+        mMoggMixerWindow->toFront(true);
+        return;
+    }
+
+    // Close existing window if any (Sonobus current design handles one mixer window at a time)
+    if (mMoggMixerWindow != nullptr) {
+        mMoggMixerWindow.reset();
+    }
+
+    Component* centreRel = (peerIndex == -1) ? (Component*)mMoggMixerButton.get() : (Component*)this;
+    mMoggMixerWindow = std::make_unique<MoggMixerWindow>(processor, centreRel, peerIndex);
+    
+    // Set callback to reset pointer when window is closed via the close button
+    mMoggMixerWindow->onClosed = [this]() {
+        mMoggMixerWindow.reset();
+    };
+}
+
 
 void SonobusAudioProcessorEditor::sliderValueChanged (Slider* slider)
 {
@@ -3211,7 +3300,30 @@ void SonobusAudioProcessorEditor::sliderValueChanged (Slider* slider)
 
 void SonobusAudioProcessorEditor::mouseDown (const MouseEvent& event) 
 {
-    
+    if (event.mods.isRightButtonDown()) {
+        auto* comp = event.eventComponent;
+        SonobusAudioProcessor::MidiTargetType type = SonobusAudioProcessor::MidiTarget_None;
+        int data = 0;
+
+        if (comp == mInGainSlider.get()) type = SonobusAudioProcessor::MidiTarget_InputGain;
+        else if (comp == mOutGainSlider.get()) type = SonobusAudioProcessor::MidiTarget_OutputGain;
+        else if (comp == mDrySlider.get()) type = SonobusAudioProcessor::MidiTarget_MonitorLevel;
+        else if (comp == mMetLevelSlider.get()) type = SonobusAudioProcessor::MidiTarget_MetronomeLevel;
+        else if (comp == mInMuteButton.get()) type = SonobusAudioProcessor::MidiTarget_InputMute;
+        else if (comp == mReverbLevelSlider.get()) type = SonobusAudioProcessor::MidiTarget_FXLevel;
+        else if (comp == mPlayButton.get()) type = SonobusAudioProcessor::MidiTarget_TransportPlay;
+        else if (comp == mRecordingButton.get()) type = SonobusAudioProcessor::MidiTarget_TransportRecord;
+        else if (comp == mLoopButton.get()) type = SonobusAudioProcessor::MidiTarget_TransportLoop;
+        else if (comp == mMetEnableButton.get()) type = SonobusAudioProcessor::MidiTarget_TransportMetronome;
+        else if (comp == mBufferMinButton.get()) type = SonobusAudioProcessor::MidiTarget_ResetAllJitters;
+        else if (comp == mReverbEnabledButton.get()) type = SonobusAudioProcessor::MidiTarget_FXEnable;
+
+        if (type != SonobusAudioProcessor::MidiTarget_None) {
+            showMidiMenu(comp, type, data);
+            return;
+        }
+    }
+
     if (event.eventComponent == mSettingsButton.get()) {
         settingsWasShownOnDown = settingsCalloutBox != nullptr || (Time::getMillisecondCounter() < settingsClosedTimestamp + 500);
 
@@ -4533,6 +4645,20 @@ void SonobusAudioProcessorEditor::resized()
                                            inmixminbounds.getHeight() + 5);
 
         mInputChannelsContainer->setBounds(inmixactualbounds);
+
+        // Limit the viewport height so it doesn't take over the whole screen if there are many tracks
+        int maxMixerHeight = jmin(inmixactualbounds.getHeight(), mMainViewport->getHeight() / 2);
+        if (processor.getFilePlaybackGroupCount() > 1) {
+            // If we have MOGG stems, give it a bit more space if available, but keep it constrained
+            maxMixerHeight = jmin(inmixactualbounds.getHeight(), (int)(mMainViewport->getHeight() * 0.6f));
+        }
+
+        mInputChannelsViewport->setBounds(Rectangle<int>(0, 0, inchantargwidth + 10, maxMixerHeight));
+        mInputChannelsViewport->setVisible(true);
+        inmixactualbounds.setHeight(maxMixerHeight);
+    }
+    else {
+        mInputChannelsViewport->setVisible(false);
     }
 
     int vgap = inmixactualbounds.getHeight() > 0 ?  6 : 0;
@@ -5012,6 +5138,9 @@ void SonobusAudioProcessorEditor::updateLayout()
             
         transportBox.items.add(FlexItem(minKnobWidth, minitemheight, *mPlaybackSlider).withMargin(0).withFlex(0));
         transportBox.items.add(FlexItem(3, 6).withMargin(0).withFlex(0));
+        if (mMoggMixerButton->isVisible())
+            transportBox.items.add(FlexItem(mintoolwidth, minitemheight, *mMoggMixerButton).withMargin(0).withFlex(1).withMaxWidth(toolwidth));
+        transportBox.items.add(FlexItem(3, 6).withMargin(0).withFlex(0));
         transportBox.items.add(FlexItem(mintoolwidth, minitemheight, *mFileSendAudioButton).withMargin(0).withFlex(1).withMaxWidth(toolwidth));
         transportBox.items.add(FlexItem(3, 6).withMargin(0).withFlex(0));
         transportBox.items.add(FlexItem(mintoolwidth, minitemheight, *mDismissTransportButton).withMargin(0).withFlex(1).withMaxWidth(toolwidth));
@@ -6041,3 +6170,61 @@ void SonobusAudioProcessorEditor::SonobusMenuBarModel::menuItemSelected (int men
 #endif
 }
 
+
+void SonobusAudioProcessorEditor::showMidiMenu(Component* source,
+                                               SonobusAudioProcessor::MidiTargetType type,
+                                               int data)
+{
+    using MidiTargetType = SonobusAudioProcessor::MidiTargetType;
+
+    int ccNum = -1, midiCh = 0;
+    bool hasMapped = processor.getMidiMapping(type, data, ccNum, midiCh);
+
+    String controlName;
+    switch (type) {
+        case MidiTargetType::MidiTarget_InputGain: controlName = TRANS("In Level"); break;
+        case MidiTargetType::MidiTarget_OutputGain: controlName = TRANS("Out Level"); break;
+        case MidiTargetType::MidiTarget_MonitorLevel: controlName = TRANS("Monitor Level"); break;
+        case MidiTargetType::MidiTarget_MetronomeLevel: controlName = TRANS("Metronome Level"); break;
+        case MidiTargetType::MidiTarget_SoundboardLevel: controlName = TRANS("Soundboard Level"); break;
+        case MidiTargetType::MidiTarget_InputMute: controlName = TRANS("In Mute"); break;
+        case MidiTargetType::MidiTarget_FXLevel: controlName = TRANS("FX Level"); break;
+        case MidiTargetType::MidiTarget_FXEnable: controlName = TRANS("FX Monitor"); break;
+        case MidiTargetType::MidiTarget_FullMixMonitorLevel: controlName = TRANS("Full Mix Monitor"); break;
+        case MidiTargetType::MidiTarget_TransportPlay: controlName = TRANS("Play"); break;
+        case MidiTargetType::MidiTarget_TransportRecord: controlName = TRANS("Record"); break;
+        case MidiTargetType::MidiTarget_TransportLoop: controlName = TRANS("Loop"); break;
+        case MidiTargetType::MidiTarget_TransportMetronome: controlName = TRANS("Metronome Toggle"); break;
+        case MidiTargetType::MidiTarget_ResetAllJitters: controlName = TRANS("Reset Jitters"); break;
+        default: controlName = TRANS("Control"); break;
+
+    }
+
+    PopupMenu m;
+    if (processor.isMidiLearning() &&
+        processor.getMidiLearnTargetType() == type &&
+        processor.getMidiLearnTargetData() == data) {
+        m.addItem(1, String(TRANS("Cancel MIDI Learn")), true, false);
+    } else {
+        m.addItem(1, String(TRANS("MIDI Learn: ")) + controlName, true, false);
+    }
+
+    String forgetText = TRANS("MIDI Forget");
+    if (hasMapped) forgetText += " (CC " + String(ccNum) + ", Ch " + String(midiCh) + ")";
+    m.addItem(2, forgetText, hasMapped, false);
+
+    m.showMenuAsync(PopupMenu::Options().withMousePosition(),
+        [this, type, data, hasMapped](int result) {
+            if (result == 1) {
+                if (processor.isMidiLearning()) {
+                    processor.stopMidiLearn();
+                } else {
+                    processor.startMidiLearn(type, data);
+                }
+            } else if (result == 2 && hasMapped) {
+                processor.clearMidiMapping(type, data);
+            }
+        });
+
+}
+
diff --git a/Source/SonobusPluginEditor.h b/Source/SonobusPluginEditor.h
index 36c8d0456..23ebed64f 100644
--- a/Source/SonobusPluginEditor.h
+++ b/Source/SonobusPluginEditor.h
@@ -9,6 +9,8 @@
 
 #include "SonobusPluginProcessor.h"
 #include "SonoLookAndFeel.h"
+#include "SonoSlider.h"
+
 #include "SonoChoiceButton.h"
 #include "SonoDrawableButton.h"
 #include "SonoTextButton.h"
@@ -24,6 +26,7 @@
 #include "OptionsView.h"
 #include "ReverbView.h"
 #include "VDONinjaView.h"
+#include "MoggMixerView.h"
 
 class RandomSentenceGenerator;
 class WaveformTransportComponent;
@@ -178,6 +181,8 @@ public PeersContainerView::Listener
 
     bool setupLocalisation(const String & overrideLang = {});
 
+    void showMoggMixer(int peerIndex = -1);
+
 private:
 
     void updateLayout();
@@ -189,7 +194,10 @@ public PeersContainerView::Listener
     void configLevelSlider(Slider *);
     void configEditor(TextEditor *editor, bool passwd = false);
 
+    void showMidiMenu(Component* source, SonobusAudioProcessor::MidiTargetType type, int data = 0);
+
     void showPatchbay(bool flag);
+
     void showMetConfig(bool flag);
     void showEffectsConfig(bool flag);
 
@@ -298,7 +306,8 @@ public PeersContainerView::Listener
     std::unique_ptr<SonoDrawableButton> mMainLinkButton;
     std::unique_ptr<Drawable> mMainLinkArrow;
 
-    std::unique_ptr<Slider> mInGainSlider;
+    std::unique_ptr<SonoSlider> mInGainSlider;
+
 
     std::unique_ptr<TextButton> mInMixerButton;
 
@@ -309,8 +318,9 @@ public PeersContainerView::Listener
     std::unique_ptr<TextButton> mMonDelayButton;
 
     
-    std::unique_ptr<Slider> mDrySlider;
-    std::unique_ptr<Slider> mOutGainSlider;
+    std::unique_ptr<SonoSlider> mDrySlider;
+    std::unique_ptr<SonoSlider> mOutGainSlider;
+
     
     std::unique_ptr<SonoDrawableButton> mMainMuteButton;
     std::unique_ptr<SonoDrawableButton> mMainRecvMuteButton;
@@ -322,9 +332,10 @@ public PeersContainerView::Listener
     std::unique_ptr<TextButton> mMetSyncButton;
     std::unique_ptr<TextButton> mMetSyncFileButton;
     std::unique_ptr<Label> mMetTempoSliderLabel;
-    std::unique_ptr<Slider> mMetTempoSlider;
+    std::unique_ptr<SonoSlider> mMetTempoSlider;
     std::unique_ptr<Label> mMetLevelSliderLabel;
-    std::unique_ptr<Slider> mMetLevelSlider;
+    std::unique_ptr<SonoSlider> mMetLevelSlider;
+
     std::unique_ptr<DrawableRectangle> mMetButtonBg;
 
     std::unique_ptr<DrawableRectangle> mDragDropBg;
@@ -359,9 +370,13 @@ public PeersContainerView::Listener
     std::unique_ptr<SonoDrawableButton> mLoopButton;
     std::unique_ptr<SonoDrawableButton> mFileSendAudioButton;
     std::unique_ptr<SonoDrawableButton> mFileMenuButton;
-    std::unique_ptr<Slider> mPlaybackSlider;
+    std::unique_ptr<SonoDrawableButton> mMoggMixerButton;  // opens floating stem mixer
+    std::unique_ptr<SonoSlider> mPlaybackSlider;
+
     std::unique_ptr<WaveformTransportComponent> mWaveformThumbnail;
 
+    std::unique_ptr<MoggMixerWindow> mMoggMixerWindow;
+
     std::unique_ptr<Drawable> mPeerRecImage;
 
 
@@ -386,13 +401,14 @@ public PeersContainerView::Listener
     std::unique_ptr<Label>  mReverbTitleLabel;
     std::unique_ptr<SonoChoiceButton> mReverbModelChoice;
     std::unique_ptr<Label>  mReverbLevelLabel;
-    std::unique_ptr<Slider> mReverbLevelSlider;
+    std::unique_ptr<SonoSlider> mReverbLevelSlider;
     std::unique_ptr<Label>  mReverbSizeLabel;
-    std::unique_ptr<Slider> mReverbSizeSlider;
+    std::unique_ptr<SonoSlider> mReverbSizeSlider;
     std::unique_ptr<Label>  mReverbDampingLabel;
-    std::unique_ptr<Slider> mReverbDampingSlider;
+    std::unique_ptr<SonoSlider> mReverbDampingSlider;
     std::unique_ptr<Label>  mReverbPreDelayLabel;
-    std::unique_ptr<Slider> mReverbPreDelaySlider;
+    std::unique_ptr<SonoSlider> mReverbPreDelaySlider;
+
 
 
     class ApproveComponent;
diff --git a/Source/SonobusPluginProcessor.cpp b/Source/SonobusPluginProcessor.cpp
index f67bcfd48..a68c417e2 100644
--- a/Source/SonobusPluginProcessor.cpp
+++ b/Source/SonobusPluginProcessor.cpp
@@ -62,7 +62,9 @@ String SonobusAudioProcessor::paramSendChannels    ("sendchannels");
 String SonobusAudioProcessor::paramSendMetAudio    ("sendmetaudio");
 String SonobusAudioProcessor::paramSendFileAudio    ("sendfileaudio");
 String SonobusAudioProcessor::paramSendSoundboardAudio    ("sendsoundboardaudio");
+String SonobusAudioProcessor::paramSoundboardGain    ("soundboardgain");
 String SonobusAudioProcessor::paramHearLatencyTest   ("hearlatencytest");
+
 String SonobusAudioProcessor::paramMetIsRecorded   ("metisrecorded");
 String SonobusAudioProcessor::paramMainReverbEnabled  ("mainreverbenabled");
 String SonobusAudioProcessor::paramMainReverbLevel  ("nmainreverblevel");
@@ -340,6 +342,7 @@ struct SonobusAudioProcessor::RemotePeer {
     // metering
     foleys::LevelMeterSource sendMeterSource;
     foleys::LevelMeterSource recvMeterSource;
+    foleys::LevelMeterSource moggStemMeterSources[MAX_CHANGROUPS];
     bool viewExpanded = false;
     int orderPriority = -1;
 
@@ -364,6 +367,12 @@ struct SonobusAudioProcessor::RemotePeer {
     bool hasRemoteInfo = false;
     bool blockedUs = false;
 
+    bool isMogg = false;
+    int moggStemCount = 0;
+    AudioSampleBuffer moggStems;
+
+    int moggStartChannel = -1;
+
     std::unique_ptr<AudioFormatWriter::ThreadedWriter> fileWriter;
 
     ReadWriteLock    sinkLock;
@@ -534,7 +543,7 @@ enum {
     OutMixBusIndex = 0,
     OutSelfBusIndex,
     OutUserBaseBusIndex,
-    OutUserLastBusIndex = 9
+    OutUserLastBusIndex = 15
 };
 
 #if JUCE_IOS
@@ -560,18 +569,12 @@ SonobusAudioProcessor::BusesProperties SonobusAudioProcessor::getDefaultLayout()
         props = props.withInput ("Aux 1 In", AudioChannelSet::mono(), ALTBUS_ACTIVE);
     }
     else if (plugtype == AudioProcessor::wrapperType_VST) {
-        // no multi-bus outputs for now for VST2, so it works in OBS
+        // no extra inputs for VST2
     }
     else {
-        // throw in some input sidechains
-        props = props.withInput  ("Aux 1 In",  AudioChannelSet::stereo(), ALTBUS_ACTIVE)
-        .withInput  ("Aux 2 In",  AudioChannelSet::stereo(), ALTBUS_ACTIVE)
-        .withInput  ("Aux 3 In",  AudioChannelSet::stereo(), ALTBUS_ACTIVE)
-        .withInput  ("Aux 4 In",  AudioChannelSet::stereo(), ALTBUS_ACTIVE)
-        .withInput  ("Aux 5 In",  AudioChannelSet::stereo(), ALTBUS_ACTIVE)
-        .withInput  ("Aux 6 In",  AudioChannelSet::stereo(), ALTBUS_ACTIVE)
-        .withInput  ("Aux 7 In",  AudioChannelSet::stereo(), ALTBUS_ACTIVE)
-        .withInput  ("Aux 8 In",  AudioChannelSet::stereo(), ALTBUS_ACTIVE);
+        for (int i=1; i <= 7; ++i) {
+            props = props.withInput ("Aux " + String(i) + " In", AudioChannelSet::stereo(), ALTBUS_ACTIVE);
+        }
     }
 
     // outputs
@@ -579,17 +582,13 @@ SonobusAudioProcessor::BusesProperties SonobusAudioProcessor::getDefaultLayout()
         // no multi-bus outputs for now for VST2, so it works in OBS
     }
     else {
-        props = props.withOutput ("Aux 1 Out", AudioChannelSet::stereo(), ALTBUS_ACTIVE)
-        .withOutput ("Aux 2 Out", AudioChannelSet::stereo(), ALTBUS_ACTIVE)
-        .withOutput ("Aux 3 Out", AudioChannelSet::stereo(), ALTBUS_ACTIVE)
-        .withOutput ("Aux 4 Out", AudioChannelSet::stereo(), ALTBUS_ACTIVE)
-        .withOutput ("Aux 5 Out", AudioChannelSet::stereo(), ALTBUS_ACTIVE)
-        .withOutput ("Aux 6 Out", AudioChannelSet::stereo(), ALTBUS_ACTIVE)
-        .withOutput ("Aux 7 Out", AudioChannelSet::stereo(), ALTBUS_ACTIVE)
-        .withOutput ("Aux 8 Out", AudioChannelSet::stereo(), ALTBUS_ACTIVE);
+        for (int i=1; i <= 15; ++i) {
+            props = props.withOutput ("Aux " + String(i) + " Out", AudioChannelSet::stereo(), ALTBUS_ACTIVE);
+        }
     }
 
 
+
     return props;
 }
 
@@ -643,6 +642,10 @@ mState (*this, &mUndoManager, "SonoBusAoO",
 
     std::make_unique<AudioParameterBool>(ParameterID(paramSendFileAudio, 1), TRANS ("Send Playback Audio"), mSendPlaybackAudio.get()),
     std::make_unique<AudioParameterBool>(ParameterID(paramSendSoundboardAudio, 1), TRANS ("Send Soundboard Audio"), mSendSoundboardAudio.get()),
+    std::make_unique<AudioParameterFloat>(ParameterID(paramSoundboardGain, 1),     TRANS ("Soundboard Gain"),    NormalisableRange<float>(0.0, 2.0, 0.0, 0.5), 1.0f, "", AudioProcessorParameter::genericParameter,
+                                          [](float v, int maxlen) -> String { return Decibels::toString(Decibels::gainToDecibels(v), 1); },
+                                          [](const String& s) -> float { return Decibels::decibelsToGain(s.getFloatValue()); }),
+
     std::make_unique<AudioParameterBool>(ParameterID(paramHearLatencyTest, 1), TRANS ("Hear Latency Test"), mHearLatencyTest.get()),
     std::make_unique<AudioParameterBool>(ParameterID(paramMetIsRecorded, 1), TRANS ("Record Metronome to File"), mMetIsRecorded.get()),
     std::make_unique<AudioParameterBool>(ParameterID(paramMainReverbEnabled, 1), TRANS ("Main Reverb Enabled"), mMainReverbEnabled.get()),
@@ -708,6 +711,8 @@ mState (*this, &mUndoManager, "SonoBusAoO",
     mState.addParameterListener (paramSendMetAudio, this);
     mState.addParameterListener (paramSendFileAudio, this);
     mState.addParameterListener (paramSendSoundboardAudio, this);
+    mState.addParameterListener (paramSoundboardGain, this);
+
     mState.addParameterListener (paramHearLatencyTest, this);
     mState.addParameterListener (paramMetIsRecorded, this);
     mState.addParameterListener (paramMainReverbEnabled, this);
@@ -822,11 +827,12 @@ mState (*this, &mUndoManager, "SonoBusAoO",
     mRecMetChannelGroup.params.name = TRANS("Metronome");
     mRecMetChannelGroup.params.numChannels = 1;
 
-    mFilePlaybackChannelGroup.params.name = TRANS("File Playback");
-    mFilePlaybackChannelGroup.params.numChannels = 2;
-
-    mRecFilePlaybackChannelGroup.params.name = TRANS("File Playback");
-    mRecFilePlaybackChannelGroup.params.numChannels = 2;
+    for (int i=0; i < MAX_CHANGROUPS; ++i) {
+        mFilePlaybackChannelGroups[i].params.name = TRANS("File Playback");
+        mFilePlaybackChannelGroups[i].params.numChannels = 1;
+        mRecFilePlaybackChannelGroups[i].params.name = TRANS("File Playback");
+        mRecFilePlaybackChannelGroups[i].params.numChannels = 1;
+    }
 
 
     mTransportSource.addChangeListener(this);
@@ -1706,67 +1712,223 @@ float SonobusAudioProcessor::getMetronomeMonitor() const
 
 
 
-void SonobusAudioProcessor::setFilePlaybackMonitorDelayParams(SonoAudio::DelayParams & params)
+void SonobusAudioProcessor::setFilePlaybackMonitorDelayParams(int index, SonoAudio::DelayParams & params)
 {
-    mFilePlaybackChannelGroup.params.monitorDelayParams = params;
-    //mInputChannelGroups[changroup].monitorDelayParamsChanged = true;
-    // commit them now
-    mFilePlaybackChannelGroup.commitMonitorDelayParams();
+    if (index >= 0 && index < MAX_CHANGROUPS) {
+        mFilePlaybackChannelGroups[index].params.monitorDelayParams = params;
+        mFilePlaybackChannelGroups[index].commitMonitorDelayParams();
 
-    mRecFilePlaybackChannelGroup.params.monitorDelayParams = params;
-    mRecFilePlaybackChannelGroup.commitMonitorDelayParams();
+        mRecFilePlaybackChannelGroups[index].params.monitorDelayParams = params;
+        mRecFilePlaybackChannelGroups[index].commitMonitorDelayParams();
+    }
+}
 
+bool SonobusAudioProcessor::getFilePlaybackMonitorDelayParams(int index, SonoAudio::DelayParams & retparams)
+{
+    if (index >= 0 && index < MAX_CHANGROUPS) {
+        retparams = mFilePlaybackChannelGroups[index].params.monitorDelayParams;
+        return true;
+    }
+    return false;
 }
 
-bool SonobusAudioProcessor::getFilePlaybackMonitorDelayParams(SonoAudio::DelayParams & retparams)
+void SonobusAudioProcessor::setFilePlaybackDestStartAndCount(int index, int start, int count)
 {
-    retparams = mFilePlaybackChannelGroup.params.monitorDelayParams;
-    return true;
+    if (index >= 0 && index < MAX_CHANGROUPS) {
+        mFilePlaybackChannelGroups[index].params.monDestStartIndex = start;
+        mFilePlaybackChannelGroups[index].params.monDestChannels = std::max(1, std::min(count, MAX_CHANNELS));
+        mFilePlaybackChannelGroups[index].commitMonitorDelayParams(); // need to do this too
+
+        mRecFilePlaybackChannelGroups[index].params.monDestStartIndex = start;
+        mRecFilePlaybackChannelGroups[index].params.monDestChannels = std::max(1, std::min(count, MAX_CHANNELS));
+        mRecFilePlaybackChannelGroups[index].commitMonitorDelayParams(); // need to do this too
+    }
 }
 
-void SonobusAudioProcessor::setFilePlaybackDestStartAndCount(int start, int count)
+bool SonobusAudioProcessor::getFilePlaybackDestStartAndCount(int index, int & retstart, int & retcount)
 {
-    mFilePlaybackChannelGroup.params.monDestStartIndex = start;
-    mFilePlaybackChannelGroup.params.monDestChannels = std::max(1, std::min(count, MAX_CHANNELS));
-    mFilePlaybackChannelGroup.commitMonitorDelayParams(); // need to do this too
+    if (index >= 0 && index < MAX_CHANGROUPS) {
+        retstart = mFilePlaybackChannelGroups[index].params.monDestStartIndex;
+        retcount = mFilePlaybackChannelGroups[index].params.monDestChannels;
+        return true;
+    }
+    return false;
+}
 
-    mRecFilePlaybackChannelGroup.params.monDestStartIndex = start;
-    mRecFilePlaybackChannelGroup.params.monDestChannels = std::max(1, std::min(count, MAX_CHANNELS));
-    mRecFilePlaybackChannelGroup.commitMonitorDelayParams(); // need to do this too
+void SonobusAudioProcessor::setFilePlaybackGain(int index, float gain)
+{
+    if (index >= 0 && index < MAX_CHANGROUPS) {
+        mFilePlaybackChannelGroups[index].params.gain = gain;
+        mRecFilePlaybackChannelGroups[index].params.gain = gain;
+    }
 }
 
-bool SonobusAudioProcessor::getFilePlaybackDestStartAndCount(int & retstart, int & retcount)
+float SonobusAudioProcessor::getFilePlaybackGain(int index) const
 {
-    retstart = mFilePlaybackChannelGroup.params.monDestStartIndex;
-    retcount = mFilePlaybackChannelGroup.params.monDestChannels;
-    return true;
+    if (index >= 0 && index < MAX_CHANGROUPS) {
+        return mFilePlaybackChannelGroups[index].params.gain;
+    }
+    return 1.0f;
+}
+
+void SonobusAudioProcessor::setFilePlaybackPan(int index, float pan)
+{
+    if (index >= 0 && index < MAX_CHANGROUPS) {
+        mFilePlaybackChannelGroups[index].params.pan[0] = pan;
+        mRecFilePlaybackChannelGroups[index].params.pan[0] = pan;
+    }
+}
+
+float SonobusAudioProcessor::getFilePlaybackPan(int index) const
+{
+    if (index >= 0 && index < MAX_CHANGROUPS) {
+        return mFilePlaybackChannelGroups[index].params.pan[0];
+    }
+    return 0.0f;
+}
+
+void SonobusAudioProcessor::setFilePlaybackMonitor(int index, float mgain)
+{
+    if (index >= 0 && index < MAX_CHANGROUPS) {
+        mFilePlaybackChannelGroups[index].params.monitor = mgain;
+        mRecFilePlaybackChannelGroups[index].params.monitor = mgain;
+    }
+}
+
+float SonobusAudioProcessor::getFilePlaybackMonitor(int index) const
+{
+    if (index >= 0 && index < MAX_CHANGROUPS) {
+        return mFilePlaybackChannelGroups[index].params.monitor;
+    }
+    return 1.0f;
+}
+
+void SonobusAudioProcessor::setFilePlaybackMuted(int index, bool muted)
+{
+    if (index >= 0 && index < MAX_CHANGROUPS) {
+        mFilePlaybackChannelGroups[index].params.muted = muted;
+        mRecFilePlaybackChannelGroups[index].params.muted = muted;
+    }
+}
+
+bool SonobusAudioProcessor::getFilePlaybackMuted(int index) const
+{
+    if (index >= 0 && index < MAX_CHANGROUPS) {
+        return mFilePlaybackChannelGroups[index].params.muted;
+    }
+    return false;
+}
+
+void SonobusAudioProcessor::setFilePlaybackSoloed(int index, bool soloed)
+{
+    if (index >= 0 && index < MAX_CHANGROUPS) {
+        mFilePlaybackChannelGroups[index].params.soloed = soloed;
+        mRecFilePlaybackChannelGroups[index].params.soloed = soloed;
+        
+        bool anysoloed = false;
+        for (int i=0; i < MAX_CHANGROUPS; ++i) {
+            if (mFilePlaybackChannelGroups[i].params.soloed || mInputChannelGroups[i].params.soloed) {
+                anysoloed = true;
+                break;
+            }
+        }
+        mAnythingSoloed = anysoloed || mMetChannelGroup.params.soloed;
+    }
+}
+
+bool SonobusAudioProcessor::getFilePlaybackSoloed(int index) const
+{
+    if (index >= 0 && index < MAX_CHANGROUPS) {
+        return mFilePlaybackChannelGroups[index].params.soloed;
+    }
+    return false;
+}
+
+String SonobusAudioProcessor::getFilePlaybackChannelGroupName(int index) const
+{
+    if (index >= 0 && index < MAX_CHANGROUPS) {
+        return mFilePlaybackChannelGroups[index].params.name;
+    }
+    return {};
+}
+
+// ==============================================================================
+// MIDI Learn Implementation
+// ==============================================================================
+
+ValueTree SonobusAudioProcessor::MidiMapping::getValueTree() const
+{
+    ValueTree v("MidiMapping");
+    v.setProperty("targetType",  (int)targetType, nullptr);
+    v.setProperty("targetData",  targetData,       nullptr);
+    v.setProperty("ccNumber",    ccNumber,          nullptr);
+    v.setProperty("midiChannel", midiChannel,       nullptr);
+    return v;
+}
+
+void SonobusAudioProcessor::MidiMapping::setFromValueTree(const ValueTree& v)
+{
+    targetType  = (MidiTargetType)(int)v.getProperty("targetType",  0);
+    targetData  = v.getProperty("targetData",  0);
+    ccNumber    = v.getProperty("ccNumber",   -1);
+    midiChannel = v.getProperty("midiChannel", 0);
+}
+
+void SonobusAudioProcessor::setMidiMapping(MidiTargetType type, int data, int ccNumber, int midiChannel)
+{
+    MidiMapping m;
+    m.targetType  = type;
+    m.targetData  = data;
+    m.ccNumber    = ccNumber;
+    m.midiChannel = midiChannel;
+    {
+        ScopedLock sl(mMidiMappingsLock);
+        mMidiMappings[m.getKey()] = m;
+    }
+    mMidiLearnListeners.call([](MidiLearnListener& l){ l.midiMappingChanged(); });
 }
 
-void SonobusAudioProcessor::setFilePlaybackGain(float gain)
+bool SonobusAudioProcessor::getMidiMapping(MidiTargetType type, int data, int& outCC, int& outChannel) const
 {
-    mFilePlaybackChannelGroup.params.gain = gain;
-    mRecFilePlaybackChannelGroup.params.gain = gain;
-    //mTransportSource.setGain(gain);
+    String key = String((int)type) + "_" + String(data);
+    const ScopedLock sl(mMidiMappingsLock);
+    auto it = mMidiMappings.find(key);
+    if (it != mMidiMappings.end() && it->second.isValid()) {
+        outCC      = it->second.ccNumber;
+        outChannel = it->second.midiChannel;
+        return true;
+    }
+    return false;
+}
+
+void SonobusAudioProcessor::clearMidiMapping(MidiTargetType type, int data)
+{
+    String key = String((int)type) + "_" + String(data);
+    { ScopedLock sl(mMidiMappingsLock); mMidiMappings.erase(key); }
+    mMidiLearnListeners.call([](MidiLearnListener& l){ l.midiMappingChanged(); });
 }
 
-float SonobusAudioProcessor::getFilePlaybackGain() const
+void SonobusAudioProcessor::clearAllMidiMappings()
 {
-    return mFilePlaybackChannelGroup.params.gain;
-    //return mTransportSource.getGain();
+    { ScopedLock sl(mMidiMappingsLock); mMidiMappings.clear(); }
+    mMidiLearnListeners.call([](MidiLearnListener& l){ l.midiMappingChanged(); });
 }
 
-void SonobusAudioProcessor::setFilePlaybackMonitor(float mgain)
+void SonobusAudioProcessor::startMidiLearn(MidiTargetType type, int data)
 {
-    mFilePlaybackChannelGroup.params.monitor = mgain;
-    mRecFilePlaybackChannelGroup.params.monitor = mgain;
+    mMidiLearnTargetType = type;
+    mMidiLearnTargetData = data;
+    mMidiLearnActive     = true;
 }
 
-float SonobusAudioProcessor::getFilePlaybackMonitor() const
+void SonobusAudioProcessor::stopMidiLearn()
 {
-    return mFilePlaybackChannelGroup.params.monitor;
+    mMidiLearnActive = false;
 }
 
 
+
+
 void SonobusAudioProcessor::setInputCompressorParams(int changroup, CompressorParams & params)
 {
     // sanity check and compute automakeupgain if necessary    
@@ -2458,6 +2620,11 @@ void SonobusAudioProcessor::doReceiveData()
 #define SONOBUS_MSG_SUGGEST_GROUP_LEN 14
 #define SONOBUS_FULLMSG_SUGGEST_GROUP SONOBUS_MSG_DOMAIN SONOBUS_MSG_SUGGEST_GROUP
 
+#define SONOBUS_MSG_MIDI "/midi"
+#define SONOBUS_MSG_MIDI_LEN 5
+#define SONOBUS_FULLMSG_MIDI SONOBUS_MSG_DOMAIN SONOBUS_MSG_MIDI
+
+
 
 enum {
     SONOBUS_MSGTYPE_UNKNOWN = 0,
@@ -2470,9 +2637,11 @@ enum {
     SONOBUS_MSGTYPE_LATINFO,
     SONOBUS_MSGTYPE_SUGGESTLAT,
     SONOBUS_MSGTYPE_BLOCKEDINFO,
-    SONOBUS_MSGTYPE_SUGGESTGROUP
+    SONOBUS_MSGTYPE_SUGGESTGROUP,
+    SONOBUS_MSGTYPE_MIDI
 };
 
+
 static int32_t sonobusOscParsePattern(const char *msg, int32_t n, int32_t & rettype)
 {
     int32_t offset = 0;
@@ -2551,6 +2720,13 @@ static int32_t sonobusOscParsePattern(const char *msg, int32_t n, int32_t & rett
             offset += SONOBUS_MSG_SUGGEST_GROUP_LEN;
             return offset;
         }
+        else if (n >= (offset + SONOBUS_MSG_MIDI_LEN)
+            && !memcmp(msg + offset, SONOBUS_MSG_MIDI, SONOBUS_MSG_MIDI_LEN))
+        {
+            rettype = SONOBUS_MSGTYPE_MIDI;
+            offset += SONOBUS_MSG_MIDI_LEN;
+            return offset;
+        }
         else {
             return 0;
         }
@@ -2851,7 +3027,20 @@ bool SonobusAudioProcessor::handleOtherMessage(EndpointState * endpoint, const c
             
             clientListeners.call(&SonobusAudioProcessor::ClientListener::peerBlockedInfoChanged, this, username, blocked);
         }
+        else if (type == SONOBUS_MSGTYPE_MIDI) {
+            auto it = message.ArgumentsBegin();
+            const void *mididata;
+            osc::osc_bundle_element_size_t size;
+            (it++)->AsBlob(mididata, size);
+            
+            if (!isAddressBlocked(endpoint->ipaddr)) {
+                MidiMessage mm(mididata, size);
+                const ScopedLock sl (mMidiMappingsLock);
+                mIncomingMidiFromPeers.addEvent(mm, 0);
+            }
+        }
         return true;
+
     } catch (const osc::Exception& e){
         DBG("exception in handleOtherMessage: " << e.what());
     }
@@ -5221,7 +5410,11 @@ void SonobusAudioProcessor::updateRemotePeerSendChannels(int index, RemotePeer *
             totinchans += 1;
         }
         if (mSendPlaybackAudio.get()) {
-            totinchans += mFilePlaybackChannelGroup.params.numChannels;
+            for (int i=0; i < mFilePlaybackGroupCount; ++i) {
+                if (!mFilePlaybackChannelGroups[i].params.muted) {
+                    totinchans += mFilePlaybackChannelGroups[i].params.numChannels;
+                }
+            }
         }
         if (mSendSoundboardAudio.get()) {
             totinchans += soundboardChannelProcessor->getNumberOfChannels();
@@ -5841,6 +6034,26 @@ bool SonobusAudioProcessor::getRemotePeerSendActive(int index) const
     return false;        
 }
 
+bool SonobusAudioProcessor::getRemotePeerIsMogg(int index) const
+{
+    const ScopedReadLock sl (mCoreLock);
+    if (index >= 0 && index < mRemotePeers.size()) {
+        return mRemotePeers.getUnchecked(index)->isMogg;
+    }
+    return false;
+}
+
+int SonobusAudioProcessor::getRemotePeerMoggStemCount(int index) const
+{
+    const ScopedReadLock sl (mCoreLock);
+    if (index >= 0 && index < mRemotePeers.size()) {
+        int count = mRemotePeers.getUnchecked(index)->moggStemCount;
+        DBG("getRemotePeerMoggStemCount for peer " << index << ": " << count);
+        return count;
+    }
+    return 0;
+}
+
 void SonobusAudioProcessor::setRemotePeerConnected(int index, bool active)
 {
     const ScopedReadLock sl (mCoreLock);        
@@ -6356,17 +6569,75 @@ void SonobusAudioProcessor::setupSourceFormat(SonobusAudioProcessor::RemotePeer
     }
 }
 
+int SonobusAudioProcessor::getSendChannels() const
+{
+    int baseMode = mSendChannels.get();
+    int count = 2;
+    if (baseMode == 0) { // Match # Inputs
+        count = 0;
+        for (auto i = 0; i < mInputChannelGroupCount && i < MAX_CHANGROUPS; ++i)
+        {
+            count += mInputChannelGroups[i].params.numChannels;
+        }
+        if (mSendMet.get()) count += 1;
+        if (mSendPlaybackAudio.get()) {
+            for (int i=0; i < mFilePlaybackGroupCount; ++i) {
+                if (!mFilePlaybackChannelGroups[i].params.muted) {
+                    count += mFilePlaybackChannelGroups[i].params.numChannels;
+                }
+            }
+        }
+        if (mSendSoundboardAudio.get()) {
+            count += soundboardChannelProcessor->getFileSourceNumberOfChannels();
+        }
+    }
+    else if (baseMode == 1) { // Mono
+        count = 1;
+    }
+    else if (baseMode == 2) { // Stereo
+        count = 2;
+    }
+
+    if (mSendPlaybackAudio.get() && (mFilePlaybackGroupCount > 1) && baseMode > 0) {
+        // Enforce extra channels for MOGG stems even in mono/stereo
+        count = jmax((int)count, (int)(2 + mFilePlaybackGroupCount - 1));
+    }
+    return count;
+}
+
 ValueTree SonobusAudioProcessor::getSendUserFormatLayoutTree()
 {
     // get userformat from send info
     ValueTree fmttree(channelLayoutsKey);
 
-    if (mSendChannels.get() == 1 || mSendChannels.get() == 2) {
-        // not multichannel, this is a mixdown
+    bool isMogg = mFilePlaybackGroupCount > 1;
+    fmttree.setProperty("isMogg", isMogg, nullptr);
+    if (isMogg) {
+        fmttree.setProperty("moggStemCount", (int)mFilePlaybackGroupCount, nullptr);
+    }
+
+    int baseSendChans = mSendChannels.get();
+    bool sendPlayback = mSendPlaybackAudio.get();
+
+    if (baseSendChans == 1 || baseSendChans == 2) {
+        // Main mixed group (Mono or Stereo)
         ChannelGroupParams tmpgrp;
+        tmpgrp.name = baseSendChans == 1 ? "Mono Mix" : "Stereo Mix";
         tmpgrp.chanStartIndex = 0;
-        tmpgrp.numChannels = mSendChannels.get();
+        tmpgrp.numChannels = baseSendChans;
         fmttree.appendChild(tmpgrp.getChannelLayoutValueTree(), nullptr);
+
+        // ALWAYS APPEND MOGG STEMS (Groups 1..N) starting at channel 2
+        // if we are in this mode. This satisfies "MOGG should still be multi-channel".
+        if (sendPlayback && isMogg) {
+            int chstart = 2;
+            for (int i=1; i < (int)mFilePlaybackGroupCount; ++i) {
+                ChannelGroupParams mgrp = mFilePlaybackChannelGroups[i].params;
+                mgrp.chanStartIndex = chstart;
+                fmttree.appendChild(mgrp.getChannelLayoutValueTree(), nullptr);
+                chstart += mgrp.numChannels;
+            }
+        }
     }
     else {
         int chstart = 0;
@@ -6385,10 +6656,15 @@ ValueTree SonobusAudioProcessor::getSendUserFormatLayoutTree()
             chstart += tmpgrp.numChannels;
         }
         if (mSendPlaybackAudio.get()) {
-            ChannelGroupParams tmpgrp = mFilePlaybackChannelGroup.params;
-            tmpgrp.chanStartIndex = chstart;
-            fmttree.appendChild(tmpgrp.getChannelLayoutValueTree(), nullptr);
-            chstart += tmpgrp.numChannels;
+            bool isMogg = mFilePlaybackGroupCount > 1;
+
+            for (int i=0; i < (int)mFilePlaybackGroupCount; ++i) {
+                if (mFilePlaybackChannelGroups[i].params.muted) continue;
+                ChannelGroupParams tmpgrp = mFilePlaybackChannelGroups[i].params;
+                tmpgrp.chanStartIndex = chstart;
+                fmttree.appendChild(tmpgrp.getChannelLayoutValueTree(), nullptr);
+                chstart += tmpgrp.numChannels;
+            }
         }
         if (mSendSoundboardAudio.get()) {
             ChannelGroupParams tmpgrp = soundboardChannelProcessor->getChannelGroupParams();
@@ -6417,6 +6693,17 @@ void SonobusAudioProcessor::setupSourceUserFormat(RemotePeer * peer, aoo::isourc
     source->set_userformat(destData.getData(), (int32_t) destData.getSize());
 }
 
+
+foleys::LevelMeterSource& SonobusAudioProcessor::getMoggStemMeterSource(int peerIndex, int stemIndex)
+{
+    const ScopedReadLock sl (mCoreLock);
+    int idx = jlimit(0, MAX_CHANGROUPS - 1, stemIndex);
+    if (peerIndex >= 0 && peerIndex < mRemotePeers.size()) {
+        return mRemotePeers.getUnchecked(peerIndex)->moggStemMeterSources[idx];
+    }
+    return moggStemMeterSources[idx];
+}
+
 void SonobusAudioProcessor::updateRemotePeerUserFormat(int index, RemotePeer * onlypeer)
 {
     // get userformat from send info
@@ -6494,6 +6781,9 @@ void SonobusAudioProcessor::applyLayoutFormatToPeer(RemotePeer * remote, const V
 {
     DBG("Got layout userformat for peer: " << valtree.toXmlString());
 
+    remote->isMogg = (bool)valtree.getProperty("isMogg", false);
+    remote->moggStemCount = (int)valtree.getProperty("moggStemCount", 0);
+
 
     // apply this valtree to the channelgroups for this peer
     for (int i=0; i < valtree.getNumChildren(); ++i) {
@@ -6707,6 +6997,15 @@ void SonobusAudioProcessor::parameterChanged (const String &parameterID, float n
     else if (parameterID == paramMetIsRecorded) {
         mMetIsRecorded = newValue > 0;
     }
+    else if (parameterID == paramSendFileAudio) {
+        mSendPlaybackAudio = newValue > 0;
+        if (mSendPlaybackAudio.get() && mFilePlaybackGroupCount > 1) {
+            // Force multichannel mode if MOGG is playing
+            if (mSendChannels.get() != 0) {
+                mState.getParameter(paramSendChannels)->setValueNotifyingHost(0.0f); // 0 is Match Inputs
+            }
+        }
+    }
     else if (parameterID == paramSendMetAudio) {
         mSendMet = newValue > 0;
     }
@@ -6804,6 +7103,10 @@ void SonobusAudioProcessor::parameterChanged (const String &parameterID, float n
     else if (parameterID == paramWet) {
         mWet = newValue;
     }
+    else if (parameterID == paramSoundboardGain) {
+        soundboardChannelProcessor->setGain(newValue);
+    }
+
     else if (parameterID == paramInMonitorMonoPan) {
         // old one
         mInMonMonoPan = newValue;
@@ -7060,9 +7363,11 @@ void SonobusAudioProcessor::prepareToPlay (double sampleRate, int samplesPerBloc
 
 
     mMetChannelGroup.init(sampleRate);
-    mFilePlaybackChannelGroup.init(sampleRate);
+    for (int i=0; i < MAX_CHANGROUPS; ++i) {
+        mFilePlaybackChannelGroups[i].init(sampleRate);
+    }
     mRecMetChannelGroup.init(sampleRate);
-    mRecFilePlaybackChannelGroup.init(sampleRate);
+    for (int i=0; i<MAX_CHANGROUPS; ++i) mRecFilePlaybackChannelGroups[i].init(sampleRate);
 
 
     if (lrintf(mPrevSampleRate) != lrintf(sampleRate) || blocksizechanged) {
@@ -7231,8 +7536,14 @@ void SonobusAudioProcessor::ensureBuffers(int numSamples)
     int fileplaychans = mCurrentAudioFileSource ? mCurrentAudioFileSource->getAudioFormatReader()->numChannels : 2;
     int fileplaymaxchans = jmax(maxchans, fileplaychans);
     if (mSendPlaybackAudio.get()) {
-        // plus a possible file sending
-        totsendchans += fileplaychans;
+        // Correctly calculate total channels for MOGG (Full Mix stereo + individual mono stems)
+        if (mFilePlaybackGroupCount > 1) {
+            for (int i=0; i < mFilePlaybackGroupCount; ++i) {
+                totsendchans += mFilePlaybackChannelGroups[i].params.numChannels;
+            }
+        } else {
+            totsendchans += fileplaychans;
+        }
     }
 
     meterRmsWindow = getSampleRate() * METER_RMS_SEC / currSamplesPerBlock;
@@ -7329,7 +7640,14 @@ void SonobusAudioProcessor::ensureBuffers(int numSamples)
 
 void SonobusAudioProcessor::processBlock (AudioBuffer<float>& buffer, MidiBuffer& midiMessages)
 {
+    {
+        const ScopedLock sl (mMidiMappingsLock);
+        midiMessages.addEvents (mIncomingMidiFromPeers, 0, buffer.getNumSamples(), 0);
+        mIncomingMidiFromPeers.clear();
+    }
+
     ScopedNoDenormals noDenormals;
+
     auto totalInputChannels  = getTotalNumInputChannels();
     auto mainBusInputChannels  = getMainBusNumInputChannels();
     auto mainBusOutputChannels = getMainBusNumOutputChannels();
@@ -7346,7 +7664,7 @@ void SonobusAudioProcessor::processBlock (AudioBuffer<float>& buffer, MidiBuffer
     float inmonPan1 = mInMonPan1.get();
     float inmonPan2 = mInMonPan2.get();
 
-    int sendChans = mSendChannels.get();
+    int sendChans = getSendChannels();
     bool sendfileaudio = mSendPlaybackAudio.get();
     bool sendsoundboardaudio = mSendSoundboardAudio.get();
     bool sendmet = mSendMet.get();
@@ -7360,6 +7678,147 @@ void SonobusAudioProcessor::processBlock (AudioBuffer<float>& buffer, MidiBuffer
 
     int numSamples = buffer.getNumSamples();
 
+    // ---- MIDI Learn / CC processing ----------------------------------------
+    for (const auto meta : midiMessages) {
+        const auto msg = meta.getMessage();
+        if (msg.isController() || msg.isNoteOn()) {
+            int cc      = msg.isController() ? msg.getControllerNumber() : msg.getNoteNumber();
+            int val     = msg.isController() ? msg.getControllerValue() : (msg.isNoteOn() ? msg.getVelocity() : 0);
+            int channel = msg.getChannel();            // 1..16
+
+            if (mMidiLearnActive.load()) {
+                // Capture this CC and assign it to the pending target
+                setMidiMapping(mMidiLearnTargetType, mMidiLearnTargetData, cc, channel);
+                mMidiLearnActive = false;
+            } else {
+                // Apply mapped CC messages
+                const ScopedLock sl(mMidiMappingsLock);
+                for (auto& kv : mMidiMappings) {
+                    const MidiMapping& m = kv.second;
+                    if (!m.isValid()) continue;
+                    if (m.ccNumber   != cc) continue;
+                    if (m.midiChannel != 0 && m.midiChannel != channel) continue;
+
+                    float fval = val / 127.0f;
+                    switch (m.targetType) {
+                        case MidiTarget_FileStemGain:
+                            setFilePlaybackGain(m.targetData, fval);
+                            break;
+                        case MidiTarget_FileStemMute:
+                            setFilePlaybackMuted(m.targetData, val >= 64);
+                            break;
+                        case MidiTarget_FileStemSolo:
+                            setFilePlaybackSoloed(m.targetData, val >= 64);
+                            break;
+                        case MidiTarget_InputGain:
+                            if (auto* p = mState.getParameter(paramInGain))
+                                p->setValueNotifyingHost(fval);
+                            break;
+                        case MidiTarget_OutputGain:
+                            if (auto* p = mState.getParameter(paramWet))
+                                p->setValueNotifyingHost(fval);
+                            break;
+                        case MidiTarget_PeerLevel:
+                            setRemotePeerLevelGain(m.targetData, fval);
+                            break;
+                        case MidiTarget_PeerPan:
+                            setRemotePeerChannelPan(m.targetData, 0, 0, fval * 2.0f - 1.0f); // -1 to 1
+                            break;
+                        case MidiTarget_PeerMute:
+                            setRemotePeerChannelMuted(m.targetData, 0, val >= 64);
+                            break;
+                        case MidiTarget_InputMute:
+                            if (auto* p = mState.getParameter(paramMainInMute))
+                                p->setValueNotifyingHost(val >= 64 ? 1.0f : 0.0f);
+                            break;
+                        case MidiTarget_SoundboardLevel:
+                            if (auto* p = mState.getParameter(paramSoundboardGain))
+                                p->setValueNotifyingHost(fval);
+                            break;
+
+                        case MidiTarget_MonitorLevel:
+                            if (auto* p = mState.getParameter(paramDry))
+                                p->setValueNotifyingHost(fval);
+                            break;
+                        case MidiTarget_MetronomeLevel:
+                            if (auto* p = mState.getParameter(paramMetGain))
+                                p->setValueNotifyingHost(fval);
+                            break;
+
+                        case MidiTarget_FXLevel:
+                            if (auto* p = mState.getParameter(paramMainReverbLevel))
+                                p->setValueNotifyingHost(fval);
+                            break;
+                        case MidiTarget_FXEnable:
+                            if (val >= 64) {
+                                if (auto* p = mState.getParameter(paramMainReverbEnabled))
+                                    p->setValueNotifyingHost(p->getValue() > 0.5f ? 0.0f : 1.0f);
+                            }
+                            break;
+
+                        case MidiTarget_FullMixMonitorLevel:
+                            setFilePlaybackMonitor(0, fval);
+                            break;
+
+                        case MidiTarget_TransportPlay:
+                            if (val >= 64) {
+                                if (mTransportSource.isPlaying()) mTransportSource.stop();
+                                else mTransportSource.start();
+                            }
+                            break;
+
+                        case MidiTarget_TransportRecord:
+                            if (val >= 64) {
+                                // Record toggle - we'll let the editor handle some of this 
+                                // but we can trigger it here if it's already configured.
+                                if (isRecordingToFile()) stopRecordingToFile();
+                                else {
+                                    // We need settings to start... this is tricky without UI.
+                                    // But we can try using defaults if available.
+                                    URL mainret;
+                                    startRecordingToFile(mDefaultRecordDir, "recording", mainret);
+                                }
+                            }
+                            break;
+
+                        case MidiTarget_TransportLoop:
+                            if (val >= 64) {
+                                mTransportSource.setLooping(!mTransportSource.isLooping());
+                            }
+                            break;
+
+                        case MidiTarget_TransportMetronome:
+                            if (val >= 64) {
+                                if (auto* p = mState.getParameter(paramMetEnabled))
+                                    p->setValueNotifyingHost(p->getValue() > 0.5f ? 0.0f : 1.0f);
+                            }
+                            break;
+
+                        case MidiTarget_ResetAllJitters:
+                            if (val >= 64) {
+                                bool initComp = false;
+                                for (int j=0; j < (int)mRemotePeers.size(); ++j) {
+                                    if (getRemotePeerAutoresizeBufferMode(j, initComp) != AutoNetBufferModeOff) {
+                                        setRemotePeerBufferTime(j, 0.0f);
+                                    }
+                                }
+                            }
+                            break;
+
+                        case MidiTarget_FileStemMonitor:
+                            setFilePlaybackMonitor(m.targetData, fval);
+                            break;
+
+
+
+                        default:
+                            break;
+                    }
+                }
+            }
+        }
+    }
+    // -------------------------------------------------------------------------
 
     if (numSamples != lastSamplesPerBlock) {
         //DBG("blocksize changed from " << lastSamplesPerBlock << " to " << numSamples);
@@ -7390,7 +7849,11 @@ void SonobusAudioProcessor::processBlock (AudioBuffer<float>& buffer, MidiBuffer
     }
     if (sendfileaudio) {
         // plus a possible file sending
-        totsendchans += mCurrentAudioFileSource ? mCurrentAudioFileSource->getAudioFormatReader()->numChannels : 2;
+        for (int i=0; i < mFilePlaybackGroupCount; ++i) {
+            if (!mFilePlaybackChannelGroups[i].params.muted) {
+                totsendchans += mFilePlaybackChannelGroups[i].params.numChannels;
+            }
+        }
     }
     if (sendsoundboardaudio) {
         // plus a possible soundboard sending
@@ -7525,9 +7988,8 @@ void SonobusAudioProcessor::processBlock (AudioBuffer<float>& buffer, MidiBuffer
     
     
     // do the input panning before everything else
-    int sendCh = mSendChannels.get();
-    //int sendPanChannels = sendCh == 0 ?  inputBuffer.getNumChannels() : jmin(inputBuffer.getNumChannels(), jmax(mainBusOutputChannels, sendCh));
-    int sendPanChannels = sendCh == 0 ?  inputPostBuffer.getNumChannels() : jmin(sendWorkBuffer.getNumChannels(), sendCh);
+    int sendCh = getSendChannels();
+    int sendPanChannels = sendCh; // Use the dynamic send channel count
     //int panChannels = jmin(inputBuffer.getNumChannels(), jmax(mainBusOutputChannels, sendCh));
     // if sending as mono, split the difference about applying gain attenuation for the number of input channels
     float tgain = sendPanChannels == 1 && inputPostBuffer.getNumChannels() > 0 ? (1.0f/std::max(1.0f, (float)(inputPostBuffer.getNumChannels() * 0.5f))) : 1.0f;
@@ -7627,63 +8089,107 @@ void SonobusAudioProcessor::processBlock (AudioBuffer<float>& buffer, MidiBuffer
         filePlaybackMeterSource.measureBlock(fileBuffer);
 
         int srcchans = fileChannels;
-        mFilePlaybackChannelGroup.params.numChannels = srcchans;
-        mFilePlaybackChannelGroup.commitMonitorDelayParams(); // need to do this too
-
-        mRecFilePlaybackChannelGroup.params.numChannels = srcchans;
-        mRecFilePlaybackChannelGroup.commitMonitorDelayParams(); // need to do this too
-
-        if (sendfileaudio) {
-
-            //add to main buffer for going out, mix as appropriate depending on how many channels being sent
-            if (sendPanChannels == 1) {
-                float fgain = sendPanChannels == 1 && srcchans > 0 ? (1.0f/std::max(1.0f, (float)(srcchans))): 1.0f;
-                fgain *= mFilePlaybackChannelGroup.params.gain;
-                auto lastfgain = _lastfplaygain;
-
-                for (int channel = 0; channel < srcchans; ++channel) {
-                    //sendWorkBuffer.addFrom(0, 0, fileBuffer, channel, 0, numSamples, fgain);
-                    sendWorkBuffer.addFromWithRamp(0, 0, fileBuffer.getReadPointer(channel), numSamples, fgain, lastfgain);
-                }
+            
+            bool layoutChanged = false;
+            // Map stems to channel groups
+            /* mFilePlaybackGroupCount update moved to Message thread (openAudioFile) */
 
-                _lastfplaygain = fgain;
+            
+            if (layoutChanged) {
+                // trigger ui rebuild ?
             }
-            else if (sendPanChannels > 2){
-                // straight-thru
 
-                // copy straight-thru
-                // find file channels TODO
-                auto filech = filestartch; // XXX
-                //sendWorkBuffer.addFrom (filech, 0, fileBuffer, 0, 0, numSamples);
-                auto fgain = mFilePlaybackChannelGroup.params.gain;
-                auto lastfgain = _lastfplaygain;
-
-                for (int channel = 0; channel < srcchans && filech < sendWorkBuffer.getNumChannels(); ++channel) {
-                    //sendWorkBuffer.addFrom(filech, 0, fileBuffer, channel, 0, numSamples);
-                    sendWorkBuffer.addFromWithRamp(filech, 0, fileBuffer.getReadPointer(channel), numSamples, fgain, lastfgain);
-                    ++filech;
+            if (sendfileaudio) {
+                if (sendChans == 1) { // sum to mono
+                    auto filech = 0;
+                    for (int i=0; i < mFilePlaybackGroupCount; i++) {
+                        if (mFilePlaybackChannelGroups[i].params.muted || mFilePlaybackChannelGroups[i].params.gain == 0.0f) {
+                            filech += 1;
+                            continue;
+                        }
+                        if (anyinputsoloed && !mFilePlaybackChannelGroups[i].params.soloed) {
+                            filech += 1;
+                            continue;
+                        }
+                        float fgain = mFilePlaybackChannelGroups[i].params.gain;
+                        if (fgain > 0.0f && filech < fileChannels) {
+                            float panv = mFilePlaybackChannelGroups[i].params.pan[0];
+                            float left = std::cos(juce::MathConstants<float>::pi * 0.25f * (panv + 1.0f));
+                            float right = std::sin(juce::MathConstants<float>::pi * 0.25f * (panv + 1.0f));
+                            float pangain = left + right; // mono mix
+                            sendWorkBuffer.addFrom(0, 0, fileBuffer.getReadPointer(filech, 0), numSamples, pangain * fgain);
+                        }
+                        filech += 1;
+                    }
+                    _lastfplaygain = mFilePlaybackChannelGroups[0].params.gain;
+                }
+                else if (sendChans >= 2) {
+                    // Group 0 is the "Full Mix" (stereo)
+                    // Individual stems are Groups 1..N
+                    int dstStereoStart = mFilePlaybackChannelGroups[0].params.panDestStartIndex;
+                    float masterGain = mFilePlaybackChannelGroups[0].params.gain; 
+                    bool masterMuted = mFilePlaybackChannelGroups[0].params.muted;
+                    bool masterSoloed = mFilePlaybackChannelGroups[0].params.soloed;
+
+                    // First pass: build the stereo downmix for all active stems
+                    if (!masterMuted && (!anyinputsoloed || masterSoloed)) {
+                        int filech = 0;
+                        for (int i=1; i < mFilePlaybackGroupCount; i++) {
+                            if (mFilePlaybackChannelGroups[i].params.muted) {
+                                filech += 1;
+                                continue;
+                            }
+                            if (anyinputsoloed && !mFilePlaybackChannelGroups[i].params.soloed) {
+                                filech += 1;
+                                continue;
+                            }
+                            float stemGain = mFilePlaybackChannelGroups[i].params.gain;
+                            if (stemGain > 0.0f && filech < fileChannels) {
+                                float panv = mFilePlaybackChannelGroups[i].params.pan[0];
+                                float left = std::cos(juce::MathConstants<float>::pi * 0.25f * (panv + 1.0f));
+                                float right = std::sin(juce::MathConstants<float>::pi * 0.25f * (panv + 1.0f));
+                                int dstL = dstStereoStart;
+                                int dstR = jmin(dstStereoStart + 1, sendChans - 1);
+                                
+                                // Mix with both stem gain and master gain
+                                sendWorkBuffer.addFrom(dstL, 0, fileBuffer.getReadPointer(filech, 0), numSamples, masterGain * stemGain * left);
+                                sendWorkBuffer.addFrom(dstR, 0, fileBuffer.getReadPointer(filech, 0), numSamples, masterGain * stemGain * right);
+                            }
+                            filech += 1;
+                        }
+                    }
+                    _lastfplaygain = masterGain; // for smoothing in next block
+                    
+                    // Second pass (multichannel sending of individual stems): send individual stems at channels 2+
+                    if (sendChans > 2) {
+                        int dstch = dstStereoStart + 2; // start after the master stereo pair
+                        int filech = 0;
+                        for (int i=1; i < mFilePlaybackGroupCount && dstch < sendChans; i++) {
+                            if (mFilePlaybackChannelGroups[i].params.muted || mFilePlaybackChannelGroups[i].params.gain == 0.0f) {
+                                filech += 1;
+                                continue;
+                            }
+                            if (anyinputsoloed && !mFilePlaybackChannelGroups[i].params.soloed) {
+                                filech += 1;
+                                continue;
+                            }
+                            float fgain = mFilePlaybackChannelGroups[i].params.gain;
+                            if (filech < fileChannels) {
+                                mFilePlaybackChannelGroups[i].processPan(fileBuffer, filech, sendWorkBuffer, dstch, 1, numSamples, fgain);
+                                moggStemMeterSources[i].measureBlock(fileBuffer, filech, 1);
+                                dstch++;
+                            }
+                            filech++;
+                        }
+                    }
                 }
-
-                _lastfplaygain = fgain;
-            }
-            else if (sendPanChannels == 2) {
-                // change dest ch target
-                int dstch = mFilePlaybackChannelGroup.params.panDestStartIndex;  // todo change dest ch target
-                int dstcnt = jmin(sendPanChannels, mFilePlaybackChannelGroup.params.panDestChannels);
-                auto fgain = mFilePlaybackChannelGroup.params.gain;
-
-                mFilePlaybackChannelGroup.processPan(fileBuffer, 0, sendWorkBuffer, dstch, dstcnt, numSamples, fgain);
-
-                _lastfplaygain = fgain;
             }
         }
 
-    }
-
     bool hassoundboarddata = soundboardChannelProcessor->processAudioBlock(numSamples);
     if (hassoundboarddata && sendsoundboardaudio) {
         int startChannel = sendfileaudio ? filestartch + fileChannels : filestartch;
-        soundboardChannelProcessor->sendAudioBlock(sendWorkBuffer, numSamples, sendPanChannels, startChannel);
+        soundboardChannelProcessor->sendAudioBlock(sendWorkBuffer, numSamples, sendChans, startChannel);
     }
 
     // process metronome
@@ -7850,6 +8356,35 @@ void SonobusAudioProcessor::processBlock (AudioBuffer<float>& buffer, MidiBuffer
                 remote->workBuffer.clear(0, numSamples);
 
                 remote->oursink->process((float **)remote->workBuffer.getArrayOfWritePointers(), numSamples, t);
+
+                // If this is a MOGG stream, extract the stems
+                if (remote->isMogg && remote->moggStemCount > 0) {
+                    if (remote->moggStems.getNumChannels() != remote->moggStemCount || remote->moggStems.getNumSamples() < numSamples) {
+                        remote->moggStems.setSize(remote->moggStemCount, numSamples, false, false, true);
+                    }
+                    remote->moggStems.clear();
+
+                    // MOGG stems start at channel 0 of the remote send, but wait!
+                    // If they sent "Full Mix" + Stems, then Stems start at channel 2.
+                    // But our userformat layout says where they start.
+                    for (int gi=0; gi < remote->numChanGroups; ++gi) {
+                        int srcStart = remote->chanGroups[gi].params.chanStartIndex;
+                        int nch = remote->chanGroups[gi].params.numChannels;
+                        if (gi < remote->moggStemCount) {
+                            for (int c=0; c < nch; ++c) {
+                                if (srcStart + c < remote->workBuffer.getNumChannels()) {
+                                    remote->moggStems.copyFrom(gi, 0, remote->workBuffer, srcStart + c, 0, numSamples);
+                                }
+                            }
+                            // Feed the meter
+                            remote->moggStemMeterSources[gi].measureBlock(remote->moggStems, gi, 1);
+                        }
+                    }
+                    
+                    // Clear the workBuffer so the standard mixing doesn't double-dip?
+                    // No, Sonobus regular mixing uses chanGroups. 
+                    // We must ensure regular mixing doesn't add the stems again.
+                }
             }
 
             
@@ -7951,15 +8486,26 @@ void SonobusAudioProcessor::processBlock (AudioBuffer<float>& buffer, MidiBuffer
             {
                 // apply solo muting to the gain here
                 float adjgain = anysubsolo && !remote->chanGroups[i].params.soloed ? 0.0f : tgain;
-                // todo change dest ch target
-                int dstch = remote->chanGroups[i].params.panDestStartIndex;
-                int dstcnt = jmin(totalOutputChannels, remote->chanGroups[i].params.panDestChannels);
-                remote->chanGroups[i].processPan(remote->workBuffer, remote->chanGroups[i].params.chanStartIndex, tempBuffer, dstch, dstcnt, numSamples, adjgain);
+                
+                if (remote->isMogg) {
+                    // MOGG mixing: use the extracted stems
+                    if (i < remote->moggStems.getNumChannels()) {
+                        int dstch = remote->chanGroups[i].params.panDestStartIndex;
+                        int dstcnt = jmin(totalOutputChannels, remote->chanGroups[i].params.panDestChannels);
+                        remote->chanGroups[i].processPan(remote->moggStems, i, tempBuffer, dstch, dstcnt, numSamples, adjgain);
+                    }
+                } else {
+                    int dstch = remote->chanGroups[i].params.panDestStartIndex;
+                    int dstcnt = jmin(totalOutputChannels, remote->chanGroups[i].params.panDestChannels);
+                    remote->chanGroups[i].processPan(remote->workBuffer, remote->chanGroups[i].params.chanStartIndex, tempBuffer, dstch, dstcnt, numSamples, adjgain);
+                }
 
                 if (doreverb) {
-                    remote->chanGroups[i].processReverbSend(remote->workBuffer, remote->chanGroups[i].params.chanStartIndex, remote->chanGroups[i].params.numChannels, mainFxBuffer, 0, fxchannels, numSamples, mainReverbEnabled, false, adjgain);
+                    if (remote->isMogg && i < remote->moggStems.getNumChannels())
+                        remote->chanGroups[i].processReverbSend(remote->moggStems, i, 1, mainFxBuffer, 0, fxchannels, numSamples, mainReverbEnabled, false, adjgain);
+                    else
+                        remote->chanGroups[i].processReverbSend(remote->workBuffer, remote->chanGroups[i].params.chanStartIndex, remote->chanGroups[i].params.numChannels, mainFxBuffer, 0, fxchannels, numSamples, mainReverbEnabled, false, adjgain);
                 }
-
             }
 
         }
@@ -8009,8 +8555,9 @@ void SonobusAudioProcessor::processBlock (AudioBuffer<float>& buffer, MidiBuffer
                                     //remote->recvPanLast[ch] = pan;
                                 }
                             } else {
-                                
-                                workBuffer.addFrom(channel, 0, crossremote->workBuffer, channel, 0, numSamples);
+                                if (channel < crossremote->workBuffer.getNumChannels()) {
+                                    workBuffer.addFrom(channel, 0, crossremote->workBuffer, channel, 0, numSamples);
+                                }
                             }
                             
                         }                        
@@ -8227,13 +8774,25 @@ void SonobusAudioProcessor::processBlock (AudioBuffer<float>& buffer, MidiBuffer
 
     // add from file playback buffer
     if (hasfiledata) {
-
-        int dstch = mFilePlaybackChannelGroup.params.monDestStartIndex;
-        int dstcnt = jmin(totalOutputChannels, mFilePlaybackChannelGroup.params.monDestChannels);
-        auto fgain = mFilePlaybackChannelGroup.params.gain;
-
-        // process the monitor part of the metchannelgroup
-        mFilePlaybackChannelGroup.processMonitor(fileBuffer, 0, buffer, dstch, dstcnt, numSamples, fgain);
+    if (mTransportSource.isPlaying() && filestartch >= 0) {
+        auto filech = filestartch;
+        for (int i=0; i < mFilePlaybackGroupCount; i++) {
+             if (mFilePlaybackChannelGroups[i].params.muted || mFilePlaybackChannelGroups[i].params.monitor == 0.0f) {
+                 filech += 1;
+                 continue;
+             }
+             if (anyinputsoloed && !mFilePlaybackChannelGroups[i].params.soloed) {
+                 filech += 1;
+                 continue;
+             }
+             int dstch = mFilePlaybackChannelGroups[i].params.monDestStartIndex;
+             int dstcnt = jmin(totalOutputChannels, mFilePlaybackChannelGroups[i].params.monDestChannels);
+             auto fgain = mFilePlaybackChannelGroups[i].params.gain; // monitor takes gain into account too? -> processMonitor uses gain
+             
+             mFilePlaybackChannelGroups[i].processMonitor(fileBuffer, filech, buffer, dstch, dstcnt, numSamples, fgain);
+             filech += 1;
+        }
+    }
     }
 
     if (hassoundboarddata) {
@@ -8319,11 +8878,25 @@ void SonobusAudioProcessor::processBlock (AudioBuffer<float>& buffer, MidiBuffer
                 }
 
                 if (hasfiledata) {
-                    int dstch = mRecFilePlaybackChannelGroup.params.monDestStartIndex;
-                    int dstcnt = jmin(totalOutputChannels, mRecFilePlaybackChannelGroup.params.monDestChannels);
-                    auto fgain = mRecFilePlaybackChannelGroup.params.gain * wetnow;
-                    // process the monitor part of the metchannelgroup
-                    mRecFilePlaybackChannelGroup.processMonitor(fileBuffer, 0, workBuffer, dstch, dstcnt, numSamples, fgain);
+                    if (mTransportSource.isPlaying() && filestartch >= 0) {
+                        auto filech = filestartch;
+                        for (int i=0; i < mFilePlaybackGroupCount; i++) {
+                             if (mRecFilePlaybackChannelGroups[i].params.muted || mRecFilePlaybackChannelGroups[i].params.monitor == 0.0f) {
+                                 filech += 1;
+                                 continue;
+                             }
+                             if (anyinputsoloed && !mRecFilePlaybackChannelGroups[i].params.soloed) {
+                                 filech += 1;
+                                 continue;
+                             }
+                             int dstch = mRecFilePlaybackChannelGroups[i].params.monDestStartIndex;
+                             int dstcnt = jmin(totalOutputChannels, mRecFilePlaybackChannelGroups[i].params.monDestChannels);
+                             auto fgain = mRecFilePlaybackChannelGroups[i].params.gain * wetnow;
+                             
+                             mRecFilePlaybackChannelGroups[i].processMonitor(fileBuffer, filech, workBuffer, dstch, dstcnt, numSamples, fgain);
+                             filech += 1;
+                        }
+                    }
                 }
 
                 if (hassoundboarddata) {
@@ -8377,9 +8950,33 @@ void SonobusAudioProcessor::processBlock (AudioBuffer<float>& buffer, MidiBuffer
 
                 }
 
-                if (activeMixWriter.load() != nullptr) {
-                    // write out full mix
-                    activeMixWriter.load()->write (workBuffer.getArrayOfReadPointers(), numSamples);
+                if (auto writer = activeMixWriter.load()) {
+                    if (moggWritingPossible.load()) {
+                        if (moggWorkBuffer.getNumChannels() != totalRecordingChannels || moggWorkBuffer.getNumSamples() < numSamples) {
+                            moggWorkBuffer.setSize(totalRecordingChannels, numSamples, false, false, true);
+                        }
+                        moggWorkBuffer.clear();
+                        
+                        // Self
+                        const float * const* inbufs = mRecordInputPreFX ? inputPreBuffer.getArrayOfReadPointers() : inputPostBuffer.getArrayOfReadPointers();
+                        for (int i=0; i < moggSelfChannels && i < totalRecordingChannels; ++i) {
+                             const bool silenceIns = mRecordInputSilenceWhenMuted && (inGain == 0.0f); 
+                             if (!silenceIns) moggWorkBuffer.copyFrom(i, 0, inbufs[i], numSamples);
+                        }
+                        
+                        // Peers
+                        for (auto & remote : mRemotePeers) {
+                             if (remote->moggStartChannel >= 0 && remote->moggStartChannel + remote->recvChannels <= totalRecordingChannels) {
+                                 for (int c=0; c < remote->recvChannels; ++c) {
+                                     moggWorkBuffer.copyFrom(remote->moggStartChannel + c, 0, remote->workBuffer, c, 0, numSamples);
+                                 }
+                             }
+                        }
+                        writer->write(moggWorkBuffer.getArrayOfReadPointers(), numSamples);
+                    } else {
+                        // write out full mix
+                        writer->write (workBuffer.getArrayOfReadPointers(), numSamples);
+                    }
                 }
                 
             }
@@ -8565,7 +9162,7 @@ void SonobusAudioProcessor::getStateInformationWithOptions(MemoryBlock& destData
     ValueTree extraChannelGroupsTree = tempstate.getOrCreateChildWithName(extraChannelGroupsStateKey, nullptr);
     extraChannelGroupsTree.removeAllChildren(nullptr);
     
-    auto fpcg = mFilePlaybackChannelGroup.params.getValueTree();
+    auto fpcg = mFilePlaybackChannelGroups[0].params.getValueTree();
     fpcg.setProperty("chgID", "filepb", nullptr);
     extraChannelGroupsTree.appendChild(fpcg, nullptr);
 
@@ -8577,6 +9174,18 @@ void SonobusAudioProcessor::getStateInformationWithOptions(MemoryBlock& destData
     sbcg.setProperty("chgID", "soundboard", nullptr);
     extraChannelGroupsTree.appendChild(sbcg, nullptr);
 
+    // Save MIDI mappings
+    ValueTree midiMappingsTree = tempstate.getOrCreateChildWithName("MidiMappings", nullptr);
+    midiMappingsTree.removeAllChildren(nullptr);
+    {
+        ScopedLock sl(mMidiMappingsLock);
+        for (auto& kv : mMidiMappings) {
+            if (kv.second.isValid()) {
+                midiMappingsTree.appendChild(kv.second.getValueTree(), nullptr);
+            }
+        }
+    }
+
     
     ValueTree peerCacheTree = tempstate.getOrCreateChildWithName(peerStateCacheMapKey, nullptr);
     if (includecache) {
@@ -8754,10 +9363,12 @@ void SonobusAudioProcessor::setStateInformationWithOptions (const void* data, in
                 params.setFromValueTree(channelGroupTree);
 
                 if (cid == "filepb") {
-                    mFilePlaybackChannelGroup.params = params;
-                    mFilePlaybackChannelGroup.commitAllParams();
-                    mRecFilePlaybackChannelGroup.params = params;
-                    mRecFilePlaybackChannelGroup.commitAllParams();
+                    for (int i=0; i < MAX_CHANGROUPS; i++) {
+                        mFilePlaybackChannelGroups[i].params = params;
+                        mFilePlaybackChannelGroups[i].commitAllParams();
+                        mRecFilePlaybackChannelGroups[i].params = params;
+                        mRecFilePlaybackChannelGroups[i].commitAllParams();
+                    }
                 }
                 else if (cid == "met") {
                     mMetChannelGroup.params = params;
@@ -8770,6 +9381,20 @@ void SonobusAudioProcessor::setStateInformationWithOptions (const void* data, in
             }
         }
 
+        // Restore MIDI mappings
+        ValueTree midiMappingsTree = mState.state.getChildWithName("MidiMappings");
+        if (midiMappingsTree.isValid()) {
+            ScopedLock sl(mMidiMappingsLock);
+            mMidiMappings.clear();
+            for (auto child : midiMappingsTree) {
+                MidiMapping m;
+                m.setFromValueTree(child);
+                if (m.isValid()) {
+                    mMidiMappings[m.getKey()] = m;
+                }
+            }
+        }
+
         
         if (includecache) {
             loadPeerCacheFromState();
@@ -9152,6 +9777,21 @@ bool SonobusAudioProcessor::startRecordingToFile(const URL & recordLocationUrl,
         usefile = usefile.withFileExtension(".ogg");
         mimetype = "audio/ogg" ;
     }
+    else if (fileformat == FileFormatMOGG || (fileformat == FileFormatAuto && usefile.getFileExtension().toLowerCase() == ".mogg")) {
+        moggSelfChannels = mActiveInputChannels;
+        totalRecordingChannels = moggSelfChannels;
+        for (auto& remote : mRemotePeers) {
+            remote->moggStartChannel = totalRecordingChannels;
+            totalRecordingChannels += remote->recvChannels;
+        }
+        if (totalRecordingChannels == 0) totalRecordingChannels = 2;
+
+        audioFormat = std::make_unique<OggVorbisAudioFormat>();
+        qualindex = 8; // 256k
+        usefile = usefile.withFileExtension(".mogg");
+        mimetype = "audio/ogg";
+        moggWritingPossible = true;
+    }
     else {
         mLastError = TRANS("Could not find format for filename");
         DBG(mLastError);
@@ -9526,6 +10166,7 @@ bool SonobusAudioProcessor::stopRecordingToFile()
 
         writingPossible.store(false);
         userWritingPossible.store(false);
+        moggWritingPossible.store(false);
 
         // transfer ownership of writers to our temporary OwnedArray to be cleared below
         for (auto & remote : mRemotePeers) {
@@ -9604,7 +10245,7 @@ bool SonobusAudioProcessor::loadURLIntoTransport (const URL& audioURL)
     AudioFormatReader* reader = nullptr;
     
 #if ! (JUCE_IOS || JUCE_ANDROID)
-    if (audioURL.isLocalFile())
+    if (audioURL.isLocalFile() && !audioURL.getLocalFile().getFileExtension().containsIgnoreCase("mogg") && !audioURL.getLocalFile().getFileExtension().containsIgnoreCase("m0gg"))
     {
         reader = mFormatManager.createReaderFor (audioURL.getLocalFile());
     }
@@ -9653,6 +10294,31 @@ bool SonobusAudioProcessor::loadURLIntoTransport (const URL& audioURL)
                                     reader->sampleRate,     // allows for sample rate correction
                                     reader->numChannels);
 
+        // Update MOGG stem counts and groups
+        int srcchans = reader->numChannels;
+        mFilePlaybackGroupCount = std::min(srcchans + 1, MAX_CHANGROUPS);
+        
+        // Group 0 is the Full Mix (stereo)
+        mFilePlaybackChannelGroups[0].params.numChannels = 2;
+        mFilePlaybackChannelGroups[0].params.name = "Full Mix";
+        mFilePlaybackChannelGroups[0].commitMonitorDelayParams();
+
+        for (int i=1; i < mFilePlaybackGroupCount; i++) {
+            mFilePlaybackChannelGroups[i].params.numChannels = 1;
+            mFilePlaybackChannelGroups[i].params.name = "Stem " + String(i);
+            mFilePlaybackChannelGroups[i].params.gain = 1.0f; // Reset gain for MOGG stems to full
+            mFilePlaybackChannelGroups[i].commitMonitorDelayParams();
+        }
+
+        if (mFilePlaybackGroupCount > 2) { // MOGG detected
+            if (mSendChannels.get() != 0) {
+                DBG("Auto switching to Multichannel (Match Inputs) mode for MOGG file");
+                mState.getParameter(paramSendChannels)->setValueNotifyingHost(0.0f);
+            }
+        }
+        
+        updateRemotePeerUserFormat();
+
         return true;
     }
 
@@ -9755,9 +10421,95 @@ double SonobusAudioProcessor::getMonitoringDelayTimeFromAvgPeerLatency(float sca
 
 
 
+
+void SonobusAudioProcessor::setMidiRelayDevice (const String& name)
+{
+    if (mMidiRelayDevice == name) return;
+    mMidiRelayDevice = name;
+    mMidiRelayInput.reset();
+    if (name.isNotEmpty()) {
+        auto devices = MidiInput::getAvailableDevices();
+        for (auto& d : devices) {
+            if (d.name == name) {
+                mMidiRelayInput = MidiInput::openDevice (d.identifier, this);
+                break;
+            }
+        }
+        if (mMidiRelayInput) mMidiRelayInput->start();
+    }
+}
+
+void SonobusAudioProcessor::setMidiLearnDevice (const String& name)
+{
+    if (mMidiLearnDevice == name) return;
+    mMidiLearnDevice = name;
+    mMidiLearnInput.reset();
+    if (name.isNotEmpty()) {
+        auto devices = MidiInput::getAvailableDevices();
+        for (auto& d : devices) {
+            if (d.name == name) {
+                mMidiLearnInput = MidiInput::openDevice (d.identifier, this);
+                break;
+            }
+        }
+        if (mMidiLearnInput) mMidiLearnInput->start();
+    }
+}
+
+void SonobusAudioProcessor::handleIncomingMidiMessage (MidiInput* source, const MidiMessage& message)
+{
+    if (source == mMidiRelayInput.get()) {
+        sendMidiToPeers (message);
+    }
+    
+    if (source == mMidiLearnInput.get()) {
+        if (mMidiLearnActive.load() && (message.isController() || message.isNoteOn())) {
+            setMidiMapping (mMidiLearnTargetType, mMidiLearnTargetData, 
+                            message.isController() ? message.getControllerNumber() : message.getNoteNumber(), 
+                            message.getChannel());
+            mMidiLearnActive = false;
+        }
+    }
+}
+
+void SonobusAudioProcessor::sendMidiToPeers (const MidiMessage& message)
+{
+    char buf[AOO_MAXPACKETSIZE];
+    osc::OutboundPacketStream msg (buf, sizeof (buf));
+    try {
+        msg << osc::BeginMessage ("/sb/midi")
+            << osc::Blob (message.getRawData(), (int) message.getRawDataSize())
+            << osc::EndMessage;
+    } catch (...) { return; }
+
+
+    const ScopedReadLock sl (mCoreLock);
+    for (int i = 0; i < mRemotePeers.size(); ++i) {
+        if (mRemotePeerMidiRelay[i]) {
+            sendPeerMessage (mRemotePeers.getUnchecked(i), msg.Data(), (int) msg.Size());
+        }
+    }
+}
+
+void SonobusAudioProcessor::setRemotePeerMidiRelay (int peerIndex, bool enabled)
+{
+    if (peerIndex >= 0 && peerIndex < MAX_PEERS) {
+        mRemotePeerMidiRelay[peerIndex] = enabled;
+    }
+}
+
+bool SonobusAudioProcessor::getRemotePeerMidiRelay (int peerIndex) const
+{
+    if (peerIndex >= 0 && peerIndex < MAX_PEERS) {
+        return mRemotePeerMidiRelay[peerIndex];
+    }
+    return false;
+}
+
 //==============================================================================
 // This creates new instances of the plugin..
 AudioProcessor* JUCE_CALLTYPE createPluginFilter()
 {
     return new SonobusAudioProcessor();
 }
+
diff --git a/Source/SonobusPluginProcessor.h b/Source/SonobusPluginProcessor.h
index 0ddcbb680..81e14c1e0 100644
--- a/Source/SonobusPluginProcessor.h
+++ b/Source/SonobusPluginProcessor.h
@@ -113,7 +113,7 @@ inline bool operator<(const AooServerConnectionInfo& lhs, const AooServerConnect
 //==============================================================================
 /**
 */
-class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValueTreeState::Listener, public ChangeListener
+class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValueTreeState::Listener, public ChangeListener, public MidiInputCallback
 {
 public:
     //==============================================================================
@@ -149,7 +149,8 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
         FileFormatAuto,
         FileFormatFLAC,
         FileFormatWAV,
-        FileFormatOGG
+        FileFormatOGG,
+        FileFormatMOGG
     };
 
     enum PeerDisplayMode {
@@ -179,7 +180,66 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
         String destName;
         float latencyMs = 0.0f; // one way latency from source->dest in ms
     };
-    
+
+    // =========================================================================
+    // MIDI Learn
+    // =========================================================================
+    enum MidiTargetType {
+        MidiTarget_None = 0,
+        MidiTarget_FileStemGain,   // data = stem index
+        MidiTarget_FileStemMute,   // data = stem index
+        MidiTarget_FileStemSolo,   // data = stem index
+        MidiTarget_InputGain,
+        MidiTarget_OutputGain,
+        MidiTarget_PeerLevel,      // data = peer index
+        MidiTarget_PeerPan,        // data = peer index
+        MidiTarget_PeerMute,       // data = peer index
+        MidiTarget_MonitorLevel,
+        MidiTarget_MetronomeLevel,
+        MidiTarget_InputMute,
+        MidiTarget_SoundboardLevel,
+        MidiTarget_FXLevel,
+        MidiTarget_FullMixMonitorLevel,
+        MidiTarget_TransportPlay,
+        MidiTarget_TransportRecord,
+        MidiTarget_TransportLoop,
+        MidiTarget_TransportMetronome,
+        MidiTarget_ResetAllJitters,
+        MidiTarget_FileStemMonitor,
+        MidiTarget_FXEnable
+    };
+
+
+    struct MidiMapping {
+        MidiTargetType  targetType = MidiTarget_None;
+        int             targetData = 0;   // stem index etc.
+        int             ccNumber   = -1;  // -1 = not assigned
+        int             midiChannel = 0;  // 0 = any channel
+
+        bool isValid() const { return targetType != MidiTarget_None && ccNumber >= 0; }
+        String getKey() const { return String((int)targetType) + "_" + String(targetData); }
+        ValueTree getValueTree() const;
+        void setFromValueTree(const ValueTree& v);
+    };
+
+    // Add / remove / query mappings
+    void setMidiMapping(MidiTargetType type, int data, int ccNumber, int midiChannel = 0);
+    bool getMidiMapping(MidiTargetType type, int data, int& outCC, int& outChannel) const;
+    void clearMidiMapping(MidiTargetType type, int data);
+    void clearAllMidiMappings();
+
+    // Enter/exit learn mode for a specific target
+    void startMidiLearn(MidiTargetType type, int data);
+    void stopMidiLearn();
+    bool isMidiLearning() const { return mMidiLearnActive; }
+    MidiTargetType getMidiLearnTargetType() const { return mMidiLearnTargetType; }
+    int  getMidiLearnTargetData() const { return mMidiLearnTargetData; }
+
+    // Listeners notified when a mapping is captured or cleared
+    struct MidiLearnListener { virtual ~MidiLearnListener(){} virtual void midiMappingChanged() {} };
+    void addMidiLearnListener(MidiLearnListener* l)    { mMidiLearnListeners.add(l); }
+    void removeMidiLearnListener(MidiLearnListener* l) { mMidiLearnListeners.remove(l); }
+
     int32 getCurrSamplesPerBlock() const { return currSamplesPerBlock; }
     
     void changeListenerCallback (ChangeBroadcaster* source) override;
@@ -190,6 +250,20 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
     void prepareToPlay (double sampleRate, int samplesPerBlock) override;
     void releaseResources() override;
 
+    void handleIncomingMidiMessage (MidiInput* source, const MidiMessage& message) override;
+
+    void setMidiRelayDevice (const String& name);
+    void setMidiLearnDevice (const String& name);
+    String getMidiRelayDevice() const { return mMidiRelayDevice; }
+    String getMidiLearnDevice() const { return mMidiLearnDevice; }
+
+    void setRemotePeerMidiRelay(int peerIndex, bool enabled);
+    bool getRemotePeerMidiRelay(int peerIndex) const;
+
+    void sendMidiToPeers (const MidiMessage& message);
+
+
+
    #ifndef JucePlugin_PreferredChannelConfigurations
     bool isBusesLayoutSupported (const BusesLayout& layouts) const override;
    #endif
@@ -254,7 +328,9 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
     static String paramSendMetAudio;
     static String paramSendFileAudio;
     static String paramSendSoundboardAudio;
+    static String paramSoundboardGain;
     static String paramHearLatencyTest;
+
     static String paramMetIsRecorded;
     static String paramMainReverbEnabled;
     static String paramMainReverbLevel;
@@ -327,7 +403,7 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
     IPAddress getLocalIPAddress() const { return mLocalIPAddress; }
     
 
-    int getSendChannels() const { return mSendChannels.get(); }
+    int getSendChannels() const;
 
     int connectRemotePeer(const String & host, int port, const String & username = "", const String & groupname = "",  bool reciprocate=true);
     bool disconnectRemotePeer(const String & host, int port, int32_t sourceId);
@@ -632,6 +708,9 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
     
     void setRemotePeerConnected(int index, bool active);
     bool getRemotePeerConnected(int index) const;
+
+    bool getRemotePeerIsMogg(int index) const;
+    int  getRemotePeerMoggStemCount(int index) const;
     
     bool getRemotePeerAddressInfo(int index, String & rethost, int & retport) const;
 
@@ -722,14 +801,23 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
     float getMetronomeMonitor() const;
 
 
-    void setFilePlaybackMonitorDelayParams(SonoAudio::DelayParams & params);
-    bool getFilePlaybackMonitorDelayParams(SonoAudio::DelayParams & retparams);
-    void setFilePlaybackDestStartAndCount(int start, int count);
-    bool getFilePlaybackDestStartAndCount(int & retstart, int & retcount);
-    void setFilePlaybackGain(float gain);
-    float getFilePlaybackGain() const;
-    void setFilePlaybackMonitor(float mgain);
-    float getFilePlaybackMonitor() const;
+    void setFilePlaybackMonitorDelayParams(int index, SonoAudio::DelayParams & params);
+    bool getFilePlaybackMonitorDelayParams(int index, SonoAudio::DelayParams & retparams);
+    void setFilePlaybackDestStartAndCount(int index, int start, int count);
+    bool getFilePlaybackDestStartAndCount(int index, int & retstart, int & retcount);
+    void setFilePlaybackGain(int index, float gain);
+    float getFilePlaybackGain(int index) const;
+    void setFilePlaybackPan(int index, float pan);
+    float getFilePlaybackPan(int index) const;
+    void setFilePlaybackMonitor(int index, float mgain);
+    float getFilePlaybackMonitor(int index) const;
+    void setFilePlaybackMuted(int index, bool muted);
+    bool getFilePlaybackMuted(int index) const;
+    void setFilePlaybackSoloed(int index, bool soloed);
+    bool getFilePlaybackSoloed(int index) const;
+    String getFilePlaybackChannelGroupName(int index) const;
+    
+    int getFilePlaybackGroupCount() const { return mFilePlaybackGroupCount; }
 
 
     void setLinkMonitoringDelayTimes(bool flag) { mLinkMonitoringDelayTimes = flag; }
@@ -830,7 +918,7 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
 
 private:
     //==============================================================================
-    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (SonobusAudioProcessor)
+
     
     struct PeerStateCache
     {
@@ -1077,6 +1165,11 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
     foleys::LevelMeterSource outputMeterSource;
     foleys::LevelMeterSource filePlaybackMeterSource;
     foleys::LevelMeterSource metMeterSource;
+    foleys::LevelMeterSource moggStemMeterSources[MAX_CHANGROUPS];
+
+public:
+    foleys::LevelMeterSource& getMoggStemMeterSource(int peerIndex, int stemIndex);
+private:
 
     // AOO stuff
     aoo::isource::pointer mAooDummySource;
@@ -1199,13 +1292,14 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
 
     // met and playback channel groups
     SonoAudio::ChannelGroup  mMetChannelGroup;
-    SonoAudio::ChannelGroup  mFilePlaybackChannelGroup;
-
-    float _lastfplaygain = 0.0f;
+    SonoAudio::ChannelGroup  mFilePlaybackChannelGroups[MAX_CHANGROUPS];
+    int mFilePlaybackGroupCount = 1;
 
-    // and a replicant one for recording purposes
     SonoAudio::ChannelGroup  mRecMetChannelGroup;
-    SonoAudio::ChannelGroup  mRecFilePlaybackChannelGroup;
+    
+    SonoAudio::ChannelGroup  mRecFilePlaybackChannelGroups[MAX_CHANGROUPS];
+
+    float _lastfplaygain = 0.0f;
 
     
     // recording stuff
@@ -1224,7 +1318,11 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
 
     std::atomic<bool> writingPossible = { false };
     std::atomic<bool> userWritingPossible = { false };
+    std::atomic<bool> moggWritingPossible = { false };
     int totalRecordingChannels = 2;
+    int moggSelfChannels = 2;
+    AudioSampleBuffer moggWorkBuffer;
+    Array<int> moggPeerChannelStartIndices;
     int64 mElapsedRecordSamples = 0;
     std::unique_ptr<TimeSliceThread> recordingThread;
     std::unique_ptr<AudioFormatWriter::ThreadedWriter> threadedMixWriter;
@@ -1264,10 +1362,29 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
     String mLangOverrideCode;
     bool mUseUniversalFont = false;
 
+    // MIDI Learn private state
+    std::map<String, MidiMapping> mMidiMappings;         // key = MidiMapping::getKey()
+    CriticalSection               mMidiMappingsLock;
+    std::atomic<bool>            mMidiLearnActive { false };
+    MidiTargetType                mMidiLearnTargetType = MidiTarget_None;
+    int                           mMidiLearnTargetData = 0;
+    ListenerList<MidiLearnListener> mMidiLearnListeners;
+
+    String mMidiRelayDevice;
+    String mMidiLearnDevice;
+    std::unique_ptr<MidiInput> mMidiRelayInput;
+    std::unique_ptr<MidiInput> mMidiLearnInput;
+    
+    bool mRemotePeerMidiRelay[MAX_PEERS];
+    MidiBuffer mIncomingMidiFromPeers;
+    bool mIncomingMidiAvailable = false;
+
+
     // main state
     AudioProcessorValueTreeState mState;
     UndoManager                  mUndoManager;
 
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (SonobusAudioProcessor)
 };
 
 
diff --git a/Source/Soundboard.h b/Source/Soundboard.h
index 91ced8106..601002d7a 100644
--- a/Source/Soundboard.h
+++ b/Source/Soundboard.h
@@ -22,12 +22,12 @@ class SoundSample
     /**
      * The file extensions of sound file types that are supported by the soundboard.
      */
-    constexpr static const char SUPPORTED_EXTENSIONS[] = "*.wav;*.flac;*.aif;*.ogg;*.mp3;*.m4a;*.caf";
+    constexpr static const char SUPPORTED_EXTENSIONS[] = "*.wav;*.flac;*.aif;*.ogg;*.mp3;*.m4a;*.caf;*.mogg;*.m0gg";
 #else
     /**
      * The file extensions of sound file types that are supported by the soundboard.
      */
-    constexpr static const char SUPPORTED_EXTENSIONS[] = "*.wav;*.flac;*.aif;*.ogg;*.mp3";
+    constexpr static const char SUPPORTED_EXTENSIONS[] = "*.wav;*.flac;*.aif;*.ogg;*.mp3;*.mogg;*.m0gg";
 #endif
 
     enum PlaybackBehaviour {
diff --git a/Source/SoundboardChannelProcessor.cpp b/Source/SoundboardChannelProcessor.cpp
index a0dbbbe84..7fa52fb4d 100644
--- a/Source/SoundboardChannelProcessor.cpp
+++ b/Source/SoundboardChannelProcessor.cpp
@@ -25,7 +25,7 @@ bool SamplePlaybackManager::loadFileFromSample(TimeSliceThread &fileReadThread)
     auto audioFileUrl = sample->getFileURL();
 
 #if ! (JUCE_IOS || JUCE_ANDROID)
-    if (audioFileUrl.isLocalFile()) {
+    if (audioFileUrl.isLocalFile() && !audioFileUrl.getLocalFile().getFileExtension().containsIgnoreCase("mogg") && !audioFileUrl.getLocalFile().getFileExtension().containsIgnoreCase("m0gg")) {
         reader = formatManager.createReaderFor(audioFileUrl.getLocalFile());
     }
     else
diff --git a/Source/SoundboardView.cpp b/Source/SoundboardView.cpp
index 548c84a37..0aebc99e5 100644
--- a/Source/SoundboardView.cpp
+++ b/Source/SoundboardView.cpp
@@ -182,14 +182,13 @@ void SoundboardView::createControlPanel()
     };
     addAndMakeVisible(mStopAllPlayback.get());
 
-    mVolumeSlider  = std::make_unique<Slider>(Slider::RotaryHorizontalVerticalDrag,  Slider::TextBoxRight);
-    mVolumeSlider->setName("level");
+    mVolumeSlider  = std::make_unique<SonoSlider>(Slider::RotaryHorizontalVerticalDrag,  Slider::TextBoxRight);
+    mVolumeSlider->setName("soundboard_level");
     mVolumeSlider->setTitle(TRANS("Soundboard volume"));
-    //mVolumeSlider->addListener(this);
-    mVolumeSlider->onValueChange = [this]() {
-        audioProcessor.getSoundboardProcessor()->setGain(mVolumeSlider->getValue());
-    };
+    mVolumeSlider->addMouseListener(this, false);
+
     mVolumeSlider->setColour(Slider::textBoxBackgroundColourId, Colours::transparentBlack);
+
     mVolumeSlider->setColour(Slider::textBoxOutlineColourId, Colours::transparentBlack);
     mVolumeSlider->setColour(Slider::textBoxTextColourId, Colour(0x90eeeeee));
     mVolumeSlider->setColour(TooltipWindow::textColourId, Colour(0xf0eeeeee));
@@ -206,7 +205,9 @@ void SoundboardView::createControlPanel()
     mVolumeSlider->textFromValueFunction = [](float v) -> String { return String(TRANS("Level: ")) + Decibels::toString(Decibels::gainToDecibels(v), 1); };
     mVolumeSlider->setLookAndFeel(&volSliderLNF);
     mVolumeSlider->setTextBoxStyle(Slider::NoTextBox, true, 60, 14);
-    mVolumeSlider->setValue(audioProcessor.getSoundboardProcessor()->getGain());
+    // mVolumeSlider->setValue(audioProcessor.getSoundboardProcessor()->getGain());
+    mVolumeAttachment = std::make_unique<AudioProcessorValueTreeState::SliderAttachment> (audioProcessor.getValueTreeState(), SonobusAudioProcessor::paramSoundboardGain, *mVolumeSlider);
+
     mVolumeSlider->setPopupDisplayEnabled(true, true, this);
 
     addAndMakeVisible(mVolumeSlider.get());
@@ -421,7 +422,15 @@ void SoundboardView::mouseEnter (const MouseEvent&)
 
 void SoundboardView::mouseDown (const MouseEvent& event)
 {
+    if (event.mods.isRightButtonDown()) {
+        if (event.eventComponent == mVolumeSlider.get()) {
+            showMidiMenu(mVolumeSlider.get(), SonobusAudioProcessor::MidiTarget_SoundboardLevel);
+            return;
+        }
+    }
+
     for (int i=0; i < mSoundButtons.size(); ++i) {
+
         auto & sbutton = mSoundButtons[i];
 
         if (event.eventComponent == sbutton.get()) {
@@ -1146,3 +1155,28 @@ void HoldSampleButtonMouseListener::mouseUp(const MouseEvent& event)
     }
 }
 
+
+void SoundboardView::showMidiMenu(Component* source, SonobusAudioProcessor::MidiTargetType type, int data)
+{
+    int ccNum = -1, midiCh = 0;
+    bool hasMapped = audioProcessor.getMidiMapping(type, data, ccNum, midiCh);
+
+    auto* menuComp = new PopupMenu();
+    menuComp->addItem(1, TRANS("MIDI Learn"));
+
+    String forgetText = TRANS("MIDI Forget");
+    if (hasMapped) forgetText += " (CC " + String(ccNum) + ", Ch " + String(midiCh) + ")";
+    menuComp->addItem(2, forgetText, hasMapped, false);
+
+    SafePointer<SoundboardView> safeThis(this);
+    menuComp->showMenuAsync(PopupMenu::Options().withMousePosition(), [safeThis, type, data, hasMapped](int result) {
+        if (safeThis == nullptr) return;
+        if (result == 1) {
+            safeThis->audioProcessor.startMidiLearn(type, data);
+        }
+        else if (result == 2 && hasMapped) {
+            safeThis->audioProcessor.clearMidiMapping(type, data);
+        }
+    });
+}
+
diff --git a/Source/SoundboardView.h b/Source/SoundboardView.h
index f0690115b..0088a451f 100644
--- a/Source/SoundboardView.h
+++ b/Source/SoundboardView.h
@@ -8,7 +8,9 @@
 
 #include "SonobusPluginProcessor.h"
 #include "SonoDrawableButton.h"
+#include "SonoSlider.h"
 #include "SonoPlaybackProgressButton.h"
+
 #include "SonoChoiceButton.h"
 #include "SoundboardProcessor.h"
 
@@ -201,13 +203,19 @@ class SoundboardView : public Component,
     std::unique_ptr<SonoDrawableButton> mStopAllPlayback;
 
     SonoPanSliderLookAndFeel volSliderLNF = { 12 };
-    std::unique_ptr<Slider> mVolumeSlider;
+    std::unique_ptr<SonoSlider> mVolumeSlider;
+
 
     std::unique_ptr<SonoDrawableButton> mSendAudioButton;
     std::unique_ptr<AudioProcessorValueTreeState::ButtonAttachment> mSendAudioAttachment;
+    std::unique_ptr<AudioProcessorValueTreeState::SliderAttachment> mVolumeAttachment;
+
+
+    void showMidiMenu(Component* source, SonobusAudioProcessor::MidiTargetType type, int data = 0);
 
     WeakReference<Component> mSampleEditCalloutBox;
 
+
     /**
      * Creates the outer UI panels.
      */