diff --git a/server/src/utils/mixerConnections/OscMixerConnection.ts b/server/src/utils/mixerConnections/OscMixerConnection.ts
index d4c43797..ca3562c1 100644
--- a/server/src/utils/mixerConnections/OscMixerConnection.ts
+++ b/server/src/utils/mixerConnections/OscMixerConnection.ts
@@ -88,7 +88,6 @@ export class OscMixerConnection {
         )
     }
 
-
     setupMixerConnection() {
         this.oscConnection
             .on('ready', () => {
@@ -115,7 +114,7 @@ export class OscMixerConnection {
                             .CHANNEL_VU?.[0].mixerMessage
                     )
                 ) {
-                    let assignedFaderIndex = this.getAssignedFaderIndex(message.address.split('/')[this.cmdChannelIndex])
+                    const assignedFaderIndex = this.getAssignedFaderIndex(message.address.split('/')[this.cmdChannelIndex])
                     if (
                         state.settings[0].mixers[
                             this.mixerIndex
@@ -146,7 +145,7 @@ export class OscMixerConnection {
                             .CHANNEL_VU_REDUCTION?.[0].mixerMessage
                     )
                 ) {
-                    let assignedFaderIndex = this.getAssignedFaderIndex(message.address.split('/')[this.cmdChannelIndex])
+                    const assignedFaderIndex = this.getAssignedFaderIndex(message.address.split('/')[this.cmdChannelIndex])
 
                     sendVuLevel(
                         assignedFaderIndex,
@@ -162,7 +161,7 @@ export class OscMixerConnection {
                     )
                 ) {
                     let ch = message.address.split('/')[this.cmdChannelIndex]
-                    let assignedFaderIndex = this.getAssignedFaderIndex(ch - 1)
+                    const assignedFaderIndex = this.getAssignedFaderIndex(ch - 1)
 
                     if (
                         assignedFaderIndex >= 0 &&
diff --git a/server/src/utils/mixerConnections/SSLMixerConnection.ts b/server/src/utils/mixerConnections/SSLMixerConnection.ts
index eeb1de6d..e46c6505 100644
--- a/server/src/utils/mixerConnections/SSLMixerConnection.ts
+++ b/server/src/utils/mixerConnections/SSLMixerConnection.ts
@@ -16,6 +16,7 @@ import {
 } from '../../../../shared/src/actions/faderActions'
 import { storeSetMixerOnline } from '../../../../shared/src/actions/settingsActions'
 import { logger } from '../logger'
+import { IChannelReference, IFader } from '../../../../shared/src/reducers/fadersReducer'
 
 export class SSLMixerConnection {
     mixerProtocol: IMixerProtocol
@@ -57,61 +58,68 @@ export class SSLMixerConnection {
         return str.substring(1)
     }
 
+    private getAssignedFaderIndex(channelIndex: number) {
+        return state.faders[0].fader.findIndex(
+            (fader: IFader) => fader.assignedChannels.includes({ mixerIndex: this.mixerIndex, channelIndex })
+        )
+    }
+
     handleReceivedFaderLevelCommand = (buffer: any) => {
         try {
             let channelIndex = buffer[6]
             let value = buffer.readUInt16BE(7) / 1024
-            const ch = state.channels[0].chMixerConnection[this.mixerIndex].channel
+            const thisMixerChannels = state.channels[0].chMixerConnection[this.mixerIndex].channel
+            const assignedFaderIndex = this.getAssignedFaderIndex(channelIndex)
 
             if (
-                !ch[channelIndex].fadeActive
+                !thisMixerChannels[channelIndex].fadeActive
             ) {
                 if (
                     value >
                     this.mixerProtocol.fader.min +
-                        (this.mixerProtocol.fader.max *
-                            state.settings[0].autoResetLevel) /
-                            100
+                    (this.mixerProtocol.fader.max *
+                        state.settings[0].autoResetLevel) /
+                    100
                 ) {
                     if (
-                        ch[channelIndex].outputLevel !== value
+                        thisMixerChannels[channelIndex].outputLevel !== value
+
                     ) {
                         store.dispatch(
-                            storeFaderLevel(ch[channelIndex].assignedFader, value)
+                            storeFaderLevel(assignedFaderIndex, value)
                         )
-                        if (!state.faders[0].fader[ch[channelIndex].assignedFader].pgmOn) {
-                            store.dispatch(storeTogglePgm(ch[channelIndex].assignedFader))
+                        if (!state.faders[0].fader[assignedFaderIndex].pgmOn) {
+                            store.dispatch(storeTogglePgm(assignedFaderIndex))
                         }
 
                         if (remoteConnections) {
                             remoteConnections.updateRemoteFaderState(
-                                ch[channelIndex].assignedFader,
+                                assignedFaderIndex,
                                 value
                             )
                         }
-                        if (state.faders[0].fader[ch[channelIndex].assignedFader].pgmOn) {
-                            ch.forEach((channel: any, index: number) => {
-                                if (
-                                    channel.assignedFader === ch[channelIndex].assignedFader
-                                ) {
-                                    this.updateOutLevel(index)
-
+                        if (state.faders[0].fader[assignedFaderIndex].pgmOn) {
+                            state.faders[0].fader[assignedFaderIndex].assignedChannels.forEach(
+                                (item: IChannelReference) => {
+                                    if (item.mixerIndex === this.mixerIndex) {
+                                        this.updateOutLevel(item.channelIndex)
+                                    }
                                 }
-                            })
+                            )
                         }
                     }
                 } else if (
-                    state.faders[0].fader[ch[channelIndex].assignedFader].pgmOn ||
-                    state.faders[0].fader[ch[channelIndex].assignedFader].voOn
+                    state.faders[0].fader[assignedFaderIndex].pgmOn ||
+                    state.faders[0].fader[assignedFaderIndex].voOn
                 ) {
-                    store.dispatch(storeFaderLevel(ch[channelIndex].assignedFader, value))
-                    ch.forEach(
-                        (item: { assignedFader: any }, index: number) => {
-                            if (item.assignedFader === ch[channelIndex].assignedFader) {
+                    store.dispatch(storeFaderLevel(assignedFaderIndex, value))
+                    state.faders[0].fader[assignedFaderIndex].assignedChannels.forEach(
+                        (item: IChannelReference) => {
+                            if (item.mixerIndex === this.mixerIndex) {
                                 store.dispatch(
                                     storeSetOutputLevel(
                                         this.mixerIndex,
-                                        index,
+                                        item.channelIndex,
                                         value
                                     )
                                 )
@@ -119,8 +127,8 @@ export class SSLMixerConnection {
                         }
                     )
                 }
-                global.mainThreadHandler.updatePartialStore(ch[channelIndex].assignedFader)
-                mixerGenericConnection.updateOutLevel(ch[channelIndex].assignedFader, 0, this.mixerIndex)
+                global.mainThreadHandler.updatePartialStore(assignedFaderIndex)
+                mixerGenericConnection.updateOutLevel(assignedFaderIndex, 0, this.mixerIndex)
             }
         } catch (error) {
             logger.error(
@@ -134,6 +142,7 @@ export class SSLMixerConnection {
         // MUTE ON/OFF COMMAND
         let commandHex = buffer.toString('hex')
         let channelIndex = buffer[6]
+        const assignedFaderIndex = this.getAssignedFaderIndex(channelIndex)
         let value: boolean = buffer[7] === 0 ? true : false
         logger.trace(
             `Receive Buffer Channel On/off: ${this.formatHexWithSpaces(
@@ -143,11 +152,6 @@ export class SSLMixerConnection {
             )}`
         )
 
-        let assignedFaderIndex =
-            state.channels[0].chMixerConnection[this.mixerIndex].channel[
-                channelIndex
-            ].assignedFader
-
         store.dispatch(storeSetMute(assignedFaderIndex, value))
 
         if (remoteConnections) {
@@ -156,6 +160,14 @@ export class SSLMixerConnection {
                 value ? 1 : 0
             )
         }
+
+        state.faders[0].fader[assignedFaderIndex].assignedChannels.forEach(
+            (item: IChannelReference) => {
+                if (item.mixerIndex === this.mixerIndex && item.channelIndex !== channelIndex) {
+                    this.updateMuteState(item.channelIndex, value)
+                }
+            }
+        )
         state.channels[0].chMixerConnection[this.mixerIndex].channel.forEach(
             (channel: any, index: number) => {
                 if (
@@ -326,15 +338,15 @@ export class SSLMixerConnection {
         sslMessage = sslMessage.replace(
             '{channel}',
             ('0' + channelByte[0].toString(16)).slice(-2) +
-                ' ' +
-                ('0' + channelByte[1].toString(16)).slice(-2)
+            ' ' +
+            ('0' + channelByte[1].toString(16)).slice(-2)
         )
         sslMessage = sslMessage.replace(
             '{level}',
             ('0' + valueByte[0].toString(16)).slice(-2) +
-                ' ' +
-                ('0' + valueByte[1].toString(16)).slice(-2) +
-                ' '
+            ' ' +
+            ('0' + valueByte[1].toString(16)).slice(-2) +
+            ' '
         )
         sslMessage = sslMessage + this.calculate_checksum8(sslMessage.slice(9))
         let a = sslMessage.split(' ')
@@ -357,8 +369,8 @@ export class SSLMixerConnection {
         sslMessage = sslMessage.replace(
             '{channel}',
             ('0' + channelByte[0].toString(16)).slice(-2) +
-                ' ' +
-                ('0' + channelByte[1].toString(16)).slice(-2)
+            ' ' +
+            ('0' + channelByte[1].toString(16)).slice(-2)
         )
         sslMessage =
             sslMessage + ' ' + this.calculate_checksum8(sslMessage.slice(9))
@@ -511,7 +523,7 @@ export class SSLMixerConnection {
         return true
     }
 
-    loadMixerPreset(presetName: string) {}
+    loadMixerPreset(presetName: string) { }
 
     injectCommand(command: string[]) {
         return true