diff --git a/apps/common-app/src/examples/MergerSplitter/MergerSplitter.tsx b/apps/common-app/src/examples/MergerSplitter/MergerSplitter.tsx
new file mode 100644
index 000000000..3e1904a07
--- /dev/null
+++ b/apps/common-app/src/examples/MergerSplitter/MergerSplitter.tsx
@@ -0,0 +1,288 @@
+import React, { useRef, useState, useEffect, FC, useMemo } from 'react';
+import { Alert, ActivityIndicator } from 'react-native';
+import {
+  AudioContext,
+  AudioBufferSourceNode,
+  AudioBuffer,
+  OscillatorNode,
+} from 'react-native-audio-api';
+
+import { Container, Slider, Spacer, Button } from '../../components';
+
+// test url pointing to my public repo, to be changed / deleted
+const AUDIO_URL =
+  'https://github.com/miloszwielgus/test-files/raw/refs/heads/main/output.m4a';
+
+const INITIAL_GAIN = 0.5;
+const labelWidth = 100;
+
+const SplitterMerger: FC = () => {
+  const [isPlayingFile, setIsPlayingFile] = useState(false);
+  const [isPlayingOsc, setIsPlayingOsc] = useState(false);
+  const [isLoading, setIsLoading] = useState(false);
+
+  const [gain1, setGain1] = useState(INITIAL_GAIN);
+  const [gain2, setGain2] = useState(INITIAL_GAIN);
+  const [gain3, setGain3] = useState(INITIAL_GAIN);
+  const [gain4, setGain4] = useState(INITIAL_GAIN);
+  const [gain5, setGain5] = useState(INITIAL_GAIN);
+  const [gain6, setGain6] = useState(INITIAL_GAIN);
+  /*
+    Uncomment all the merger lines and comment the gain connect to destintation lines to test the merger node. 
+    The changes you will notice are that the channels are panned out correctly (channel 1st is left etc) 
+    and that channel 4 is silent (effect of 6->2 downmixing)
+  */
+  const {
+    context,
+    splitter,
+    // merger,
+    gainNode1,
+    gainNode2,
+    gainNode3,
+    gainNode4,
+    gainNode5,
+    gainNode6,
+  } = useMemo(() => {
+    const ctx = new AudioContext();
+
+    const splitNode = ctx.createChannelSplitter(6);
+    // const mergeNode = ctx.createChannelMerger(6);
+
+    const g1 = ctx.createGain();
+    g1.gain.value = INITIAL_GAIN;
+    const g2 = ctx.createGain();
+    g2.gain.value = INITIAL_GAIN;
+    const g3 = ctx.createGain();
+    g3.gain.value = INITIAL_GAIN;
+    const g4 = ctx.createGain();
+    g4.gain.value = INITIAL_GAIN;
+    const g5 = ctx.createGain();
+    g5.gain.value = INITIAL_GAIN;
+    const g6 = ctx.createGain();
+    g6.gain.value = INITIAL_GAIN;
+
+    splitNode.connect(g1, 0, 0);
+    // g1.connect(mergeNode, 0, 0);
+    g1.connect(ctx.destination);
+    splitNode.connect(g2, 1, 0);
+    // g2.connect(mergeNode, 0, 1);
+    g2.connect(ctx.destination);
+    splitNode.connect(g3, 2, 0);
+    // g3.connect(mergeNode, 0, 2);
+    g3.connect(ctx.destination);
+    splitNode.connect(g4, 3, 0);
+    // g4.connect(mergeNode, 0, 3);
+    g4.connect(ctx.destination);
+    splitNode.connect(g5, 4, 0);
+    // g5.connect(mergeNode, 0, 4);
+    g5.connect(ctx.destination);
+    splitNode.connect(g6, 5, 0);
+    g6.connect(ctx.destination);
+    // g6.connect(mergeNode, 0, 5);
+
+    // mergeNode.connect(ctx.destination);
+
+    return {
+      context: ctx,
+      splitter: splitNode,
+      // merger: mergeNode,
+      gainNode1: g1,
+      gainNode2: g2,
+      gainNode3: g3,
+      gainNode4: g4,
+      gainNode5: g5,
+      gainNode6: g6,
+    };
+  }, []);
+
+  const [audioBuffer, setAudioBuffer] = useState<AudioBuffer | null>(null);
+
+  const sourceNodeRef = useRef<AudioBufferSourceNode | null>(null);
+  const oscNodeRef = useRef<OscillatorNode | null>(null);
+
+  useEffect(() => {
+    const fetchAndDecodeAudio = async () => {
+      setIsLoading(true);
+      try {
+        const response = await fetch(AUDIO_URL);
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = await context.decodeAudioData(arrayBuffer);
+        setAudioBuffer(buffer);
+      } catch (error) {
+        console.error('Failed to fetch or decode audio:', error);
+        Alert.alert(
+          'Error',
+          'Could not load the audio file. Check network and URL.'
+        );
+      } finally {
+        setIsLoading(false);
+      }
+    };
+
+    fetchAndDecodeAudio();
+
+    return () => {
+      if (sourceNodeRef.current) {
+        sourceNodeRef.current.stop(0);
+        sourceNodeRef.current.disconnect();
+        sourceNodeRef.current = null;
+      }
+      if (oscNodeRef.current) {
+        oscNodeRef.current.stop(0);
+        oscNodeRef.current.disconnect();
+        oscNodeRef.current = null;
+      }
+      context.close();
+    };
+  }, [context]);
+
+  const handlePlayPauseFile = () => {
+    if (isPlayingFile) {
+      if (sourceNodeRef.current) {
+        sourceNodeRef.current.stop(0);
+        sourceNodeRef.current.disconnect();
+        sourceNodeRef.current = null;
+      }
+      setIsPlayingFile(false);
+    } else {
+      if (!audioBuffer) return;
+
+      const sourceNode = context.createBufferSource();
+      sourceNode.buffer = audioBuffer;
+      sourceNode.loop = true;
+
+      sourceNode.connect(splitter);
+
+      sourceNode.start(0);
+      sourceNodeRef.current = sourceNode;
+      setIsPlayingFile(true);
+    }
+  };
+
+  const handlePlayPauseOsc = () => {
+    if (isPlayingOsc) {
+      if (oscNodeRef.current) {
+        oscNodeRef.current.stop(0);
+        oscNodeRef.current.disconnect();
+        oscNodeRef.current = null;
+      }
+      setIsPlayingOsc(false);
+    } else {
+      const osc = context.createOscillator();
+      osc.type = 'sine';
+      osc.frequency.value = 440; // A4
+
+      osc.connect(splitter);
+
+      osc.start(0);
+      oscNodeRef.current = osc;
+      setIsPlayingOsc(true);
+    }
+  };
+
+  const handleGain1Change = (value: number) => {
+    setGain1(value);
+    gainNode1.gain.value = value;
+  };
+  const handleGain2Change = (value: number) => {
+    setGain2(value);
+    gainNode2.gain.value = value;
+  };
+  const handleGain3Change = (value: number) => {
+    setGain3(value);
+    gainNode3.gain.value = value;
+  };
+  const handleGain4Change = (value: number) => {
+    setGain4(value);
+    gainNode4.gain.value = value;
+  };
+  const handleGain5Change = (value: number) => {
+    setGain5(value);
+    gainNode5.gain.value = value;
+  };
+  const handleGain6Change = (value: number) => {
+    setGain6(value);
+    gainNode6.gain.value = value;
+  };
+
+  return (
+    <Container centered>
+      {isLoading && <ActivityIndicator size="large" color="#FFFFFF" />}
+      <Button
+        onPress={handlePlayPauseFile}
+        title={isPlayingFile ? 'Stop File' : 'Play File'}
+        disabled={isLoading || !audioBuffer}
+      />
+      <Spacer.Vertical size={15} />
+      <Button
+        onPress={handlePlayPauseOsc}
+        title={isPlayingOsc ? 'Stop Oscillator' : 'Play Oscillator'}
+        disabled={isLoading}
+      />
+      <Spacer.Vertical size={30} />
+
+      <Slider
+        label="Gain Path 1"
+        value={gain1}
+        onValueChange={handleGain1Change}
+        min={0.0}
+        max={1.5}
+        step={0.01}
+        minLabelWidth={labelWidth}
+      />
+      <Spacer.Vertical size={15} />
+      <Slider
+        label="Gain Path 2"
+        value={gain2}
+        onValueChange={handleGain2Change}
+        min={0.0}
+        max={1.5}
+        step={0.01}
+        minLabelWidth={labelWidth}
+      />
+      <Spacer.Vertical size={15} />
+      <Slider
+        label="Gain Path 3"
+        value={gain3}
+        onValueChange={handleGain3Change}
+        min={0.0}
+        max={1.5}
+        step={0.01}
+        minLabelWidth={labelWidth}
+      />
+      <Spacer.Vertical size={15} />
+      <Slider
+        label="Gain Path 4"
+        value={gain4}
+        onValueChange={handleGain4Change}
+        min={0.0}
+        max={1.5}
+        step={0.01}
+        minLabelWidth={labelWidth}
+      />
+      <Spacer.Vertical size={15} />
+      <Slider
+        label="Gain Path 5"
+        value={gain5}
+        onValueChange={handleGain5Change}
+        min={0.0}
+        max={1.5}
+        step={0.01}
+        minLabelWidth={labelWidth}
+      />
+      <Spacer.Vertical size={15} />
+      <Slider
+        label="Gain Path 6"
+        value={gain6}
+        onValueChange={handleGain6Change}
+        min={0.0}
+        max={1.5}
+        step={0.01}
+        minLabelWidth={labelWidth}
+      />
+      <Spacer.Vertical size={30} />
+    </Container>
+  );
+};
+
+export default SplitterMerger;
diff --git a/apps/common-app/src/examples/MergerSplitter/index.tsx b/apps/common-app/src/examples/MergerSplitter/index.tsx
new file mode 100644
index 000000000..f64976cfa
--- /dev/null
+++ b/apps/common-app/src/examples/MergerSplitter/index.tsx
@@ -0,0 +1 @@
+export { default } from './MergerSplitter';
diff --git a/apps/common-app/src/examples/index.ts b/apps/common-app/src/examples/index.ts
index ac4da5d1f..ada61fce4 100644
--- a/apps/common-app/src/examples/index.ts
+++ b/apps/common-app/src/examples/index.ts
@@ -11,6 +11,7 @@ import Record from './Record/Record';
 import PlaybackSpeed from './PlaybackSpeed/PlaybackSpeed';
 import Worklets from './Worklets/Worklets';
 import Streaming from './Streaming/Streaming';
+import SplitterMerger from './MergerSplitter/MergerSplitter';
 
 type NavigationParamList = {
   Oscillator: undefined;
@@ -25,6 +26,7 @@ type NavigationParamList = {
   Record: undefined;
   Worklets: undefined;
   Streamer: undefined;
+  SplitterMerger: undefined;
 };
 
 export type ExampleKey = keyof NavigationParamList;
@@ -104,4 +106,10 @@ export const Examples: Example[] = [
     subtitle: 'Stream audio from a URL',
     screen: Streaming,
   },
+  {
+    key: 'SplitterMerger',
+    title: 'Channel Splitter and Merger',
+    subtitle: 'Split and merge audio channels',
+    screen: SplitterMerger,
+  },
 ] as const;
diff --git a/packages/audiodocs/docs/core/audio-node.mdx b/packages/audiodocs/docs/core/audio-node.mdx
index 26aa21223..78c8af2df 100644
--- a/packages/audiodocs/docs/core/audio-node.mdx
+++ b/packages/audiodocs/docs/core/audio-node.mdx
@@ -18,9 +18,14 @@ We usually represent the channels with the standard abbreviations detailed in th
 | Quad | 4 | 0: L - left <br /> 1: R - right <br /> 2: SL - surround left <br /> 3: SR - surround right |
 | Stereo | 6 | 0: L - left <br /> 1: R - right <br /> 2: C - center <br /> 3: LFE - subwoofer <br /> 4: SL - surround left <br /> 5: SR - surround right |
 
+#### Number of inputs and outputs
+
+Each node has a specified `numberOfInputs` and `numberOfOutputs`. These represent multiple logical processing paths in the node, and currently are used only by the [`ChannelMergerNode`](/docs/effects/channel-merger-node) and [`ChannelSplitterNode`](/docs/effects/channel-splitter-node). 
+The rest of the nodes have at most one input and output. You can connect multiple nodes to a single input, but keep in mind that the data will be put through a mixing process described below.
+
 #### Mixing
 
-When node has more then one input or number of inputs channels differs from output up-mixing or down-mixing must be conducted.
+When a nodes input has more then one input or number of inputs channels differs from output up-mixing or down-mixing must be conducted.
 There are three properties involved in mixing process: `channelCount`, [`ChannelCountMode`](/docs/types/channel-count-mode), [`ChannelInterpretation`](/docs/types/channel-interpretation).
 Based on them we can obtain output's number of channels and mixing strategy.
 
@@ -54,6 +59,50 @@ function App() {
 }
 ```
 
+### Connecting nodes specific output to a nodes specific input
+
+```tsx
+import { OscillatorNode, GainNode, AudioContext } from 'react-native-audio-api';
+
+function App() {
+  const audioContext = new AudioContext();
+  const oscillatorNode = audioContext.createOscillator();
+  // we create a ChannelSplitterNode which will split our mono input into two channels
+  const splitterNode = audioContext.createSplitter(2);
+  // we create two separate gains for each of the channels
+  const gainNode1 = audioContext.createGain(); 
+  const gainNode2 = audioContext.createGain();
+  // we create a ChannelMergerNode which merges towo channels into one
+  const mergerNode = audioContext.createMerger(2);
+  
+
+
+  gainNode1.gain.value = 0.5; // set left channel volume to 0.5
+  gainNode2.gain.value = 1; // set right channel volume to 1
+  /*
+    we connect oscillator to the splitter
+    oscillator has one output and splitter has one input 
+    so we dont need to specify the indices
+  */
+  oscillatorNode.connect(splitterNode);
+  // we connect output 0 (left channel) of the splittter to input 0 of the gain1
+  splitterNode.connect(gainNode1, 0, 0);
+  // we connect output 1 (right channel) of the splitter to input 0 of gain2 
+  splitterNode.connect(gainNode1, 1, 0);
+  // we connect output 0 of the gain1 to input 0 of the merger 
+  gainNode1.connect(mergerNode, 0, 0);
+  // we connect output 0 of the gain2 to input 1 of the merger 
+  gainNode2.connect(mergerNode, 0, 1);
+  /*
+    we connect merger to the destination
+    merger has one output and destination has one input 
+    so we dont need to specify the indices
+  */
+  mergerNode.connect(audioContext.destination);
+  oscillatorNode.start(audioContext.currentTime);
+}
+```
+
 ### Connecting node to audio param (LFO-controlled parameter)
 
 ```tsx
@@ -90,6 +139,8 @@ Connects one of the node's outputs to a destination.
 | Parameter | Type | Description |
 | :---: | :---: | :---- |
 | `destination` | [`AudioNode`](/docs/core/audio-node) or [`AudioParam`](/docs/core/audio-param) | `AudioNode` or `AudioParam` to which to connect. |
+| `outputIndex` <Optional/> | `number` | An index specifying which output of the current `AudioNode` to connect to the destination. Defaults to 0. |
+| `inputIndex` <Optional/> | `number` | An index describing which input of the destination you want to connect the current `AudioNode` to. Defaults to 0. Cannot be used with when destination is an `AudioParam`.|
 
 #### Errors:
 
@@ -101,13 +152,26 @@ Connects one of the node's outputs to a destination.
 
 ### `disconnect`
 
-Disconnects one or more nodes from the node.
+Disconnects one or more nodes / params from the node.
 
 | Parameter | Type | Description |
 | :---: | :---: | :---- |
 | `destination` <Optional /> | [`AudioNode`](/docs/core/audio-node) or [`AudioParam`](/docs/core/audio-param) | `AudioNode` or `AudioParam` from which to disconnect. |
-
-If no arguments provided node disconnects from all outgoing connections.
+| `outputIndex` <Optional/> | `number` | An index specifying which output of the current `AudioNode` is to be disconnected.|
+| `inputIndex` <Optional/> | `number` | An index describing which input of the destination you want to disconnect the current `AudioNode` from. Cannot be used with when destination is an `AudioParam`.|
+
+The method behaves differently depending on the combination of the provided parameters: 
+
+#### `disconnect()`
+Disconnects all outgoing connections from the [`AudioNode`](/docs/core/audio-node).
+#### `disconnect(outputIndex)`
+Disconnects all connections going out from the specified `outputIndex` of the [`AudioNode`](/docs/core/audio-node) .
+#### `disconnect(destination)`
+Disconnects all outputs of the [`AudioNode`](/docs/core/audio-node) going to a specific destination [`AudioNode`](/docs/core/audio-node) or [`AudioParam`](/docs/core/audio-param).
+#### `disconnect(destination, outputIndex)`
+Disconnects a specific output of the [`AudioNode`](/docs/core/audio-node) from any and all inputs of some destination [`AudioNode`](/docs/core/audio-node) or [`AudioParam`](/docs/core/audio-param). 
+#### `disconnect(destinationNode, outputIndex,inputIndex)`
+Disconnects a specific output of the [`AudioNode`](/docs/core/audio-node) from a specific input of some destination [`AudioNode`](/docs/core/audio-node).
 
 #### Returns `undefined`.
 
diff --git a/packages/audiodocs/docs/core/base-audio-context.mdx b/packages/audiodocs/docs/core/base-audio-context.mdx
index 8823f992d..2b37ad2b9 100644
--- a/packages/audiodocs/docs/core/base-audio-context.mdx
+++ b/packages/audiodocs/docs/core/base-audio-context.mdx
@@ -224,6 +224,38 @@ Creates [`BiquadFilterNode`](/docs/effects/biquad-filter-node).
 
 #### Returns `BiquadFilterNode`.
 
+### `createChannelSplitter` 
+
+Creates [`ChannelSplitterNode`](/docs/effects/channel-splitter-node).
+
+| Parameter | Type | Description |
+| :---: | :---: | :---- |
+| `numberOfOutputs` | `number` | The number of outputs. | <ReadOnly /> |
+
+#### Errors
+
+| Error type | Description |
+| :---: | :---- |
+| `IndexSizeError` | `numberOfOutputs` is outside the nominal range [1, 32]. |
+
+#### Returns `ChannelSplitterNode`.
+
+### `createChannelMerger` 
+
+Creates [`ChannelMergerNode`](/docs/effects/channel-merger-node).
+
+| Parameter | Type | Description |
+| :---: | :---: | :---- |
+| `numberOfInputs` | `number` | The number of inputs. | <ReadOnly /> |
+
+#### Errors
+
+| Error type | Description |
+| :---: | :---- |
+| `IndexSizeError` | `numberOfInputs` is outside the nominal range [1, 32]. |
+
+#### Returns `ChannelMergerNode`.
+
 :::caution
 Supported file formats:
 - aac
diff --git a/packages/audiodocs/docs/effects/channel-merger-node.mdx b/packages/audiodocs/docs/effects/channel-merger-node.mdx
new file mode 100644
index 000000000..d24a84cdf
--- /dev/null
+++ b/packages/audiodocs/docs/effects/channel-merger-node.mdx
@@ -0,0 +1,33 @@
+---
+sidebar_position: 2
+---
+
+import AudioNodePropsTable from "@site/src/components/AudioNodePropsTable"
+import { ReadOnly, Optional } from '@site/src/components/Badges';
+
+# ChannelMergerNode
+
+The `ChannelMergerNode`, often used in conjunction with its opposite,[`ChannelSplitterNode`](/docs/effects/channel-splitter-node),
+combines multiple mono inputs into a single output channel. This is useful for mixing audio signals from different sources, allowing for more complex audio routing and processing.
+
+The `numberOfInputs` is defined by a parameter passed to the [`BaseAudioContext.createChannelMerger(numberOfInputs)`](/docs/core/base-audio-context#createchannelmerger). 
+This number in most cases should be equal to the number of inputs you want to connect to the merger.
+If you create a six-input merger and only connect one node to input 0, the output will be a 5.1 signal with channel 0 containing the audio from the connected node and the rest of the channels being silent.
+If you connect a non-mono signal to the merger (e.g., a stereo signal to input 0), the signal will be down-mixed into mono before merging. 
+
+#### [`AudioNode`](/docs/core/audio-node#read-only-properties) properties
+<AudioNodePropsTable numberOfInputs={"variable - defaults to 6"} numberOfOutputs={1} channelCount={"numberOfInputs"} channelCountMode={"explicit"} channelInterpretation={"speakers"} />
+
+## Constructor
+
+[`BaseAudioContext.createChannelMerger()`](/docs/core/base-audio-context#createchannelmerger)
+
+## Methods
+
+It inherits all methods from [`AudioNode`](/docs/core/audio-node#methods).
+
+## Remarks
+
+#### `numberOfInputs`
+- Default value is 6.
+- range is from 1 to 32 inputs.
\ No newline at end of file
diff --git a/packages/audiodocs/docs/effects/channel-splitter-node.mdx b/packages/audiodocs/docs/effects/channel-splitter-node.mdx
new file mode 100644
index 000000000..aea0a0f17
--- /dev/null
+++ b/packages/audiodocs/docs/effects/channel-splitter-node.mdx
@@ -0,0 +1,33 @@
+---
+sidebar_position: 2
+---
+
+import AudioNodePropsTable from "@site/src/components/AudioNodePropsTable"
+import { ReadOnly, Optional } from '@site/src/components/Badges';
+
+# ChannelSplitterNode
+
+The `ChannelSplitterNode`, often used in conjunction with its opposite,[`ChannelMergerNode`](/docs/effects/channel-merger-node),
+separates the different channels of an audio source into a set of mono outputs. This is useful for accessing each channel separately, e.g., for performing channel mixing where gain must be separately controlled on each channel.
+
+The `numberOfOutputs` is defined by a parameter passed to the [`BaseAudioContext.createChannelSplitter(numberOfOutputs)`](/docs/core/base-audio-context#createchannelsplitter). 
+This number in most cases should be equal to the number of channels of the input signal. 
+If you pass a mono signal to a six-output splitter then output 0 will hold the mono signal and outputs 1-5 will be silent. 
+On the other hand when you pass a 5.1 signal into a two-output splitter, the data from channel 0 and 1 will be copied into outputs 0 and 1 and the rest of the channels will be ignored.
+
+#### [`AudioNode`](/docs/core/audio-node#read-only-properties) properties
+<AudioNodePropsTable numberOfInputs={1} numberOfOutputs={"variable - defaults to 6"} channelCount={"numberOfOutputs"} channelCountMode={"explicit"} channelInterpretation={"speakers"} />
+
+## Constructor
+
+[`BaseAudioContext.createChannelSplitter()`](/docs/core/base-audio-context#createchannelsplitter)
+
+## Methods
+
+It inherits all methods from [`AudioNode`](/docs/core/audio-node#methods).
+
+## Remarks
+
+#### `numberOfOutputs`
+- Default value is 6.
+- range is from 1 to 32 outputs.
\ No newline at end of file
diff --git a/packages/audiodocs/docs/other/web-audio-api-coverage.mdx b/packages/audiodocs/docs/other/web-audio-api-coverage.mdx
index 3854d8eda..6e7571e38 100644
--- a/packages/audiodocs/docs/other/web-audio-api-coverage.mdx
+++ b/packages/audiodocs/docs/other/web-audio-api-coverage.mdx
@@ -18,13 +18,15 @@ sidebar_position: 2
 | AudioParam | ✅ |
 | AudioScheduledSourceNode | ✅ |
 | BiquadFilterNode | ✅ |
+| ChannelMergerNode | ✅ |
+| ChannelSplitterNode | ✅ |
 | ConstantSourceNode | ✅ |
+| ConvolverNode | ✅ |
 | GainNode | ✅ |
 | OfflineAudioContext | ✅ |
 | OscillatorNode | ✅ |
 | PeriodicWave | ✅ |
 | StereoPannerNode | ✅ |
-| ConvolverNode | ✅ |
 | AudioContext | 🚧 | Available props and methods: `close`, `suspend`, `resume` |
 | BaseAudioContext | 🚧 | Available props and methods: `currentTime`, `destination`, `sampleRate`, `state`, `decodeAudioData`, all create methods for available or partially implemented nodes |
 | AudioListener | ❌ |
@@ -33,8 +35,6 @@ sidebar_position: 2
 | AudioWorkletGlobalScope | ❌ |
 | AudioWorkletNode | ❌ |
 | AudioWorkletProcessor | ❌ |
-| ChannelMergerNode | ❌ |
-| ChannelSplitterNode | ❌ |
 | DelayNode | ❌ |
 | DynamicsCompressorNode | ❌ |
 | IIRFilterNode | ❌ |
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
index d5d3ce4bf..c3d2a3f2c 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
@@ -42,32 +42,120 @@ JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, channelInterpretation) {
 
 JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, connect) {
   auto obj = args[0].getObject(runtime);
+
   if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
     auto node = obj.getHostObject<AudioNodeHostObject>(runtime);
-    node_->connect(std::shared_ptr<AudioNodeHostObject>(node)->node_);
+    size_t outputIndex = args[1].asNumber();
+    size_t inputIndex = args[2].asNumber();
+    node_->connect(
+        std::shared_ptr<AudioNodeHostObject>(node)->node_,
+        outputIndex,
+        inputIndex);
   }
   if (obj.isHostObject<AudioParamHostObject>(runtime)) {
     auto param = obj.getHostObject<AudioParamHostObject>(runtime);
-    node_->connect(std::shared_ptr<AudioParamHostObject>(param)->param_);
+    size_t outputIndex = args[1].asNumber();
+    node_->connect(
+        std::shared_ptr<AudioParamHostObject>(param)->param_, outputIndex);
   }
   return jsi::Value::undefined();
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, disconnect) {
-  if (args[0].isUndefined()) {
-    node_->disconnect();
-    return jsi::Value::undefined();
-  }
-  auto obj = args[0].getObject(runtime);
-  if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
-    auto node = obj.getHostObject<AudioNodeHostObject>(runtime);
-    node_->disconnect(std::shared_ptr<AudioNodeHostObject>(node)->node_);
-  }
+  auto throwInvalidAccessError = [&](const std::string &message) {
+    throw jsi::JSError(runtime, "InvalidAccessError: " + message);
+  };
 
-  if (obj.isHostObject<AudioParamHostObject>(runtime)) {
-    auto param = obj.getHostObject<AudioParamHostObject>(runtime);
-    node_->disconnect(std::shared_ptr<AudioParamHostObject>(param)->param_);
+  switch (count) {
+    case 0: {
+      // Signature: disconnect()
+      node_->disconnect();
+      break;
+    }
+
+    case 1: {
+      const auto &arg = args[0];
+      if (arg.isNumber()) {
+        // Signature: disconnect(outputIndex)
+        // TS layer handled IndexSizeError
+        node_->disconnect(static_cast<unsigned int>(arg.asNumber()));
+      } else {
+        auto obj = arg.asObject(runtime);
+        if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
+          // Signature: disconnect(destinationNode)
+          auto destHostObject = obj.getHostObject<AudioNodeHostObject>(runtime);
+          bool disconnected = node_->disconnect(destHostObject->node_);
+          if (!disconnected) {
+            throwInvalidAccessError(
+                "Failed to execute 'disconnect' on 'AudioNode': "
+                "the specified destination node is not connected to this node.");
+          }
+        } else {
+          auto destHostObject =
+              obj.getHostObject<AudioParamHostObject>(runtime);
+          bool disconnected = node_->disconnect(destHostObject->param_);
+          if (!disconnected) {
+            throwInvalidAccessError(
+                "Failed to execute 'disconnect' on 'AudioNode': "
+                "the specified destination parameter is not connected to this node.");
+          }
+        }
+      }
+      break;
+    }
+
+    case 2: {
+      auto obj = args[0].asObject(runtime);
+      auto outputIndex = static_cast<unsigned int>(args[1].asNumber());
+
+      if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
+        // Signature: disconnect(destinationNode, outputIndex)
+        auto destHostObject = obj.getHostObject<AudioNodeHostObject>(runtime);
+
+        bool disconnected =
+            node_->disconnect(destHostObject->node_, outputIndex);
+        if (!disconnected) {
+          throwInvalidAccessError(
+              "Failed to execute 'disconnect' on 'AudioNode': "
+              "no connection was found from the given output to the specified AudioNode.");
+        }
+
+      } else {
+        auto destHostObject = obj.getHostObject<AudioParamHostObject>(runtime);
+
+        bool disconnected =
+            node_->disconnect(destHostObject->param_, outputIndex);
+        if (!disconnected) {
+          throwInvalidAccessError(
+              "Failed to execute 'disconnect' on 'AudioNode': "
+              "no connection was found from the given output to the specified AudioParam.");
+        }
+      }
+      break;
+    }
+
+    case 3: {
+      auto obj = args[0].asObject(runtime);
+      auto destHostObject = obj.getHostObject<AudioNodeHostObject>(runtime);
+      auto outputIndex = static_cast<unsigned int>(args[1].asNumber());
+      auto inputIndex = static_cast<unsigned int>(args[2].asNumber());
+
+      // Signature: disconnect(destinationNode, outputIndex, inputIndex)
+      bool disconnected =
+          node_->disconnect(destHostObject->node_, outputIndex, inputIndex);
+      if (!disconnected) {
+        throwInvalidAccessError(
+            "Failed to execute 'disconnect' on 'AudioNode': "
+            "no connection was found from the given output to the given input of the specified AudioNode.");
+      }
+      break;
+    }
+
+    default: {
+      throw jsi::JSError(runtime, "disconnect: Invalid number of arguments.");
+    }
   }
+
   return jsi::Value::undefined();
 }
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
index 17ab237d7..19106a74a 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
@@ -5,6 +5,8 @@
 #include <audioapi/HostObjects/analysis/AnalyserNodeHostObject.h>
 #include <audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h>
 #include <audioapi/HostObjects/effects/BiquadFilterNodeHostObject.h>
+#include <audioapi/HostObjects/effects/ChannelMergerNodeHostObject.h>
+#include <audioapi/HostObjects/effects/ChannelSplitterNodeHostObject.h>
 #include <audioapi/HostObjects/effects/ConvolverNodeHostObject.h>
 #include <audioapi/HostObjects/effects/GainNodeHostObject.h>
 #include <audioapi/HostObjects/effects/PeriodicWaveHostObject.h>
@@ -46,6 +48,8 @@ BaseAudioContextHostObject::BaseAudioContextHostObject(
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createGain),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createStereoPanner),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBiquadFilter),
+      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createChannelSplitter),
+      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createChannelMerger),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBufferSource),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBufferQueueSource),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBuffer),
@@ -209,6 +213,34 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBiquadFilter) {
   return jsi::Object::createFromHostObject(runtime, biquadFilterHostObject);
 }
 
+JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createChannelSplitter) {
+  unsigned int numberOfOutputs = 6;
+  if (count > 0 && args[0].isNumber()) {
+    numberOfOutputs = static_cast<unsigned int>(args[0].asNumber());
+  }
+
+  auto channelSplitter = context_->createChannelSplitter(numberOfOutputs);
+
+  auto channelSplitterHostObject =
+      std::make_shared<ChannelSplitterNodeHostObject>(channelSplitter);
+
+  return jsi::Object::createFromHostObject(runtime, channelSplitterHostObject);
+}
+
+JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createChannelMerger) {
+  unsigned int numberOfInputs = 6;
+  if (count > 0 && args[0].isNumber()) {
+    numberOfInputs = static_cast<unsigned int>(args[0].asNumber());
+  }
+
+  auto channelMerger = context_->createChannelMerger(numberOfInputs);
+
+  auto channelMergerHostObject =
+      std::make_shared<ChannelMergerNodeHostObject>(channelMerger);
+
+  return jsi::Object::createFromHostObject(runtime, channelMergerHostObject);
+}
+
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBufferSource) {
   auto pitchCorrection = args[0].asBool();
   auto bufferSource = context_->createBufferSource(pitchCorrection);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.h
index 4ab17b29f..e739b77ee 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.h
@@ -36,6 +36,8 @@ class BaseAudioContextHostObject : public JsiHostObject {
   JSI_HOST_FUNCTION_DECL(createGain);
   JSI_HOST_FUNCTION_DECL(createStereoPanner);
   JSI_HOST_FUNCTION_DECL(createBiquadFilter);
+  JSI_HOST_FUNCTION_DECL(createChannelSplitter);
+  JSI_HOST_FUNCTION_DECL(createChannelMerger);
   JSI_HOST_FUNCTION_DECL(createBufferSource);
   JSI_HOST_FUNCTION_DECL(createBufferQueueSource);
   JSI_HOST_FUNCTION_DECL(createBuffer);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ChannelMergerNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ChannelMergerNodeHostObject.cpp
new file mode 100644
index 000000000..13d14ec1f
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ChannelMergerNodeHostObject.cpp
@@ -0,0 +1,12 @@
+#include <audioapi/HostObjects/effects/ChannelMergerNodeHostObject.h>
+
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/core/effects/ChannelMergerNode.h>
+
+namespace audioapi {
+
+ChannelMergerNodeHostObject::ChannelMergerNodeHostObject(
+    const std::shared_ptr<ChannelMergerNode> &node)
+    : AudioNodeHostObject(node) {}
+
+} // namespace audioapi
\ No newline at end of file
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ChannelMergerNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ChannelMergerNodeHostObject.h
new file mode 100644
index 000000000..8c6ac1d79
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ChannelMergerNodeHostObject.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class ChannelMergerNode;
+
+class ChannelMergerNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit ChannelMergerNodeHostObject(const std::shared_ptr<ChannelMergerNode> &node);
+};
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ChannelSplitterNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ChannelSplitterNodeHostObject.cpp
new file mode 100644
index 000000000..cc0fdd6ca
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ChannelSplitterNodeHostObject.cpp
@@ -0,0 +1,12 @@
+#include <audioapi/HostObjects/effects/ChannelSplitterNodeHostObject.h>
+
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/core/effects/ChannelSplitterNode.h>
+
+namespace audioapi {
+
+ChannelSplitterNodeHostObject::ChannelSplitterNodeHostObject(
+    const std::shared_ptr<ChannelSplitterNode> &node)
+    : AudioNodeHostObject(node) {}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ChannelSplitterNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ChannelSplitterNodeHostObject.h
new file mode 100644
index 000000000..b39d7b55c
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ChannelSplitterNodeHostObject.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class ChannelSplitterNode;
+
+class ChannelSplitterNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit ChannelSplitterNodeHostObject(const std::shared_ptr<ChannelSplitterNode> &node);
+};
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.cpp
index dcc9d34a3..ac1e4eb78 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.cpp
@@ -2,14 +2,22 @@
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
-#include <audioapi/utils/AudioArray.h>
+#include <audioapi/core/utils/NodeConnections.h>
 #include <audioapi/utils/AudioBus.h>
+#include <stdexcept>
 
 namespace audioapi {
 
-AudioNode::AudioNode(BaseAudioContext *context) : context_(context) {
-  audioBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
+AudioNode::AudioNode(BaseAudioContext *context, unsigned int numberOfInputs)
+    : context_(context), numberOfInputs_(numberOfInputs) {
+  connections_ = std::make_unique<NodeConnections>(this, context);
+  isInitialized_ = true;
+
+  outputBuses_.resize(numberOfOutputs_);
+  for (unsigned int i = 0; i < numberOfOutputs_; ++i) {
+    outputBuses_[i] = std::make_shared<AudioBus>(
+        RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
+  }
 }
 
 AudioNode::~AudioNode() {
@@ -18,81 +26,120 @@ AudioNode::~AudioNode() {
   }
 }
 
-int AudioNode::getNumberOfInputs() const {
-  return numberOfInputs_;
-}
-
-int AudioNode::getNumberOfOutputs() const {
-  return numberOfOutputs_;
-}
-
-int AudioNode::getChannelCount() const {
-  return channelCount_;
+void AudioNode::connect(
+    const std::shared_ptr<AudioNode> &destination,
+    unsigned int outputIndex,
+    unsigned int inputIndex) {
+  context_->getNodeManager()->addPendingNodeConnection(
+      shared_from_this(),
+      destination,
+      AudioNodeManager::ConnectionType::CONNECT,
+      outputIndex,
+      inputIndex);
 }
 
-std::string AudioNode::getChannelCountMode() const {
-  return AudioNode::toString(channelCountMode_);
+void AudioNode::connect(
+    const std::shared_ptr<AudioParam> &param,
+    unsigned int outputIndex) {
+  context_->getNodeManager()->addPendingParamConnection(
+      shared_from_this(),
+      param,
+      AudioNodeManager::ConnectionType::CONNECT,
+      outputIndex);
 }
 
-std::string AudioNode::getChannelInterpretation() const {
-  return AudioNode::toString(channelInterpretation_);
+void AudioNode::disconnect() {
+  connections_->disconnect();
 }
 
-void AudioNode::connect(const std::shared_ptr<AudioNode> &node) {
-  context_->getNodeManager()->addPendingNodeConnection(
-      shared_from_this(), node, AudioNodeManager::ConnectionType::CONNECT);
+// disconnect a single output from any other nodes or params
+void AudioNode::disconnect(unsigned int outputIndex) {
+  connections_->disconnect(outputIndex);
 }
 
-void AudioNode::connect(const std::shared_ptr<AudioParam> &param) {
-  context_->getNodeManager()->addPendingParamConnection(
-      shared_from_this(), param, AudioNodeManager::ConnectionType::CONNECT);
+// disconnect all connections to a specific node param / node connections
+bool AudioNode::disconnect(const std::shared_ptr<AudioNode> &destination) {
+  if (destination == nullptr)
+    return false;
+  return connections_->disconnect(destination);
 }
 
-void AudioNode::disconnect() {
-  context_->getNodeManager()->addPendingNodeConnection(
-      shared_from_this(),
-      nullptr,
-      AudioNodeManager::ConnectionType::DISCONNECT_ALL);
+bool AudioNode::disconnect(
+    const std::shared_ptr<AudioNode> &destination,
+    unsigned int outputIndex) {
+  if (destination == nullptr)
+    return false;
+  return connections_->disconnect(destination, outputIndex);
 }
 
-void AudioNode::disconnect(const std::shared_ptr<AudioNode> &node) {
-  context_->getNodeManager()->addPendingNodeConnection(
-      shared_from_this(), node, AudioNodeManager::ConnectionType::DISCONNECT);
+bool AudioNode::disconnect(
+    const std::shared_ptr<AudioNode> &destination,
+    unsigned int outputIndex,
+    unsigned int inputIndex) {
+  if (destination == nullptr)
+    return false;
+  return connections_->disconnect(destination, outputIndex, inputIndex);
 }
 
-void AudioNode::disconnect(const std::shared_ptr<AudioParam> &param) {
-  context_->getNodeManager()->addPendingParamConnection(
-      shared_from_this(), param, AudioNodeManager::ConnectionType::DISCONNECT);
+bool AudioNode::disconnect(const std::shared_ptr<AudioParam> &param) {
+  if (param == nullptr)
+    return false;
+  return connections_->disconnect(param);
 }
 
-bool AudioNode::isEnabled() const {
-  return isEnabled_;
+bool AudioNode::disconnect(
+    const std::shared_ptr<AudioParam> &param,
+    unsigned int outputIndex) {
+  if (param == nullptr)
+    return false;
+  return connections_->disconnect(param, outputIndex);
 }
 
-void AudioNode::enable() {
-  if (isEnabled()) {
+void AudioNode::processAudio(
+    int framesToProcess,
+    bool checkIsAlreadyProcessed) {
+  if (!isInitialized_ || framesToProcess <= 0) {
     return;
   }
 
-  isEnabled_ = true;
+  if (checkIsAlreadyProcessed && isAlreadyProcessed()) {
+    return;
+  }
 
-  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end;
-       ++it) {
-    it->get()->onInputEnabled();
+  for (int i = 0; i < numberOfOutputs_; ++i) {
+    outputBuses_[i]->zero();
   }
-}
 
-void AudioNode::disable() {
-  if (!isEnabled()) {
+  // we could also do the check in NodeConnections::processInputAtIndex, not
+  // sure which is better
+  if (!isEnabled_) {
     return;
   }
 
-  isEnabled_ = false;
+  // process all inputs for each input index
+  const auto &inputBuses =
+      connections_->processAllInputs(framesToProcess, checkIsAlreadyProcessed);
+  // process the node itself
+  processNode(inputBuses, framesToProcess);
+}
 
-  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end;
-       ++it) {
-    it->get()->onInputDisabled();
-  }
+int AudioNode::getNumberOfInputs() const {
+  return numberOfInputs_;
+}
+int AudioNode::getNumberOfOutputs() const {
+  return numberOfOutputs_;
+}
+int AudioNode::getChannelCount() const {
+  return channelCount_;
+}
+bool AudioNode::isEnabled() const {
+  return isEnabled_;
+}
+std::string AudioNode::getChannelCountMode() const {
+  return AudioNode::toString(channelCountMode_);
+}
+std::string AudioNode::getChannelInterpretation() const {
+  return AudioNode::toString(channelInterpretation_);
 }
 
 std::string AudioNode::toString(ChannelCountMode mode) {
@@ -119,199 +166,155 @@ std::string AudioNode::toString(ChannelInterpretation interpretation) {
   }
 }
 
-std::shared_ptr<AudioBus> AudioNode::processAudio(
-    const std::shared_ptr<AudioBus> &outputBus,
-    int framesToProcess,
-    bool checkIsAlreadyProcessed) {
-  if (!isInitialized_) {
-    return outputBus;
-  }
-
-  if (checkIsAlreadyProcessed && isAlreadyProcessed()) {
-    return audioBus_;
-  }
-
-  // Process inputs and return the bus with the most channels.
-  auto processingBus =
-      processInputs(outputBus, framesToProcess, checkIsAlreadyProcessed);
-
-  // Apply channel count mode.
-  processingBus = applyChannelCountMode(processingBus);
-
-  // Mix all input buses into the processing bus.
-  mixInputsBuses(processingBus);
-
-  assert(processingBus != nullptr);
-
-  // Finally, process the node itself.
-  return processNode(processingBus, framesToProcess);
-  ;
+void AudioNode::enable() {
+  if (isEnabled_)
+    return;
+  isEnabled_ = true;
+  connections_->propagateEnable();
 }
 
-bool AudioNode::isAlreadyProcessed() {
-  assert(context_ != nullptr);
-
-  std::size_t currentSampleFrame = context_->getCurrentSampleFrame();
-
-  // check if the node has already been processed for this rendering quantum
-  if (currentSampleFrame == lastRenderedFrame_) {
-    return true;
-  }
-
-  // Update the last rendered frame before processing node and its inputs.
-  lastRenderedFrame_ = currentSampleFrame;
-
-  return false;
+void AudioNode::disable() {
+  if (!isEnabled_)
+    return;
+  isEnabled_ = false;
+  connections_->propagateDisable();
 }
 
-std::shared_ptr<AudioBus> AudioNode::processInputs(
-    const std::shared_ptr<AudioBus> &outputBus,
-    int framesToProcess,
-    bool checkIsAlreadyProcessed) {
-  auto processingBus = audioBus_;
-  processingBus->zero();
-
-  int maxNumberOfChannels = 0;
-  for (auto it = inputNodes_.begin(), end = inputNodes_.end(); it != end;
-       ++it) {
-    auto inputNode = *it;
-    assert(inputNode != nullptr);
-
-    if (!inputNode->isEnabled()) {
-      continue;
-    }
-
-    auto inputBus = inputNode->processAudio(
-        outputBus, framesToProcess, checkIsAlreadyProcessed);
-    inputBuses_.push_back(inputBus);
-
-    if (maxNumberOfChannels < inputBus->getNumberOfChannels()) {
-      maxNumberOfChannels = inputBus->getNumberOfChannels();
-      processingBus = inputBus;
-    }
-  }
-
-  return processingBus;
+void AudioNode::connectNode(
+    const std::shared_ptr<AudioNode> &destination,
+    unsigned int outputIndex,
+    unsigned int inputIndex) {
+  connections_->connectNode(destination, outputIndex, inputIndex);
 }
 
-std::shared_ptr<AudioBus> AudioNode::applyChannelCountMode(
-    const std::shared_ptr<AudioBus> &processingBus) {
-  // If the channelCountMode is EXPLICIT, the node should output the number of
-  // channels specified by the channelCount.
-  if (channelCountMode_ == ChannelCountMode::EXPLICIT) {
-    return audioBus_;
+void AudioNode::onInputConnected(
+    AudioNode *source,
+    unsigned int outputIndexFromSource,
+    unsigned int inputIndex) {
+  if (!isInitialized_) {
+    return;
   }
 
-  // If the channelCountMode is CLAMPED_MAX, the node should output the maximum
-  // number of channels clamped to channelCount.
-  if (channelCountMode_ == ChannelCountMode::CLAMPED_MAX &&
-      processingBus->getNumberOfChannels() >= channelCount_) {
-    return audioBus_;
+  connections_->onInputConnected(source, outputIndexFromSource, inputIndex);
+  if (source->isEnabled()) {
+    onInputEnabled();
   }
-
-  return processingBus;
 }
 
-void AudioNode::mixInputsBuses(const std::shared_ptr<AudioBus> &processingBus) {
-  assert(processingBus != nullptr);
-
-  for (auto it = inputBuses_.begin(), end = inputBuses_.end(); it != end;
-       ++it) {
-    processingBus->sum(it->get(), channelInterpretation_);
-  }
-
-  inputBuses_.clear();
+void AudioNode::disconnectNode(
+    const std::shared_ptr<AudioNode> &destination,
+    unsigned int outputIndex,
+    unsigned int inputIndex) {
+  connections_->disconnectNode(destination, outputIndex, inputIndex);
 }
 
-void AudioNode::connectNode(const std::shared_ptr<AudioNode> &node) {
-  auto position = outputNodes_.find(node);
-
-  if (position == outputNodes_.end()) {
-    outputNodes_.insert(node);
-    node->onInputConnected(this);
+void AudioNode::onInputDisconnected(
+    AudioNode *source,
+    unsigned int outputIndexFromSource,
+    unsigned int inputIndex) {
+  if (!isInitialized_) {
+    return;
   }
-}
 
-void AudioNode::connectParam(const std::shared_ptr<AudioParam> &param) {
-  auto position = outputParams_.find(param);
-
-  if (position == outputParams_.end()) {
-    outputParams_.insert(param);
-    param->addInputNode(this);
+  connections_->onInputDisconnected(source, outputIndexFromSource, inputIndex);
+  if (source->isEnabled()) {
+    onInputDisabled();
   }
 }
 
-void AudioNode::disconnectNode(const std::shared_ptr<AudioNode> &node) {
-  auto position = outputNodes_.find(node);
-
-  if (position != outputNodes_.end()) {
-    node->onInputDisconnected(this);
-    outputNodes_.erase(node);
-  }
+void AudioNode::connectParam(
+    const std::shared_ptr<AudioParam> &param,
+    unsigned int outputIndex) {
+  connections_->connectParam(param, outputIndex);
 }
 
-void AudioNode::disconnectParam(const std::shared_ptr<AudioParam> &param) {
-  auto position = outputParams_.find(param);
-
-  if (position != outputParams_.end()) {
-    param->removeInputNode(this);
-    outputParams_.erase(param);
-  }
+void AudioNode::disconnectParam(
+    const std::shared_ptr<AudioParam> &param,
+    unsigned int outputIndex) {
+  connections_->disconnectParam(param, outputIndex);
 }
 
 void AudioNode::onInputEnabled() {
-  numberOfEnabledInputNodes_ += 1;
-
-  if (!isEnabled()) {
+  numberOfEnabledInputNodes_++;
+  if (!isEnabled_) {
     enable();
   }
 }
 
 void AudioNode::onInputDisabled() {
-  numberOfEnabledInputNodes_ -= 1;
-
-  if (isEnabled() && numberOfEnabledInputNodes_ == 0) {
+  numberOfEnabledInputNodes_--;
+  if (isEnabled_ && numberOfEnabledInputNodes_ == 0) {
     disable();
   }
 }
 
-void AudioNode::onInputConnected(AudioNode *node) {
-  if (!isInitialized_) {
-    return;
+bool AudioNode::isAlreadyProcessed() {
+  std::size_t currentSampleFrame = context_->getCurrentSampleFrame();
+  if (currentSampleFrame == lastRenderedFrame_) {
+    return true;
   }
+  lastRenderedFrame_ = currentSampleFrame;
+  return false;
+}
 
-  inputNodes_.insert(node);
+void AudioNode::cleanup() {
+  isInitialized_ = false;
+  connections_->cleanup();
+}
 
-  if (node->isEnabled()) {
-    onInputEnabled();
+std::shared_ptr<AudioBus> AudioNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  if (processingBus == nullptr) {
+    return nullptr;
   }
+  processingBus->zero();
+  return processingBus;
 }
 
-void AudioNode::onInputDisconnected(AudioNode *node) {
-  if (!isInitialized_) {
-    return;
+// this acts as an adapter for all the single input/output nodes (every node
+// besides merger/splitter)
+void AudioNode::processNode(
+    const std::vector<std::shared_ptr<AudioBus>> &inputBuses,
+    int framesToProcess) {
+  std::shared_ptr<AudioBus> processingBus;
+
+  // this handles source (0 input) node case
+  if (inputBuses.empty() || inputBuses[0] == nullptr) {
+    processingBus = getOutputBus(0);
+    processingBus->zero();
+  } else {
+    processingBus = inputBuses[0];
   }
 
-  if (node->isEnabled()) {
-    onInputDisabled();
-  }
+  std::shared_ptr<AudioBus> returnedBus =
+      processNode(processingBus, framesToProcess);
 
-  auto position = inputNodes_.find(node);
+  if (!outputBuses_.empty()) {
+    auto outBus = getOutputBus(0);
 
-  if (position != inputNodes_.end()) {
-    inputNodes_.erase(position);
-  }
-}
+    if (returnedBus != nullptr) {
+      unsigned int requiredChannels = returnedBus->getNumberOfChannels();
 
-void AudioNode::cleanup() {
-  isInitialized_ = false;
+      // Reallocate output bus if channel count doesn't match
+      if (outBus->getNumberOfChannels() != requiredChannels ||
+          outBus->getSampleRate() != context_->getSampleRate()) {
+        outputBuses_[0] = std::make_shared<AudioBus>(
+            RENDER_QUANTUM_SIZE, requiredChannels, context_->getSampleRate());
+        outBus = outputBuses_[0];
+      }
 
-  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end;
-       ++it) {
-    it->get()->onInputDisconnected(this);
+      if (returnedBus != outBus) {
+        outBus->copy(returnedBus.get());
+      }
+    } else {
+      outBus->zero();
+    }
   }
+}
 
-  outputNodes_.clear();
+std::shared_ptr<AudioBus> AudioNode::getOutputBus(unsigned int index) {
+  return outputBuses_.at(index);
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
index 4b726ff1b..9624cb859 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
@@ -1,91 +1,118 @@
+
 #pragma once
 
 #include <audioapi/core/types/ChannelCountMode.h>
 #include <audioapi/core/types/ChannelInterpretation.h>
 #include <audioapi/core/utils/Constants.h>
 
+#include <limits>
+#include <cstddef>
+#include <map>
 #include <memory>
 #include <string>
-#include <unordered_set>
-#include <cstddef>
 #include <vector>
-#include <cassert>
 
 namespace audioapi {
 
 class AudioBus;
 class BaseAudioContext;
 class AudioParam;
+class NodeConnections;
 
 class AudioNode : public std::enable_shared_from_this<AudioNode> {
  public:
-  explicit AudioNode(BaseAudioContext *context);
+  // allocates correct amount of space for m_outputBuses
+  //explicit AudioNode(BaseAudioContext *context);
   virtual ~AudioNode();
 
+  // just delegates it to the NodeManager
+  void
+  connect(const std::shared_ptr<AudioNode> &destination, unsigned int outputIndex = 0, unsigned int inputIndex = 0);
+  // just delegates it to the NodeManager
+  void connect(const std::shared_ptr<AudioParam> &param, unsigned int outputIndex = 0);
+
+  // overloaded disconnect methods - these just call equivalent methods in NodeConnection
+  void disconnect();
+  void disconnect(unsigned int outputIndex);
+  bool disconnect(const std::shared_ptr<AudioNode> &destination);
+  bool disconnect(const std::shared_ptr<AudioNode> &destination, unsigned int outputIndex);
+  bool disconnect(const std::shared_ptr<AudioNode> &destination, unsigned int outputIndex, unsigned int inputIndex);
+  bool disconnect(const std::shared_ptr<AudioParam> &param);
+  bool disconnect(const std::shared_ptr<AudioParam> &param, unsigned int outputIndex);
+
+  // calls NodeConnections::processAllInputs
+  virtual void processAudio(int framesToProcess, bool checkIsAlreadyProcessed);
+
+  std::shared_ptr<AudioBus> getOutputBus(unsigned int outputIndex);
+
   int getNumberOfInputs() const;
   int getNumberOfOutputs() const;
   int getChannelCount() const;
+  bool isEnabled() const;
   std::string getChannelCountMode() const;
   std::string getChannelInterpretation() const;
-  void connect(const std::shared_ptr<AudioNode> &node);
-  void connect(const std::shared_ptr<AudioParam> &param);
-  void disconnect();
-  void disconnect(const std::shared_ptr<AudioNode> &node);
-  void disconnect(const std::shared_ptr<AudioParam> &param);
-  virtual std::shared_ptr<AudioBus> processAudio(const std::shared_ptr<AudioBus> &outputBus, int framesToProcess, bool checkIsAlreadyProcessed);
-
-  bool isEnabled() const;
+  BaseAudioContext *getContext() const {
+    return context_;
+  }
+  ChannelCountMode getChannelCountModeEnum() const {
+    return channelCountMode_;
+  }
+  ChannelInterpretation getChannelInterpretationEnum() const {
+    return channelInterpretation_;
+  }
+  // sets the node's state to enabled and propagates this change to its outputs.
   void enable();
+  // sets the node's state to disabled and propagates this change to its outputs.
   virtual void disable();
 
  protected:
   friend class AudioNodeManager;
-  friend class AudioDestinationNode;
+  friend class NodeConnections;
   friend class ConvolverNode;
+  friend class AudioDestinationNode;
+
+  explicit AudioNode(BaseAudioContext *context, unsigned int numberOfInputs = DEFAULT_NUMBER_OF_INPUTS);
+
+  // these are all forwarders to NodeConnections
+  void connectNode(const std::shared_ptr<AudioNode> &destination, unsigned int outputIndex, unsigned int inputIndex);
+  void onInputConnected(AudioNode *source, unsigned int outputIndexFromSource, unsigned int inputIndex);
+
+  void disconnectNode(const std::shared_ptr<AudioNode> &destination, unsigned int outputIndex, unsigned int inputIndex);
+  void onInputDisconnected(AudioNode *source, unsigned int outputIndexFromSource, unsigned int inputIndex);
+
+  void connectParam(const std::shared_ptr<AudioParam> &param, unsigned int outputIndex);
+  void disconnectParam(const std::shared_ptr<AudioParam> &param, unsigned int outputIndex);
+
+  // created for compability with the single input/ouput nodes
+  virtual std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus> &processingBus, int framesToProcess);
+  virtual void processNode(const std::vector<std::shared_ptr<AudioBus>> &inputBuses, int framesToProcess);
+
+  // called by an upstream node when it becomes enabled. Increments the active input counter.
+  virtual void onInputEnabled();
+  // called by an upstream node when it becomes disabled. Decrements the active input counter.
+  virtual void onInputDisabled();
+
+  std::vector<std::shared_ptr<AudioBus>> outputBuses_;
 
   BaseAudioContext *context_;
-  std::shared_ptr<AudioBus> audioBus_;
+  std::unique_ptr<NodeConnections> connections_;
+  std::size_t lastRenderedFrame_{SIZE_MAX};
 
   int numberOfInputs_ = 1;
   int numberOfOutputs_ = 1;
   int channelCount_ = 2;
+  int numberOfEnabledInputNodes_ = 0;
   ChannelCountMode channelCountMode_ = ChannelCountMode::MAX;
-  ChannelInterpretation channelInterpretation_ =
-          ChannelInterpretation::SPEAKERS;
+  ChannelInterpretation channelInterpretation_ = ChannelInterpretation::SPEAKERS;
 
-  std::unordered_set<AudioNode *> inputNodes_ = {};
-  std::unordered_set<std::shared_ptr<AudioNode>> outputNodes_ = {};
-  std::unordered_set<std::shared_ptr<AudioParam>> outputParams_ = {};
 
-  int numberOfEnabledInputNodes_ = 0;
   bool isInitialized_ = false;
   bool isEnabled_ = true;
 
-  std::size_t lastRenderedFrame_{SIZE_MAX};
-
  private:
-  std::vector<std::shared_ptr<AudioBus>> inputBuses_ = {};
-
+  bool isAlreadyProcessed();
   static std::string toString(ChannelCountMode mode);
   static std::string toString(ChannelInterpretation interpretation);
-
-  virtual std::shared_ptr<AudioBus> processInputs(const std::shared_ptr<AudioBus>& outputBus, int framesToProcess, bool checkIsAlreadyProcessed);
-  virtual std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>&, int) = 0;
-
-  bool isAlreadyProcessed();
-  std::shared_ptr<AudioBus> applyChannelCountMode(const std::shared_ptr<AudioBus> &processingBus);
-  void mixInputsBuses(const std::shared_ptr<AudioBus>& processingBus);
-
-  void connectNode(const std::shared_ptr<AudioNode> &node);
-  void disconnectNode(const std::shared_ptr<AudioNode> &node);
-  void connectParam(const std::shared_ptr<AudioParam> &param);
-  void disconnectParam(const std::shared_ptr<AudioParam> &param);
-
-  void onInputEnabled();
-  virtual void onInputDisabled();
-  void onInputConnected(AudioNode *node);
-  void onInputDisconnected(AudioNode *node);
-
   void cleanup();
 };
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.cpp
index 09eca8227..20eb52b77 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.cpp
@@ -24,7 +24,7 @@ AudioParam::AudioParam(
               1,
               context->getSampleRate())) {
   inputBuses_.reserve(4);
-  inputNodes_.reserve(4);
+  inputConnections_.reserve(4);
   startTime_ = 0;
   endTime_ = 0;
   startValue_ = value_;
@@ -254,15 +254,20 @@ void AudioParam::cancelAndHoldAtTime(double cancelTime) {
   });
 }
 
-void AudioParam::addInputNode(AudioNode *node) {
-  inputNodes_.emplace_back(node);
+void AudioParam::addInputNode(
+    AudioNode *node,
+    unsigned int outputIndexFromSource) {
+  inputConnections_.emplace_back(InputConnection{node, outputIndexFromSource});
 }
 
-void AudioParam::removeInputNode(AudioNode *node) {
-  for (int i = 0; i < inputNodes_.size(); i++) {
-    if (inputNodes_[i] == node) {
-      std::swap(inputNodes_[i], inputNodes_.back());
-      inputNodes_.resize(inputNodes_.size() - 1);
+void AudioParam::removeInputNode(
+    AudioNode *node,
+    unsigned int outputIndexFromSource) {
+  for (int i = 0; i < inputConnections_.size(); i++) {
+    if (inputConnections_[i].sourceNode == node &&
+        inputConnections_[i].outputIndexFromSource == outputIndexFromSource) {
+      std::swap(inputConnections_[i], inputConnections_.back());
+      inputConnections_.resize(inputConnections_.size() - 1);
       break;
     }
   }
@@ -272,7 +277,7 @@ std::shared_ptr<AudioBus> AudioParam::calculateInputs(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   processingBus->zero();
-  if (inputNodes_.empty()) {
+  if (inputConnections_.empty()) {
     return processingBus;
   }
   processInputs(processingBus, framesToProcess, true);
@@ -313,18 +318,21 @@ void AudioParam::processInputs(
     const std::shared_ptr<AudioBus> &outputBus,
     int framesToProcess,
     bool checkIsAlreadyProcessed) {
-  for (auto it = inputNodes_.begin(), end = inputNodes_.end(); it != end;
+  for (auto it = inputConnections_.begin(), end = inputConnections_.end();
+       it != end;
        ++it) {
-    auto inputNode = *it;
+    auto inputNode = it->sourceNode;
+    auto outputIndex = it->outputIndexFromSource;
     assert(inputNode != nullptr);
 
     if (!inputNode->isEnabled()) {
       continue;
     }
 
-    // Process this input node and store its output bus
-    auto inputBus = inputNode->processAudio(
-        outputBus, framesToProcess, checkIsAlreadyProcessed);
+    inputNode->processAudio(framesToProcess, checkIsAlreadyProcessed);
+
+    auto inputBus = inputNode->getOutputBus(outputIndex);
+
     inputBuses_.emplace_back(inputBus);
   }
 }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.h b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.h
index b849af5bb..41700f112 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.h
@@ -1,16 +1,17 @@
 #pragma once
 
+#include <audioapi/core/AudioNode.h>
 #include <audioapi/core/types/ParamChangeEventType.h>
+#include <audioapi/core/utils/AudioParamEventQueue.h>
+#include <audioapi/core/utils/ConnectionTypes.h>
 #include <audioapi/core/utils/ParamChangeEvent.h>
 #include <audioapi/utils/AudioBus.h>
-#include <audioapi/core/AudioNode.h>
-#include <audioapi/core/utils/AudioParamEventQueue.h>
 
 #include <cstddef>
-#include <utility>
 #include <memory>
-#include <vector>
 #include <unordered_set>
+#include <utility>
+#include <vector>
 #include <audioapi/utils/CrossThreadEventScheduler.hpp>
 
 namespace audioapi {
@@ -60,11 +61,8 @@ class AudioParam {
   void setTargetAtTime(float target, double startTime, double timeConstant);
 
   // JS-Thread only
-  void setValueCurveAtTime(
-      std::shared_ptr<std::vector<float>> values,
-      size_t length,
-      double startTime,
-      double duration);
+  void
+  setValueCurveAtTime(std::shared_ptr<std::vector<float>> values, size_t length, double startTime, double duration);
 
   // JS-Thread only
   void cancelScheduledValues(double cancelTime);
@@ -72,15 +70,14 @@ class AudioParam {
   // JS-Thread only
   void cancelAndHoldAtTime(double cancelTime);
 
-
   /// Audio-Thread only methods
   /// These methods are called only from the Audio rendering thread.
 
   // Audio-Thread only (indirectly through AudioNode::connectParam by AudioNodeManager)
-  void addInputNode(AudioNode* node);
+  void addInputNode(AudioNode *node, unsigned int outputIndexFromSource);
 
   // Audio-Thread only (indirectly through AudioNode::disconnectParam by AudioNodeManager)
-  void removeInputNode(AudioNode* node);
+  void removeInputNode(AudioNode *node, unsigned int outputIndexFromSource);
 
   // Audio-Thread only
   std::shared_ptr<AudioBus> processARateParam(int framesToProcess, double time);
@@ -107,7 +104,7 @@ class AudioParam {
   std::function<float(double, double, float, float, double)> calculateValue_;
 
   // Input modulation system
-  std::vector<AudioNode *> inputNodes_;
+  std::vector<InputConnection> inputConnections_;
   std::shared_ptr<AudioBus> audioBus_;
   std::vector<std::shared_ptr<AudioBus>> inputBuses_;
 
@@ -141,9 +138,9 @@ class AudioParam {
     eventsQueue_.pushBack(std::move(event));
   }
   float getValueAtTime(double time);
-  void processInputs(const std::shared_ptr<AudioBus>& outputBus, int framesToProcess, bool checkIsAlreadyProcessed);
-  void mixInputsBuses(const std::shared_ptr<AudioBus>& processingBus);
-  std::shared_ptr<AudioBus> calculateInputs(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess);
+  void processInputs(const std::shared_ptr<AudioBus> &outputBus, int framesToProcess, bool checkIsAlreadyProcessed);
+  void mixInputsBuses(const std::shared_ptr<AudioBus> &processingBus);
+  std::shared_ptr<AudioBus> calculateInputs(const std::shared_ptr<AudioBus> &processingBus, int framesToProcess);
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
index fa05c13e2..0d5db59eb 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
@@ -2,6 +2,8 @@
 #include <audioapi/core/analysis/AnalyserNode.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/effects/BiquadFilterNode.h>
+#include <audioapi/core/effects/ChannelMergerNode.h>
+#include <audioapi/core/effects/ChannelSplitterNode.h>
 #include <audioapi/core/effects/ConvolverNode.h>
 #include <audioapi/core/effects/GainNode.h>
 #include <audioapi/core/effects/StereoPannerNode.h>
@@ -146,6 +148,22 @@ std::shared_ptr<BiquadFilterNode> BaseAudioContext::createBiquadFilter() {
   return biquadFilter;
 }
 
+std::shared_ptr<ChannelSplitterNode> BaseAudioContext::createChannelSplitter(
+    unsigned int numberOfOutputs) {
+  auto channelSplitter =
+      std::make_shared<ChannelSplitterNode>(this, numberOfOutputs);
+  nodeManager_->addProcessingNode(channelSplitter);
+  return channelSplitter;
+}
+
+std::shared_ptr<ChannelMergerNode> BaseAudioContext::createChannelMerger(
+    unsigned int numberOfInputs) {
+  auto channelMerger =
+      std::make_shared<ChannelMergerNode>(this, numberOfInputs);
+  nodeManager_->addProcessingNode(channelMerger);
+  return channelMerger;
+}
+
 std::shared_ptr<AudioBufferSourceNode> BaseAudioContext::createBufferSource(
     bool pitchCorrection) {
   auto bufferSource =
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
index eba8b3460..520037908 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
@@ -35,6 +35,8 @@ class WorkletSourceNode;
 class WorkletNode;
 class WorkletProcessingNode;
 class StreamerNode;
+class ChannelSplitterNode;
+class ChannelMergerNode;
 
 class BaseAudioContext {
  public:
@@ -70,6 +72,8 @@ class BaseAudioContext {
   std::shared_ptr<BiquadFilterNode> createBiquadFilter();
   std::shared_ptr<AudioBufferSourceNode> createBufferSource(bool pitchCorrection);
   std::shared_ptr<AudioBufferQueueSourceNode> createBufferQueueSource(bool pitchCorrection);
+  std::shared_ptr<ChannelSplitterNode> createChannelSplitter(unsigned int numberOfOutputs = 6);
+  std::shared_ptr<ChannelMergerNode> createChannelMerger(unsigned int numberOfInputs = 6);
   static std::shared_ptr<AudioBuffer>
   createBuffer(int numberOfChannels, size_t length, float sampleRate);
   std::shared_ptr<PeriodicWave> createPeriodicWave(
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.cpp
index 8147c4733..cea95ce53 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.cpp
@@ -2,6 +2,7 @@
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
+#include <audioapi/core/utils/NodeConnections.h>
 #include <audioapi/utils/AudioBus.h>
 
 namespace audioapi {
@@ -9,7 +10,6 @@ namespace audioapi {
 AudioDestinationNode::AudioDestinationNode(BaseAudioContext *context)
     : AudioNode(context), currentSampleFrame_(0) {
   numberOfOutputs_ = 0;
-  numberOfInputs_ = 1;
   channelCountMode_ = ChannelCountMode::EXPLICIT;
   isInitialized_ = true;
 }
@@ -25,7 +25,7 @@ double AudioDestinationNode::getCurrentTime() const {
 void AudioDestinationNode::renderAudio(
     const std::shared_ptr<AudioBus> &destinationBus,
     int numFrames) {
-  if (numFrames < 0 || !destinationBus || !isInitialized_) {
+  if (numFrames <= 0 || !destinationBus || !isInitialized_) {
     return;
   }
 
@@ -33,10 +33,10 @@ void AudioDestinationNode::renderAudio(
 
   destinationBus->zero();
 
-  auto processedBus = processAudio(destinationBus, numFrames, true);
+  const auto &inputBuses = connections_->processAllInputs(numFrames, true);
 
-  if (processedBus && processedBus != destinationBus) {
-    destinationBus->copy(processedBus.get());
+  if (!inputBuses.empty() && inputBuses[0]) {
+    destinationBus->copy(inputBuses[0].get());
   }
 
   destinationBus->normalize();
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.h
index 5488e6e7c..8547bb02d 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.h
@@ -3,9 +3,9 @@
 #include <audioapi/core/AudioNode.h>
 
 #include <algorithm>
+#include <cstddef>
 #include <memory>
 #include <vector>
-#include <cstddef>
 
 namespace audioapi {
 
@@ -15,16 +15,17 @@ class BaseAudioContext;
 class AudioDestinationNode : public AudioNode {
  public:
   explicit AudioDestinationNode(BaseAudioContext *context);
-
   std::size_t getCurrentSampleFrame() const;
   double getCurrentTime() const;
 
-  void renderAudio(const std::shared_ptr<AudioBus>& audioData, int numFrames);
+  void renderAudio(const std::shared_ptr<AudioBus> &audioData, int numFrames);
 
  protected:
   // DestinationNode is triggered by AudioContext using renderAudio
   // processNode function is not necessary and is never called.
-  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int) final { return processingBus; };
+  void processNode(const std::vector<std::shared_ptr<AudioBus>> &inputBuses, int framesToProcess) final {
+    return;
+  }
 
  private:
   std::size_t currentSampleFrame_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ChannelMergerNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ChannelMergerNode.cpp
new file mode 100644
index 000000000..03cd37754
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ChannelMergerNode.cpp
@@ -0,0 +1,42 @@
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/effects/ChannelMergerNode.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+
+namespace audioapi {
+
+ChannelMergerNode::ChannelMergerNode(
+    BaseAudioContext *context,
+    unsigned int numberOfInputs)
+    : AudioNode(context, numberOfInputs) {
+  channelCount_ = 1;
+  channelCountMode_ = ChannelCountMode::EXPLICIT;
+  channelInterpretation_ = ChannelInterpretation::SPEAKERS;
+
+  outputBuses_.clear();
+  outputBuses_.push_back(
+      std::make_shared<AudioBus>(
+          RENDER_QUANTUM_SIZE, numberOfInputs_, context->getSampleRate()));
+
+  isInitialized_ = true;
+}
+
+void ChannelMergerNode::processNode(
+    const std::vector<std::shared_ptr<AudioBus>> &inputBuses,
+    int framesToProcess) {
+  auto outputBus = getOutputBus(0);
+
+  size_t count_ = std::min(
+      static_cast<size_t>(numberOfInputs_), inputBuses.size()); // cache size
+  for (size_t i = 0; i < count_; ++i) {
+    bool isInputConnected = inputBuses[i] != nullptr;
+    if (isInputConnected) {
+      const auto &sourceBus = inputBuses[i];
+      outputBus->getChannel(i)->copy(sourceBus->getChannel(0));
+    } else {
+      outputBus->getChannel(i)->zero();
+    }
+  }
+}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ChannelMergerNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ChannelMergerNode.h
new file mode 100644
index 000000000..9edc3f0db
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ChannelMergerNode.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <audioapi/core/AudioNode.h>
+#include <vector>
+
+namespace audioapi {
+
+class ChannelMergerNode : public AudioNode {
+ public:
+  explicit ChannelMergerNode(BaseAudioContext *context, unsigned int numberOfInputs = 6);
+  virtual ~ChannelMergerNode() = default;
+
+ protected:
+  void processNode(const std::vector<std::shared_ptr<AudioBus>> &inputBuses, int framesToProcess) override;
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ChannelSplitterNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ChannelSplitterNode.cpp
new file mode 100644
index 000000000..f02e9b899
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ChannelSplitterNode.cpp
@@ -0,0 +1,53 @@
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/effects/ChannelSplitterNode.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <algorithm>
+
+namespace audioapi {
+
+ChannelSplitterNode::ChannelSplitterNode(
+    BaseAudioContext *context,
+    unsigned int numberOfOutputs)
+    : AudioNode(context) {
+  numberOfOutputs_ = numberOfOutputs;
+
+  channelCount_ = numberOfOutputs;
+  channelCountMode_ = ChannelCountMode::EXPLICIT;
+  channelInterpretation_ = ChannelInterpretation::DISCRETE;
+
+  outputBuses_.clear();
+  for (unsigned int i = 0; i < numberOfOutputs_; ++i) {
+    outputBuses_.emplace_back(
+        std::make_shared<AudioBus>(
+            RENDER_QUANTUM_SIZE, 1, context->getSampleRate()));
+  }
+
+  isInitialized_ = true;
+}
+
+void ChannelSplitterNode::processNode(
+    const std::vector<std::shared_ptr<AudioBus>> &inputBuses,
+    int framesToProcess) {
+  if (inputBuses.empty() || inputBuses[0] == nullptr) {
+    for (unsigned int i = 0; i < numberOfOutputs_; ++i) {
+      getOutputBus(i)->zero();
+    }
+    return;
+  }
+
+  const auto &sourceBus = inputBuses[0];
+  unsigned int numberOfSourceChannels = sourceBus->getNumberOfChannels();
+
+  for (unsigned int i = 0; i < numberOfOutputs_; ++i) {
+    auto destinationBus = getOutputBus(i);
+
+    if (i < numberOfSourceChannels) {
+      destinationBus->getChannel(0)->copy(sourceBus->getChannel(i));
+    } else {
+      destinationBus->zero();
+    }
+  }
+}
+
+} // namespace audioapi
\ No newline at end of file
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ChannelSplitterNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ChannelSplitterNode.h
new file mode 100644
index 000000000..6d5a14a22
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ChannelSplitterNode.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <audioapi/core/AudioNode.h>
+#include <vector>
+
+namespace audioapi {
+
+class ChannelSplitterNode : public AudioNode {
+ public:
+  explicit ChannelSplitterNode(BaseAudioContext *context, unsigned int numberOfOutputs = 6);
+  virtual ~ChannelSplitterNode() = default;
+
+ protected:
+  void processNode(const std::vector<std::shared_ptr<AudioBus>> &inputBuses, int framesToProcess) override;
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
index 28f457f8c..f4ff0f66b 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
@@ -26,9 +26,9 @@ ConvolverNode::ConvolverNode(
   normalize_ = !disableNormalization;
   gainCalibrationSampleRate_ = context->getSampleRate();
   setBuffer(buffer);
-  audioBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
-  isInitialized_ = true;
+  // audioBus_ = std::make_shared<AudioBus>(
+  //     RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
+  // isInitialized_ = true;
 }
 
 bool ConvolverNode::getNormalize_() const {
@@ -94,15 +94,15 @@ void ConvolverNode::onInputDisabled() {
   }
 }
 
-std::shared_ptr<AudioBus> ConvolverNode::processInputs(
-    const std::shared_ptr<AudioBus> &outputBus,
-    int framesToProcess,
-    bool checkIsAlreadyProcessed) {
-  if (internalBufferIndex_ < framesToProcess) {
-    return AudioNode::processInputs(outputBus, RENDER_QUANTUM_SIZE, false);
-  }
-  return AudioNode::processInputs(outputBus, 0, false);
-}
+// std::shared_ptr<AudioBus> ConvolverNode::processInputs(
+//     const std::shared_ptr<AudioBus> &outputBus,
+//     int framesToProcess,
+//     bool checkIsAlreadyProcessed) {
+//   if (internalBufferIndex_ < framesToProcess) {
+//     return AudioNode::processInputs(outputBus, RENDER_QUANTUM_SIZE, false);
+//   }
+//   return AudioNode::processInputs(outputBus, 0, false);
+// }
 
 // processing pipeline: processingBus -> intermediateBus_ -> audioBus_ (mixing
 // with intermediateBus_)
@@ -119,16 +119,18 @@ std::shared_ptr<AudioBus> ConvolverNode::processNode(
       return processingBus;
     }
   }
+  std::shared_ptr<AudioBus> audioBus = getOutputBus(0);
+
   if (internalBufferIndex_ < framesToProcess) {
     performConvolution(processingBus); // result returned to intermediateBus_
-    audioBus_->sum(intermediateBus_.get());
+    audioBus->sum(intermediateBus_.get());
 
     internalBuffer_->copy(
-        audioBus_.get(), 0, internalBufferIndex_, RENDER_QUANTUM_SIZE);
+        audioBus.get(), 0, internalBufferIndex_, RENDER_QUANTUM_SIZE);
     internalBufferIndex_ += RENDER_QUANTUM_SIZE;
   }
-  audioBus_->zero();
-  audioBus_->copy(internalBuffer_.get(), 0, 0, framesToProcess);
+  audioBus->zero();
+  audioBus->copy(internalBuffer_.get(), 0, 0, framesToProcess);
   int remainingFrames = internalBufferIndex_ - framesToProcess;
   if (remainingFrames > 0) {
     for (int i = 0; i < internalBuffer_->getNumberOfChannels(); ++i) {
@@ -140,15 +142,15 @@ std::shared_ptr<AudioBus> ConvolverNode::processNode(
   }
   internalBufferIndex_ -= framesToProcess;
 
-  for (int i = 0; i < audioBus_->getNumberOfChannels(); ++i) {
+  for (int i = 0; i < audioBus->getNumberOfChannels(); ++i) {
     dsp::multiplyByScalar(
-        audioBus_->getChannel(i)->getData(),
+        audioBus->getChannel(i)->getData(),
         scaleFactor_,
-        audioBus_->getChannel(i)->getData(),
+        audioBus->getChannel(i)->getData(),
         framesToProcess);
   }
 
-  return audioBus_;
+  return audioBus;
 }
 
 void ConvolverNode::calculateNormalizationScale() {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.h
index d1208bea0..ab8914410 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.h
@@ -30,7 +30,7 @@ class ConvolverNode : public AudioNode {
   std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
 
  private:
-  std::shared_ptr<AudioBus> processInputs(const std::shared_ptr<AudioBus>& outputBus, int framesToProcess, bool checkIsAlreadyProcessed) override;
+  //std::shared_ptr<AudioBus> processInputs(const std::shared_ptr<AudioBus>& outputBus, int framesToProcess, bool checkIsAlreadyProcessed) override;
   void onInputDisabled() override;
   float gainCalibrationSampleRate_;
   size_t remainingSegments_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.cpp
index 74532ef2e..c58573614 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.cpp
@@ -30,8 +30,10 @@ std::shared_ptr<AudioBus> StereoPannerNode::processNode(
                             ->getChannel(0)
                             ->getData();
 
-  auto *outputLeft = audioBus_->getChannelByType(AudioBus::ChannelLeft);
-  auto *outputRight = audioBus_->getChannelByType(AudioBus::ChannelRight);
+  std::shared_ptr<AudioBus> audioBus = getOutputBus(0);
+
+  auto *outputLeft = audioBus->getChannelByType(AudioBus::ChannelLeft);
+  auto *outputRight = audioBus->getChannelByType(AudioBus::ChannelRight);
 
   // Input is mono
   if (processingBus->getNumberOfChannels() == 1) {
@@ -72,7 +74,7 @@ std::shared_ptr<AudioBus> StereoPannerNode::processNode(
     }
   }
 
-  return audioBus_;
+  return audioBus;
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp
index b59db5f55..aa82b1ce6 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp
@@ -100,10 +100,16 @@ void AudioBufferSourceNode::setBuffer(
     alignedBus_ = std::make_shared<AudioBus>(*buffer_->bus_);
   }
 
-  audioBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
+  // Re-initialize output buses with the correct channel count.
+  for (unsigned int i = 0; i < numberOfOutputs_; ++i) {
+    outputBuses_[i] = std::make_shared<AudioBus>(
+        RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
+  }
+
   playbackRateBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE * 3, channelCount_, context_->getSampleRate());
+      RENDER_QUANTUM_SIZE * 3,
+      channelCount_,
+      context_->getSampleRate());
 
   loopEnd_ = buffer_->getDuration();
 }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp
index e8cd3a179..ed0b65b86 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp
@@ -13,7 +13,7 @@
 namespace audioapi {
 
 AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
-    : AudioNode(context),
+    : AudioNode(context, 0),
       startTime_(-1.0),
       stopTime_(-1.0),
       playbackState_(PlaybackState::UNSCHEDULED) {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/OscillatorNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/OscillatorNode.cpp
index 832a452a7..aeb44a804 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/OscillatorNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/OscillatorNode.cpp
@@ -21,9 +21,6 @@ OscillatorNode::OscillatorNode(BaseAudioContext *context)
   type_ = OscillatorType::SINE;
   periodicWave_ = context_->getBasicWaveForm(type_);
 
-  audioBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
-
   isInitialized_ = true;
 }
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.cpp
index 3468b33f0..8be97fa51 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.cpp
@@ -65,8 +65,6 @@ bool StreamerNode::initialize(const std::string &input_url) {
   }
 
   channelCount_ = codecpar_->ch_layout.nb_channels;
-  audioBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, channelCount_, context_->getSampleRate());
 
   auto [sender, receiver] = channels::spsc::channel<
       StreamingData,
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioNodeManager.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioNodeManager.cpp
index 94ac0732a..618628de9 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioNodeManager.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioNodeManager.cpp
@@ -88,12 +88,16 @@ AudioNodeManager::~AudioNodeManager() {
 void AudioNodeManager::addPendingNodeConnection(
     const std::shared_ptr<AudioNode> &from,
     const std::shared_ptr<AudioNode> &to,
-    ConnectionType type) {
+    ConnectionType type,
+    unsigned int outputIndex,
+    unsigned int inputIndex) {
   auto event = std::make_unique<Event>();
   event->type = type;
   event->payloadType = EventPayloadType::NODES;
   event->payload.nodes.from = from;
   event->payload.nodes.to = to;
+  event->payload.nodes.outputIndex = outputIndex;
+  event->payload.nodes.inputIndex = inputIndex;
 
   sender_.send(std::move(event));
 }
@@ -101,12 +105,14 @@ void AudioNodeManager::addPendingNodeConnection(
 void AudioNodeManager::addPendingParamConnection(
     const std::shared_ptr<AudioNode> &from,
     const std::shared_ptr<AudioParam> &to,
-    ConnectionType type) {
+    ConnectionType type,
+    unsigned int outputIndex) {
   auto event = std::make_unique<Event>();
   event->type = type;
   event->payloadType = EventPayloadType::PARAMS;
   event->payload.params.from = from;
   event->payload.params.to = to;
+  event->payload.params.outputIndex = outputIndex;
 
   sender_.send(std::move(event));
 }
@@ -157,9 +163,6 @@ void AudioNodeManager::settlePendingConnections() {
       case ConnectionType::DISCONNECT:
         handleDisconnectEvent(std::move(value));
         break;
-      case ConnectionType::DISCONNECT_ALL:
-        handleDisconnectAllEvent(std::move(value));
-        break;
       case ConnectionType::ADD:
         handleAddToDeconstructionEvent(std::move(value));
         break;
@@ -169,9 +172,13 @@ void AudioNodeManager::settlePendingConnections() {
 
 void AudioNodeManager::handleConnectEvent(std::unique_ptr<Event> event) {
   if (event->payloadType == EventPayloadType::NODES) {
-    event->payload.nodes.from->connectNode(event->payload.nodes.to);
+    event->payload.nodes.from->connectNode(
+        event->payload.nodes.to,
+        event->payload.nodes.outputIndex,
+        event->payload.nodes.inputIndex);
   } else if (event->payloadType == EventPayloadType::PARAMS) {
-    event->payload.params.from->connectParam(event->payload.params.to);
+    event->payload.params.from->connectParam(
+        event->payload.params.to, event->payload.params.outputIndex);
   } else {
     assert(false && "Invalid payload type for connect event");
   }
@@ -179,24 +186,18 @@ void AudioNodeManager::handleConnectEvent(std::unique_ptr<Event> event) {
 
 void AudioNodeManager::handleDisconnectEvent(std::unique_ptr<Event> event) {
   if (event->payloadType == EventPayloadType::NODES) {
-    event->payload.nodes.from->disconnectNode(event->payload.nodes.to);
+    event->payload.nodes.from->disconnectNode(
+        event->payload.nodes.to,
+        event->payload.nodes.outputIndex,
+        event->payload.nodes.inputIndex);
   } else if (event->payloadType == EventPayloadType::PARAMS) {
-    event->payload.params.from->disconnectParam(event->payload.params.to);
+    event->payload.params.from->disconnectParam(
+        event->payload.params.to, event->payload.params.outputIndex);
   } else {
     assert(false && "Invalid payload type for disconnect event");
   }
 }
 
-void AudioNodeManager::handleDisconnectAllEvent(std::unique_ptr<Event> event) {
-  assert(event->payloadType == EventPayloadType::NODES);
-  for (auto it = event->payload.nodes.from->outputNodes_.begin();
-       it != event->payload.nodes.from->outputNodes_.end();) {
-    auto next = std::next(it);
-    event->payload.nodes.from->disconnectNode(*it);
-    it = next;
-  }
-}
-
 void AudioNodeManager::handleAddToDeconstructionEvent(
     std::unique_ptr<Event> event) {
   switch (event->payloadType) {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioNodeManager.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioNodeManager.h
index a92613214..fac2df40e 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioNodeManager.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioNodeManager.h
@@ -29,10 +29,13 @@ class AudioNodeManager {
     struct {
       std::shared_ptr<AudioNode> from;
       std::shared_ptr<AudioNode> to;
+      unsigned int outputIndex;
+      unsigned int inputIndex;
     } nodes;
     struct {
       std::shared_ptr<AudioNode> from;
       std::shared_ptr<AudioParam> to;
+      unsigned int outputIndex;
     } params;
     std::shared_ptr<AudioScheduledSourceNode> sourceNode;
     std::shared_ptr<AudioParam> audioParam;
@@ -68,7 +71,9 @@ class AudioNodeManager {
   void addPendingNodeConnection(
       const std::shared_ptr<AudioNode> &from,
       const std::shared_ptr<AudioNode> &to,
-      ConnectionType type);
+      ConnectionType type,
+      unsigned int outputIndex = 0,
+      unsigned int inputIndex = 0);
 
   /// @brief Adds a pending connection between an audio node and an audio parameter.
   /// @param from The source audio node.
@@ -78,7 +83,8 @@ class AudioNodeManager {
   void addPendingParamConnection(
       const std::shared_ptr<AudioNode> &from,
       const std::shared_ptr<AudioParam> &to,
-    ConnectionType type);
+      ConnectionType type,
+       unsigned int outputIndex = 0 );
 
   /// @brief Adds a processing node to the manager.
   /// @param node The processing node to add.
@@ -121,7 +127,6 @@ class AudioNodeManager {
   void settlePendingConnections();
   void handleConnectEvent(std::unique_ptr<Event> event);
   void handleDisconnectEvent(std::unique_ptr<Event> event);
-  void handleDisconnectAllEvent(std::unique_ptr<Event> event);
   void handleAddToDeconstructionEvent(std::unique_ptr<Event> event);
 
   template <typename U>
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/ConnectionTypes.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/ConnectionTypes.h
new file mode 100644
index 000000000..5cb59040a
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/ConnectionTypes.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <memory>
+
+namespace audioapi {
+
+class AudioNode;
+
+struct InputConnection {
+  AudioNode *sourceNode;
+  unsigned int outputIndexFromSource;
+};
+
+struct OutputConnection {
+  std::shared_ptr<AudioNode> destinationNode;
+  unsigned int inputIndexAtDestination;
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/Constants.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/Constants.h
index 3606b0d2c..23373ee47 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/Constants.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/Constants.h
@@ -26,4 +26,7 @@ static constexpr float PI = std::numbers::pi_v<float>;
 static constexpr size_t PROMISE_VENDOR_THREAD_POOL_WORKER_COUNT = 4;
 static constexpr size_t PROMISE_VENDOR_THREAD_POOL_LOAD_BALANCER_QUEUE_SIZE = 32;
 static constexpr size_t PROMISE_VENDOR_THREAD_POOL_WORKER_QUEUE_SIZE = 32;
+
+// default node attributes
+static constexpr int DEFAULT_NUMBER_OF_INPUTS = 1;
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/NodeConnections.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/NodeConnections.cpp
new file mode 100644
index 000000000..58919a5a9
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/NodeConnections.cpp
@@ -0,0 +1,522 @@
+#include <audioapi/core/AudioNode.h>
+#include <audioapi/core/AudioParam.h>
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/utils/AudioNodeManager.h>
+#include <audioapi/core/utils/Constants.h>
+#include <audioapi/core/utils/NodeConnections.h>
+#include <audioapi/utils/AudioBus.h>
+#include <algorithm>
+#include <stdexcept>
+
+namespace audioapi {
+
+NodeConnections::NodeConnections(AudioNode *owner, BaseAudioContext *context)
+    : owner_(owner), context_(context) {
+  processingInputBuses_.resize(owner_->getNumberOfInputs());
+  internalSummingBus_ = std::make_shared<AudioBus>(
+      RENDER_QUANTUM_SIZE, 1, context->getSampleRate());
+}
+
+void NodeConnections::disconnect() {
+  // Disconnect from all nodes
+  for (auto it = indexedOutputs_.begin(); it != indexedOutputs_.end(); ++it) {
+    unsigned int outputIndex = it->first;
+    std::vector<OutputConnection> &connections = it->second;
+    for (auto conn_it = connections.begin(); conn_it != connections.end();
+         ++conn_it) {
+      context_->getNodeManager()->addPendingNodeConnection(
+          owner_->shared_from_this(),
+          conn_it->destinationNode,
+          AudioNodeManager::ConnectionType::DISCONNECT,
+          outputIndex,
+          conn_it->inputIndexAtDestination);
+    }
+  }
+  // Disconnect from all params
+  for (auto it = indexedOutputParams_.begin(); it != indexedOutputParams_.end();
+       ++it) {
+    unsigned int outputIndex = it->first;
+    std::vector<std::shared_ptr<AudioParam>> &params = it->second;
+    for (auto param_it = params.begin(); param_it != params.end(); ++param_it) {
+      context_->getNodeManager()->addPendingParamConnection(
+          owner_->shared_from_this(),
+          *param_it,
+          AudioNodeManager::ConnectionType::DISCONNECT,
+          outputIndex);
+    }
+  }
+}
+
+void NodeConnections::disconnect(unsigned int outputIndex) {
+  // Disconnect all nodes from a specific output
+  auto it = indexedOutputs_.find(outputIndex);
+  if (it != indexedOutputs_.end()) {
+    std::vector<OutputConnection> &connections = it->second;
+    for (auto conn_it = connections.begin(); conn_it != connections.end();
+         ++conn_it) {
+      context_->getNodeManager()->addPendingNodeConnection(
+          owner_->shared_from_this(),
+          conn_it->destinationNode,
+          AudioNodeManager::ConnectionType::DISCONNECT,
+          outputIndex,
+          conn_it->inputIndexAtDestination);
+    }
+  }
+
+  // Disconnect all params from a specific output
+  auto output_it = indexedOutputParams_.find(outputIndex);
+  if (output_it != indexedOutputParams_.end()) {
+    std::vector<std::shared_ptr<AudioParam>> &params = output_it->second;
+    for (auto param_it = params.begin(); param_it != params.end(); ++param_it) {
+      context_->getNodeManager()->addPendingParamConnection(
+          owner_->shared_from_this(),
+          *param_it,
+          AudioNodeManager::ConnectionType::DISCONNECT,
+          outputIndex);
+    }
+  }
+}
+
+bool NodeConnections::disconnect(const std::shared_ptr<AudioNode> &node) {
+  bool disconnected = false;
+  for (auto it = indexedOutputs_.begin(); it != indexedOutputs_.end(); ++it) {
+    unsigned int outputIndex = it->first;
+    std::vector<OutputConnection> &connections = it->second;
+    for (auto conn_it = connections.begin(); conn_it != connections.end();
+         ++conn_it) {
+      if (conn_it->destinationNode == node) {
+        context_->getNodeManager()->addPendingNodeConnection(
+            owner_->shared_from_this(),
+            conn_it->destinationNode,
+            AudioNodeManager::ConnectionType::DISCONNECT,
+            outputIndex,
+            conn_it->inputIndexAtDestination);
+        disconnected = true;
+      }
+    }
+  }
+  return disconnected;
+}
+
+bool NodeConnections::disconnect(
+    const std::shared_ptr<AudioNode> &node,
+    unsigned int outputIndex) {
+  bool disconnected = false;
+  auto it = indexedOutputs_.find(outputIndex);
+  if (it != indexedOutputs_.end()) {
+    std::vector<OutputConnection> &connections = it->second;
+    for (auto conn_it = connections.begin(); conn_it != connections.end();
+         ++conn_it) {
+      if (conn_it->destinationNode == node) {
+        context_->getNodeManager()->addPendingNodeConnection(
+            owner_->shared_from_this(),
+            conn_it->destinationNode,
+            AudioNodeManager::ConnectionType::DISCONNECT,
+            outputIndex,
+            conn_it->inputIndexAtDestination);
+        disconnected = true;
+      }
+    }
+  }
+  return disconnected;
+}
+
+bool NodeConnections::disconnect(
+    const std::shared_ptr<AudioNode> &node,
+    unsigned int output,
+    unsigned int input) {
+  bool connectionFound = false;
+  auto it = indexedOutputs_.find(output);
+  if (it != indexedOutputs_.end()) {
+    auto &connections = it->second;
+    for (const auto &conn : connections) {
+      if (conn.destinationNode == node &&
+          conn.inputIndexAtDestination == input) {
+        connectionFound = true;
+        break;
+      }
+    }
+  }
+  // This is a specific request, so we can dispatch a single event.
+  context_->getNodeManager()->addPendingNodeConnection(
+      owner_->shared_from_this(),
+      node,
+      AudioNodeManager::ConnectionType::DISCONNECT,
+      output,
+      input);
+  return connectionFound;
+}
+
+bool NodeConnections::disconnect(const std::shared_ptr<AudioParam> &param) {
+  bool disconnected = false;
+  for (auto it = indexedOutputParams_.begin(); it != indexedOutputParams_.end();
+       ++it) {
+    unsigned int outputIndex = it->first;
+    std::vector<std::shared_ptr<AudioParam>> &params = it->second;
+    for (auto param_it = params.begin(); param_it != params.end(); ++param_it) {
+      if (*param_it == param) {
+        context_->getNodeManager()->addPendingParamConnection(
+            owner_->shared_from_this(),
+            *param_it,
+            AudioNodeManager::ConnectionType::DISCONNECT,
+            outputIndex);
+        disconnected = true;
+      }
+    }
+  }
+  return disconnected;
+}
+
+bool NodeConnections::disconnect(
+    const std::shared_ptr<AudioParam> &param,
+    unsigned int output) {
+  bool connectionFound = false;
+  auto it = indexedOutputParams_.find(output);
+  if (it != indexedOutputParams_.end()) {
+    auto &params = it->second;
+    for (const auto &p : params) {
+      if (p == param) {
+        connectionFound = true;
+        break;
+      }
+    }
+  }
+  if (connectionFound) {
+    context_->getNodeManager()->addPendingParamConnection(
+        owner_->shared_from_this(),
+        param,
+        AudioNodeManager::ConnectionType::DISCONNECT,
+        output);
+  }
+  return connectionFound;
+}
+
+void NodeConnections::connectNode(
+    const std::shared_ptr<AudioNode> &destination,
+    unsigned int outputIndex,
+    unsigned int inputIndex) {
+  OutputConnection newConnection{destination, inputIndex};
+  indexedOutputs_[outputIndex].emplace_back(newConnection);
+  destination->onInputConnected(owner_, outputIndex, inputIndex);
+}
+
+void NodeConnections::onInputConnected(
+    AudioNode *sourceNode,
+    unsigned int outputIndexFromSource,
+    unsigned int inputIndex) {
+  InputConnection newConnection{sourceNode, outputIndexFromSource};
+  indexedInputs_[inputIndex].emplace_back(newConnection);
+}
+
+void NodeConnections::disconnectNode(
+    const std::shared_ptr<AudioNode> &destination,
+    unsigned int outputIndex,
+    unsigned int inputIndex) {
+  auto output_it = indexedOutputs_.find(outputIndex);
+  if (output_it == indexedOutputs_.end()) {
+    return;
+  }
+  auto &connections = output_it->second;
+  auto it = std::remove_if(
+      connections.begin(),
+      connections.end(),
+      [&](const OutputConnection &conn) {
+        return conn.destinationNode == destination &&
+            conn.inputIndexAtDestination == inputIndex;
+      });
+  if (it != connections.end()) {
+    connections.erase(it, connections.end());
+    destination->onInputDisconnected(owner_, outputIndex, inputIndex);
+  }
+}
+
+void NodeConnections::onInputDisconnected(
+    AudioNode *sourceNode,
+    unsigned int outputIndexFromSource,
+    unsigned int inputIndex) {
+  auto output_it = indexedInputs_.find(inputIndex);
+  if (output_it == indexedInputs_.end()) {
+    return;
+  }
+  auto &connections = output_it->second;
+  auto it = std::remove_if(
+      connections.begin(), connections.end(), [&](const InputConnection &conn) {
+        return conn.sourceNode == sourceNode &&
+            conn.outputIndexFromSource == outputIndexFromSource;
+      });
+  connections.erase(it, connections.end());
+}
+
+void NodeConnections::connectParam(
+    const std::shared_ptr<AudioParam> &param,
+    unsigned int outputIndex) {
+  indexedOutputParams_[outputIndex].push_back(param);
+  param->addInputNode(owner_, outputIndex);
+}
+
+void NodeConnections::disconnectParam(
+    const std::shared_ptr<AudioParam> &param,
+    unsigned int outputIndex) {
+  auto output_it = indexedOutputParams_.find(outputIndex);
+  if (output_it == indexedOutputParams_.end())
+    return;
+  auto &params = output_it->second;
+  auto it = std::remove(params.begin(), params.end(), param);
+  if (it != params.end()) {
+    param->removeInputNode(owner_, outputIndex);
+    params.erase(it, params.end());
+  }
+}
+
+void NodeConnections::cleanup() {
+  for (std::map<unsigned int, std::vector<OutputConnection>>::iterator map_it =
+           indexedOutputs_.begin();
+       map_it != indexedOutputs_.end();
+       ++map_it) {
+    unsigned int outputIndex = map_it->first;
+    std::vector<OutputConnection> &connections = map_it->second;
+    for (auto conn_it = connections.begin(); conn_it != connections.end();
+         ++conn_it) {
+      const std::shared_ptr<AudioNode> &destinationNode =
+          conn_it->destinationNode;
+      unsigned int inputIndexAtDestination = conn_it->inputIndexAtDestination;
+      if (destinationNode) {
+        destinationNode->onInputDisconnected(
+            owner_, outputIndex, inputIndexAtDestination);
+      }
+    }
+  }
+
+  for (std::map<unsigned int, std::vector<std::shared_ptr<AudioParam>>>::
+           iterator map_it = indexedOutputParams_.begin();
+       map_it != indexedOutputParams_.end();
+       ++map_it) {
+    unsigned int outputIndex = map_it->first;
+    std::vector<std::shared_ptr<AudioParam>> &params = map_it->second;
+    for (auto param_it = params.begin(); param_it != params.end(); ++param_it) {
+      const std::shared_ptr<AudioParam> &destinationParam = *param_it;
+      if (destinationParam) {
+        destinationParam->removeInputNode(owner_, outputIndex);
+      }
+    }
+  }
+
+  indexedInputs_.clear();
+  indexedOutputs_.clear();
+  indexedOutputParams_.clear();
+}
+
+void NodeConnections::propagateEnable() {
+  for (auto it = indexedOutputs_.begin(); it != indexedOutputs_.end(); ++it) {
+    const std::vector<OutputConnection> &connections = it->second;
+    for (auto conn_it = connections.begin(); conn_it != connections.end();
+         ++conn_it) {
+      conn_it->destinationNode->onInputEnabled();
+    }
+  }
+}
+
+void NodeConnections::propagateDisable() {
+  for (auto it = indexedOutputs_.begin(); it != indexedOutputs_.end(); ++it) {
+    const std::vector<OutputConnection> &connections = it->second;
+    for (auto conn_it = connections.begin(); conn_it != connections.end();
+         ++conn_it) {
+      conn_it->destinationNode->onInputDisabled();
+    }
+  }
+}
+
+unsigned int NodeConnections::computeNumberOfChannelsForInput(
+    unsigned int index) const {
+  const ChannelCountMode mode = owner_->getChannelCountModeEnum();
+
+  if (mode == ChannelCountMode::EXPLICIT) {
+    return owner_->getChannelCount();
+  }
+
+  unsigned int maxInputChannels = 0;
+  auto it = indexedInputs_.find(index);
+  if (it != indexedInputs_.end()) {
+    const std::vector<InputConnection> &connections = it->second;
+    for (const InputConnection &ic : connections) {
+      if (ic.sourceNode) {
+        auto sourceBus = ic.sourceNode->getOutputBus(ic.outputIndexFromSource);
+        maxInputChannels = std::max(
+            maxInputChannels, (unsigned int)sourceBus->getNumberOfChannels());
+      }
+    }
+  }
+
+  unsigned int computedChannels = 0;
+  if (mode == ChannelCountMode::MAX) {
+    computedChannels = maxInputChannels;
+  } else { // CLAMPED_MAX
+    computedChannels =
+        std::min((unsigned int)owner_->getChannelCount(), maxInputChannels);
+  }
+
+  return computedChannels > 0 ? computedChannels : 1;
+}
+
+const std::vector<std::shared_ptr<AudioBus>> &NodeConnections::processAllInputs(
+    int framesToProcess,
+    bool checkIsAlreadyProcessed) {
+  int numInputs = owner_->getNumberOfInputs();
+
+  if (internalSummingBus_->getSampleRate() != context_->getSampleRate()) {
+    internalSummingBus_ = std::make_shared<AudioBus>(
+        RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
+  }
+
+  for (int i = 0; i < numInputs; ++i) {
+    processingInputBuses_[i] = processInputAtIndex(
+        static_cast<unsigned int>(i), framesToProcess, checkIsAlreadyProcessed);
+  }
+
+  return processingInputBuses_;
+}
+
+std::shared_ptr<AudioBus> NodeConnections::processInputAtIndex(
+    unsigned int index,
+    int framesToProcess,
+    bool checkIsAlreadyProcessed) {
+  if (hasSilentInput(index)) {
+    return createSilentBus(index, framesToProcess);
+  }
+
+  const std::vector<InputConnection> &connections = indexedInputs_.at(index);
+
+  if (canUseDirectBusPassthrough(connections)) {
+    return processDirectConnection(
+        connections[0], framesToProcess, checkIsAlreadyProcessed);
+  }
+
+  return processMixedConnections(
+      index, connections, framesToProcess, checkIsAlreadyProcessed);
+}
+
+bool NodeConnections::hasSilentInput(unsigned int index) const {
+  auto it = indexedInputs_.find(index);
+  return (it == indexedInputs_.end()) || it->second.empty();
+}
+
+std::shared_ptr<AudioBus> NodeConnections::createSilentBus(
+    unsigned int index,
+    int framesToProcess) {
+  unsigned int channels = owner_->getChannelCount();
+  auto bus = getProcessingBusForIndex(index, channels, framesToProcess);
+  bus->zero();
+  return bus;
+}
+
+bool NodeConnections::canUseDirectBusPassthrough(
+    const std::vector<InputConnection> &connections) const {
+  return connections.size() == 1 &&
+      owner_->getChannelCountModeEnum() == ChannelCountMode::MAX;
+}
+
+std::shared_ptr<AudioBus> NodeConnections::processDirectConnection(
+    const InputConnection &connection,
+    int framesToProcess,
+    bool checkIsAlreadyProcessed) {
+  AudioNode *sourceNode = connection.sourceNode;
+  if (sourceNode) {
+    sourceNode->processAudio(framesToProcess, checkIsAlreadyProcessed);
+    return sourceNode->getOutputBus(connection.outputIndexFromSource);
+  }
+
+  // Fallback if source is null
+  auto fallback = getProcessingBusForIndex(0, 1, framesToProcess);
+  fallback->zero();
+  return fallback;
+}
+
+std::shared_ptr<AudioBus> NodeConnections::processMixedConnections(
+    unsigned int index,
+    const std::vector<InputConnection> &connections,
+    int framesToProcess,
+    bool checkIsAlreadyProcessed) {
+  unsigned int computedChannels = computeNumberOfChannelsForInput(index);
+  unsigned int maxSourceChannels = findMaxSourceChannels(connections);
+
+  prepareSummingBus(computedChannels, maxSourceChannels);
+  internalSummingBus_->zero();
+
+  sumAllConnections(connections, framesToProcess, checkIsAlreadyProcessed);
+
+  auto finalBus =
+      getProcessingBusForIndex(index, computedChannels, framesToProcess);
+  finalBus->copy(internalSummingBus_.get(), 0, 0, framesToProcess);
+
+  return finalBus;
+}
+
+unsigned int NodeConnections::findMaxSourceChannels(
+    const std::vector<InputConnection> &connections) const {
+  unsigned int maxChannels = 0;
+
+  for (const InputConnection &ic : connections) {
+    if (!ic.sourceNode)
+      continue;
+
+    auto srcBus = ic.sourceNode->getOutputBus(ic.outputIndexFromSource);
+    if (srcBus != nullptr) {
+      maxChannels =
+          std::max(maxChannels, (unsigned int)srcBus->getNumberOfChannels());
+    }
+  }
+
+  return maxChannels;
+}
+
+void NodeConnections::prepareSummingBus(
+    unsigned int computedChannels,
+    unsigned int maxSourceChannels) {
+  unsigned int requiredChannels = std::max(computedChannels, maxSourceChannels);
+  if (requiredChannels == 0) {
+    requiredChannels = 1;
+  }
+
+  bool needsReallocation = internalSummingBus_ == nullptr ||
+      internalSummingBus_->getNumberOfChannels() != requiredChannels ||
+      internalSummingBus_->getSampleRate() != context_->getSampleRate();
+
+  if (needsReallocation) {
+    internalSummingBus_ = std::make_shared<AudioBus>(
+        RENDER_QUANTUM_SIZE, requiredChannels, context_->getSampleRate());
+  }
+}
+
+void NodeConnections::sumAllConnections(
+    const std::vector<InputConnection> &connections,
+    int framesToProcess,
+    bool checkIsAlreadyProcessed) {
+  for (const InputConnection &ic : connections) {
+    if (ic.sourceNode == nullptr)
+      continue;
+
+    ic.sourceNode->processAudio(framesToProcess, checkIsAlreadyProcessed);
+
+    auto srcBus = ic.sourceNode->getOutputBus(ic.outputIndexFromSource);
+    if (srcBus != nullptr) {
+      internalSummingBus_->sum(
+          srcBus.get(), owner_->getChannelInterpretationEnum());
+    }
+  }
+}
+
+std::shared_ptr<AudioBus> NodeConnections::getProcessingBusForIndex(
+    unsigned int inputIndex,
+    unsigned int numChannels,
+    int framesToProcess) {
+  auto &bus = processingInputBuses_[inputIndex];
+  // this handles source (0 input) node case
+  if (bus == nullptr || bus->getNumberOfChannels() != numChannels ||
+      bus->getSampleRate() != context_->getSampleRate()) {
+    bus = std::make_shared<AudioBus>(
+        RENDER_QUANTUM_SIZE, numChannels, context_->getSampleRate());
+  }
+  return bus;
+}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/NodeConnections.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/NodeConnections.h
new file mode 100644
index 000000000..d1d297030
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/NodeConnections.h
@@ -0,0 +1,201 @@
+
+#pragma once
+
+#include <audioapi/core/utils/ConnectionTypes.h>
+
+#include <map>
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+
+class AudioNode;
+class AudioBus;
+class AudioParam;
+class BaseAudioContext;
+
+class NodeConnections {
+ public:
+  /// @brief Construct NodeConnections for a specific audio node
+  /// @param owner The audio node that owns these connections
+  /// @param context The audio context
+  explicit NodeConnections(AudioNode *owner, BaseAudioContext *context);
+
+  /// @brief Disconnect all connections from this node
+  void disconnect();
+
+  /// @brief Disconnect everything (params and nodes) from an output index
+  /// @param outputIndex The output index to disconnect from
+  void disconnect(unsigned int outputIndex);
+
+  /// @brief Disconnects all outputs of the node which go to a specific destination
+  /// @param node The destination node to disconnect from
+  /// @return True if disconnection was successful, false otherwise
+  bool disconnect(const std::shared_ptr<AudioNode> &node);
+
+  /// @brief Disconnects a specific output of the node from any and all inputs of some destination node
+  /// @param node The destination node to disconnect from
+  /// @param outputIndex The output index to disconnect
+  /// @return True if disconnection was successful, false otherwise
+  bool disconnect(const std::shared_ptr<AudioNode> &node, unsigned int outputIndex);
+
+  /// @brief Disconnects a specific output of the node from a specific input of some destination node
+  /// @param node The destination node to disconnect from
+  /// @param output The output index to disconnect
+  /// @param input The input index to disconnect to
+  /// @return True if disconnection was successful, false otherwise
+  bool disconnect(const std::shared_ptr<AudioNode> &node, unsigned int output, unsigned int input);
+
+  /// @brief Disconnects all outputs of the node that go to a specific destination node
+  /// @note The contribution of this node to the computed parameter value goes to 0 when this operation takes effect
+  /// @note The intrinsic parameter value is not affected by this operation
+  /// @param param The destination AudioParam to disconnect from
+  /// @return True if disconnection was successful, false otherwise
+  bool disconnect(const std::shared_ptr<AudioParam> &param);
+
+  /// @brief Disconnects a specific output of the AudioNode from a specific destination AudioParam
+  /// @note The contribution of this AudioNode to the computed parameter value goes to 0 when this operation takes
+  /// effect
+  /// @note The intrinsic parameter value is not affected by this operation
+  /// @param param The destination AudioParam to disconnect from
+  /// @param output The output index to disconnect
+  /// @return True if disconnection was successful, false otherwise
+  bool disconnect(const std::shared_ptr<AudioParam> &param, unsigned int output);
+
+  /// @brief Process all inputs and return the processed audio buses
+  /// @param framesToProcess Number of frames to process
+  /// @param checkIsAlreadyProcessed Whether to check if inputs are already processed
+  /// @return Vector of processed audio buses
+  const std::vector<std::shared_ptr<AudioBus>> &processAllInputs(int framesToProcess, bool checkIsAlreadyProcessed);
+
+  /// @brief Adds a node to the output nodes map
+  /// @param destination The destination node to connect to
+  /// @param outputIndex The output index on this node
+  /// @param inputIndex The input index on the destination node
+  void connectNode(const std::shared_ptr<AudioNode> &destination, unsigned int outputIndex, unsigned int inputIndex);
+
+  /// @brief Inserts a node into the inputs map
+  /// @param sourceNode The source node that connected
+  /// @param outputIndexFromSource The output index from the source node
+  /// @param inputIndex The input index on this node
+  void onInputConnected(AudioNode *sourceNode, unsigned int outputIndexFromSource, unsigned int inputIndex);
+
+  /// @brief Deletes the node from the output map
+  /// @param destination The destination node to disconnect from
+  /// @param outputIndex The output index on this node
+  /// @param inputIndex The input index on the destination node
+  void disconnectNode(const std::shared_ptr<AudioNode> &destination, unsigned int outputIndex, unsigned int inputIndex);
+
+  /// @brief Deletes the node from the input map
+  /// @param sourceNode The source node that disconnected
+  /// @param outputIndexFromSource The output index from the source node
+  /// @param inputIndex The input index on this node
+  void onInputDisconnected(AudioNode *sourceNode, unsigned int outputIndexFromSource, unsigned int inputIndex);
+
+  /// @brief Adds param to the output param map
+  /// @param param The AudioParam to connect
+  /// @param outputIndex The output index to connect from
+  void connectParam(const std::shared_ptr<AudioParam> &param, unsigned int outputIndex);
+
+  /// @brief Deletes param from the output param map
+  /// @param param The AudioParam to disconnect
+  /// @param outputIndex The output index to disconnect from
+  void disconnectParam(const std::shared_ptr<AudioParam> &param, unsigned int outputIndex);
+
+  /// @brief Clears the output map and calls onInputDisconnected on nodes inside the map
+  void cleanup();
+
+  /// @brief Iterates through all outputs and calls onInputEnabled() on connected nodes
+  void propagateEnable();
+
+  /// @brief Iterates through all outputs and calls onInputDisabled() on connected nodes
+  void propagateDisable();
+
+ private:
+  AudioNode *owner_;
+  BaseAudioContext *context_;
+
+  std::map<unsigned int, std::vector<InputConnection>> indexedInputs_;
+  std::map<unsigned int, std::vector<OutputConnection>> indexedOutputs_;
+  std::map<unsigned int, std::vector<std::shared_ptr<AudioParam>>> indexedOutputParams_;
+
+  /// @brief Used for calculations inside processInputAtIndex
+  std::vector<std::shared_ptr<AudioBus>> processingInputBuses_;
+  std::shared_ptr<AudioBus> internalSummingBus_;
+
+  /// @brief Processes all inputs connected to a particular input index
+  /// @param index The input index to process
+  /// @param framesToProcess Number of frames to process
+  /// @param checkIsAlreadyProcessed Whether to check if inputs are already processed
+  /// @return Processed AudioBus for the specified input
+  std::shared_ptr<AudioBus> processInputAtIndex(unsigned int index, int framesToProcess, bool checkIsAlreadyProcessed);
+
+  /// @brief Compute the number of channels for a specific input
+  /// @param index The input index
+  /// @return Number of channels for the input
+  unsigned int computeNumberOfChannelsForInput(unsigned int index) const;
+
+  /// @brief Helpers for processInputAtIndex
+  /// @brief Get processing bus for a specific input index
+  /// @param inputIndex The input index
+  /// @param numChannels Number of channels needed
+  /// @param framesToProcess Number of frames to process
+  /// @return Processing bus for the specified index
+  std::shared_ptr<AudioBus>
+  getProcessingBusForIndex(unsigned int inputIndex, unsigned int numChannels, int framesToProcess);
+
+  /// @brief Check if input is silent
+  /// @param index The input index to check
+  /// @return True if input is silent, false otherwise
+  bool hasSilentInput(unsigned int index) const;
+
+  /// @brief Create a silent bus for the specified input
+  /// @param index The input index
+  /// @param framesToProcess Number of frames to process
+  /// @return Silent AudioBus
+  std::shared_ptr<AudioBus> createSilentBus(unsigned int index, int framesToProcess);
+
+  /// @brief Check if direct bus passthrough can be used
+  /// @param connections The input connections to check
+  /// @return True if direct passthrough can be used, false otherwise
+  bool canUseDirectBusPassthrough(const std::vector<InputConnection> &connections) const;
+
+  /// @brief Process a direct connection
+  /// @param connection The input connection to process
+  /// @param framesToProcess Number of frames to process
+  /// @param checkIsAlreadyProcessed Whether to check if already processed
+  /// @return Processed AudioBus
+  std::shared_ptr<AudioBus>
+  processDirectConnection(const InputConnection &connection, int framesToProcess, bool checkIsAlreadyProcessed);
+
+  /// @brief Process multiple mixed connections
+  /// @param index The input index
+  /// @param connections The connections to process
+  /// @param framesToProcess Number of frames to process
+  /// @param checkIsAlreadyProcessed Whether to check if already processed
+  /// @return Processed AudioBus
+  std::shared_ptr<AudioBus> processMixedConnections(
+      unsigned int index,
+      const std::vector<InputConnection> &connections,
+      int framesToProcess,
+      bool checkIsAlreadyProcessed);
+
+  /// @brief Find the maximum number of source channels
+  /// @param connections The connections to check
+  /// @return Maximum number of source channels
+  unsigned int findMaxSourceChannels(const std::vector<InputConnection> &connections) const;
+
+  /// @brief Prepare the summing bus for mixing
+  /// @param computedChannels Number of computed channels
+  /// @param maxSourceChannels Maximum number of source channels
+  void prepareSummingBus(unsigned int computedChannels, unsigned int maxSourceChannels);
+
+  /// @brief Sum all connections into the summing bus
+  /// @param connections The connections to sum
+  /// @param framesToProcess Number of frames to process
+  /// @param checkIsAlreadyProcessed Whether to check if already processed
+  void
+  sumAllConnections(const std::vector<InputConnection> &connections, int framesToProcess, bool checkIsAlreadyProcessed);
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/src/api.ts b/packages/react-native-audio-api/src/api.ts
index 9a575300d..ba06961f9 100644
--- a/packages/react-native-audio-api/src/api.ts
+++ b/packages/react-native-audio-api/src/api.ts
@@ -70,6 +70,8 @@ export { default as BiquadFilterNode } from './core/BiquadFilterNode';
 export { default as GainNode } from './core/GainNode';
 export { default as OscillatorNode } from './core/OscillatorNode';
 export { default as StereoPannerNode } from './core/StereoPannerNode';
+export { default as ChannelSplitterNode } from './core/ChannelSplitterNode';
+export { default as ChannelMergerNode } from './core/ChannelMergerNode';
 export { default as AudioRecorder } from './core/AudioRecorder';
 export { default as StreamerNode } from './core/StreamerNode';
 export { default as ConstantSourceNode } from './core/ConstantSourceNode';
diff --git a/packages/react-native-audio-api/src/api.web.ts b/packages/react-native-audio-api/src/api.web.ts
index 292f86993..d3b1ae39d 100644
--- a/packages/react-native-audio-api/src/api.web.ts
+++ b/packages/react-native-audio-api/src/api.web.ts
@@ -10,6 +10,8 @@ export { default as AudioScheduledSourceNode } from './web-core/AudioScheduledSo
 export { default as BaseAudioContext } from './web-core/BaseAudioContext';
 export { default as BiquadFilterNode } from './web-core/BiquadFilterNode';
 export { default as GainNode } from './web-core/GainNode';
+export { default as ChannelSplitterNode } from './web-core/ChannelSplitterNode';
+export { default as ChannelMergerNode } from './web-core/ChannelMergerNode';
 export { default as OscillatorNode } from './web-core/OscillatorNode';
 export { default as StereoPannerNode } from './web-core/StereoPannerNode';
 export { default as ConstantSourceNode } from './web-core/ConstantSourceNode';
diff --git a/packages/react-native-audio-api/src/core/AudioNode.ts b/packages/react-native-audio-api/src/core/AudioNode.ts
index 2e19d51d1..5b981f1a1 100644
--- a/packages/react-native-audio-api/src/core/AudioNode.ts
+++ b/packages/react-native-audio-api/src/core/AudioNode.ts
@@ -2,7 +2,11 @@ import { IAudioNode } from '../interfaces';
 import AudioParam from './AudioParam';
 import { ChannelCountMode, ChannelInterpretation } from '../types';
 import BaseAudioContext from './BaseAudioContext';
-import { InvalidAccessError } from '../errors';
+import {
+  InvalidAccessError,
+  IndexSizeError,
+  NotSupportedError,
+} from '../errors';
 
 export default class AudioNode {
   readonly context: BaseAudioContext;
@@ -23,27 +27,104 @@ export default class AudioNode {
     this.channelInterpretation = this.node.channelInterpretation;
   }
 
-  public connect(destination: AudioNode | AudioParam): AudioNode | AudioParam {
+  public connect(
+    destination: AudioNode | AudioParam,
+    outputIndex: number = 0,
+    inputIndex: number = 0
+  ): AudioNode | AudioParam | undefined {
     if (this.context !== destination.context) {
       throw new InvalidAccessError(
         'Source and destination are from different BaseAudioContexts'
       );
     }
+    if (outputIndex < 0 || outputIndex >= this.numberOfOutputs) {
+      throw new IndexSizeError('Output index is out of range');
+    }
+    if (destination instanceof AudioNode) {
+      if (inputIndex < 0 || inputIndex >= destination.numberOfInputs) {
+        throw new IndexSizeError('Input index is out of range');
+      }
+    }
+    if (destination instanceof AudioParam && inputIndex !== 0) {
+      throw new NotSupportedError(
+        'Cannot specify input index when connecting to an AudioParam'
+      );
+    }
 
     if (destination instanceof AudioParam) {
-      this.node.connect(destination.audioParam);
+      this.node.connect(destination.audioParam, outputIndex);
+      return undefined;
     } else {
-      this.node.connect(destination.node);
+      this.node.connect(destination.node, outputIndex, inputIndex);
     }
 
     return destination;
   }
 
-  public disconnect(destination?: AudioNode | AudioParam): void {
+  public disconnect(
+    destinationOrOutput?: AudioNode | AudioParam | number,
+    output?: number,
+    input?: number
+  ): void {
+    const numberOfOutputs = this.node.numberOfOutputs;
+
+    // disconnect()
+    if (destinationOrOutput === undefined) {
+      this.node.disconnect();
+      return;
+    }
+
+    // disconnect(outputIndex: number)
+    if (typeof destinationOrOutput === 'number') {
+      const outputIndex = destinationOrOutput;
+      if (outputIndex < 0 || outputIndex >= numberOfOutputs) {
+        throw new IndexSizeError('Output index is out of range.');
+      }
+      this.node.disconnect(outputIndex);
+      return;
+    }
+
+    const destination = destinationOrOutput;
+
     if (destination instanceof AudioParam) {
-      this.node.disconnect(destination.audioParam);
+      // Destination is an AudioParam
+      if (output === undefined) {
+        // disconnect(destination: AudioParam)
+        this.node.disconnect(destination.audioParam);
+      } else {
+        // disconnect(destination: AudioParam, output: number)
+        if (output < 0 || output >= numberOfOutputs) {
+          throw new IndexSizeError('Output index is out of range.');
+        }
+        this.node.disconnect(destination.audioParam, output);
+      }
+    } else if (destination instanceof AudioNode) {
+      // Destination is an AudioNode
+      if (output === undefined) {
+        // disconnect(destination: AudioNode)
+        this.node.disconnect(destination.node);
+      } else if (input === undefined) {
+        // disconnect(destination: AudioNode, output: number)
+        if (output < 0 || output >= numberOfOutputs) {
+          throw new IndexSizeError('Output index is out of range.');
+        }
+        this.node.disconnect(destination.node, output);
+      } else {
+        // disconnect(destination: AudioNode, output: number, input: number)
+        if (output < 0 || output >= numberOfOutputs) {
+          throw new IndexSizeError('Output index is out of range.');
+        }
+        if (input < 0 || input >= destination.numberOfInputs) {
+          throw new IndexSizeError('Input index is out of range.');
+        }
+
+        this.node.disconnect(destination.node, output, input);
+      }
     } else {
-      this.node.disconnect(destination?.node);
+      throw new TypeError(
+        "Failed to execute 'disconnect' on 'AudioNode': " +
+          'Overload resolution failed.'
+      );
     }
   }
 }
diff --git a/packages/react-native-audio-api/src/core/BaseAudioContext.ts b/packages/react-native-audio-api/src/core/BaseAudioContext.ts
index 86938d40c..53929776e 100644
--- a/packages/react-native-audio-api/src/core/BaseAudioContext.ts
+++ b/packages/react-native-audio-api/src/core/BaseAudioContext.ts
@@ -1,4 +1,8 @@
-import { InvalidAccessError, NotSupportedError } from '../errors';
+import {
+  InvalidAccessError,
+  NotSupportedError,
+  IndexSizeError,
+} from '../errors';
 import { IBaseAudioContext } from '../interfaces';
 import {
   AudioBufferBaseSourceNodeOptions,
@@ -25,6 +29,8 @@ import RecorderAdapterNode from './RecorderAdapterNode';
 import StereoPannerNode from './StereoPannerNode';
 import StreamerNode from './StreamerNode';
 import WorkletNode from './WorkletNode';
+import ChannelSplitterNode from './ChannelSplitterNode';
+import ChannelMergerNode from './ChannelMergerNode';
 import { decodeAudioData, decodePCMInBase64 } from './AudioDecoder';
 
 export default class BaseAudioContext {
@@ -204,6 +210,30 @@ export default class BaseAudioContext {
     return new BiquadFilterNode(this, this.context.createBiquadFilter());
   }
 
+  createChannelSplitter(numberOfOutputs: number = 6): ChannelSplitterNode {
+    if (numberOfOutputs < 1 || numberOfOutputs > 32) {
+      throw new IndexSizeError(
+        `The number of outputs provided (${numberOfOutputs}) is outside the range [1, 32]`
+      );
+    }
+    return new ChannelSplitterNode(
+      this,
+      this.context.createChannelSplitter(numberOfOutputs)
+    );
+  }
+
+  createChannelMerger(numberOfInputs: number = 6): ChannelSplitterNode {
+    if (numberOfInputs < 1 || numberOfInputs > 32) {
+      throw new IndexSizeError(
+        `The number of inputs provided (${numberOfInputs}) is outside the range [1, 32]`
+      );
+    }
+    return new ChannelMergerNode(
+      this,
+      this.context.createChannelMerger(numberOfInputs)
+    );
+  }
+
   createBufferSource(
     options?: AudioBufferBaseSourceNodeOptions
   ): AudioBufferSourceNode {
diff --git a/packages/react-native-audio-api/src/core/ChannelMergerNode.ts b/packages/react-native-audio-api/src/core/ChannelMergerNode.ts
new file mode 100644
index 000000000..8e8474252
--- /dev/null
+++ b/packages/react-native-audio-api/src/core/ChannelMergerNode.ts
@@ -0,0 +1,12 @@
+import { IChannelMergerNode } from '../interfaces';
+import AudioNode from './AudioNode';
+import BaseAudioContext from './BaseAudioContext';
+
+export default class ChannelMergerNode extends AudioNode {
+  readonly numberOfInputs: number;
+
+  constructor(context: BaseAudioContext, merger: IChannelMergerNode) {
+    super(context, merger);
+    this.numberOfInputs = merger.numberOfInputs;
+  }
+}
diff --git a/packages/react-native-audio-api/src/core/ChannelSplitterNode.ts b/packages/react-native-audio-api/src/core/ChannelSplitterNode.ts
new file mode 100644
index 000000000..9f3507ee8
--- /dev/null
+++ b/packages/react-native-audio-api/src/core/ChannelSplitterNode.ts
@@ -0,0 +1,12 @@
+import { IChannelSplitterNode } from '../interfaces';
+import AudioNode from './AudioNode';
+import BaseAudioContext from './BaseAudioContext';
+
+export default class ChannelSplitterNode extends AudioNode {
+  readonly numberOfOutputs: number;
+
+  constructor(context: BaseAudioContext, splitter: IChannelSplitterNode) {
+    super(context, splitter);
+    this.numberOfOutputs = splitter.numberOfOutputs;
+  }
+}
diff --git a/packages/react-native-audio-api/src/interfaces.ts b/packages/react-native-audio-api/src/interfaces.ts
index 5c1bc8a0a..a4602b7ee 100644
--- a/packages/react-native-audio-api/src/interfaces.ts
+++ b/packages/react-native-audio-api/src/interfaces.ts
@@ -62,6 +62,8 @@ export interface IBaseAudioContext {
   createGain(): IGainNode;
   createStereoPanner(): IStereoPannerNode;
   createBiquadFilter: () => IBiquadFilterNode;
+  createChannelSplitter: (numberOfOutputs?: number) => IChannelSplitterNode;
+  createChannelMerger: (numberOfInputs?: number) => IChannelMergerNode;
   createBufferSource: (pitchCorrection: boolean) => IAudioBufferSourceNode;
   createBufferQueueSource: (
     pitchCorrection: boolean
@@ -104,8 +106,17 @@ export interface IAudioNode {
   readonly channelCountMode: ChannelCountMode;
   readonly channelInterpretation: ChannelInterpretation;
 
-  connect: (destination: IAudioNode | IAudioParam) => void;
-  disconnect: (destination?: IAudioNode | IAudioParam) => void;
+  connect(
+    destination: IAudioNode | IAudioParam,
+    output?: number,
+    input?: number
+  ): void;
+
+  disconnect(): void;
+  disconnect(output: number): void;
+  disconnect(destination: IAudioNode | IAudioParam): void;
+  disconnect(destination: IAudioNode | IAudioParam, output: number): void;
+  disconnect(destination: IAudioNode, output: number, input: number): void;
 }
 
 export interface IGainNode extends IAudioNode {
@@ -130,6 +141,14 @@ export interface IBiquadFilterNode extends IAudioNode {
   ): void;
 }
 
+export interface IChannelSplitterNode extends IAudioNode {
+  readonly numberOfOutputs: number;
+}
+
+export interface IChannelMergerNode extends IAudioNode {
+  readonly numberOfInputs: number;
+}
+
 export interface IAudioDestinationNode extends IAudioNode {}
 
 export interface IAudioScheduledSourceNode extends IAudioNode {
diff --git a/packages/react-native-audio-api/src/web-core/AudioContext.tsx b/packages/react-native-audio-api/src/web-core/AudioContext.tsx
index d7ab486a4..2d8ad2368 100644
--- a/packages/react-native-audio-api/src/web-core/AudioContext.tsx
+++ b/packages/react-native-audio-api/src/web-core/AudioContext.tsx
@@ -4,7 +4,11 @@ import {
   AudioContextOptions,
   AudioBufferBaseSourceNodeOptions,
 } from '../types';
-import { InvalidAccessError, NotSupportedError } from '../errors';
+import {
+  InvalidAccessError,
+  NotSupportedError,
+  IndexSizeError,
+} from '../errors';
 import BaseAudioContext from './BaseAudioContext';
 import AnalyserNode from './AnalyserNode';
 import AudioDestinationNode from './AudioDestinationNode';
@@ -17,6 +21,8 @@ import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
 import ConvolverNode from './ConvolverNode';
 import { ConvolverNodeOptions } from './ConvolverNodeOptions';
+import ChannelMergerNode from './ChannelMergerNode';
+import ChannelSplitterNode from './ChannelSplitterNode';
 
 import { globalWasmPromise, globalTag } from './custom/LoadCustomWasm';
 import ConstantSourceNode from './ConstantSourceNode';
@@ -95,6 +101,30 @@ export default class AudioContext implements BaseAudioContext {
     );
   }
 
+  createChannelSplitter(numberOfOutputs: number = 6): ChannelSplitterNode {
+    if (numberOfOutputs < 1 || numberOfOutputs > 32) {
+      throw new IndexSizeError(
+        `The number of outputs provided (${numberOfOutputs}) is outside the range [1, 32]`
+      );
+    }
+    return new ChannelSplitterNode(
+      this,
+      this.context.createChannelSplitter(numberOfOutputs)
+    );
+  }
+
+  createChannelMerger(numberOfInputs: number = 6): ChannelSplitterNode {
+    if (numberOfInputs < 1 || numberOfInputs > 32) {
+      throw new IndexSizeError(
+        `The number of inputs provided (${numberOfInputs}) is outside the range [1, 32]`
+      );
+    }
+    return new ChannelMergerNode(
+      this,
+      this.context.createChannelMerger(numberOfInputs)
+    );
+  }
+
   async createBufferSource(
     options?: AudioBufferBaseSourceNodeOptions
   ): Promise<AudioBufferSourceNode> {
diff --git a/packages/react-native-audio-api/src/web-core/AudioNode.tsx b/packages/react-native-audio-api/src/web-core/AudioNode.tsx
index a66113f1f..8519fffb6 100644
--- a/packages/react-native-audio-api/src/web-core/AudioNode.tsx
+++ b/packages/react-native-audio-api/src/web-core/AudioNode.tsx
@@ -22,28 +22,62 @@ export default class AudioNode {
     this.channelInterpretation = this.node.channelInterpretation;
   }
 
-  public connect(destination: AudioNode | AudioParam): AudioNode | AudioParam {
+  public connect(
+    destination: AudioNode | AudioParam,
+    output = 0,
+    input = 0
+  ): AudioNode | void {
     if (this.context !== destination.context) {
       throw new Error(
         'Source and destination are from different BaseAudioContexts'
       );
     }
-
     if (destination instanceof AudioParam) {
-      this.node.connect(destination.param);
-    } else {
-      this.node.connect(destination.node);
+      this.node.connect(destination.param, output);
+      return;
     }
 
-    return destination;
+    if (destination instanceof AudioNode) {
+      this.node.connect(destination.node, output, input);
+      return destination;
+    }
   }
 
-  public disconnect(destination?: AudioNode): void {
-    if (destination === undefined) {
+  public disconnect(
+    destinationOrOutput?: AudioNode | AudioParam | number,
+    output?: number,
+    input?: number
+  ): void {
+    if (destinationOrOutput === undefined) {
       this.node.disconnect();
       return;
     }
 
-    this.node.disconnect(destination.node);
+    if (typeof destinationOrOutput === 'number') {
+      const outputIndex = destinationOrOutput;
+      this.node.disconnect(outputIndex);
+      return;
+    }
+
+    const destination = destinationOrOutput;
+
+    if (destination instanceof AudioParam) {
+      if (output !== undefined) {
+        this.node.disconnect(destination.param, output);
+      } else {
+        this.node.disconnect(destination.param);
+      }
+      return;
+    }
+
+    if (destination instanceof AudioNode) {
+      if (output !== undefined && input !== undefined) {
+        this.node.disconnect(destination.node, output, input);
+      } else if (output !== undefined) {
+        this.node.disconnect(destination.node, output);
+      } else {
+        this.node.disconnect(destination.node);
+      }
+    }
   }
 }
diff --git a/packages/react-native-audio-api/src/web-core/BaseAudioContext.tsx b/packages/react-native-audio-api/src/web-core/BaseAudioContext.tsx
index 5d2fa9a74..b3523c37b 100644
--- a/packages/react-native-audio-api/src/web-core/BaseAudioContext.tsx
+++ b/packages/react-native-audio-api/src/web-core/BaseAudioContext.tsx
@@ -10,6 +10,8 @@ import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
 import ConstantSourceNode from './ConstantSourceNode';
 import ConvolverNode from './ConvolverNode';
+import ChannelMergerNode from './ChannelMergerNode';
+import ChannelSplitterNode from './ChannelSplitterNode';
 
 export default interface BaseAudioContext {
   readonly context: globalThis.BaseAudioContext;
@@ -25,6 +27,8 @@ export default interface BaseAudioContext {
   createStereoPanner(): StereoPannerNode;
   createBiquadFilter(): BiquadFilterNode;
   createConvolver(): ConvolverNode;
+  createChannelSplitter(): ChannelSplitterNode;
+  createChannelMerger(): ChannelMergerNode;
   createBufferSource(): Promise<AudioBufferSourceNode>;
   createBuffer(
     numOfChannels: number,
diff --git a/packages/react-native-audio-api/src/web-core/ChannelMergerNode.tsx b/packages/react-native-audio-api/src/web-core/ChannelMergerNode.tsx
new file mode 100644
index 000000000..4cff86914
--- /dev/null
+++ b/packages/react-native-audio-api/src/web-core/ChannelMergerNode.tsx
@@ -0,0 +1,11 @@
+import AudioNode from './AudioNode';
+import BaseAudioContext from './BaseAudioContext';
+
+export default class ChannelMergerNode extends AudioNode {
+  readonly numberOfInputs: number;
+
+  constructor(context: BaseAudioContext, merger: globalThis.ChannelMergerNode) {
+    super(context, merger);
+    this.numberOfInputs = merger.numberOfInputs;
+  }
+}
diff --git a/packages/react-native-audio-api/src/web-core/ChannelSplitterNode.tsx b/packages/react-native-audio-api/src/web-core/ChannelSplitterNode.tsx
new file mode 100644
index 000000000..9fdd43276
--- /dev/null
+++ b/packages/react-native-audio-api/src/web-core/ChannelSplitterNode.tsx
@@ -0,0 +1,14 @@
+import AudioNode from './AudioNode';
+import BaseAudioContext from './BaseAudioContext';
+
+export default class ChannelSplitterNode extends AudioNode {
+  readonly numberOfOutputs: number;
+
+  constructor(
+    context: BaseAudioContext,
+    splitter: globalThis.ChannelSplitterNode
+  ) {
+    super(context, splitter);
+    this.numberOfOutputs = splitter.numberOfOutputs;
+  }
+}
diff --git a/packages/react-native-audio-api/src/web-core/OfflineAudioContext.tsx b/packages/react-native-audio-api/src/web-core/OfflineAudioContext.tsx
index cf9eec733..a1a847442 100644
--- a/packages/react-native-audio-api/src/web-core/OfflineAudioContext.tsx
+++ b/packages/react-native-audio-api/src/web-core/OfflineAudioContext.tsx
@@ -4,7 +4,11 @@ import {
   OfflineAudioContextOptions,
   AudioBufferBaseSourceNodeOptions,
 } from '../types';
-import { InvalidAccessError, NotSupportedError } from '../errors';
+import {
+  InvalidAccessError,
+  NotSupportedError,
+  IndexSizeError,
+} from '../errors';
 import BaseAudioContext from './BaseAudioContext';
 import AnalyserNode from './AnalyserNode';
 import AudioDestinationNode from './AudioDestinationNode';
@@ -16,6 +20,8 @@ import OscillatorNode from './OscillatorNode';
 import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
 import ConstantSourceNode from './ConstantSourceNode';
+import ChannelMergerNode from './ChannelMergerNode';
+import ChannelSplitterNode from './ChannelSplitterNode';
 
 import { globalWasmPromise, globalTag } from './custom/LoadCustomWasm';
 import ConvolverNode from './ConvolverNode';
@@ -101,6 +107,30 @@ export default class OfflineAudioContext implements BaseAudioContext {
     );
   }
 
+  createChannelSplitter(numberOfOutputs: number = 6): ChannelSplitterNode {
+    if (numberOfOutputs < 1 || numberOfOutputs > 32) {
+      throw new IndexSizeError(
+        `The number of outputs provided (${numberOfOutputs}) is outside the range [1, 32]`
+      );
+    }
+    return new ChannelSplitterNode(
+      this,
+      this.context.createChannelSplitter(numberOfOutputs)
+    );
+  }
+
+  createChannelMerger(numberOfInputs: number = 6): ChannelSplitterNode {
+    if (numberOfInputs < 1 || numberOfInputs > 32) {
+      throw new IndexSizeError(
+        `The number of inputs provided (${numberOfInputs}) is outside the range [1, 32]`
+      );
+    }
+    return new ChannelMergerNode(
+      this,
+      this.context.createChannelMerger(numberOfInputs)
+    );
+  }
+
   async createBufferSource(
     options?: AudioBufferBaseSourceNodeOptions
   ): Promise<AudioBufferSourceNode> {