diff --git a/Source/OptionsView.cpp b/Source/OptionsView.cpp
index acb82f4eb..069f04339 100644
--- a/Source/OptionsView.cpp
+++ b/Source/OptionsView.cpp
@@ -117,9 +117,10 @@ OptionsView::OptionsView(SonobusAudioProcessor& proc, std::function<AudioDeviceM
     int numformats = processor.getNumberAudioCodecFormats();
     for (int i=0; i < numformats; ++i) {
         SonobusAudioProcessor::AudioCodecFormatInfo finfo;
-        processor.getAudioCodeFormatInfo(i, finfo);
+        processor.getAudioCodecFormatInfo(i, finfo);
         auto name = finfo.name;
-        if (finfo.codec == SonobusAudioProcessor::AudioCodecFormatCodec::CodecOpus && finfo.bitrate < 96000) {
+        if (finfo.codec == SonobusAudioProcessor::AudioCodecFormatCodec::CodecOpus && finfo.bitrate < 96000 ||
+            finfo.codec == SonobusAudioProcessor::AudioCodecFormatCodec::CodecPCM  && finfo.bitdepth == 1) {
             name += String(" (*)");
         }
         mOptionsFormatChoiceDefaultChoice->addItem(name, i+1);
diff --git a/Source/PeersContainerView.cpp b/Source/PeersContainerView.cpp
index 18f670509..4cf0ff3d1 100644
--- a/Source/PeersContainerView.cpp
+++ b/Source/PeersContainerView.cpp
@@ -526,35 +526,19 @@ PeerViewInfo * PeersContainerView::createPeerViewInfo()
     pvf->changeAllFormatButton->addListener(this);
     pvf->changeAllFormatButton->setLookAndFeel(&pvf->smallLnf);
 
-    
+    // initially don't add any choices to the send format choice buttons here
+    // the choices will later be added as soon as a peer sends us their supported codecs
     pvf->formatChoiceButton = std::make_unique<SonoChoiceButton>();
     pvf->formatChoiceButton->setTitle(TRANS("Send Quality"));
     pvf->formatChoiceButton->addChoiceListener(this);
-    int numformats = processor.getNumberAudioCodecFormats();
-    for (int i=0; i < numformats; ++i) {
-        SonobusAudioProcessor::AudioCodecFormatInfo finfo;
-        processor.getAudioCodeFormatInfo(i, finfo);
-        auto name = finfo.name;
-        if (finfo.codec == SonobusAudioProcessor::AudioCodecFormatCodec::CodecOpus && finfo.bitrate < 96000) {
-            name += String(" (*)");
-        }
-        pvf->formatChoiceButton->addItem(name, i);
-    }
-    pvf->formatChoiceButton->addItem("(*) " + TRANS("not recommended"), -2, true, true);
+    pvf->remoteSendFormatChoiceButton = std::make_unique<SonoChoiceButton>();
+    pvf->remoteSendFormatChoiceButton->addChoiceListener(this);
+    pvf->remoteSendFormatChoiceButton->setTitle(TRANS("Preferred Receive Quality"));
 
     pvf->staticFormatChoiceLabel = std::make_unique<Label>("sendfmtst", TRANS("Send Quality"));
     pvf->staticFormatChoiceLabel->setAccessible(false);
     configLabel(pvf->staticFormatChoiceLabel.get(), LabelTypeRegular);
 
-
-    pvf->remoteSendFormatChoiceButton = std::make_unique<SonoChoiceButton>();
-    pvf->remoteSendFormatChoiceButton->addChoiceListener(this);
-    pvf->remoteSendFormatChoiceButton->setTitle(TRANS("Preferred Receive Quality"));
-    pvf->remoteSendFormatChoiceButton->addItem(TRANS("No Preference"), -1);
-    for (int i=0; i < numformats; ++i) {
-        pvf->remoteSendFormatChoiceButton->addItem(processor.getAudioCodeFormatName(i), i);
-    }
-
     pvf->staticRemoteSendFormatChoiceLabel = std::make_unique<Label>("recvfmtst", TRANS("Preferred Recv Quality"));
     configLabel(pvf->staticRemoteSendFormatChoiceLabel.get(), LabelTypeRegular);
     pvf->staticRemoteSendFormatChoiceLabel->setAccessible(false);
@@ -1578,6 +1562,8 @@ void PeersContainerView::updatePeerViews(int specific)
     //    for (int i=0; i < mPeerViews.size(); ++i) {
     for (int di=0; di < mPeerUpdateOrdering.size(); ++di) {
         int i = mPeerUpdateOrdering[di];
+        // update the send format choice buttons dropdown choices, because a reordering of the peer views could have happened
+        updateAvailableCodecOptions(processor.getRemotePeerUserName(i));
 
         if (specific >= 0 && specific != i) continue;
         if (di >= mPeerViews.size()) {
@@ -1752,9 +1738,11 @@ void PeersContainerView::updatePeerViews(int specific)
         
         
         int formatindex = processor.getRemotePeerAudioCodecFormat(i);
-        pvf->formatChoiceButton->setSelectedItemIndex(formatindex >= 0 ? formatindex : processor.getDefaultAudioCodecFormat(), dontSendNotification);
+        // the formatIndex can differ from the choice buttons index
+        // thus set the selected value by using the SonoChoiceButtons "ident" and not the "index"
+        pvf->formatChoiceButton->setSelectedId(formatindex >= 0 ? formatindex : processor.getDefaultAudioCodecFormat(), dontSendNotification);
         String sendqual;
-        sendqual << processor.getRemotePeerActualSendChannelCount(i) << "ch " << processor.getAudioCodeFormatName(formatindex);
+        sendqual << processor.getRemotePeerActualSendChannelCount(i) << "ch " << processor.getAudioCodecFormatName(formatindex);
         pvf->sendQualityLabel->setText(sendqual, dontSendNotification);
         
         // pvf->recvMeter->setMeterSource (processor.getRemotePeerRecvMeterSource(i));
@@ -1825,6 +1813,39 @@ void PeersContainerView::updatePeerViews(int specific)
     lastUpdateTimestampMs = nowstampms;
 }
 
+// updates the send format choice buttons choices
+void PeersContainerView::updateAvailableCodecOptions(const String & username) {
+    // resolve view of peer
+    for (int di=0; di < mPeerViews.size(); ++di) {
+        int i = mPeerUpdateOrdering[di];
+        if (username == processor.getRemotePeerUserName(i)) {
+            PeerViewInfo * pvf = mPeerViews.getUnchecked(di);
+            pvf->formatChoiceButton->clearItems();
+            pvf->remoteSendFormatChoiceButton->clearItems();
+            // show codecs in the send and receive choices that are supported by the peer
+            std::vector<int> formats = processor.getRemotePeerSupportedAudioFormatIndexes(i);
+
+            for (auto & format : formats) {
+                SonobusAudioProcessor::AudioCodecFormatInfo finfo;
+                processor.getAudioCodecFormatInfo(format, finfo);
+                auto name = finfo.name;
+                if (finfo.codec == SonobusAudioProcessor::AudioCodecFormatCodec::CodecOpus && finfo.bitrate < 96000 ||
+                    finfo.codec == SonobusAudioProcessor::AudioCodecFormatCodec::CodecPCM  && finfo.bitdepth == 1) {
+                    name += String(" (*)");
+                }
+                pvf->formatChoiceButton->addItem(name, format);
+            }
+            pvf->formatChoiceButton->addItem("(*) " + TRANS("not recommended"), -2, true, true);
+
+            pvf->remoteSendFormatChoiceButton->addItem(TRANS("No Preference"), -1);
+            for (auto & format : formats) {
+                pvf->remoteSendFormatChoiceButton->addItem(processor.getAudioCodecFormatName(format), format);
+            }
+            return;
+        }
+    }
+}
+
 void PeersContainerView::startLatencyTest(int di)
 {
     if (di >= mPeerViews.size()) return;
diff --git a/Source/PeersContainerView.h b/Source/PeersContainerView.h
index 08017a913..efa9cc3be 100644
--- a/Source/PeersContainerView.h
+++ b/Source/PeersContainerView.h
@@ -244,6 +244,7 @@ public MultiTimer
 
     void setPeerDisplayMode(SonobusAudioProcessor::PeerDisplayMode mode);
 
+    void updateAvailableCodecOptions(const String & username);
 
 protected:
     
diff --git a/Source/SonobusPluginEditor.cpp b/Source/SonobusPluginEditor.cpp
index ec2717657..d9a7f25c8 100644
--- a/Source/SonobusPluginEditor.cpp
+++ b/Source/SonobusPluginEditor.cpp
@@ -1708,6 +1708,14 @@ void SonobusAudioProcessorEditor::peerBlockedInfoChanged(SonobusAudioProcessor *
 
 }
 
+void SonobusAudioProcessorEditor::peerCodecInfoReceived(SonobusAudioProcessor *comp, const String & username)
+{
+    {
+        const ScopedLock sl (clientStateLock);
+        clientEvents.add(ClientEvent(ClientEvent::PeerCodecInfoReceivedEvent, username));
+    }
+    triggerAsyncUpdate();
+}
 
 //////////////////////////
 
@@ -3938,6 +3946,8 @@ void SonobusAudioProcessorEditor::handleAsyncUpdate()
         }
         else if (ev.type == ClientEvent::PeerBlockedInfoChangedEvent) {
             updatePeerState(true);
+        } else if (ev.type == ClientEvent::PeerCodecInfoReceivedEvent) {
+            mPeerContainer->updateAvailableCodecOptions(ev.message);
         }
     }
 
diff --git a/Source/SonobusPluginEditor.h b/Source/SonobusPluginEditor.h
index 56cda39b0..e5b830ae8 100644
--- a/Source/SonobusPluginEditor.h
+++ b/Source/SonobusPluginEditor.h
@@ -146,6 +146,7 @@ public PeersContainerView::Listener
     void sbChatEventReceived(SonobusAudioProcessor *comp, const SBChatEvent & mesg) override;
     void peerRequestedLatencyMatch(SonobusAudioProcessor *comp, const String & username, float latency) override;
     void peerBlockedInfoChanged(SonobusAudioProcessor *comp, const String & username, bool blocked) override;
+    void peerCodecInfoReceived(SonobusAudioProcessor *comp, const String & userName) override;
 
     std::function<AudioDeviceManager*()> getAudioDeviceManager; // = []() { return 0; };
     std::function<bool()> isInterAppAudioConnected; // = []() { return 0; };
@@ -454,6 +455,7 @@ public PeersContainerView::Listener
             PublicGroupDeletedEvent,
             PeerRequestedLatencyMatchEvent,
             PeerBlockedInfoChangedEvent,
+            PeerCodecInfoReceivedEvent,
             Error
         };
         
diff --git a/Source/SonobusPluginProcessor.cpp b/Source/SonobusPluginProcessor.cpp
index ab4f921cd..2b9fc181d 100644
--- a/Source/SonobusPluginProcessor.cpp
+++ b/Source/SonobusPluginProcessor.cpp
@@ -359,6 +359,7 @@ struct SonobusAudioProcessor::RemotePeer {
     float remoteOutLatMs = 0.0f;
     int remoteNetType = RemoteNetTypeUnknown;
     bool remoteIsRecording = false;
+    std::set<Uuid> supportedCodecs;
     bool hasRemoteInfo = false;
     bool blockedUs = false;
 
@@ -1309,6 +1310,9 @@ void SonobusAudioProcessor::AudioCodecFormatInfo::computeName()
         name = String::formatted("%d kbps/ch", bitrate/1000);
     }
     else {
+        if (bitdepth == 1) {
+            name = "PCM 8 bit";
+        }
         if (bitdepth == 2) {
             name = "PCM 16 bit";
         }
@@ -1330,23 +1334,46 @@ void SonobusAudioProcessor::initFormats()
     
     // low bandwidth to high
     //mAudioFormats.add(AudioCodecFormatInfo(8000, 10, OPUS_SIGNAL_MUSIC, 960));
-    mAudioFormats.add(AudioCodecFormatInfo(16000, 10, OPUS_SIGNAL_MUSIC, 960));
-    mAudioFormats.add(AudioCodecFormatInfo(24000, 10, OPUS_SIGNAL_MUSIC, 480));
-    mAudioFormats.add(AudioCodecFormatInfo(48000, 10, OPUS_SIGNAL_MUSIC, 240));
-    mAudioFormats.add(AudioCodecFormatInfo(64000, 10, OPUS_SIGNAL_MUSIC, 240));
-    mAudioFormats.add(AudioCodecFormatInfo(96000, 10, OPUS_SIGNAL_MUSIC, 120));
-    mAudioFormats.add(AudioCodecFormatInfo(128000, 10, OPUS_SIGNAL_MUSIC, 120));
-    mAudioFormats.add(AudioCodecFormatInfo(160000, 10, OPUS_SIGNAL_MUSIC, 120));
-    mAudioFormats.add(AudioCodecFormatInfo(256000, 10, OPUS_SIGNAL_MUSIC, 120));
-    
-    mAudioFormats.add(AudioCodecFormatInfo(2));
-    mAudioFormats.add(AudioCodecFormatInfo(3));
-    mAudioFormats.add(AudioCodecFormatInfo(4));
+    mAudioFormats.add(AudioCodecFormatInfo(Uuid("d30affc3-db76-40fd-85bd-6ba4f67d75f0"), 16000, 10, OPUS_SIGNAL_MUSIC, 960));
+    mAudioFormats.add(AudioCodecFormatInfo(Uuid("540af31d-3047-420d-89d7-472c07dcbb2e"), 24000, 10, OPUS_SIGNAL_MUSIC, 480));
+    mAudioFormats.add(AudioCodecFormatInfo(Uuid("df40ba8a-3621-42d2-a9d7-b6fa0ef1be84"), 48000, 10, OPUS_SIGNAL_MUSIC, 240));
+    mAudioFormats.add(AudioCodecFormatInfo(Uuid("e440a4d9-a450-4462-8aa8-9b4af8576514"), 64000, 10, OPUS_SIGNAL_MUSIC, 240));
+    mAudioFormats.add(AudioCodecFormatInfo(Uuid("14aaab94-dbd6-4446-bf1b-64efb55f16f6"), 96000, 10, OPUS_SIGNAL_MUSIC, 120));
+    mAudioFormats.add(AudioCodecFormatInfo(Uuid("79dbf03b-c112-4517-aa1c-fa501fc7d0b6"), 128000, 10, OPUS_SIGNAL_MUSIC, 120));
+    mAudioFormats.add(AudioCodecFormatInfo(Uuid("4333f3e5-7537-4b94-af9a-dfd836d59055"), 160000, 10, OPUS_SIGNAL_MUSIC, 120));
+    mAudioFormats.add(AudioCodecFormatInfo(Uuid("46c728a4-d830-4388-a493-361cb3f7a220"), 256000, 10, OPUS_SIGNAL_MUSIC, 120));
+
+    mAudioFormats.add(AudioCodecFormatInfo(Uuid("25e8723d-4b66-4fa4-9c0b-1ee96ca74824"), 1));
+    mAudioFormats.add(AudioCodecFormatInfo(Uuid("d7942c5c-4802-425b-ac51-16e995af03cd"), 2));
+    mAudioFormats.add(AudioCodecFormatInfo(Uuid("70b9b5d8-e263-4053-a584-72a9e97ed97d"), 3));
+    mAudioFormats.add(AudioCodecFormatInfo(Uuid("9825290e-f2cf-41be-9ff8-0c25f60ae8ad"), 4));
     //mAudioFormats.add(AudioCodecFormatInfo(CodecPCM, 8)); // insanity!
 
     mDefaultAudioFormatIndex = 4; // 96kpbs/ch Opus
 }
 
+SonobusAudioProcessor::AudioCodecFormatInfo SonobusAudioProcessor::resolveOpusCodecInfo(int bitrate, int complexity, int signaltype) {
+    for (auto & format : mAudioFormats) {
+        if (format.codec == CodecOpus && format.bitrate == bitrate && format.complexity == complexity && format.signal_type == signaltype) {
+            DBG("resolved opus codec bitrate: " << format.bitrate << " complexity: " << format.complexity << " signaltype" << format.signal_type);
+            return format;
+        }
+    }
+    DBG("unable to resolve opus codec with bitrate: " << bitrate);
+    throw "opus codec not found";
+}
+
+SonobusAudioProcessor::AudioCodecFormatInfo SonobusAudioProcessor::resolvePcmCodecInfo(int bitdepth) {
+    for (auto & format : mAudioFormats) {
+        if (format.codec == CodecPCM && format.bitdepth == bitdepth) {
+            DBG("resolved pcm codec bitdepth: " << format.bitdepth);
+            return format;
+        }
+    }
+    DBG("unable to resolve pcm codec with bitdepth: " << bitdepth);
+    throw "pcm codec not found";
+}
+
 int SonobusAudioProcessor::findFormatIndex(SonobusAudioProcessor::AudioCodecFormatCodec codec, int bitrate, int bitdepth)
 {
     for (int i=0; i < mAudioFormats.size(); ++i) {
@@ -1367,7 +1394,7 @@ int SonobusAudioProcessor::findFormatIndex(SonobusAudioProcessor::AudioCodecForm
 }
 
 
-String SonobusAudioProcessor::getAudioCodeFormatName(int formatIndex) const
+String SonobusAudioProcessor::getAudioCodecFormatName(int formatIndex) const
 {
     if (formatIndex >= mAudioFormats.size() || formatIndex < 0) return "";
     
@@ -1375,7 +1402,7 @@ String SonobusAudioProcessor::getAudioCodeFormatName(int formatIndex) const
     return info.name;    
 }
 
-bool SonobusAudioProcessor::getAudioCodeFormatInfo(int formatIndex, AudioCodecFormatInfo & retinfo) const
+bool SonobusAudioProcessor::getAudioCodecFormatInfo(int formatIndex, AudioCodecFormatInfo & retinfo) const
 {
     if (formatIndex >= mAudioFormats.size() || formatIndex < 0) return false;
     retinfo = mAudioFormats.getReference(formatIndex);
@@ -1404,7 +1431,8 @@ void SonobusAudioProcessor::setDefaultAutoresizeBufferMode(AutoNetBufferMode fla
 void SonobusAudioProcessor::setRemotePeerAudioCodecFormat(int index, int formatIndex)
 {
     if (formatIndex >= mAudioFormats.size() || index >= mRemotePeers.size()) return;
-    
+    if (!doesPeerSupportCodec(mRemotePeers.getUnchecked(index), formatIndex)) return;
+
     const AudioCodecFormatInfo & info = mAudioFormats.getReference(formatIndex);
 
     const ScopedReadLock sl (mCoreLock);        
@@ -3073,20 +3101,89 @@ void SonobusAudioProcessor::handleRemotePeerInfoUpdate(RemotePeer * peer, const
         DBG("peerinfo: Got remote recording: " << (int)isrec);
         peer->remoteIsRecording = isrec;
     }
+    if (infodata.hasProperty("supportedcodecs")) {
+        auto supportedCodecs = infodata.getProperty("supportedcodecs", var()).getArray();
+        for (auto& supportedCodec : *supportedCodecs) {
+            peer->supportedCodecs.insert(Uuid(supportedCodec));
+        }
+    } else {
+        // fallback mode if the client is too old to send codec support information
+        // static, because this map never changes, so avoid multiple unnecessary calls
+        static std::set<Uuid> fallbackSupportedCodecs = getSupportedFallbackCodecs();
+        peer->supportedCodecs = std::set(fallbackSupportedCodecs);
+    }
+    clientListeners.call(&SonobusAudioProcessor::ClientListener::peerCodecInfoReceived, this, peer->userName);
+
+    for (const auto & supportedCodec : peer->supportedCodecs) {
+        DBG("peerinfo: peer supports codec with ID: " << supportedCodec.toString());
+    }
 
     peer->hasRemoteInfo = true;
+}
+
+// returns all audio format indexes supported by the peer
+std::vector<int> SonobusAudioProcessor::getRemotePeerSupportedAudioFormatIndexes(int index) {
+    auto remote = mRemotePeers.getUnchecked(index);
+    std::vector<int> formats;
+    for (int i=0; i < mAudioFormats.size(); i++) {
+        for (const auto & supportedCodec : remote->supportedCodecs) {
+            if (supportedCodec == mAudioFormats[i].id) {
+                formats.push_back(i);
+                continue;
+            }
+        }
+    }
+    return formats;
+}
+
+// fallback mode, returns all codecs that are supported by the older clients which don't send any codec support information
+std::set<Uuid> SonobusAudioProcessor::getSupportedFallbackCodecs() {
+    std::set<Uuid> minimumSupportedCodecs;
+    minimumSupportedCodecs.insert(Uuid("d30affc3-db76-40fd-85bd-6ba4f67d75f0"));
+    minimumSupportedCodecs.insert(Uuid("540af31d-3047-420d-89d7-472c07dcbb2e"));
+    minimumSupportedCodecs.insert(Uuid("df40ba8a-3621-42d2-a9d7-b6fa0ef1be84"));
+    minimumSupportedCodecs.insert(Uuid("e440a4d9-a450-4462-8aa8-9b4af8576514"));
+    minimumSupportedCodecs.insert(Uuid("14aaab94-dbd6-4446-bf1b-64efb55f16f6"));
+    minimumSupportedCodecs.insert(Uuid("79dbf03b-c112-4517-aa1c-fa501fc7d0b6"));
+    minimumSupportedCodecs.insert(Uuid("4333f3e5-7537-4b94-af9a-dfd836d59055"));
+    minimumSupportedCodecs.insert(Uuid("46c728a4-d830-4388-a493-361cb3f7a220"));
 
+    minimumSupportedCodecs.insert(Uuid("d7942c5c-4802-425b-ac51-16e995af03cd"));
+    minimumSupportedCodecs.insert(Uuid("70b9b5d8-e263-4053-a584-72a9e97ed97d"));
+    minimumSupportedCodecs.insert(Uuid("9825290e-f2cf-41be-9ff8-0c25f60ae8ad"));
+    return minimumSupportedCodecs;
+}
+
+StringArray SonobusAudioProcessor::getSupportedCodecsByThisClient() {
+    StringArray supportedCodecs;
+    for (const auto & format : mAudioFormats) {
+         supportedCodecs.add(format.id.toString());
+    }
+    return supportedCodecs;
+}
+
+bool SonobusAudioProcessor::doesPeerSupportCodec(RemotePeer * peer, int audioFormatIndex) {
+    SonobusAudioProcessor::AudioCodecFormatInfo finfo;
+    getAudioCodecFormatInfo(audioFormatIndex, finfo);
+    for (auto & supportedCodec : peer->supportedCodecs) {
+        if (supportedCodec == finfo.id) {
+            return true;
+        }
+    }
+    return false;
 }
 
 void SonobusAudioProcessor::sendRemotePeerInfoUpdate(int index, RemotePeer * topeer)
 {
     // send our info to this remote peer
     DynamicObject::Ptr info = new DynamicObject(); // this will delete itself
+    static StringArray supportedCodecs = getSupportedCodecsByThisClient();
 
     // not great, better than nothing - TODO make this accurate
     info->setProperty("inlat", 1e3 * currSamplesPerBlock / getSampleRate());
     info->setProperty("outlat", 1e3 * currSamplesPerBlock / getSampleRate());
     info->setProperty("rec", isRecordingToFile());
+    info->setProperty("supportedcodecs", supportedCodecs);
 
     // nettype TODO
 
@@ -3578,21 +3675,33 @@ int32_t SonobusAudioProcessor::handleSourceEvents(const aoo_event ** events, int
                     peer->latencysource->set_format(fmt.header);
                     peer->echosource->set_format(fmt.header);
 
-                    AudioCodecFormatCodec codec = String(fmt.header.codec) == AOO_CODEC_OPUS ? CodecOpus : CodecPCM;
-                    if (codec == CodecOpus) {
-                        aoo_format_opus *ofmt = (aoo_format_opus *)&fmt;
-                        int retindex = findFormatIndex(codec, ofmt->bitrate / ofmt->header.nchannels, 0);
-                        if (retindex >= 0) {
-                            peer->formatIndex = retindex; // new sending format index
+                    String codecHeader = String(fmt.header.codec);
+                    AudioCodecFormatCodec codec = codecHeader == AOO_CODEC_OPUS ? CodecOpus : codecHeader == AOO_CODEC_PCM ? CodecPCM : CodecUnknown;
+                    switch(codec) {
+                        case CodecOpus:
+                        {
+                            aoo_format_opus *ofmt = (aoo_format_opus *)&fmt;
+                            int retindex = findFormatIndex(codec, ofmt->bitrate / ofmt->header.nchannels, 0);
+                            if (retindex >= 0) {
+                                peer->formatIndex = retindex; // new sending format index
+                            }
+                            break;
                         }
-                    }
-                    else if (codec == CodecPCM) {
-                        aoo_format_pcm *pfmt = (aoo_format_pcm *)&fmt;
-                        int bdepth = pfmt->bitdepth == AOO_PCM_FLOAT32 ? 4 : pfmt->bitdepth == AOO_PCM_INT24 ? 3 : pfmt->bitdepth == AOO_PCM_FLOAT64 ? 8 : 2;
-                        int retindex = findFormatIndex(codec, 0, bdepth);
-                        if (retindex >= 0) {
-                            peer->formatIndex = retindex; // new sending format index
-                        }                        
+                        case CodecPCM:
+                        {
+                            aoo_format_pcm *pfmt = (aoo_format_pcm *)&fmt;
+                            int bdepth = pfmt->bitdepth == AOO_PCM_FLOAT32 ? 4 : pfmt->bitdepth == AOO_PCM_INT24 ? 3 : pfmt->bitdepth == AOO_PCM_FLOAT64 ? 8 : pfmt->bitdepth == AOO_PCM_INT16 ? 2 : 1;
+                            int retindex = findFormatIndex(codec, 0, bdepth);
+                            if (retindex >= 0) {
+                                peer->formatIndex = retindex; // new sending format index
+                            }
+                            break;
+                        }
+                        default:
+                            // codec unknown, this should theoretically never happen
+                            // only if for example a newer client for some reason sends us some codec not yet known to us without
+                            // regarding our supported codecs, or if this client doesn't correctly transmit the supported codecs
+                            DBG("codec is unknown to this sonobus client: " << codecHeader);
                     }
                 }
                 
@@ -3747,18 +3856,33 @@ int32_t SonobusAudioProcessor::handleSinkEvents(const aoo_event ** events, int32
                          */
                     }
 
-
-                    
-                    AudioCodecFormatCodec codec = String(f.header.codec) == AOO_CODEC_OPUS ? CodecOpus : CodecPCM;
-                    if (codec == CodecOpus) {
-                        aoo_format_opus *fmt = (aoo_format_opus *)&f;
-                        peer->recvFormat = AudioCodecFormatInfo(fmt->bitrate/fmt->header.nchannels, fmt->complexity, fmt->signal_type);
-                        //peer->recvFormatIndex = findFormatIndex(codec, fmt->bitrate / fmt->header.nchannels, 0);
-                    } else {
-                        aoo_format_pcm *fmt = (aoo_format_pcm *)&f;
-                        int bitdepth = fmt->bitdepth == AOO_PCM_INT16 ? 2 : fmt->bitdepth == AOO_PCM_INT24  ? 3  : fmt->bitdepth == AOO_PCM_FLOAT32 ? 4 : fmt->bitdepth == AOO_PCM_FLOAT64  ? 8 : 2;
-                        peer->recvFormat = AudioCodecFormatInfo(bitdepth);
-                        //peer->recvFormatIndex = findFormatIndex(codec, 0, fmt->bitdepth);
+                    String codecHeader = String(f.header.codec);
+                    AudioCodecFormatCodec codec = codecHeader == AOO_CODEC_OPUS ? CodecOpus : codecHeader == AOO_CODEC_PCM ? CodecPCM : CodecUnknown;
+                    try {
+                        switch (codec) {
+                            case CodecOpus:
+                            {
+                                aoo_format_opus *fmt = (aoo_format_opus *)&f;
+                                peer->recvFormat = resolveOpusCodecInfo(fmt->bitrate/fmt->header.nchannels, fmt->complexity, fmt->signal_type);
+                                //peer->recvFormatIndex = findFormatIndex(codec, fmt->bitrate / fmt->header.nchannels, 0);
+                                break;
+                            }
+                            case CodecPCM:
+                            {
+                                aoo_format_pcm *fmt = (aoo_format_pcm *)&f;
+                                int bitdepth = fmt->bitdepth == AOO_PCM_INT16 ? 2 : fmt->bitdepth == AOO_PCM_INT24  ? 3  : fmt->bitdepth == AOO_PCM_FLOAT32 ? 4 : fmt->bitdepth == AOO_PCM_FLOAT64 ? 8 : 1;
+                                peer->recvFormat = resolvePcmCodecInfo(bitdepth);
+                                //peer->recvFormatIndex = findFormatIndex(codec, 0, fmt->bitdepth);
+                                break;
+                            }
+                            default:
+                                // codec unknown, this should theoretically never happen
+                                // only if for example a newer client for some reason sends us some codec not yet known to us without
+                                // regarding our supported codecs, or if this client doesn't correctly transmit the supported codecs
+                                DBG("codec is unknown to this sonobus client: " << codecHeader);
+                        }
+                    } catch (const char * exceptionMsg) {
+                        DBG("exception at resolving the codec: " << exceptionMsg);
                     }
                     
                     clientListeners.call(&SonobusAudioProcessor::ClientListener::aooClientPeerChangedState, this, "format");
@@ -6225,7 +6349,7 @@ bool SonobusAudioProcessor::formatInfoToAooFormat(const AudioCodecFormatInfo & i
             fmt->header.blocksize = currSamplesPerBlock >= info.min_preferred_blocksize ? currSamplesPerBlock : info.min_preferred_blocksize;
             fmt->header.samplerate = getSampleRate();
             fmt->header.nchannels = channels;
-            fmt->bitdepth = info.bitdepth == 2 ? AOO_PCM_INT16 : info.bitdepth == 3 ? AOO_PCM_INT24 : info.bitdepth == 4 ? AOO_PCM_FLOAT32 : info.bitdepth == 8 ? AOO_PCM_FLOAT64 : AOO_PCM_INT16;
+            fmt->bitdepth = info.bitdepth == 2 ? AOO_PCM_INT16 : info.bitdepth == 3 ? AOO_PCM_INT24 : info.bitdepth == 4 ? AOO_PCM_FLOAT32 : info.bitdepth == 8 ? AOO_PCM_FLOAT64 : AOO_PCM_INT8;
 
             return true;
         } 
diff --git a/Source/SonobusPluginProcessor.h b/Source/SonobusPluginProcessor.h
index 7cd646db7..e774c5870 100644
--- a/Source/SonobusPluginProcessor.h
+++ b/Source/SonobusPluginProcessor.h
@@ -127,7 +127,7 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
         AutoNetBufferModeInitAuto
     };
     
-    enum AudioCodecFormatCodec { CodecPCM = 0, CodecOpus };
+    enum AudioCodecFormatCodec { CodecPCM = 0, CodecOpus, CodecUnknown };
 
     enum ReverbModel {
         ReverbModelFreeverb = 0,
@@ -159,11 +159,12 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
 
     struct AudioCodecFormatInfo {
         AudioCodecFormatInfo() {}
-        AudioCodecFormatInfo(int bitdepth_) : codec(CodecPCM), bitdepth(bitdepth_), min_preferred_blocksize(16)  { computeName(); }
-        AudioCodecFormatInfo(int bitrate_, int complexity_, int signaltype, int minblocksize=120) :  codec(CodecOpus), bitrate(bitrate_), complexity(complexity_), signal_type(signaltype), min_preferred_blocksize(minblocksize) { computeName(); }
+        AudioCodecFormatInfo(Uuid id_, int bitdepth_) : codec(CodecPCM), id(id_), bitdepth(bitdepth_), min_preferred_blocksize(16)  { computeName(); }
+        AudioCodecFormatInfo(Uuid id_, int bitrate_, int complexity_, int signaltype, int minblocksize=120) : codec(CodecOpus), id(id_), bitrate(bitrate_), complexity(complexity_), signal_type(signaltype), min_preferred_blocksize(minblocksize) { computeName(); }
         void computeName();
         
         String name;
+        Uuid id;
         AudioCodecFormatCodec codec;
         // PCM options
         int bitdepth = 2; // bytes
@@ -371,6 +372,8 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
 
     int getRemotePeerRecvChannelCount(int index) const;
 
+    std::vector<int> getRemotePeerSupportedAudioFormatIndexes(int index);
+
     //int getRemotePeerChannelGroupChannelCount(int index, int changroup) const;
     //void setRemotePeerChannelGroupChannelCount(int index, int changroup, int count);
 
@@ -563,8 +566,8 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
     bool getChangingDefaultRecvAudioCodecSetsExisting() const { return mChangingDefaultRecvAudioCodecChangesAll;}
 
     
-    String getAudioCodeFormatName(int formatIndex) const;
-    bool getAudioCodeFormatInfo(int formatIndex, AudioCodecFormatInfo & retinfo) const;
+    String getAudioCodecFormatName(int formatIndex) const;
+    bool getAudioCodecFormatInfo(int formatIndex, AudioCodecFormatInfo & retinfo) const;
 
     void setDefaultAutoresizeBufferMode(AutoNetBufferMode flag);
     AutoNetBufferMode getDefaultAutoresizeBufferMode() const { return (AutoNetBufferMode) defaultAutoNetbufMode; }
@@ -668,6 +671,7 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
         virtual void sbChatEventReceived(SonobusAudioProcessor *comp, const SBChatEvent & chatevent) {}
         virtual void peerRequestedLatencyMatch(SonobusAudioProcessor *comp, const String & username, float latency) {}
         virtual void peerBlockedInfoChanged(SonobusAudioProcessor *comp, const String & username, bool blocked) {}
+        virtual void peerCodecInfoReceived(SonobusAudioProcessor *comp, const String & username) {}
     };
     
     void addClientListener(ClientListener * l) {
@@ -851,6 +855,11 @@ class SonobusAudioProcessor  : public AudioProcessor, public AudioProcessorValue
     void handleRemotePeerInfoUpdate(RemotePeer * peer, const juce::var & infodata);
     void sendRemotePeerInfoUpdate(int peerindex = -1, RemotePeer * topeer = nullptr);
 
+    std::set<Uuid> getSupportedFallbackCodecs();
+    StringArray getSupportedCodecsByThisClient();
+    bool doesPeerSupportCodec(RemotePeer * peer, int audioFormatIndex);
+    AudioCodecFormatInfo resolveOpusCodecInfo(int bitdepth, int complexity, int signaltype);
+    AudioCodecFormatInfo resolvePcmCodecInfo(int bitdepth);
 
     void handlePingEvent(EndpointState * endpoint, uint64_t tt1, uint64_t tt2, uint64_t tt3);
 
diff --git a/deps/aoo/lib/aoo/aoo_pcm.h b/deps/aoo/lib/aoo/aoo_pcm.h
index 869976a90..19c48847f 100644
--- a/deps/aoo/lib/aoo/aoo_pcm.h
+++ b/deps/aoo/lib/aoo/aoo_pcm.h
@@ -21,6 +21,9 @@ typedef enum
     AOO_PCM_INT24,
     AOO_PCM_FLOAT32,
     AOO_PCM_FLOAT64,
+    // int8 has been intentionally added to the last place before AOO_PCM_BITDEPTH_SIZE as moving it to another
+    // place WILL break old clients which will try to decode this enum
+    AOO_PCM_INT8,
     AOO_PCM_BITDEPTH_SIZE
 } aoo_pcm_bitdepth;
 
diff --git a/deps/aoo/lib/src/codec_pcm.cpp b/deps/aoo/lib/src/codec_pcm.cpp
index bca753164..f9c901c67 100644
--- a/deps/aoo/lib/src/codec_pcm.cpp
+++ b/deps/aoo/lib/src/codec_pcm.cpp
@@ -10,6 +10,20 @@
 
 namespace {
 
+// Q_8BIt is a constant required for the 8-bit dithered noise shaping
+// it's the pre-calculation of 1 / 256 and represents the "step size" of the quantized data for an 8-bit resolution
+const float Q_8BIT = 0.00390625f;
+// constants for the quantization error tracking ring-buffer
+const int ERROR_BUF_MASK = 15;
+const int ERROR_BUF_SIZE = 16;
+// example coefficients for a FIR filter of size 9 from "Minimally Audible Noise Shaping" by Lipshitz 1991
+const float SHAPED_BS[] = { 2.847f, -4.685f, 6.214f, -7.184f, 6.639f, -5.032f, 3.263f, -1.632f, 0.4191f};
+
+// returns a random number from 0.f to 1.f
+float get_random_number() {
+    return static_cast<float> (rand()) / static_cast<float> (RAND_MAX);
+}
+
 // conversion routines between aoo_sample and PCM data
 union convert {
     int8_t b[8];
@@ -23,6 +37,8 @@ union convert {
 int32_t bytes_per_sample(int32_t bd)
 {
     switch (bd){
+    case AOO_PCM_INT8:
+        return 1;
     case AOO_PCM_INT16:
         return 2;
     case AOO_PCM_INT24:
@@ -37,6 +53,38 @@ int32_t bytes_per_sample(int32_t bd)
     }
 }
 
+// converts the sample to an 8-bit value including noise shaped dithering
+// it's based on the implementations from Ardour and from Audacity and uses
+// methods from "Minimally Audible Noise Shaping" by Lipshitz from 1991
+void sample_to_int8(aoo_sample in, char *out, int *mPhase, float *errorBuffer)
+{
+    // add shaped noise with a FIR filter function based on recent errors
+    in += errorBuffer[*mPhase] * SHAPED_BS[0]
+        + errorBuffer[(*mPhase - 1) & ERROR_BUF_MASK] * SHAPED_BS[1]
+        + errorBuffer[(*mPhase - 2) & ERROR_BUF_MASK] * SHAPED_BS[2]
+        + errorBuffer[(*mPhase - 3) & ERROR_BUF_MASK] * SHAPED_BS[3]
+        + errorBuffer[(*mPhase - 4) & ERROR_BUF_MASK] * SHAPED_BS[4]
+        + errorBuffer[(*mPhase - 5) & ERROR_BUF_MASK] * SHAPED_BS[5]
+        + errorBuffer[(*mPhase - 6) & ERROR_BUF_MASK] * SHAPED_BS[6]
+        + errorBuffer[(*mPhase - 7) & ERROR_BUF_MASK] * SHAPED_BS[7]
+        + errorBuffer[(*mPhase - 8) & ERROR_BUF_MASK] * SHAPED_BS[8];
+
+    *mPhase = (*mPhase + 1) & ERROR_BUF_MASK;
+    // save input value before quantization
+    float pre_quantization = in;
+
+    // add two linear probability density function (LPDF) values together
+    // to create a triangular probability density function (TPDF)
+    in += Q_8BIT * (get_random_number() + get_random_number() - 1.0f);
+
+    // quantize
+    int32_t temp = in * 0x80;
+    // save quantization error
+    errorBuffer[*mPhase] = pre_quantization - temp / 128.0f;
+
+    out[0] = (temp > INT8_MAX) ? INT8_MAX : (temp < INT8_MIN) ? INT8_MIN : temp;
+}
+
 void sample_to_int16(aoo_sample in, char *out)
 {
     convert c;
@@ -77,6 +125,11 @@ void sample_to_float64(aoo_sample in, char *out)
     aoo::to_bytes<double>(in, out);
 }
 
+aoo_sample int8_to_sample(const char *in)
+{
+    return(aoo_sample)in[0] / 128.f;
+}
+
 aoo_sample int16_to_sample(const char *in){
     convert c;
 #if BYTE_ORDER == BIG_ENDIAN
@@ -134,14 +187,27 @@ struct codec {
     aoo_format_pcm format;
 };
 
-int32_t codec_setformat(void *enc, aoo_format *f)
-{
-    if (strcmp(f->codec, AOO_CODEC_PCM)){
-        return 0;
+// the encoder requires a state for the noise shaping per channel, the decoder is simpler and doesn't need any states
+struct encoder : codec {
+    ~encoder(){
+        if (errorBuffer) {
+            for (int i = 0; i < nchannels; i++) {
+                delete[] errorBuffer[i];
+            }
+            delete[] errorBuffer;
+        }
+        if (mPhase) {
+            delete[] mPhase;
+        }
     }
-    auto c = static_cast<codec *>(enc);
-    auto fmt = reinterpret_cast<aoo_format_pcm *>(f);
+    // remember the number of channels so that we can free the right amount of resources later on
+    int nchannels = 0;
+    int *mPhase = nullptr;
+    float **errorBuffer = nullptr;
+};
 
+void validate_format(aoo_format_pcm * fmt)
+{
     // validate blocksize
     if (fmt->header.blocksize <= 0){
         LOG_WARNING("PCM: bad blocksize " << fmt->header.blocksize
@@ -165,6 +231,38 @@ int32_t codec_setformat(void *enc, aoo_format *f)
         LOG_WARNING("PCM: bad bitdepth, using 32bit float");
         fmt->bitdepth = AOO_PCM_FLOAT32;
     }
+}
+
+int32_t encoder_setformat(void *enc, aoo_format *f)
+{
+    if (strcmp(f->codec, AOO_CODEC_PCM)){
+        return 0;
+    }
+    auto c = static_cast<encoder *>(enc);
+    auto fmt = reinterpret_cast<aoo_format_pcm *>(f);
+    validate_format(fmt);
+
+    // clear noise shaping state
+    if (c->errorBuffer != nullptr) {
+        // the number of channels could have changed in the format so use the old channels number for the free calls!
+        for(int i = 0; i < c->nchannels; i++) {
+            delete[] c->errorBuffer[i];
+        }
+        delete[] c->errorBuffer;
+    }
+    if (c->mPhase != nullptr) {
+        delete[] c->mPhase;
+    }
+
+    // init noise shaping state
+    c->nchannels = fmt->header.nchannels;
+    c->errorBuffer = new float*[c->nchannels];
+    for (int i = 0; i < c->nchannels; i++){
+        c->errorBuffer[i] = new float[ERROR_BUF_SIZE];
+        std::fill(c->errorBuffer[i], c->errorBuffer[i] + ERROR_BUF_SIZE, 0);
+    }
+    c->mPhase = new int[ERROR_BUF_SIZE];
+    std::fill(c->mPhase, c->mPhase + ERROR_BUF_SIZE, 0);
 
     // save and print settings
     memcpy(&c->format, fmt, sizeof(aoo_format_pcm));
@@ -188,7 +286,7 @@ int32_t encoder_readformat(void *enc, aoo_format *fmt,
             c->format.header.codec = AOO_CODEC_PCM; // !
             //print_settings(c->format);
             
-            if (codec_setformat(enc, &c->format.header)) {     
+            if (encoder_setformat(enc, &c->format.header)) {
                 // it could have been modified during validation, need to re-write the base format of 
                 // passed in value
                 memcpy(fmt, &c->format.header, sizeof(aoo_format));
@@ -226,11 +324,11 @@ int32_t codec_getformat(void *x, aoo_format_storage *f)
 }
 
 void *encoder_new(){
-    return new codec;
+    return new encoder;
 }
 
 void encoder_free(void *enc){
-    delete (codec *)enc;
+    delete (encoder *)enc;
 }
 
 int32_t encoder_encode(void *enc,
@@ -244,6 +342,16 @@ int32_t encoder_encode(void *enc,
         return 0;
     }
 
+    auto samples_to_blob_8bit = [&]{
+        auto c = static_cast<encoder *>(enc);
+        int nchannels = c->format.header.nchannels;
+        auto b = buf;
+        for (int i = 0; i < n; ++i){
+            sample_to_int8(s[i], b, &(c->mPhase[i % nchannels]), c->errorBuffer[i % nchannels]);
+            ++b;
+        }
+    };
+
     auto samples_to_blob = [&](auto fn){
         auto b = buf;
         for (int i = 0; i < n; ++i){
@@ -253,6 +361,9 @@ int32_t encoder_encode(void *enc,
     };
 
     switch (bitdepth){
+    case AOO_PCM_INT8:
+        samples_to_blob_8bit();
+        break;
     case AOO_PCM_INT16:
         samples_to_blob(sample_to_int16);
         break;
@@ -331,6 +442,9 @@ int32_t decoder_decode(void *dec,
     };
 
     switch (c->format.bitdepth){
+    case AOO_PCM_INT8:
+        blob_to_samples(int8_to_sample);
+        break;
     case AOO_PCM_INT16:
         blob_to_samples(int16_to_sample);
         break;
@@ -351,6 +465,23 @@ int32_t decoder_decode(void *dec,
     return size / samplesize;
 }
 
+int32_t decoder_setformat(void *enc, aoo_format *f)
+{
+    if (strcmp(f->codec, AOO_CODEC_PCM)){
+        return 0;
+    }
+    auto c = static_cast<codec *>(enc);
+    auto fmt = reinterpret_cast<aoo_format_pcm *>(f);
+    validate_format(fmt);
+
+    // save and print settings
+    memcpy(&c->format, fmt, sizeof(aoo_format_pcm));
+    c->format.header.codec = AOO_CODEC_PCM; // !
+    print_settings(c->format);
+
+    return 1;
+}
+
 int32_t decoder_readformat(void *dec, aoo_format *fmt,
                            const char *buf, int32_t size)
 {
@@ -379,7 +510,7 @@ aoo_codec codec_class = {
     AOO_CODEC_PCM,
     encoder_new,
     encoder_free,
-    codec_setformat,
+    encoder_setformat,
     codec_getformat,
     encoder_readformat,
     encoder_writeformat,
@@ -387,7 +518,7 @@ aoo_codec codec_class = {
     codec_reset,
     decoder_new,
     decoder_free,
-    codec_setformat,
+    decoder_setformat,
     codec_getformat,
     decoder_readformat,
     decoder_decode,
diff --git a/deps/aoo/pd/src/aoo_common.c b/deps/aoo/pd/src/aoo_common.c
index a3c0325ed..130260e04 100644
--- a/deps/aoo/pd/src/aoo_common.c
+++ b/deps/aoo/pd/src/aoo_common.c
@@ -229,6 +229,9 @@ int aoo_format_parse(void *x, aoo_format_storage *f, int argc, t_atom *argv)
 
         int bitdepth = argc > 3 ? atom_getfloat(argv + 3) : 4;
         switch (bitdepth){
+        case 1:
+            fmt->bitdepth = AOO_PCM_INT8;
+            break;
         case 2:
             fmt->bitdepth = AOO_PCM_INT16;
             break;
@@ -343,6 +346,9 @@ int aoo_format_toatoms(const aoo_format *f, int argc, t_atom *argv)
         aoo_format_pcm *fmt = (aoo_format_pcm *)f;
         int nbits;
         switch (fmt->bitdepth){
+        case AOO_PCM_INT8:
+            nbits = 1;
+            break;
         case AOO_PCM_INT16:
             nbits = 2;
             break;