diff --git a/.claude/skills/host-objects/SKILL.md b/.claude/skills/host-objects/SKILL.md
index 27d27bd66..fc10b693c 100644
--- a/.claude/skills/host-objects/SKILL.md
+++ b/.claude/skills/host-objects/SKILL.md
@@ -72,6 +72,7 @@ HostObjects/
 │   ├── DelayNodeHostObject.h/.cpp
 │   ├── IIRFilterNodeHostObject.h/.cpp
 │   ├── StereoPannerNodeHostObject.h/.cpp
+│   ├── PannerNodeHostObject.h/.cpp
 │   ├── WaveShaperNodeHostObject.h/.cpp
 │   ├── ConvolverNodeHostObject.h/.cpp
 │   ├── ChannelMergerNodeHostObject.h/.cpp   # Composite: routes inputs to slot hosts
diff --git a/.claude/skills/web-audio-api/SKILL.md b/.claude/skills/web-audio-api/SKILL.md
index edb287e58..188e11705 100644
--- a/.claude/skills/web-audio-api/SKILL.md
+++ b/.claude/skills/web-audio-api/SKILL.md
@@ -115,10 +115,11 @@ Current status (from `packages/audiodocs/docs/other/web-audio-api-coverage.mdx`)
 |---|---|
 | `AudioContext` | `close`, `suspend`, `resume`, `currentTime`, `destination`, `sampleRate`, `state` |
 | `BaseAudioContext` | `currentTime`, `destination`, `listener`, `sampleRate`, `state`, `decodeAudioData`, all `create*` for available nodes |
-| `AudioListener` | All nine AudioParams; deprecated `setPosition` / `setOrientation` omitted; no audible effect until `PannerNode` |
+| `AudioListener` | All nine AudioParams; used by `PannerNode` for 3D spatialization; deprecated `setPosition` / `setOrientation` omitted |
+| `PannerNode` | Equal-power spatialization, distance models, cone gain; `'HRTF'` throws `NotSupportedError` on native |
 
 ### Not yet implemented ❌
-`AudioSinkInfo`, `AudioWorklet`, `AudioWorkletGlobalScope`, `AudioWorkletNode`, `AudioWorkletProcessor`, `DynamicsCompressorNode`, `MediaStreamAudioDestinationNode`, `MediaStreamAudioSourceNode`, `PannerNode`
+`AudioSinkInfo`, `AudioWorklet`, `AudioWorkletGlobalScope`, `AudioWorkletNode`, `AudioWorkletProcessor`, `DynamicsCompressorNode`, `MediaStreamAudioDestinationNode`, `MediaStreamAudioSourceNode`
 
 **Goal**: everything in the Web Audio API spec should eventually be in this library. If you implement a node from the ❌ list, update the coverage table in `packages/audiodocs/docs/other/web-audio-api-coverage.mdx`.
 
diff --git a/apps/common-app/src/examples/PannerNode/PannerNode.tsx b/apps/common-app/src/examples/PannerNode/PannerNode.tsx
new file mode 100644
index 000000000..801657682
--- /dev/null
+++ b/apps/common-app/src/examples/PannerNode/PannerNode.tsx
@@ -0,0 +1,549 @@
+import React, { useEffect, useRef, useState, FC } from 'react';
+import { Pressable, ScrollView, StyleSheet, Text, View } from 'react-native';
+import {
+  AudioContext,
+  GainNode,
+  OscillatorNode,
+  PannerNode,
+} from 'react-native-audio-api';
+import type { DistanceModelType } from 'react-native-audio-api';
+
+import { Button, Container, Slider, Spacer } from '../../components';
+import { colors, layout } from '../../styles';
+
+const LABEL_WIDTH = 100;
+const DISTANCE_MODELS: DistanceModelType[] = [
+  'inverse',
+  'linear',
+  'exponential',
+];
+
+type Vec3State = {
+  positionX: number;
+  positionY: number;
+  positionZ: number;
+};
+
+type SpatialState = Vec3State & {
+  orientationX: number;
+  orientationY: number;
+  orientationZ: number;
+};
+
+const INITIAL_LISTENER: Vec3State = {
+  positionX: 0,
+  positionY: 0,
+  positionZ: 0,
+};
+
+const INITIAL_SPATIAL: SpatialState = {
+  positionX: 0,
+  positionY: 0,
+  positionZ: -1,
+  orientationX: 0,
+  orientationY: 0,
+  orientationZ: 1,
+};
+
+type Preset = {
+  label: string;
+  spatial: SpatialState;
+  coneEnabled?: boolean;
+  hint: string;
+};
+
+const PRESETS: Preset[] = [
+  {
+    label: 'Center',
+    spatial: { ...INITIAL_SPATIAL },
+    coneEnabled: false,
+    hint: 'In front of the listener',
+  },
+  {
+    label: 'Left',
+    spatial: { ...INITIAL_SPATIAL, positionX: -3 },
+    coneEnabled: false,
+    hint: 'Stronger in the left ear (with cone off)',
+  },
+  {
+    label: 'Right',
+    spatial: { ...INITIAL_SPATIAL, positionX: 3 },
+    coneEnabled: false,
+    hint: 'Stronger in the right ear (with cone off)',
+  },
+  {
+    label: 'Far',
+    spatial: { ...INITIAL_SPATIAL, positionZ: -8 },
+    coneEnabled: false,
+    hint: 'Quieter via distance attenuation (cone off)',
+  },
+  {
+    label: 'Away',
+    spatial: {
+      ...INITIAL_SPATIAL,
+      orientationX: 0,
+      orientationY: 0,
+      orientationZ: -1,
+    },
+    coneEnabled: true,
+    hint: 'Cone on + facing away - steer with inner and outer angle and outer gain',
+  },
+];
+
+const PannerNodeExample: FC = () => {
+  const [isPlaying, setIsPlaying] = useState(false);
+  const [gain, setGain] = useState(0.4);
+  const [spatial, setSpatial] = useState<SpatialState>(INITIAL_SPATIAL);
+  const [listener, setListener] = useState<Vec3State>(INITIAL_LISTENER);
+  const [coneEnabled, setConeEnabled] = useState(false);
+  const [coneInnerAngle, setConeInnerAngle] = useState(60);
+  const [coneOuterAngle, setConeOuterAngle] = useState(90);
+  const [coneOuterGain, setConeOuterGain] = useState(0);
+  const [distanceModel, setDistanceModel] =
+    useState<DistanceModelType>('inverse');
+  const [rolloffFactor, setRolloffFactor] = useState(1);
+  const [hint, setHint] = useState(
+    'Equal-power model. Use headphones. Listener orientation forward is -Z. Move source and/or listener. Cone OFF: source "Pos X" pans L/R. Turn Cone ON to test orientation together with inner and outer angle and outer gain.'
+  );
+
+  const audioContextRef = useRef<AudioContext | null>(null);
+  const oscillatorRef = useRef<OscillatorNode | null>(null);
+  const gainRef = useRef<GainNode | null>(null);
+  const pannerRef = useRef<PannerNode | null>(null);
+
+  useEffect(() => {
+    audioContextRef.current = new AudioContext();
+    return () => {
+      audioContextRef.current?.close();
+      audioContextRef.current = null;
+    };
+  }, []);
+
+  const applyCone = (
+    panner: PannerNode,
+    enabled: boolean,
+    inner = coneInnerAngle,
+    outer = coneOuterAngle,
+    outerGain = coneOuterGain
+  ) => {
+    if (enabled) {
+      panner.coneInnerAngle = inner;
+      panner.coneOuterAngle = Math.max(outer, inner);
+      panner.coneOuterGain = outerGain;
+    } else {
+      panner.coneInnerAngle = 360;
+      panner.coneOuterAngle = 360;
+      panner.coneOuterGain = 0;
+    }
+  };
+
+  const applySpatial = (next: SpatialState) => {
+    const panner = pannerRef.current;
+    if (!panner) {
+      return;
+    }
+    panner.positionX.value = next.positionX;
+    panner.positionY.value = next.positionY;
+    panner.positionZ.value = next.positionZ;
+    panner.orientationX.value = next.orientationX;
+    panner.orientationY.value = next.orientationY;
+    panner.orientationZ.value = next.orientationZ;
+  };
+
+  const applyListener = (next: Vec3State) => {
+    const ctx = audioContextRef.current;
+    if (!ctx) {
+      return;
+    }
+    ctx.listener.positionX.value = next.positionX;
+    ctx.listener.positionY.value = next.positionY;
+    ctx.listener.positionZ.value = next.positionZ;
+  };
+
+  const updateSpatial = <K extends keyof SpatialState>(
+    key: K,
+    value: SpatialState[K]
+  ) => {
+    setSpatial((prev) => {
+      const next = { ...prev, [key]: value };
+      applySpatial(next);
+      return next;
+    });
+  };
+
+  const updateListener = <K extends keyof Vec3State>(
+    key: K,
+    value: Vec3State[K]
+  ) => {
+    setListener((prev) => {
+      const next = { ...prev, [key]: value };
+      applyListener(next);
+      return next;
+    });
+  };
+
+  const setup = () => {
+    if (!audioContextRef.current) {
+      audioContextRef.current = new AudioContext();
+    }
+
+    const ctx = audioContextRef.current;
+    oscillatorRef.current = ctx.createOscillator();
+    oscillatorRef.current.type = 'sine';
+    oscillatorRef.current.frequency.value = 440;
+
+    gainRef.current = ctx.createGain();
+    gainRef.current.gain.value = gain;
+
+    pannerRef.current = ctx.createPanner();
+    pannerRef.current.distanceModel = distanceModel;
+    pannerRef.current.rolloffFactor = rolloffFactor;
+    applyCone(pannerRef.current, coneEnabled);
+    applySpatial(spatial);
+    applyListener(listener);
+
+    oscillatorRef.current.connect(gainRef.current);
+    gainRef.current.connect(pannerRef.current);
+    pannerRef.current.connect(ctx.destination);
+  };
+
+  const handlePlayPause = () => {
+    if (isPlaying) {
+      oscillatorRef.current?.stop(0);
+      oscillatorRef.current = null;
+      gainRef.current = null;
+      pannerRef.current = null;
+    } else {
+      setup();
+      oscillatorRef.current?.start(0);
+    }
+    setIsPlaying((prev) => !prev);
+  };
+
+  const applyPreset = (preset: Preset) => {
+    setSpatial(preset.spatial);
+    applySpatial(preset.spatial);
+    setListener(INITIAL_LISTENER);
+    applyListener(INITIAL_LISTENER);
+    if (preset.coneEnabled !== undefined) {
+      setConeEnabled(preset.coneEnabled);
+      if (pannerRef.current) {
+        applyCone(pannerRef.current, preset.coneEnabled);
+      }
+    }
+    setHint(preset.hint);
+  };
+
+  return (
+    <Container>
+      <ScrollView contentContainerStyle={styles.scrollContent}>
+        <Text style={styles.title}>PannerNode</Text>
+        <Text style={styles.hint}>{hint}</Text>
+        <Spacer.Vertical size={16} />
+
+        <Button
+          onPress={handlePlayPause}
+          title={isPlaying ? 'Stop' : 'Play tone'}
+        />
+        <Spacer.Vertical size={20} />
+
+        <Text style={styles.section}>Presets</Text>
+        <View style={styles.row}>
+          {PRESETS.map((preset) => (
+            <Pressable
+              key={preset.label}
+              style={styles.chip}
+              onPress={() => applyPreset(preset)}>
+              <Text style={styles.chipText}>{preset.label}</Text>
+            </Pressable>
+          ))}
+        </View>
+        <Spacer.Vertical size={16} />
+
+        <Pressable
+          style={[styles.chip, coneEnabled && styles.chipActive]}
+          onPress={() => {
+            const next = !coneEnabled;
+            setConeEnabled(next);
+            if (pannerRef.current) {
+              applyCone(pannerRef.current, next);
+            }
+            setHint(
+              next
+                ? 'Cone on — use inner/outer angle + outer gain with orientation'
+                : 'Cone off (360°) — orientation has no effect'
+            );
+          }}>
+          <Text style={styles.chipText}>
+            Cone {coneEnabled ? 'ON' : 'OFF'}
+          </Text>
+        </Pressable>
+        <Spacer.Vertical size={12} />
+
+        <Text style={styles.section}>Cone</Text>
+        <Slider
+          label="Inner °"
+          value={coneInnerAngle}
+          onValueChange={(value) => {
+            setConeInnerAngle(value);
+            const outer = Math.max(coneOuterAngle, value);
+            if (outer !== coneOuterAngle) {
+              setConeOuterAngle(outer);
+            }
+            if (pannerRef.current && coneEnabled) {
+              applyCone(pannerRef.current, true, value, outer, coneOuterGain);
+            }
+          }}
+          min={0}
+          max={360}
+          step={1}
+          minLabelWidth={LABEL_WIDTH}
+        />
+        <Spacer.Vertical size={10} />
+        <Slider
+          label="Outer °"
+          value={coneOuterAngle}
+          onValueChange={(value) => {
+            const outer = Math.max(value, coneInnerAngle);
+            setConeOuterAngle(outer);
+            if (pannerRef.current && coneEnabled) {
+              applyCone(
+                pannerRef.current,
+                true,
+                coneInnerAngle,
+                outer,
+                coneOuterGain
+              );
+            }
+          }}
+          min={0}
+          max={360}
+          step={1}
+          minLabelWidth={LABEL_WIDTH}
+        />
+        <Spacer.Vertical size={10} />
+        <Slider
+          label="Outer gain"
+          value={coneOuterGain}
+          onValueChange={(value) => {
+            setConeOuterGain(value);
+            if (pannerRef.current && coneEnabled) {
+              applyCone(
+                pannerRef.current,
+                true,
+                coneInnerAngle,
+                coneOuterAngle,
+                value
+              );
+            }
+          }}
+          min={0}
+          max={1}
+          step={0.01}
+          minLabelWidth={LABEL_WIDTH}
+        />
+        <Spacer.Vertical size={16} />
+
+        <Text style={styles.section}>Distance model</Text>
+        <View style={styles.row}>
+          {DISTANCE_MODELS.map((model) => (
+            <Pressable
+              key={model}
+              style={[
+                styles.chip,
+                distanceModel === model && styles.chipActive,
+              ]}
+              onPress={() => {
+                setDistanceModel(model);
+                if (pannerRef.current) {
+                  pannerRef.current.distanceModel = model;
+                }
+              }}>
+              <Text style={styles.chipText}>{model}</Text>
+            </Pressable>
+          ))}
+        </View>
+        <Spacer.Vertical size={16} />
+
+        <Slider
+          label="Gain"
+          value={gain}
+          onValueChange={(value) => {
+            setGain(value);
+            if (gainRef.current) {
+              gainRef.current.gain.value = value;
+            }
+          }}
+          min={0}
+          max={1}
+          step={0.01}
+          minLabelWidth={LABEL_WIDTH}
+        />
+        <Spacer.Vertical size={12} />
+        <Slider
+          label="Rolloff"
+          value={rolloffFactor}
+          onValueChange={(value) => {
+            setRolloffFactor(value);
+            if (pannerRef.current) {
+              pannerRef.current.rolloffFactor = value;
+            }
+          }}
+          min={0}
+          max={4}
+          step={0.1}
+          minLabelWidth={LABEL_WIDTH}
+        />
+        <Spacer.Vertical size={16} />
+
+        <Text style={styles.section}>Listener position</Text>
+        <Spacer.Vertical size={10} />
+        <Slider
+          label="Listener X"
+          value={listener.positionX}
+          onValueChange={(value) => updateListener('positionX', value)}
+          min={-8}
+          max={8}
+          step={0.1}
+          minLabelWidth={LABEL_WIDTH}
+        />
+        <Spacer.Vertical size={10} />
+        <Slider
+          label="Listener Y"
+          value={listener.positionY}
+          onValueChange={(value) => updateListener('positionY', value)}
+          min={-8}
+          max={8}
+          step={0.1}
+          minLabelWidth={LABEL_WIDTH}
+        />
+        <Spacer.Vertical size={10} />
+        <Slider
+          label="Listener Z"
+          value={listener.positionZ}
+          onValueChange={(value) => updateListener('positionZ', value)}
+          min={-12}
+          max={4}
+          step={0.1}
+          minLabelWidth={LABEL_WIDTH}
+        />
+        <Spacer.Vertical size={16} />
+
+        <Text style={styles.section}>Source position</Text>
+        <Spacer.Vertical size={10} />
+        <Slider
+          label="Pos X"
+          value={spatial.positionX}
+          onValueChange={(value) => updateSpatial('positionX', value)}
+          min={-8}
+          max={8}
+          step={0.1}
+          minLabelWidth={LABEL_WIDTH}
+        />
+        <Spacer.Vertical size={10} />
+        <Slider
+          label="Pos Y"
+          value={spatial.positionY}
+          onValueChange={(value) => updateSpatial('positionY', value)}
+          min={-8}
+          max={8}
+          step={0.1}
+          minLabelWidth={LABEL_WIDTH}
+        />
+        <Spacer.Vertical size={10} />
+        <Slider
+          label="Pos Z"
+          value={spatial.positionZ}
+          onValueChange={(value) => updateSpatial('positionZ', value)}
+          min={-12}
+          max={4}
+          step={0.1}
+          minLabelWidth={LABEL_WIDTH}
+        />
+        <Spacer.Vertical size={16} />
+
+        <Text style={styles.section}>Source orientation</Text>
+        <Slider
+          label="Ori X"
+          value={spatial.orientationX}
+          onValueChange={(value) => updateSpatial('orientationX', value)}
+          min={-1}
+          max={1}
+          step={0.05}
+          minLabelWidth={LABEL_WIDTH}
+        />
+        <Spacer.Vertical size={10} />
+        <Slider
+          label="Ori Y"
+          value={spatial.orientationY}
+          onValueChange={(value) => updateSpatial('orientationY', value)}
+          min={-1}
+          max={1}
+          step={0.05}
+          minLabelWidth={LABEL_WIDTH}
+        />
+        <Spacer.Vertical size={10} />
+        <Slider
+          label="Ori Z"
+          value={spatial.orientationZ}
+          onValueChange={(value) => updateSpatial('orientationZ', value)}
+          min={-1}
+          max={1}
+          step={0.05}
+          minLabelWidth={LABEL_WIDTH}
+        />
+        <Spacer.Vertical size={24} />
+      </ScrollView>
+    </Container>
+  );
+};
+
+const styles = StyleSheet.create({
+  scrollContent: {
+    paddingVertical: layout.spacing,
+    paddingBottom: 40,
+  },
+  title: {
+    color: colors.white,
+    fontSize: 22,
+    fontWeight: '700',
+    marginBottom: 8,
+  },
+  hint: {
+    color: colors.white,
+    opacity: 0.7,
+    fontSize: 14,
+    lineHeight: 20,
+  },
+  section: {
+    color: colors.white,
+    fontSize: 14,
+    fontWeight: '600',
+    marginBottom: 10,
+    opacity: 0.85,
+  },
+  row: {
+    flexDirection: 'row',
+    flexWrap: 'wrap',
+    gap: 8,
+  },
+  chip: {
+    borderWidth: 1,
+    borderColor: colors.border,
+    borderRadius: layout.radius,
+    paddingHorizontal: 12,
+    paddingVertical: 8,
+    marginRight: 8,
+    marginBottom: 8,
+  },
+  chipActive: {
+    backgroundColor: colors.main,
+    borderColor: colors.main,
+  },
+  chipText: {
+    color: colors.white,
+    textTransform: 'capitalize',
+  },
+});
+
+export default PannerNodeExample;
diff --git a/apps/common-app/src/examples/PannerNode/index.tsx b/apps/common-app/src/examples/PannerNode/index.tsx
new file mode 100644
index 000000000..025a11bd0
--- /dev/null
+++ b/apps/common-app/src/examples/PannerNode/index.tsx
@@ -0,0 +1 @@
+export { default } from './PannerNode';
diff --git a/apps/common-app/src/examples/index.ts b/apps/common-app/src/examples/index.ts
index ca0e12773..b976241dc 100644
--- a/apps/common-app/src/examples/index.ts
+++ b/apps/common-app/src/examples/index.ts
@@ -8,6 +8,7 @@ import DrumMachine from './DrumMachine';
 import Metronome from './Metronome';
 import OfflineRendering from './OfflineRendering';
 import Oscillator from './Oscillator';
+import PannerNode from './PannerNode';
 import Piano from './Piano';
 import PlaybackSpeed from './PlaybackSpeed';
 import Record from './Record/Record';
@@ -18,6 +19,7 @@ import ChannelMergerSplitter from './ChannelMergerSplitter';
 
 type NavigationParamList = {
   Oscillator: undefined;
+  PannerNode: undefined;
   Metronome: undefined;
   DrumMachine: undefined;
   Piano: undefined;
@@ -90,6 +92,12 @@ export const Examples: Example[] = [
     Icon: icons.Waves,
     screen: Oscillator,
   },
+  {
+    key: 'PannerNode',
+    title: 'PannerNode',
+    Icon: icons.Move3d,
+    screen: PannerNode,
+  },
   {
     key: 'AudioVisualizer',
     title: 'Audio Visualizer',
diff --git a/apps/fabric-example/ios/Podfile.lock b/apps/fabric-example/ios/Podfile.lock
index 0b311863e..3d20d364a 100644
--- a/apps/fabric-example/ios/Podfile.lock
+++ b/apps/fabric-example/ios/Podfile.lock
@@ -2523,7 +2523,7 @@ EXTERNAL SOURCES:
 
 SPEC CHECKSUMS:
   FBLazyVector: c00c20551d40126351a6783c47ce75f5b374851b
-  hermes-engine: 91023181d4bc5948b457de5314623fbfe4f8604e
+  hermes-engine: fd79291075647a2216de246626b26b8c068f1039
   RCTDeprecation: 3bb167081b134461cfeb875ff7ae1945f8635257
   RCTRequired: 74839f55d5058a133a0bc4569b0afec750957f64
   RCTSwiftUI: 87a316382f3eab4dd13d2a0d0fd2adcce917361a
@@ -2532,7 +2532,7 @@ SPEC CHECKSUMS:
   React: 1b1536b9099195944034e65b1830f463caaa8390
   React-callinvoker: 6dff6d17d1d6cc8fdf85468a649bafed473c65f5
   React-Core: 00faa4d038298089a1d5a5b21dde8660c4f0820d
-  React-Core-prebuilt: a6d614de037caff7898424dfc22915ec792de921
+  React-Core-prebuilt: 6ff532f696eb538a6b1beb5875de609724d9b426
   React-CoreModules: a17807f849bfd86045b0b9a75ec8c19373b482f6
   React-cxxreact: c7b53ace5827be54048288bce5c55f337c41e95f
   React-debug: e1f00fcd2cef58a2897471a6d76a4ef5f5f90c74
@@ -2596,7 +2596,7 @@ SPEC CHECKSUMS:
   ReactAppDependencyProvider: 5787b37b8e2e51dfeab697ec031cc7c4080dcea2
   ReactCodegen: d07ee3c8db75b43d1cbe479ae6affebf9925c733
   ReactCommon: fe2a3af8975e63efa60f95fca8c34dc85deee360
-  ReactNativeDependencies: 4d5ce2683b6d74f7c686bf90a88c7d381295cf3c
+  ReactNativeDependencies: bdd62b51872418996ef6cb305f40de2b1e95b084
   RNAudioAPI: 50957b72cc742b9aa1e05349be71b9db73c9cf74
   RNAudioWorklets: ff0c53fd3c3bbffacb7dd3beb03ffe0ea9f1fd05
   RNGestureHandler: 187c5c7936abf427bc4d22d6c3b1ac80ad1f63c0
diff --git a/packages/audiodocs/docs/core/audio-listener.mdx b/packages/audiodocs/docs/core/audio-listener.mdx
index b9d3ce1db..b0f0f43c7 100644
--- a/packages/audiodocs/docs/core/audio-listener.mdx
+++ b/packages/audiodocs/docs/core/audio-listener.mdx
@@ -53,4 +53,4 @@ All properties are [`AudioParam`](/docs/core/audio-param)s with `minValue`/`maxV
 ## Remarks
 
 - The deprecated Web Audio API methods `setPosition(x, y, z)` and `setOrientation(x, y, z, xUp, yUp, zUp)` are intentionally **not implemented**. Set the corresponding `AudioParam` values directly instead.
-- `PannerNode` — the consumer of these parameters — is not implemented yet, so changing the listener currently has no audible effect. The interface is provided ahead of `PannerNode` support.
+- Used by [`PannerNode`](/docs/effects/panner-node) for 3D spatialization relative to the listener.
diff --git a/packages/audiodocs/docs/core/base-audio-context.mdx b/packages/audiodocs/docs/core/base-audio-context.mdx
index b88969568..87d1b89ac 100644
--- a/packages/audiodocs/docs/core/base-audio-context.mdx
+++ b/packages/audiodocs/docs/core/base-audio-context.mdx
@@ -195,6 +195,12 @@ Creates [`StereoPannerNode`](/docs/effects/stereo-panner-node).
 
 **Returns:** `StereoPannerNode`
 
+### `createPanner`
+
+Creates [`PannerNode`](/docs/effects/panner-node).
+
+**Returns:** `PannerNode`
+
 ### `createWaveShaper`
 
 Creates [`WaveShaperNode`](/docs/effects/wave-shaper-node).
diff --git a/packages/audiodocs/docs/effects/panner-node.mdx b/packages/audiodocs/docs/effects/panner-node.mdx
new file mode 100644
index 000000000..b05444aa4
--- /dev/null
+++ b/packages/audiodocs/docs/effects/panner-node.mdx
@@ -0,0 +1,90 @@
+---
+sidebar_position: 7
+---
+
+import AudioNodePropsTable from "@site/src/components/AudioNodePropsTable"
+import AudioNodeMethodsTable from "@site/src/components/AudioNodeMethodsTable"
+import { Optional, ReadOnly } from '@site/src/components/Badges';
+
+# PannerNode
+
+The [`PannerNode`](https://developer.mozilla.org/en-US/docs/Web/API/PannerNode) interface positions an audio source in 3D space relative to the context's [`AudioListener`](/docs/core/audio-listener).
+
+## Constructor
+
+```tsx
+constructor(context: BaseAudioContext, options?: PannerOptions)
+```
+
+### `PannerOptions`
+
+Inherits all properties from [`AudioNodeOptions`](/docs/core/audio-node#audionodeoptions).
+
+| Parameter | Type | Default | |
+| :---: | :---: | :----: | :---- |
+| `panningModel` <Optional /> | `'equalpower' \| 'HRTF'` | `'equalpower'` | Spatialization algorithm. Native supports `'equalpower'` only; `'HRTF'` throws `NotSupportedError`. |
+| `distanceModel` <Optional /> | `'linear' \| 'inverse' \| 'exponential'` | `'inverse'` | Distance attenuation model. |
+| `positionX` … `positionZ` <Optional /> | `number` | `(0, 0, 0)` | Initial source position. |
+| `orientationX` … `orientationZ` <Optional /> | `number` | `(1, 0, 0)` | Initial source orientation. |
+| `refDistance` <Optional /> | `number` | `1` | Reference distance for attenuation. |
+| `maxDistance` <Optional /> | `number` | `10000` | Maximum distance for the linear model. |
+| `rolloffFactor` <Optional /> | `number` | `1` | Rolloff for distance models. |
+| `coneInnerAngle` / `coneOuterAngle` <Optional /> | `number` | `360` | Directional cone angles (degrees). |
+| `coneOuterGain` <Optional /> | `number` | `0` | Gain outside the outer cone. |
+
+You can also create a `PannerNode` via [`BaseAudioContext.createPanner()`](/docs/core/base-audio-context#createpanner).
+
+## Example
+
+Position a tone to the listener's left. Use headphones to hear the pan clearly. The default listener faces `-Z`.
+
+```tsx
+import { AudioContext } from 'react-native-audio-api';
+
+const ctx = new AudioContext();
+const osc = ctx.createOscillator();
+const panner = ctx.createPanner();
+
+panner.panningModel = 'equalpower';
+panner.positionX.value = -3;
+panner.positionY.value = 0;
+panner.positionZ.value = -1;
+
+osc.connect(panner);
+panner.connect(ctx.destination);
+osc.start();
+```
+
+To move the listener instead of the source, set [`ctx.listener`](/docs/core/audio-listener) position params the same way.
+
+## Properties
+
+Inherits all properties from [`AudioNode`](/docs/core/audio-node#properties).
+
+<AudioNodePropsTable numberOfInputs={1} numberOfOutputs={1} channelCount={2} channelCountMode="clamped-max" channelInterpretation="speakers" />
+
+| Name | Type | Description |
+| :----: | :----: | :-------- |
+| `positionX`, `positionY`, `positionZ` | [`AudioParam`](/docs/core/audio-param) | Source position in 3D space. |
+| `orientationX`, `orientationY`, `orientationZ` | [`AudioParam`](/docs/core/audio-param) | Source orientation vector. |
+| `panningModel` | `PanningModelType` | `'equalpower'` (native). `'HRTF'` throws `NotSupportedError` on native. |
+| `distanceModel` | `DistanceModelType` | `'linear'`, `'inverse'`, or `'exponential'`. |
+| `refDistance`, `maxDistance`, `rolloffFactor` | `number` | Distance model parameters. |
+| `coneInnerAngle`, `coneOuterAngle`, `coneOuterGain` | `number` | Directional cone. |
+
+## Methods
+
+Inherits all methods from [`AudioNode`](/docs/core/audio-node#methods).
+
+<AudioNodeMethodsTable />
+
+| Method | Description |
+| :---- | :-------- |
+| `setPosition(x, y, z)` | Sets `positionX/Y/Z.value` (deprecated in the spec; provided for compatibility). |
+| `setOrientation(x, y, z)` | Sets `orientationX/Y/Z.value`. |
+
+## Remarks
+
+- Output is always stereo (2 channels), like [`StereoPannerNode`](/docs/effects/stereo-panner-node).
+- Spatialization uses the context [`listener`](/docs/core/audio-listener) position and orientation.
+- On native, setting `panningModel` to `'HRTF'` throws `NotSupportedError`. Use `'equalpower'`.
diff --git a/packages/audiodocs/docs/other/web-audio-api-coverage.mdx b/packages/audiodocs/docs/other/web-audio-api-coverage.mdx
index 5a67b75a5..e2b9ff4da 100644
--- a/packages/audiodocs/docs/other/web-audio-api-coverage.mdx
+++ b/packages/audiodocs/docs/other/web-audio-api-coverage.mdx
@@ -45,7 +45,7 @@ We will do our best to ship it as soon as possible!
 | WaveShaperNode | ✅ |
 | AudioContext | 🚧 | Available props and methods: `baseLatency`, `outputLatency`, `close`, `suspend`, `resume` |
 | BaseAudioContext | 🚧 | Available props and methods: `currentTime`, `destination`, `listener`, `sampleRate`, `state`, `decodeAudioData`, all create methods for available or partially implemented nodes |
-| AudioListener | 🚧 | No effect until PannerNode. |
+| AudioListener | ✅ | Used by PannerNode for 3D spatialization, in the equal-power model. |
 | AudioSinkInfo | ❌ |
 | AudioWorklet | ❌ |
 | AudioWorkletGlobalScope | ❌ |
@@ -54,7 +54,7 @@ We will do our best to ship it as soon as possible!
 | DynamicsCompressorNode | ❌ |
 | MediaStreamAudioDestinationNode | ❌ |
 | MediaStreamAudioSourceNode | ❌ |
-| PannerNode | ❌ |
+| PannerNode | 🚧 | Equal-power spatialization, distance models, and cone gain are implemented. `'HRTF'` throws `NotSupportedError` on native (supported on web via the browser). |
 
 ### Description
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioListenerHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioListenerHostObject.h
index ca6bdb00a..479d47056 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioListenerHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioListenerHostObject.h
@@ -36,6 +36,10 @@ class AudioListenerHostObject : public HostObject, public utils::graph::HostNode
   JSI_PROPERTY_GETTER_DECL(upY);
   JSI_PROPERTY_GETTER_DECL(upZ);
 
+  [[nodiscard]] AudioListener *audioListener() const {
+    return listener_.get();
+  }
+
  private:
   std::unique_ptr<AudioListener> listener_;
 
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 e66d8feaf..39e9e2d56 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
@@ -9,6 +9,7 @@
 #include <audioapi/HostObjects/effects/DelayNodeHostObject.h>
 #include <audioapi/HostObjects/effects/GainNodeHostObject.h>
 #include <audioapi/HostObjects/effects/IIRFilterNodeHostObject.h>
+#include <audioapi/HostObjects/effects/PannerNodeHostObject.h>
 #include <audioapi/HostObjects/effects/PeriodicWaveHostObject.h>
 #include <audioapi/HostObjects/effects/StereoPannerNodeHostObject.h>
 #include <audioapi/HostObjects/effects/WaveShaperNodeHostObject.h>
@@ -58,6 +59,7 @@ BaseAudioContextHostObject::BaseAudioContextHostObject(
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createGain),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createDelay),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createStereoPanner),
+      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createPanner),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBiquadFilter),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createIIRFilter),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBufferSource),
@@ -185,6 +187,16 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createStereoPanner) {
   return object;
 }
 
+JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createPanner) {
+  const auto options = args[0].asObject(runtime);
+  const auto pannerOptions = audioapi::option_parser::parsePannerOptions(runtime, options);
+  auto pannerHostObject =
+      std::make_shared<PannerNodeHostObject>(context_, listener_->audioListener(), pannerOptions);
+  auto object = jsi::Object::createFromHostObject(runtime, pannerHostObject);
+  object.setExternalMemoryPressure(runtime, pannerHostObject->getMemoryPressure());
+  return object;
+}
+
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBiquadFilter) {
   const auto options = args[0].asObject(runtime);
   const auto biquadFilterOptions =
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 5457ec121..60d353b72 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,7 @@ class BaseAudioContextHostObject : public HostObject {
   JSI_HOST_FUNCTION_DECL(createConstantSource);
   JSI_HOST_FUNCTION_DECL(createGain);
   JSI_HOST_FUNCTION_DECL(createStereoPanner);
+  JSI_HOST_FUNCTION_DECL(createPanner);
   JSI_HOST_FUNCTION_DECL(createBiquadFilter);
   JSI_HOST_FUNCTION_DECL(createIIRFilter);
   JSI_HOST_FUNCTION_DECL(createBufferSource);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/PannerNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/PannerNodeHostObject.cpp
new file mode 100644
index 000000000..8ae9535a7
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/PannerNodeHostObject.cpp
@@ -0,0 +1,246 @@
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/HostObjects/TypedAudioNodePtr.hpp>
+#include <audioapi/HostObjects/effects/PannerNodeHostObject.h>
+#include <audioapi/HostObjects/utils/JsEnumParser.h>
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/effects/PannerNode.h>
+#include <audioapi/types/NodeOptions.h>
+
+#include <memory>
+#include <utility>
+
+namespace audioapi {
+
+PannerNodeHostObject::PannerNodeHostObject(
+    const std::shared_ptr<BaseAudioContext> &context,
+    AudioListener *listener,
+    const PannerOptions &options)
+    : AudioNodeHostObject(
+          context->getGraph(),
+          std::make_unique<PannerNode>(context, listener, options),
+          options),
+      pannerNode_(typedAudioNode<PannerNode>(node_)),
+      panningModel_(options.panningModel),
+      distanceModel_(options.distanceModel),
+      refDistance_(options.refDistance),
+      maxDistance_(options.maxDistance),
+      rolloffFactor_(options.rolloffFactor),
+      coneInnerAngle_(options.coneInnerAngle),
+      coneOuterAngle_(options.coneOuterAngle),
+      coneOuterGain_(options.coneOuterGain) {
+  positionXParam_ =
+      std::make_shared<AudioParamHostObject>(graph_, node_, pannerNode_->getPositionXParam());
+  positionYParam_ =
+      std::make_shared<AudioParamHostObject>(graph_, node_, pannerNode_->getPositionYParam());
+  positionZParam_ =
+      std::make_shared<AudioParamHostObject>(graph_, node_, pannerNode_->getPositionZParam());
+  orientationXParam_ =
+      std::make_shared<AudioParamHostObject>(graph_, node_, pannerNode_->getOrientationXParam());
+  orientationYParam_ =
+      std::make_shared<AudioParamHostObject>(graph_, node_, pannerNode_->getOrientationYParam());
+  orientationZParam_ =
+      std::make_shared<AudioParamHostObject>(graph_, node_, pannerNode_->getOrientationZParam());
+
+  addGetters(
+      JSI_EXPORT_PROPERTY_GETTER(PannerNodeHostObject, positionX),
+      JSI_EXPORT_PROPERTY_GETTER(PannerNodeHostObject, positionY),
+      JSI_EXPORT_PROPERTY_GETTER(PannerNodeHostObject, positionZ),
+      JSI_EXPORT_PROPERTY_GETTER(PannerNodeHostObject, orientationX),
+      JSI_EXPORT_PROPERTY_GETTER(PannerNodeHostObject, orientationY),
+      JSI_EXPORT_PROPERTY_GETTER(PannerNodeHostObject, orientationZ),
+      JSI_EXPORT_PROPERTY_GETTER(PannerNodeHostObject, panningModel),
+      JSI_EXPORT_PROPERTY_GETTER(PannerNodeHostObject, distanceModel),
+      JSI_EXPORT_PROPERTY_GETTER(PannerNodeHostObject, refDistance),
+      JSI_EXPORT_PROPERTY_GETTER(PannerNodeHostObject, maxDistance),
+      JSI_EXPORT_PROPERTY_GETTER(PannerNodeHostObject, rolloffFactor),
+      JSI_EXPORT_PROPERTY_GETTER(PannerNodeHostObject, coneInnerAngle),
+      JSI_EXPORT_PROPERTY_GETTER(PannerNodeHostObject, coneOuterAngle),
+      JSI_EXPORT_PROPERTY_GETTER(PannerNodeHostObject, coneOuterGain));
+
+  addSetters(
+      JSI_EXPORT_PROPERTY_SETTER(PannerNodeHostObject, panningModel),
+      JSI_EXPORT_PROPERTY_SETTER(PannerNodeHostObject, distanceModel),
+      JSI_EXPORT_PROPERTY_SETTER(PannerNodeHostObject, refDistance),
+      JSI_EXPORT_PROPERTY_SETTER(PannerNodeHostObject, maxDistance),
+      JSI_EXPORT_PROPERTY_SETTER(PannerNodeHostObject, rolloffFactor),
+      JSI_EXPORT_PROPERTY_SETTER(PannerNodeHostObject, coneInnerAngle),
+      JSI_EXPORT_PROPERTY_SETTER(PannerNodeHostObject, coneOuterAngle),
+      JSI_EXPORT_PROPERTY_SETTER(PannerNodeHostObject, coneOuterGain));
+}
+
+JSI_PROPERTY_GETTER_IMPL(PannerNodeHostObject, positionX) {
+  return jsi::Object::createFromHostObject(runtime, positionXParam_);
+}
+
+JSI_PROPERTY_GETTER_IMPL(PannerNodeHostObject, positionY) {
+  return jsi::Object::createFromHostObject(runtime, positionYParam_);
+}
+
+JSI_PROPERTY_GETTER_IMPL(PannerNodeHostObject, positionZ) {
+  return jsi::Object::createFromHostObject(runtime, positionZParam_);
+}
+
+JSI_PROPERTY_GETTER_IMPL(PannerNodeHostObject, orientationX) {
+  return jsi::Object::createFromHostObject(runtime, orientationXParam_);
+}
+
+JSI_PROPERTY_GETTER_IMPL(PannerNodeHostObject, orientationY) {
+  return jsi::Object::createFromHostObject(runtime, orientationYParam_);
+}
+
+JSI_PROPERTY_GETTER_IMPL(PannerNodeHostObject, orientationZ) {
+  return jsi::Object::createFromHostObject(runtime, orientationZParam_);
+}
+
+JSI_PROPERTY_GETTER_IMPL(PannerNodeHostObject, panningModel) {
+  return jsi::String::createFromUtf8(runtime, js_enum_parser::panningModelToString(panningModel_));
+}
+
+JSI_PROPERTY_SETTER_IMPL(PannerNodeHostObject, panningModel) {
+  const auto modelStr = value.toString(runtime).utf8(runtime);
+  if (modelStr == "HRTF") {
+    throw jsi::JSError(
+        runtime, "NotSupportedError: panningModel 'HRTF' is not supported yet; use 'equalpower'");
+  }
+
+  PanningModelType parsedModel;
+  try {
+    parsedModel = js_enum_parser::panningModelFromString(modelStr);
+  } catch (const std::invalid_argument &) {
+    return;
+  }
+  panningModel_ = parsedModel;
+  auto event = [node = pannerNode_, parsedModel](BaseAudioContext &) {
+    node->setPanningModel(parsedModel);
+  };
+  pannerNode_->scheduleAudioEvent(std::move(event));
+}
+
+JSI_PROPERTY_GETTER_IMPL(PannerNodeHostObject, distanceModel) {
+  return jsi::String::createFromUtf8(
+      runtime, js_enum_parser::distanceModelToString(distanceModel_));
+}
+
+JSI_PROPERTY_SETTER_IMPL(PannerNodeHostObject, distanceModel) {
+  DistanceModelType parsedModel;
+  try {
+    parsedModel = js_enum_parser::distanceModelFromString(value.asString(runtime).utf8(runtime));
+  } catch (const std::invalid_argument &) {
+    return;
+  }
+  distanceModel_ = parsedModel;
+  auto event = [node = pannerNode_, parsedModel](BaseAudioContext &) {
+    node->setDistanceModel(parsedModel);
+  };
+  pannerNode_->scheduleAudioEvent(std::move(event));
+}
+
+JSI_PROPERTY_GETTER_IMPL(PannerNodeHostObject, refDistance) {
+  return refDistance_;
+}
+
+JSI_PROPERTY_SETTER_IMPL(PannerNodeHostObject, refDistance) {
+  if (!value.isNumber()) {
+    return;
+  }
+  const double distance = value.getNumber();
+  if (distance < 0.0) {
+    throw jsi::JSError(runtime, "refDistance cannot be set to a negative value");
+  }
+  refDistance_ = distance;
+  auto event = [node = pannerNode_, distance](BaseAudioContext &) {
+    node->setRefDistance(distance);
+  };
+  pannerNode_->scheduleAudioEvent(std::move(event));
+}
+
+JSI_PROPERTY_GETTER_IMPL(PannerNodeHostObject, maxDistance) {
+  return maxDistance_;
+}
+
+JSI_PROPERTY_SETTER_IMPL(PannerNodeHostObject, maxDistance) {
+  if (!value.isNumber()) {
+    return;
+  }
+  const double distance = value.getNumber();
+  if (distance <= 0.0) {
+    throw jsi::JSError(runtime, "maxDistance cannot be set to a non-positive value");
+  }
+  maxDistance_ = distance;
+  auto event = [node = pannerNode_, distance](BaseAudioContext &) {
+    node->setMaxDistance(distance);
+  };
+  pannerNode_->scheduleAudioEvent(std::move(event));
+}
+
+JSI_PROPERTY_GETTER_IMPL(PannerNodeHostObject, rolloffFactor) {
+  return rolloffFactor_;
+}
+
+JSI_PROPERTY_SETTER_IMPL(PannerNodeHostObject, rolloffFactor) {
+  if (!value.isNumber()) {
+    return;
+  }
+  const double factor = value.getNumber();
+  if (factor < 0.0) {
+    throw jsi::JSError(runtime, "rolloffFactor cannot be set to a negative value");
+  }
+  rolloffFactor_ = factor;
+  auto event = [node = pannerNode_, factor](BaseAudioContext &) {
+    node->setRolloffFactor(factor);
+  };
+  pannerNode_->scheduleAudioEvent(std::move(event));
+}
+
+JSI_PROPERTY_GETTER_IMPL(PannerNodeHostObject, coneInnerAngle) {
+  return coneInnerAngle_;
+}
+
+JSI_PROPERTY_SETTER_IMPL(PannerNodeHostObject, coneInnerAngle) {
+  if (!value.isNumber()) {
+    return;
+  }
+  const double angle = value.getNumber();
+  coneInnerAngle_ = angle;
+  auto event = [node = pannerNode_, angle](BaseAudioContext &) {
+    node->setConeInnerAngle(angle);
+  };
+  pannerNode_->scheduleAudioEvent(std::move(event));
+}
+
+JSI_PROPERTY_GETTER_IMPL(PannerNodeHostObject, coneOuterAngle) {
+  return coneOuterAngle_;
+}
+
+JSI_PROPERTY_SETTER_IMPL(PannerNodeHostObject, coneOuterAngle) {
+  if (!value.isNumber()) {
+    return;
+  }
+  const double angle = value.getNumber();
+  coneOuterAngle_ = angle;
+  auto event = [node = pannerNode_, angle](BaseAudioContext &) {
+    node->setConeOuterAngle(angle);
+  };
+  pannerNode_->scheduleAudioEvent(std::move(event));
+}
+
+JSI_PROPERTY_GETTER_IMPL(PannerNodeHostObject, coneOuterGain) {
+  return coneOuterGain_;
+}
+
+JSI_PROPERTY_SETTER_IMPL(PannerNodeHostObject, coneOuterGain) {
+  if (!value.isNumber()) {
+    return;
+  }
+  const double gain = value.getNumber();
+  if (gain < 0.0 || gain > 1.0) {
+    throw jsi::JSError(runtime, "coneOuterGain must be between 0 and 1");
+  }
+  coneOuterGain_ = gain;
+  auto event = [node = pannerNode_, gain](BaseAudioContext &) {
+    node->setConeOuterGain(gain);
+  };
+  pannerNode_->scheduleAudioEvent(std::move(event));
+}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/PannerNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/PannerNodeHostObject.h
new file mode 100644
index 000000000..a8ae9113b
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/PannerNodeHostObject.h
@@ -0,0 +1,71 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/types/NodeOptions.h>
+
+#include <memory>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioListener;
+struct PannerOptions;
+class BaseAudioContext;
+class PannerNode;
+
+class PannerNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit PannerNodeHostObject(
+      const std::shared_ptr<BaseAudioContext> &context,
+      AudioListener *listener,
+      const PannerOptions &options);
+
+  JSI_PROPERTY_GETTER_DECL(positionX);
+  JSI_PROPERTY_GETTER_DECL(positionY);
+  JSI_PROPERTY_GETTER_DECL(positionZ);
+  JSI_PROPERTY_GETTER_DECL(orientationX);
+  JSI_PROPERTY_GETTER_DECL(orientationY);
+  JSI_PROPERTY_GETTER_DECL(orientationZ);
+  JSI_PROPERTY_GETTER_DECL(panningModel);
+  JSI_PROPERTY_SETTER_DECL(panningModel);
+  JSI_PROPERTY_GETTER_DECL(distanceModel);
+  JSI_PROPERTY_SETTER_DECL(distanceModel);
+  JSI_PROPERTY_GETTER_DECL(refDistance);
+  JSI_PROPERTY_SETTER_DECL(refDistance);
+  JSI_PROPERTY_GETTER_DECL(maxDistance);
+  JSI_PROPERTY_SETTER_DECL(maxDistance);
+  JSI_PROPERTY_GETTER_DECL(rolloffFactor);
+  JSI_PROPERTY_SETTER_DECL(rolloffFactor);
+  JSI_PROPERTY_GETTER_DECL(coneInnerAngle);
+  JSI_PROPERTY_SETTER_DECL(coneInnerAngle);
+  JSI_PROPERTY_GETTER_DECL(coneOuterAngle);
+  JSI_PROPERTY_SETTER_DECL(coneOuterAngle);
+  JSI_PROPERTY_GETTER_DECL(coneOuterGain);
+  JSI_PROPERTY_SETTER_DECL(coneOuterGain);
+
+  [[nodiscard]] size_t getMemoryPressure() const override {
+    return AudioNodeHostObject::getMemoryPressure() + 6 * kAudioParamBytes;
+  }
+
+ private:
+  PannerNode *pannerNode_ = nullptr;
+
+  std::shared_ptr<AudioParamHostObject> positionXParam_;
+  std::shared_ptr<AudioParamHostObject> positionYParam_;
+  std::shared_ptr<AudioParamHostObject> positionZParam_;
+  std::shared_ptr<AudioParamHostObject> orientationXParam_;
+  std::shared_ptr<AudioParamHostObject> orientationYParam_;
+  std::shared_ptr<AudioParamHostObject> orientationZParam_;
+
+  PanningModelType panningModel_;
+  DistanceModelType distanceModel_;
+  double refDistance_;
+  double maxDistance_;
+  double rolloffFactor_;
+  double coneInnerAngle_;
+  double coneOuterAngle_;
+  double coneOuterGain_;
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/JsEnumParser.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/JsEnumParser.cpp
index bcfa85d5b..ffc2790f4 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/JsEnumParser.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/JsEnumParser.cpp
@@ -202,6 +202,50 @@ std::string channelInterpretationToString(ChannelInterpretation interpretation)
   }
 }
 
+std::string panningModelToString(PanningModelType model) {
+  switch (model) {
+    case PanningModelType::EqualPower:
+      return "equalpower";
+    case PanningModelType::HRTF:
+      return "HRTF";
+    default:
+      throw std::invalid_argument("Unknown panning model");
+  }
+}
+
+PanningModelType panningModelFromString(const std::string &model) {
+  if (model == "equalpower")
+    return PanningModelType::EqualPower;
+  if (model == "HRTF")
+    return PanningModelType::HRTF;
+
+  throw std::invalid_argument("Invalid panning model: " + model);
+}
+
+std::string distanceModelToString(DistanceModelType model) {
+  switch (model) {
+    case DistanceModelType::Linear:
+      return "linear";
+    case DistanceModelType::Inverse:
+      return "inverse";
+    case DistanceModelType::Exponential:
+      return "exponential";
+    default:
+      throw std::invalid_argument("Unknown distance model");
+  }
+}
+
+DistanceModelType distanceModelFromString(const std::string &model) {
+  if (model == "linear")
+    return DistanceModelType::Linear;
+  if (model == "inverse")
+    return DistanceModelType::Inverse;
+  if (model == "exponential")
+    return DistanceModelType::Exponential;
+
+  throw std::invalid_argument("Invalid distance model: " + model);
+}
+
 ChannelInterpretation channelInterpretationFromString(const std::string &interpretation) {
   if (interpretation == "speakers") {
     return ChannelInterpretation::SPEAKERS;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/JsEnumParser.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/JsEnumParser.h
index d9bb1969d..f70b19070 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/JsEnumParser.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/JsEnumParser.h
@@ -8,6 +8,7 @@
 #include <audioapi/core/types/OscillatorType.h>
 #include <audioapi/core/types/OverSampleType.h>
 #include <audioapi/events/AudioEvent.h>
+#include <audioapi/types/NodeOptions.h>
 #include <string>
 
 namespace audioapi::js_enum_parser {
@@ -22,5 +23,9 @@ std::string contextStateToString(ContextState state);
 std::string channelCountModeToString(ChannelCountMode mode);
 ChannelCountMode channelCountModeFromString(const std::string &mode);
 std::string channelInterpretationToString(ChannelInterpretation interpretation);
+std::string panningModelToString(PanningModelType model);
+PanningModelType panningModelFromString(const std::string &model);
+std::string distanceModelToString(DistanceModelType model);
+DistanceModelType distanceModelFromString(const std::string &model);
 ChannelInterpretation channelInterpretationFromString(const std::string &interpretation);
 } // namespace audioapi::js_enum_parser
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/NodeOptionsParser.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/NodeOptionsParser.h
index 03f7f5c09..bfc73d429 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/NodeOptionsParser.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/NodeOptionsParser.h
@@ -12,6 +12,7 @@
 
 #include <audioapi/HostObjects/effects/PeriodicWaveHostObject.h>
 #include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/HostObjects/utils/JsEnumParser.h>
 #include <audioapi/decoding/AudioDecoding.h>
 #include <audioapi/types/NodeOptions.h>
 #include <audioapi/utils/AudioArray.hpp>
@@ -106,6 +107,83 @@ inline StereoPannerOptions parseStereoPannerOptions(
   return options;
 }
 
+inline PannerOptions parsePannerOptions(jsi::Runtime &runtime, const jsi::Object &optionsObject) {
+  PannerOptions options(parseAudioNodeOptions(runtime, optionsObject));
+
+  auto panningModelValue = optionsObject.getProperty(runtime, "panningModel");
+  if (panningModelValue.isString()) {
+    const auto modelStr = panningModelValue.asString(runtime).utf8(runtime);
+    if (modelStr == "HRTF") {
+      throw jsi::JSError(
+          runtime, "NotSupportedError: panningModel 'HRTF' is not supported yet; use 'equalpower'");
+    }
+    try {
+      options.panningModel = js_enum_parser::panningModelFromString(modelStr);
+    } catch (const std::invalid_argument &) {}
+  }
+
+  auto distanceModelValue = optionsObject.getProperty(runtime, "distanceModel");
+  if (distanceModelValue.isString()) {
+    try {
+      options.distanceModel = js_enum_parser::distanceModelFromString(
+          distanceModelValue.asString(runtime).utf8(runtime));
+    } catch (const std::invalid_argument &) {}
+  }
+
+  auto positionXValue = optionsObject.getProperty(runtime, "positionX");
+  if (positionXValue.isNumber()) {
+    options.positionX = static_cast<float>(positionXValue.getNumber());
+  }
+  auto positionYValue = optionsObject.getProperty(runtime, "positionY");
+  if (positionYValue.isNumber()) {
+    options.positionY = static_cast<float>(positionYValue.getNumber());
+  }
+  auto positionZValue = optionsObject.getProperty(runtime, "positionZ");
+  if (positionZValue.isNumber()) {
+    options.positionZ = static_cast<float>(positionZValue.getNumber());
+  }
+
+  auto orientationXValue = optionsObject.getProperty(runtime, "orientationX");
+  if (orientationXValue.isNumber()) {
+    options.orientationX = static_cast<float>(orientationXValue.getNumber());
+  }
+  auto orientationYValue = optionsObject.getProperty(runtime, "orientationY");
+  if (orientationYValue.isNumber()) {
+    options.orientationY = static_cast<float>(orientationYValue.getNumber());
+  }
+  auto orientationZValue = optionsObject.getProperty(runtime, "orientationZ");
+  if (orientationZValue.isNumber()) {
+    options.orientationZ = static_cast<float>(orientationZValue.getNumber());
+  }
+
+  auto refDistanceValue = optionsObject.getProperty(runtime, "refDistance");
+  if (refDistanceValue.isNumber()) {
+    options.refDistance = refDistanceValue.getNumber();
+  }
+  auto maxDistanceValue = optionsObject.getProperty(runtime, "maxDistance");
+  if (maxDistanceValue.isNumber()) {
+    options.maxDistance = maxDistanceValue.getNumber();
+  }
+  auto rolloffFactorValue = optionsObject.getProperty(runtime, "rolloffFactor");
+  if (rolloffFactorValue.isNumber()) {
+    options.rolloffFactor = rolloffFactorValue.getNumber();
+  }
+  auto coneInnerAngleValue = optionsObject.getProperty(runtime, "coneInnerAngle");
+  if (coneInnerAngleValue.isNumber()) {
+    options.coneInnerAngle = coneInnerAngleValue.getNumber();
+  }
+  auto coneOuterAngleValue = optionsObject.getProperty(runtime, "coneOuterAngle");
+  if (coneOuterAngleValue.isNumber()) {
+    options.coneOuterAngle = coneOuterAngleValue.getNumber();
+  }
+  auto coneOuterGainValue = optionsObject.getProperty(runtime, "coneOuterGain");
+  if (coneOuterGainValue.isNumber()) {
+    options.coneOuterGain = coneOuterGainValue.getNumber();
+  }
+
+  return options;
+}
+
 inline ConvolverOptions parseConvolverOptions(
     jsi::Runtime &runtime,
     const jsi::Object &optionsObject) {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioListener.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioListener.cpp
index 07b7da0da..46ff78649 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioListener.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioListener.cpp
@@ -29,4 +29,25 @@ AudioListener::AudioListener(const std::shared_ptr<BaseAudioContext> &context)
       upXParam_(makeListenerParam(0.0f, context)),
       upYParam_(makeListenerParam(1.0f, context)),
       upZParam_(makeListenerParam(0.0f, context)) {}
+
+void AudioListener::processForQuantum(int framesToProcess, double time, std::size_t sampleFrame) {
+  if (lastProcessedSampleFrame_.has_value() && *lastProcessedSampleFrame_ == sampleFrame) {
+    return;
+  }
+
+  lastProcessedSampleFrame_ = sampleFrame;
+  positionXValues_ =
+      positionXParam_->processARateParam(framesToProcess, time)->getChannel(0)->span();
+  positionYValues_ =
+      positionYParam_->processARateParam(framesToProcess, time)->getChannel(0)->span();
+  positionZValues_ =
+      positionZParam_->processARateParam(framesToProcess, time)->getChannel(0)->span();
+  forwardXValues_ = forwardXParam_->processARateParam(framesToProcess, time)->getChannel(0)->span();
+  forwardYValues_ = forwardYParam_->processARateParam(framesToProcess, time)->getChannel(0)->span();
+  forwardZValues_ = forwardZParam_->processARateParam(framesToProcess, time)->getChannel(0)->span();
+  upXValues_ = upXParam_->processARateParam(framesToProcess, time)->getChannel(0)->span();
+  upYValues_ = upYParam_->processARateParam(framesToProcess, time)->getChannel(0)->span();
+  upZValues_ = upZParam_->processARateParam(framesToProcess, time)->getChannel(0)->span();
+}
+
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioListener.h b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioListener.h
index 29b908cbd..140678b58 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioListener.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioListener.h
@@ -2,7 +2,10 @@
 
 #include <audioapi/core/AudioParam.h>
 
+#include <cstddef>
 #include <memory>
+#include <optional>
+#include <span>
 
 namespace audioapi {
 
@@ -43,6 +46,40 @@ class AudioListener {
     return upZParam_;
   }
 
+  /// @brief Process listener AudioParams once per render quantum.
+  /// Multiple PannerNodes share these params; calling processARateParam from
+  /// each panner would advance automation and zero modulation inputs repeatedly.
+  /// @note Audio-thread only.
+  void processForQuantum(int framesToProcess, double time, std::size_t sampleFrame);
+
+  [[nodiscard]] std::span<const float> positionXValues() const {
+    return positionXValues_;
+  }
+  [[nodiscard]] std::span<const float> positionYValues() const {
+    return positionYValues_;
+  }
+  [[nodiscard]] std::span<const float> positionZValues() const {
+    return positionZValues_;
+  }
+  [[nodiscard]] std::span<const float> forwardXValues() const {
+    return forwardXValues_;
+  }
+  [[nodiscard]] std::span<const float> forwardYValues() const {
+    return forwardYValues_;
+  }
+  [[nodiscard]] std::span<const float> forwardZValues() const {
+    return forwardZValues_;
+  }
+  [[nodiscard]] std::span<const float> upXValues() const {
+    return upXValues_;
+  }
+  [[nodiscard]] std::span<const float> upYValues() const {
+    return upYValues_;
+  }
+  [[nodiscard]] std::span<const float> upZValues() const {
+    return upZValues_;
+  }
+
  private:
   std::shared_ptr<AudioParam> positionXParam_;
   std::shared_ptr<AudioParam> positionYParam_;
@@ -53,6 +90,17 @@ class AudioListener {
   std::shared_ptr<AudioParam> upXParam_;
   std::shared_ptr<AudioParam> upYParam_;
   std::shared_ptr<AudioParam> upZParam_;
+
+  std::optional<std::size_t> lastProcessedSampleFrame_;
+  std::span<const float> positionXValues_;
+  std::span<const float> positionYValues_;
+  std::span<const float> positionZValues_;
+  std::span<const float> forwardXValues_;
+  std::span<const float> forwardYValues_;
+  std::span<const float> forwardZValues_;
+  std::span<const float> upXValues_;
+  std::span<const float> upYValues_;
+  std::span<const float> upZValues_;
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/PannerNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/PannerNode.cpp
new file mode 100644
index 000000000..e5af2779b
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/PannerNode.cpp
@@ -0,0 +1,296 @@
+#include <audioapi/core/AudioListener.h>
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/effects/PannerNode.h>
+#include <audioapi/core/effects/PannerSpatialization.h>
+#include <audioapi/core/utils/Constants.h>
+#include <audioapi/types/NodeOptions.h>
+#include <audioapi/utils/AudioArray.hpp>
+
+#include <memory>
+
+namespace audioapi {
+
+namespace {
+
+using panner::Vec3;
+
+using panner::DEG_180;
+using panner::DEG_270;
+using panner::DEG_360;
+using panner::DEG_450;
+using panner::DEG_90;
+
+} // namespace
+
+PannerNode::PannerNode(
+    const std::shared_ptr<BaseAudioContext> &context,
+    AudioListener *listener,
+    const PannerOptions &options)
+    : AudioNode(context, options),
+      listener_(listener),
+      positionXParam_(
+          std::make_shared<AudioParam>(
+              options.positionX,
+              MOST_NEGATIVE_SINGLE_FLOAT,
+              MOST_POSITIVE_SINGLE_FLOAT,
+              context)),
+      positionYParam_(
+          std::make_shared<AudioParam>(
+              options.positionY,
+              MOST_NEGATIVE_SINGLE_FLOAT,
+              MOST_POSITIVE_SINGLE_FLOAT,
+              context)),
+      positionZParam_(
+          std::make_shared<AudioParam>(
+              options.positionZ,
+              MOST_NEGATIVE_SINGLE_FLOAT,
+              MOST_POSITIVE_SINGLE_FLOAT,
+              context)),
+      orientationXParam_(
+          std::make_shared<AudioParam>(
+              options.orientationX,
+              MOST_NEGATIVE_SINGLE_FLOAT,
+              MOST_POSITIVE_SINGLE_FLOAT,
+              context)),
+      orientationYParam_(
+          std::make_shared<AudioParam>(
+              options.orientationY,
+              MOST_NEGATIVE_SINGLE_FLOAT,
+              MOST_POSITIVE_SINGLE_FLOAT,
+              context)),
+      orientationZParam_(
+          std::make_shared<AudioParam>(
+              options.orientationZ,
+              MOST_NEGATIVE_SINGLE_FLOAT,
+              MOST_POSITIVE_SINGLE_FLOAT,
+              context)),
+      panningModel_(options.panningModel),
+      distanceModel_(options.distanceModel),
+      refDistance_(options.refDistance),
+      maxDistance_(options.maxDistance),
+      rolloffFactor_(options.rolloffFactor),
+      coneInnerAngle_(options.coneInnerAngle),
+      coneOuterAngle_(options.coneOuterAngle),
+      coneOuterGain_(options.coneOuterGain),
+      outputBuffer_(
+          std::make_shared<DSPAudioBuffer>(
+              RENDER_QUANTUM_SIZE,
+              channelCount_,
+              context->getSampleRate())) {}
+
+std::shared_ptr<AudioParam> PannerNode::getPositionXParam() const {
+  return positionXParam_;
+}
+
+std::shared_ptr<AudioParam> PannerNode::getPositionYParam() const {
+  return positionYParam_;
+}
+
+std::shared_ptr<AudioParam> PannerNode::getPositionZParam() const {
+  return positionZParam_;
+}
+
+std::shared_ptr<AudioParam> PannerNode::getOrientationXParam() const {
+  return orientationXParam_;
+}
+
+std::shared_ptr<AudioParam> PannerNode::getOrientationYParam() const {
+  return orientationYParam_;
+}
+
+std::shared_ptr<AudioParam> PannerNode::getOrientationZParam() const {
+  return orientationZParam_;
+}
+
+void PannerNode::setPanningModel(PanningModelType model) {
+  panningModel_ = model;
+}
+
+PanningModelType PannerNode::getPanningModel() const {
+  return panningModel_;
+}
+
+void PannerNode::setDistanceModel(DistanceModelType model) {
+  distanceModel_ = model;
+}
+
+DistanceModelType PannerNode::getDistanceModel() const {
+  return distanceModel_;
+}
+
+void PannerNode::setRefDistance(double distance) {
+  refDistance_ = distance;
+}
+
+double PannerNode::getRefDistance() const {
+  return refDistance_;
+}
+
+void PannerNode::setMaxDistance(double distance) {
+  maxDistance_ = distance;
+}
+
+double PannerNode::getMaxDistance() const {
+  return maxDistance_;
+}
+
+void PannerNode::setRolloffFactor(double factor) {
+  rolloffFactor_ = factor;
+}
+
+double PannerNode::getRolloffFactor() const {
+  return rolloffFactor_;
+}
+
+void PannerNode::setConeInnerAngle(double angle) {
+  coneInnerAngle_ = angle;
+}
+
+double PannerNode::getConeInnerAngle() const {
+  return coneInnerAngle_;
+}
+
+void PannerNode::setConeOuterAngle(double angle) {
+  coneOuterAngle_ = angle;
+}
+
+double PannerNode::getConeOuterAngle() const {
+  return coneOuterAngle_;
+}
+
+void PannerNode::setConeOuterGain(double gain) {
+  coneOuterGain_ = gain;
+}
+
+double PannerNode::getConeOuterGain() const {
+  return coneOuterGain_;
+}
+
+std::shared_ptr<DSPAudioBuffer> PannerNode::getOutputBuffer() const {
+  return outputBuffer_;
+}
+
+std::shared_ptr<DSPAudioBuffer> PannerNode::getNegotiatedBuffer() const {
+  return getInputBuffer();
+}
+
+void PannerNode::setNegotiatedBuffer(const std::shared_ptr<DSPAudioBuffer> &buffer) {
+  audioBuffer_ = buffer;
+}
+
+size_t PannerNode::getUpstreamChannelCount(size_t /*negotiatedChannelCount*/) const {
+  return outputBuffer_->getNumberOfChannels();
+}
+
+void PannerNode::processNode(int framesToProcess) {
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (context == nullptr || audioBuffer_ == nullptr || listener_ == nullptr) {
+    outputBuffer_->zero();
+    return;
+  }
+
+  const double time = context->getCurrentTime();
+  const bool monoInput = audioBuffer_->getNumberOfChannels() == 1;
+
+  listener_->processForQuantum(framesToProcess, time, context->getCurrentSampleFrame());
+
+  const auto posX =
+      positionXParam_->processARateParam(framesToProcess, time)->getChannel(0)->span();
+  const auto posY =
+      positionYParam_->processARateParam(framesToProcess, time)->getChannel(0)->span();
+  const auto posZ =
+      positionZParam_->processARateParam(framesToProcess, time)->getChannel(0)->span();
+  const auto orientX =
+      orientationXParam_->processARateParam(framesToProcess, time)->getChannel(0)->span();
+  const auto orientY =
+      orientationYParam_->processARateParam(framesToProcess, time)->getChannel(0)->span();
+  const auto orientZ =
+      orientationZParam_->processARateParam(framesToProcess, time)->getChannel(0)->span();
+
+  const auto listenerPosX = listener_->positionXValues();
+  const auto listenerPosY = listener_->positionYValues();
+  const auto listenerPosZ = listener_->positionZValues();
+  const auto listenerForwardX = listener_->forwardXValues();
+  const auto listenerForwardY = listener_->forwardYValues();
+  const auto listenerForwardZ = listener_->forwardZValues();
+  const auto listenerUpX = listener_->upXValues();
+  const auto listenerUpY = listener_->upYValues();
+  const auto listenerUpZ = listener_->upZValues();
+
+  auto outputLeft = outputBuffer_->getChannelByType(AudioBuffer::ChannelLeft)->span();
+  auto outputRight = outputBuffer_->getChannelByType(AudioBuffer::ChannelRight)->span();
+
+  auto inputLeftSpan = monoInput ? audioBuffer_->getChannelByType(AudioBuffer::ChannelMono)->span()
+                                 : audioBuffer_->getChannelByType(AudioBuffer::ChannelLeft)->span();
+  auto inputRightSpan =
+      monoInput ? inputLeftSpan : audioBuffer_->getChannelByType(AudioBuffer::ChannelRight)->span();
+
+  // HRTF is not implemented yet — equal-power panning is used for all models.
+  (void)panningModel_;
+
+  for (int i = 0; i < framesToProcess; ++i) {
+    const auto idx = static_cast<size_t>(i);
+    const Vec3 sourcePosition{.x = posX[idx], .y = posY[idx], .z = posZ[idx]};
+    const Vec3 sourceOrientation{.x = orientX[idx], .y = orientY[idx], .z = orientZ[idx]};
+    const Vec3 listenerPosition{
+        .x = listenerPosX[idx], .y = listenerPosY[idx], .z = listenerPosZ[idx]};
+    const Vec3 listenerForward{
+        .x = listenerForwardX[idx], .y = listenerForwardY[idx], .z = listenerForwardZ[idx]};
+    const Vec3 listenerUp{.x = listenerUpX[idx], .y = listenerUpY[idx], .z = listenerUpZ[idx]};
+
+    float azimuth =
+        panner::computeAzimuth(sourcePosition, listenerPosition, listenerForward, listenerUp);
+
+    azimuth = panner::clampAzimuth(azimuth);
+    azimuth = panner::wrapAzimuth(azimuth);
+
+    float x;
+    if (monoInput) {
+      x = (azimuth + DEG_90) / DEG_180;
+    } else {
+      if (azimuth <= 0.0f) {
+        x = (azimuth + DEG_90) / DEG_90;
+      } else {
+        x = azimuth / DEG_90;
+      }
+    }
+
+    float gainL = std::cos(x * PI / 2.0f);
+    float gainR = std::sin(x * PI / 2.0f);
+
+    const float inputL = inputLeftSpan[idx];
+    const float inputR = inputRightSpan[idx];
+
+    const float input = inputL;
+
+    if (monoInput) {
+      outputLeft[idx] = input * gainL;
+      outputRight[idx] = input * gainR;
+    } else {
+      if (azimuth <= 0.0f) {
+        outputLeft[idx] = inputL + inputR * gainL;
+        outputRight[idx] = inputR * gainR;
+      } else {
+        outputLeft[idx] = inputL * gainL;
+        outputRight[idx] = inputR + inputL * gainR;
+      }
+    }
+
+    const float distance = panner::computeDistance(sourcePosition, listenerPosition);
+    const float distanceGain = panner::computeDistanceGain(
+        distanceModel_, distance, refDistance_, maxDistance_, rolloffFactor_);
+    const float coneGain = panner::computeConeGain(
+        sourcePosition,
+        listenerPosition,
+        sourceOrientation,
+        coneInnerAngle_,
+        coneOuterAngle_,
+        coneOuterGain_);
+    const float totalGain = coneGain * distanceGain;
+
+    outputLeft[idx] = totalGain * outputLeft[idx];
+    outputRight[idx] = totalGain * outputRight[idx];
+  }
+}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/PannerNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/PannerNode.h
new file mode 100644
index 000000000..7bbdf8dda
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/PannerNode.h
@@ -0,0 +1,89 @@
+#pragma once
+
+#include <memory>
+
+#include <audioapi/core/AudioNode.h>
+#include <audioapi/core/AudioParam.h>
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/types/NodeOptions.h>
+#include <audioapi/utils/AudioBuffer.hpp>
+
+namespace audioapi {
+
+class AudioListener;
+
+class PannerNode : public AudioNode {
+ public:
+  PannerNode(
+      const std::shared_ptr<BaseAudioContext> &context,
+      AudioListener *listener,
+      const PannerOptions &options);
+
+  ~PannerNode() override = default;
+
+  [[nodiscard]] std::shared_ptr<AudioParam> getPositionXParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParam> getPositionYParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParam> getPositionZParam() const;
+
+  [[nodiscard]] std::shared_ptr<AudioParam> getOrientationXParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParam> getOrientationYParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParam> getOrientationZParam() const;
+
+  void setPanningModel(PanningModelType model);
+  [[nodiscard]] PanningModelType getPanningModel() const;
+
+  void setDistanceModel(DistanceModelType model);
+  [[nodiscard]] DistanceModelType getDistanceModel() const;
+
+  void setRefDistance(double distance);
+  [[nodiscard]] double getRefDistance() const;
+
+  void setMaxDistance(double distance);
+  [[nodiscard]] double getMaxDistance() const;
+
+  void setRolloffFactor(double factor);
+  [[nodiscard]] double getRolloffFactor() const;
+
+  void setConeInnerAngle(double angle);
+  [[nodiscard]] double getConeInnerAngle() const;
+
+  void setConeOuterAngle(double angle);
+  [[nodiscard]] double getConeOuterAngle() const;
+
+  void setConeOuterGain(double gain);
+  [[nodiscard]] double getConeOuterGain() const;
+
+  [[nodiscard]] std::shared_ptr<DSPAudioBuffer> getOutputBuffer() const override;
+  [[nodiscard]] std::shared_ptr<DSPAudioBuffer> getNegotiatedBuffer() const override;
+  void setNegotiatedBuffer(const std::shared_ptr<DSPAudioBuffer> &buffer) override;
+  [[nodiscard]] size_t getUpstreamChannelCount(size_t negotiatedChannelCount) const override;
+
+ protected:
+  void processNode(int framesToProcess) override;
+  [[nodiscard]] const DSPAudioBuffer *getOutput() const override {
+    return outputBuffer_.get();
+  }
+
+ private:
+  AudioListener *listener_ = nullptr;
+
+  const std::shared_ptr<AudioParam> positionXParam_;
+  const std::shared_ptr<AudioParam> positionYParam_;
+  const std::shared_ptr<AudioParam> positionZParam_;
+  const std::shared_ptr<AudioParam> orientationXParam_;
+  const std::shared_ptr<AudioParam> orientationYParam_;
+  const std::shared_ptr<AudioParam> orientationZParam_;
+
+  PanningModelType panningModel_;
+  DistanceModelType distanceModel_;
+  double refDistance_;
+  double maxDistance_;
+  double rolloffFactor_;
+  double coneInnerAngle_;
+  double coneOuterAngle_;
+  double coneOuterGain_;
+
+  const std::shared_ptr<DSPAudioBuffer> outputBuffer_;
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/PannerSpatialization.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/PannerSpatialization.h
new file mode 100644
index 000000000..1d8aaa984
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/PannerSpatialization.h
@@ -0,0 +1,196 @@
+#pragma once
+
+#include <audioapi/core/utils/Constants.h>
+#include <audioapi/types/NodeOptions.h>
+
+#include <algorithm>
+#include <cmath>
+
+namespace audioapi::panner {
+
+constexpr float DEG_90 = 90.0f;
+constexpr float DEG_180 = 180.0f;
+constexpr float DEG_270 = 270.0f;
+constexpr float DEG_360 = 360.0f;
+constexpr float DEG_450 = 450.0f;
+
+struct Vec3 {
+  float x = 0.0f;
+  float y = 0.0f;
+  float z = 0.0f;
+};
+
+inline float dot(const Vec3 &a, const Vec3 &b) {
+  return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+
+inline float magnitude(const Vec3 &v) {
+  return std::sqrt(dot(v, v));
+}
+
+inline Vec3 subtract(const Vec3 &a, const Vec3 &b) {
+  return {.x = a.x - b.x, .y = a.y - b.y, .z = a.z - b.z};
+}
+
+inline Vec3 scale(const Vec3 &v, float s) {
+  return {.x = v.x * s, .y = v.y * s, .z = v.z * s};
+}
+
+inline Vec3 normalize(const Vec3 &v) {
+  const float mag = magnitude(v);
+  if (mag == 0.0f) {
+    return {};
+  }
+  return scale(v, 1.0f / mag);
+}
+
+inline Vec3 cross(const Vec3 &a, const Vec3 &b) {
+  return {
+      .x = a.y * b.z - a.z * b.y,
+      .y = a.z * b.x - a.x * b.z,
+      .z = a.x * b.y - a.y * b.x,
+  };
+}
+
+/// https://www.w3.org/TR/webaudio-1.0/#azimuth-elevation
+/// Elevation calculation is not implemented due to elevation not being used.
+inline float computeAzimuth(
+    const Vec3 &sourcePosition,
+    const Vec3 &listenerPosition,
+    const Vec3 &listenerForward,
+    const Vec3 &listenerUp) {
+
+  Vec3 sourceListener = subtract(sourcePosition, listenerPosition);
+  sourceListener = normalize(sourceListener);
+  if (magnitude(sourceListener) == 0.0f) {
+    return 0.0f;
+  }
+
+  Vec3 listenerRight = cross(listenerForward, listenerUp);
+  if (magnitude(listenerRight) == 0.0f) {
+    return 0.0f;
+  }
+
+  const Vec3 listenerRightNorm = normalize(listenerRight);
+  const Vec3 listenerForwardNorm = normalize(listenerForward);
+  const Vec3 up = cross(listenerRightNorm, listenerForwardNorm);
+
+  const float upProjection = dot(sourceListener, up);
+  Vec3 projectedSource = normalize(subtract(sourceListener, scale(up, upProjection)));
+
+  float azimuth =
+      DEG_180 * std::acos(std::clamp(dot(projectedSource, listenerRightNorm), -1.0f, 1.0f)) / PI;
+
+  const float frontBack = dot(projectedSource, listenerForwardNorm);
+  if (frontBack < 0.0f) {
+    azimuth = DEG_360 - azimuth;
+  }
+
+  if (azimuth >= 0.0f && azimuth <= DEG_270) {
+    azimuth = DEG_90 - azimuth;
+  } else {
+    azimuth = DEG_450 - azimuth;
+  }
+
+  return azimuth;
+}
+
+inline float clampAzimuth(float azimuth) {
+  azimuth = std::max(-1 * DEG_180, azimuth);
+  azimuth = std::min(DEG_180, azimuth);
+
+  return azimuth;
+}
+
+inline float wrapAzimuth(float azimuth) {
+  if (azimuth < -1 * DEG_90) {
+    azimuth = -1 * DEG_180 - azimuth;
+  } else if (azimuth > DEG_90) {
+    azimuth = DEG_180 - azimuth;
+  }
+  return azimuth;
+}
+
+inline float computeDistance(const Vec3 &sourcePosition, const Vec3 &listenerPosition) {
+  return magnitude(subtract(sourcePosition, listenerPosition));
+}
+
+inline float computeDistanceGain(
+    DistanceModelType model,
+    float distance,
+    double refDistance,
+    double maxDistance,
+    double rolloffFactor) {
+  const auto dRef = static_cast<float>(refDistance);
+  const auto dMax = static_cast<float>(maxDistance);
+  auto f = static_cast<float>(rolloffFactor);
+
+  switch (model) {
+    case DistanceModelType::Linear: {
+      const float dRefClamped = std::min(dRef, dMax);
+      const float dMaxClamped = std::max(dRef, dMax);
+
+      distance = std::clamp(distance, dRefClamped, dMaxClamped);
+
+      f = std::clamp(f, 0.0f, 1.0f);
+
+      if (dRefClamped == dMaxClamped) {
+        return 1.0f - f;
+      }
+      return 1.0f - f * (distance - dRefClamped) / (dMaxClamped - dRefClamped);
+    }
+    case DistanceModelType::Inverse: {
+      if (dRef == 0.0f) {
+        return 0.0f;
+      }
+      f = std::max(f, 0.0f);
+      distance = std::max(distance, dRef);
+      return dRef / (dRef + f * (distance - dRef));
+    }
+    case DistanceModelType::Exponential: {
+      if (dRef == 0.0f) {
+        return 0.0f;
+      }
+      f = std::max(f, 0.0f);
+      distance = std::max(distance, dRef);
+      return std::pow(distance / dRef, -f);
+    }
+  }
+  return 1.0f;
+}
+
+inline float computeConeGain(
+    const Vec3 &sourcePosition,
+    const Vec3 &listenerPosition,
+    const Vec3 &sourceOrientation,
+    double coneInnerAngle,
+    double coneOuterAngle,
+    double coneOuterGain) {
+  if (magnitude(sourceOrientation) == 0.0f) {
+    return 1.0f;
+  }
+  if (coneInnerAngle == DEG_360 && coneOuterAngle == DEG_360) {
+    return 1.0f;
+  }
+
+  const Vec3 sourceToListener = normalize(subtract(listenerPosition, sourcePosition));
+  const Vec3 normalizedOrientation = normalize(sourceOrientation);
+
+  const float angle = DEG_180 *
+      std::acos(std::clamp(dot(sourceToListener, normalizedOrientation), -1.0f, 1.0f)) / PI;
+  const float absAngle = std::abs(angle);
+  const auto absInnerAngle = static_cast<float>(std::abs(coneInnerAngle) / 2.0);
+  const auto absOuterAngle = static_cast<float>(std::abs(coneOuterAngle) / 2.0);
+
+  if (absAngle <= absInnerAngle) {
+    return 1.0f;
+  }
+  if (absAngle >= absOuterAngle) {
+    return static_cast<float>(coneOuterGain);
+  }
+
+  const float x = (absAngle - absInnerAngle) / (absOuterAngle - absInnerAngle);
+  return (1.0f - x) + static_cast<float>(coneOuterGain) * x;
+}
+
+} // namespace audioapi::panner
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/types/NodeOptions.h b/packages/react-native-audio-api/common/cpp/audioapi/types/NodeOptions.h
index 11d16717e..06d782149 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/types/NodeOptions.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/types/NodeOptions.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstdint>
 #include <map>
 #include <memory>
 #include <string>
@@ -62,6 +63,45 @@ struct StereoPannerOptions : AudioNodeOptions {
   }
 };
 
+enum class PanningModelType : std::uint8_t { EqualPower, HRTF };
+
+enum class DistanceModelType : std::uint8_t { Inverse, Linear, Exponential };
+
+struct PannerOptions : public AudioNodeOptions {
+  static constexpr double kDefaultRefDistance = 1.0;
+  static constexpr double kDefaultMaxDistance = 10000.0;
+  static constexpr double kDefaultRolloffFactor = 1.0;
+  static constexpr double kDefaultConeAngle = 360.0;
+  static constexpr double kDefaultConeOuterGain = 0.0;
+
+  PanningModelType panningModel = PanningModelType::EqualPower;
+  DistanceModelType distanceModel = DistanceModelType::Inverse;
+
+  float positionX = 0.0f;
+  float positionY = 0.0f;
+  float positionZ = 0.0f;
+
+  float orientationX = 1.0f;
+  float orientationY = 0.0f;
+  float orientationZ = 0.0f;
+
+  double refDistance = kDefaultRefDistance;
+  double maxDistance = kDefaultMaxDistance;
+  double rolloffFactor = kDefaultRolloffFactor;
+
+  double coneInnerAngle = kDefaultConeAngle;
+  double coneOuterAngle = kDefaultConeAngle;
+  double coneOuterGain = kDefaultConeOuterGain;
+
+  PannerOptions() {
+    channelCountMode = ChannelCountMode::CLAMPED_MAX;
+  }
+
+  explicit PannerOptions(const AudioNodeOptions &options) : AudioNodeOptions(options) {
+    channelCountMode = ChannelCountMode::CLAMPED_MAX;
+  }
+};
+
 struct ConvolverOptions : AudioNodeOptions {
   bool disableNormalization = false;
   std::shared_ptr<AudioBuffer> buffer = nullptr;
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/effects/PannerSpatializationTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/effects/PannerSpatializationTest.cpp
new file mode 100644
index 000000000..5af51ef3c
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/effects/PannerSpatializationTest.cpp
@@ -0,0 +1,92 @@
+#include <audioapi/core/effects/PannerSpatialization.h>
+#include <gtest/gtest.h>
+
+using namespace audioapi;
+using namespace audioapi::panner;
+
+TEST(PannerSpatializationTest, WrapAzimuth) {
+  EXPECT_FLOAT_EQ(wrapAzimuth(120.0f), 60.0f);
+  EXPECT_FLOAT_EQ(wrapAzimuth(-120.0f), -60.0f);
+  EXPECT_FLOAT_EQ(wrapAzimuth(90.0f), 90.0f);
+  EXPECT_FLOAT_EQ(wrapAzimuth(-90.0f), -90.0f);
+  EXPECT_FLOAT_EQ(wrapAzimuth(0.0f), 0.0f);
+  EXPECT_FLOAT_EQ(wrapAzimuth(180.0f), 0.0f);
+  EXPECT_FLOAT_EQ(wrapAzimuth(-180.0f), 0.0f);
+}
+
+TEST(PannerSpatializationTest, ClampAzimuth) {
+  EXPECT_FLOAT_EQ(clampAzimuth(200.0f), 180);
+  EXPECT_FLOAT_EQ(clampAzimuth(-200.0f), -1.0f * 180);
+  EXPECT_FLOAT_EQ(clampAzimuth(45.0f), 45.0f);
+}
+
+TEST(PannerSpatializationTest, ComputeAzimuth) {
+  const Vec3 listenerPos{.x = 0.0f, .y = 0.0f, .z = 0.0f};
+  const Vec3 listenerFwd{.x = 0.0f, .y = 0.0f, .z = -1.0f};
+  const Vec3 listenerUp{.x = 0.0f, .y = 1.0f, .z = 0.0f};
+
+  constexpr float TOLERANCE = 1e-4f;
+
+  EXPECT_NEAR(
+      computeAzimuth({0.0f, 0.0f, -1.0f}, listenerPos, listenerFwd, listenerUp), 0.0f, TOLERANCE);
+  EXPECT_NEAR(
+      computeAzimuth({1.0f, 0.0f, 0.0f}, listenerPos, listenerFwd, listenerUp), 90.0f, TOLERANCE);
+  EXPECT_NEAR(
+      computeAzimuth({-1.0f, 0.0f, 0.0f}, listenerPos, listenerFwd, listenerUp), -90.0f, TOLERANCE);
+  EXPECT_NEAR(
+      computeAzimuth({0.0f, 0.0f, 0.0f}, listenerPos, listenerFwd, listenerUp), 0.0f, TOLERANCE);
+  EXPECT_NEAR(
+      computeAzimuth({0.0f, 0.0f, 1.0f}, listenerPos, listenerFwd, listenerUp), -180.0f, TOLERANCE);
+}
+
+TEST(PannerSpatializationTest, ComputeDistance) {
+  EXPECT_FLOAT_EQ(computeDistance({0.0f, 0.0f, 0.0f}, {3.0f, 4.0f, 0.0f}), 5.0f);
+  EXPECT_FLOAT_EQ(computeDistance({1.0f, 1.0f, 1.0f}, {1.0f, 1.0f, 1.0f}), 0.0f);
+}
+
+TEST(PannerSpatializationTest, ComputeDistanceGain) {
+  constexpr double maxDist = 10000.0;
+
+  EXPECT_FLOAT_EQ(computeDistanceGain(DistanceModelType::Inverse, 10.0f, 1.0, maxDist, 1.0), 0.1f);
+
+  EXPECT_FLOAT_EQ(computeDistanceGain(DistanceModelType::Inverse, 10.0f, 0.0, maxDist, 1.0), 0.0f);
+
+  EXPECT_FLOAT_EQ(computeDistanceGain(DistanceModelType::Linear, 5.0f, 1.0, 9.0, 1.0), 0.5f);
+
+  EXPECT_FLOAT_EQ(
+      computeDistanceGain(DistanceModelType::Exponential, 2.0f, 1.0, maxDist, 1.0), 0.5f);
+}
+
+TEST(PannerSpatializationTest, ComputeConeGain) {
+  const Vec3 listenerPos{.x = 0.0f, .y = 0.0f, .z = 0.0f};
+  const Vec3 sourcePos{.x = 0.0f, .y = 0.0f, .z = -1.0f};
+
+  constexpr float SILENCE = 0.0f;
+  constexpr float FULL_GAIN = 1.0f;
+
+  // 360/360 cone angles act as a bypass (omnidirectional) => fully audible
+  const Vec3 orientationRight{.x = 1.0f, .y = 0.0f, .z = 0.0f};
+  EXPECT_FLOAT_EQ(
+      computeConeGain(sourcePos, listenerPos, orientationRight, 360.0, 360.0, 0.0), FULL_GAIN);
+
+  // Source is facing front, listener in the inner angle => fully audible
+  const Vec3 orientationFront{.x = 0.0f, .y = 0.0f, .z = 1.0f};
+  EXPECT_FLOAT_EQ(
+      computeConeGain(sourcePos, listenerPos, orientationFront, 60.0, 90.0, 0.0), FULL_GAIN);
+
+  // Source is facing back, listener outside the outer angle => silent
+  const Vec3 orientationBack{.x = 0.0f, .y = 0.0f, .z = -1.0f};
+  EXPECT_FLOAT_EQ(
+      computeConeGain(sourcePos, listenerPos, orientationBack, 60.0, 90.0, 0.0), SILENCE);
+
+  // Interpolation gain equal to 0.5. Angle is 37.5 degrees from the listener.
+  const float angle = 37.5f * PI / DEG_180;
+  Vec3 orientationLerp{.x = std::sin(angle), .y = 0.0f, .z = std::cos(angle)};
+  constexpr float TOLERANCE = 1e-5f;
+  EXPECT_NEAR(
+      computeConeGain(sourcePos, listenerPos, orientationLerp, 60.0, 90.0, 0.0), 0.5f, TOLERANCE);
+
+  const Vec3 orientationZero{.x = 0.0f, .y = 0.0f, .z = 0.0f};
+  EXPECT_FLOAT_EQ(
+      computeConeGain(sourcePos, listenerPos, orientationZero, 60.0, 90.0, 0.0), FULL_GAIN);
+}
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/effects/PannerTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/effects/PannerTest.cpp
new file mode 100644
index 000000000..4c1dd2ccd
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/effects/PannerTest.cpp
@@ -0,0 +1,358 @@
+#include <audioapi/core/AudioListener.h>
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/destinations/AudioDestinationNode.h>
+#include <audioapi/core/effects/PannerNode.h>
+#include <audioapi/core/effects/PannerSpatialization.h>
+#include <audioapi/types/NodeOptions.h>
+#include <audioapi/utils/AudioBuffer.hpp>
+#include <gtest/gtest.h>
+#include <test/src/MockAudioEventHandlerRegistry.h>
+
+#include <memory>
+
+using namespace audioapi;
+using namespace audioapi::panner;
+
+// NOLINTBEGIN
+
+class PannerTest : public ::testing::Test {
+ protected:
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
+  std::shared_ptr<OfflineAudioContext> context;
+  std::shared_ptr<AudioDestinationNode> destination;
+  std::shared_ptr<AudioListener> listener;
+  static constexpr int sampleRate = 44100;
+
+  void SetUp() override {
+    eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
+    context = std::make_shared<OfflineAudioContext>(2, 5 * sampleRate, sampleRate, eventRegistry);
+    destination = std::make_shared<AudioDestinationNode>(context);
+    context->initialize(destination.get());
+    listener = std::make_shared<AudioListener>(context);
+  }
+};
+
+class TestablePannerNode : public PannerNode {
+ public:
+  TestablePannerNode(const std::shared_ptr<BaseAudioContext> &context, AudioListener *listener)
+      : PannerNode(context, listener, PannerOptions()) {}
+
+  void setInputBuffer(const std::shared_ptr<DSPAudioBuffer> &input) {
+    audioBuffer_ = input;
+  }
+
+  using PannerNode::processNode;
+};
+
+TEST_F(PannerTest, PannerCanBeCreated) {
+  auto panner = std::make_shared<PannerNode>(context, listener.get(), PannerOptions());
+  ASSERT_NE(panner, nullptr);
+}
+
+struct PannerTestParams {
+  Vec3 sourcePosition;
+  Vec3 sourceOrientation;
+  Vec3 listenerPosition;
+  Vec3 listenerForward;
+  Vec3 listenerUp;
+  float expectedGainL;
+  float expectedGainR;
+};
+
+class PannerMonoParametrizedTest : public PannerTest,
+                                   public testing::WithParamInterface<PannerTestParams> {};
+
+TEST_P(PannerMonoParametrizedTest, PanModulatesInputMonoCorrectly) {
+  const PannerTestParams &params = GetParam();
+
+  static constexpr int FRAMES_TO_PROCESS = 4;
+  TestablePannerNode panNode(context, listener.get());
+
+  listener->getPositionXParam()->setValue(params.listenerPosition.x);
+  listener->getPositionYParam()->setValue(params.listenerPosition.y);
+  listener->getPositionZParam()->setValue(params.listenerPosition.z);
+
+  listener->getForwardXParam()->setValue(params.listenerForward.x);
+  listener->getForwardYParam()->setValue(params.listenerForward.y);
+  listener->getForwardZParam()->setValue(params.listenerForward.z);
+
+  listener->getUpXParam()->setValue(params.listenerUp.x);
+  listener->getUpYParam()->setValue(params.listenerUp.y);
+  listener->getUpZParam()->setValue(params.listenerUp.z);
+
+  panNode.getPositionXParam()->setValue(params.sourcePosition.x);
+  panNode.getPositionYParam()->setValue(params.sourcePosition.y);
+  panNode.getPositionZParam()->setValue(params.sourcePosition.z);
+
+  panNode.getOrientationXParam()->setValue(params.sourceOrientation.x);
+  panNode.getOrientationYParam()->setValue(params.sourceOrientation.y);
+  panNode.getOrientationZParam()->setValue(params.sourceOrientation.z);
+
+  auto monoInputBuffer = std::make_shared<DSPAudioBuffer>(FRAMES_TO_PROCESS, 1, sampleRate);
+
+  for (size_t i = 0; i < monoInputBuffer->getSize(); ++i) {
+    (*monoInputBuffer->getChannelByType(AudioBuffer::ChannelMono))[i] = i + 1;
+  }
+
+  panNode.setInputBuffer(monoInputBuffer);
+  panNode.processNode(FRAMES_TO_PROCESS);
+
+  auto resultBuffer = panNode.getOutputBuffer();
+
+  const float distance = panner::computeDistance(params.sourcePosition, params.listenerPosition);
+  const float distanceGain = panner::computeDistanceGain(
+      panNode.getDistanceModel(),
+      distance,
+      panNode.getRefDistance(),
+      panNode.getMaxDistance(),
+      panNode.getRolloffFactor());
+  const float coneGain = panner::computeConeGain(
+      params.sourcePosition,
+      params.listenerPosition,
+      params.sourceOrientation,
+      panNode.getConeInnerAngle(),
+      panNode.getConeOuterAngle(),
+      panNode.getConeOuterGain());
+  const float totalGain = distanceGain * coneGain;
+
+  constexpr float TOLERANCE = 1e-5f;
+
+  for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
+    EXPECT_NEAR(
+        (*resultBuffer->getChannelByType(AudioBuffer::ChannelLeft))[i],
+        (i + 1) * params.expectedGainL * totalGain,
+        TOLERANCE);
+    EXPECT_NEAR(
+        (*resultBuffer->getChannelByType(AudioBuffer::ChannelRight))[i],
+        (i + 1) * params.expectedGainR * totalGain,
+        TOLERANCE);
+  }
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    PanModulatesInputMonoCorrectly,
+    PannerMonoParametrizedTest,
+    testing::Values(
+        PannerTestParams{
+            {1.0f, 0.0f, 0.0f},
+            {1.0f, 0.0f, 0.0f},
+            {0.0f, 0.0f, 0.0f},
+            {0.0f, 0.0f, -1.0f},
+            {0.0f, 1.0f, 0.0f},
+            0.0f,
+            1.0f},
+
+        PannerTestParams{
+            {0.0f, 0.0f, -1.0f},
+            {1.0f, 0.0f, 0.0f},
+            {0.0f, 0.0f, 0.0f},
+            {0.0f, 0.0f, -1.0f},
+            {0.0f, 1.0f, 0.0f},
+            0.707107f,
+            0.707107f},
+
+        PannerTestParams{
+            {-1.0f, 0.0f, 0.0f},
+            {1.0f, 0.0f, 0.0f},
+            {0.0f, 0.0f, 0.0f},
+            {0.0f, 0.0f, -1.0f},
+            {0.0f, 1.0f, 0.0f},
+            1.0f,
+            0.0f}));
+
+class PannerStereoParametrizedTest : public PannerTest,
+                                     public testing::WithParamInterface<PannerTestParams> {};
+
+TEST_P(PannerStereoParametrizedTest, PanModulatesInputStereoCorrectly) {
+  const PannerTestParams &params = GetParam();
+
+  static constexpr int FRAMES_TO_PROCESS = 4;
+  TestablePannerNode panNode(context, listener.get());
+
+  listener->getPositionXParam()->setValue(params.listenerPosition.x);
+  listener->getPositionYParam()->setValue(params.listenerPosition.y);
+  listener->getPositionZParam()->setValue(params.listenerPosition.z);
+
+  listener->getForwardXParam()->setValue(params.listenerForward.x);
+  listener->getForwardYParam()->setValue(params.listenerForward.y);
+  listener->getForwardZParam()->setValue(params.listenerForward.z);
+
+  listener->getUpXParam()->setValue(params.listenerUp.x);
+  listener->getUpYParam()->setValue(params.listenerUp.y);
+  listener->getUpZParam()->setValue(params.listenerUp.z);
+
+  panNode.getPositionXParam()->setValue(params.sourcePosition.x);
+  panNode.getPositionYParam()->setValue(params.sourcePosition.y);
+  panNode.getPositionZParam()->setValue(params.sourcePosition.z);
+
+  panNode.getOrientationXParam()->setValue(params.sourceOrientation.x);
+  panNode.getOrientationYParam()->setValue(params.sourceOrientation.y);
+  panNode.getOrientationZParam()->setValue(params.sourceOrientation.z);
+
+  auto inputBuffer = std::make_shared<DSPAudioBuffer>(FRAMES_TO_PROCESS, 2, sampleRate);
+  for (size_t i = 0; i < inputBuffer->getSize(); ++i) {
+    (*inputBuffer->getChannelByType(AudioBuffer::ChannelLeft))[i] = i + 1;
+    (*inputBuffer->getChannelByType(AudioBuffer::ChannelRight))[i] = i + 1;
+  }
+  const auto inputLeftSpan = inputBuffer->getChannelByType(AudioBuffer::ChannelLeft)->span();
+  const auto inputRightSpan = inputBuffer->getChannelByType(AudioBuffer::ChannelRight)->span();
+
+  panNode.setInputBuffer(inputBuffer);
+  panNode.processNode(FRAMES_TO_PROCESS);
+
+  auto resultBuffer = panNode.getOutputBuffer();
+
+  float azimuth = panner::computeAzimuth(
+      params.sourcePosition, params.listenerPosition, params.listenerForward, params.listenerUp);
+  azimuth = panner::clampAzimuth(azimuth);
+  azimuth = panner::wrapAzimuth(azimuth);
+
+  const float distance = panner::computeDistance(params.sourcePosition, params.listenerPosition);
+  const float distanceGain = panner::computeDistanceGain(
+      panNode.getDistanceModel(),
+      distance,
+      panNode.getRefDistance(),
+      panNode.getMaxDistance(),
+      panNode.getRolloffFactor());
+  const float coneGain = panner::computeConeGain(
+      params.sourcePosition,
+      params.listenerPosition,
+      params.sourceOrientation,
+      panNode.getConeInnerAngle(),
+      panNode.getConeOuterAngle(),
+      panNode.getConeOuterGain());
+  const float totalGain = distanceGain * coneGain;
+
+  constexpr float TOLERANCE = 1e-5f;
+
+  for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
+    if (azimuth <= 0) {
+      EXPECT_NEAR(
+          (*resultBuffer->getChannelByType(AudioBuffer::ChannelLeft))[i],
+          ((i + 1) + (i + 1) * params.expectedGainL) * totalGain,
+          TOLERANCE);
+      EXPECT_NEAR(
+          (*resultBuffer->getChannelByType(AudioBuffer::ChannelRight))[i],
+          ((i + 1) * params.expectedGainR) * totalGain,
+          TOLERANCE);
+    } else {
+      EXPECT_NEAR(
+          (*resultBuffer->getChannelByType(AudioBuffer::ChannelLeft))[i],
+          ((i + 1) * params.expectedGainL) * totalGain,
+          TOLERANCE);
+      EXPECT_NEAR(
+          (*resultBuffer->getChannelByType(AudioBuffer::ChannelRight))[i],
+          ((i + 1) + (i + 1) * params.expectedGainR) * totalGain,
+          TOLERANCE);
+    }
+  }
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    StereoPanningPositions,
+    PannerStereoParametrizedTest,
+    testing::Values(
+        PannerTestParams{
+            {1.0f, 0.0f, 0.0f},
+            {1.0f, 0.0f, 0.0f},
+            {0.0f, 0.0f, 0.0f},
+            {0.0f, 0.0f, -1.0f},
+            {0.0f, 1.0f, 0.0f},
+            0.0f,
+            1.0f},
+        PannerTestParams{
+            {0.0f, 0.0f, -1.0f},
+            {1.0f, 0.0f, 0.0f},
+            {0.0f, 0.0f, 0.0f},
+            {0.0f, 0.0f, -1.0f},
+            {0.0f, 1.0f, 0.0f},
+            0.0f,
+            1.0f},
+        PannerTestParams{
+            {-1.0f, 0.0f, 0.0f},
+            {1.0f, 0.0f, 0.0f},
+            {0.0f, 0.0f, 0.0f},
+            {0.0f, 0.0f, -1.0f},
+            {0.0f, 1.0f, 0.0f},
+            1.0f,
+            0.0f}));
+
+TEST_F(PannerTest, PositionXAudioRateProcessing) {
+  static constexpr int FRAMES_TO_PROCESS = 4;
+  TestablePannerNode panNode(context, listener.get());
+
+  auto monoInputBuffer = std::make_shared<DSPAudioBuffer>(FRAMES_TO_PROCESS, 1, sampleRate);
+  for (size_t i = 0; i < monoInputBuffer->getSize(); ++i) {
+    (*monoInputBuffer->getChannelByType(AudioBuffer::ChannelMono))[i] = 1.0f;
+  }
+
+  // Test only the change in positionX parameter
+  panNode.setRolloffFactor(0.0f);
+  panNode.getPositionZParam()->setValue(-1.0f);
+
+  panNode.setInputBuffer(monoInputBuffer);
+
+  auto posXparam = panNode.getPositionXParam();
+  const double startTime = context->getCurrentTime();
+  const double endTime = startTime + (static_cast<double>(FRAMES_TO_PROCESS) / sampleRate);
+
+  posXparam->setValueAtTime(-1.0f, startTime);
+  posXparam->linearRampToValueAtTime(1.0f, endTime);
+
+  panNode.processNode(FRAMES_TO_PROCESS);
+
+  auto resultBuffer = panNode.getOutputBuffer();
+  const auto outLeft = resultBuffer->getChannelByType(AudioBuffer::ChannelLeft)->span();
+  const auto outRight = resultBuffer->getChannelByType(AudioBuffer::ChannelRight)->span();
+
+  EXPECT_GT(outLeft[0], outLeft[1]);
+  EXPECT_GT(outLeft[1], outLeft[2]);
+  EXPECT_GT(outLeft[2], outLeft[3]);
+
+  EXPECT_LT(outRight[0], outRight[1]);
+  EXPECT_LT(outRight[1], outRight[2]);
+  EXPECT_LT(outRight[2], outRight[3]);
+}
+
+TEST_F(PannerTest, ConeAngles) {
+  static constexpr int FRAMES_TO_PROCESS = 4;
+  TestablePannerNode panNode(context, listener.get());
+  panNode.setConeInnerAngle(60);
+  panNode.setConeOuterAngle(90);
+  panNode.setConeOuterGain(0.0f);
+
+  auto monoInputBuffer = std::make_shared<DSPAudioBuffer>(FRAMES_TO_PROCESS, 1, sampleRate);
+  for (size_t i = 0; i < monoInputBuffer->getSize(); ++i) {
+    (*monoInputBuffer->getChannelByType(AudioBuffer::ChannelMono))[i] = 1.0f;
+  }
+
+  panNode.setInputBuffer(monoInputBuffer);
+
+  constexpr float POSITION_Z_INFRONT = -1.0f;
+  // The source is facing backwards, sound should not be heard by the listener
+  constexpr float ORIENTATION_Z_BEHIND = -1.0f;
+  panNode.getPositionZParam()->setValue(POSITION_Z_INFRONT);
+  panNode.getOrientationXParam()->setValue(0.0f);
+  panNode.getOrientationYParam()->setValue(0.0f);
+  panNode.getOrientationZParam()->setValue(ORIENTATION_Z_BEHIND);
+
+  panNode.processNode(FRAMES_TO_PROCESS);
+
+  auto resultBuffer = panNode.getOutputBuffer();
+
+  constexpr float TOLERANCE = 1e-5f;
+  constexpr float EXPECTED_SILENCE = 0.0f;
+
+  for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
+    EXPECT_NEAR(
+        (*resultBuffer->getChannelByType(AudioBuffer::ChannelLeft))[i],
+        EXPECTED_SILENCE,
+        TOLERANCE);
+    EXPECT_NEAR(
+        (*resultBuffer->getChannelByType(AudioBuffer::ChannelRight))[i],
+        EXPECTED_SILENCE,
+        TOLERANCE);
+  }
+}
+
+// NOLINTEND
diff --git a/packages/react-native-audio-api/src/api.ts b/packages/react-native-audio-api/src/api.ts
index 5aa212b3b..a7bc4be9e 100644
--- a/packages/react-native-audio-api/src/api.ts
+++ b/packages/react-native-audio-api/src/api.ts
@@ -27,6 +27,7 @@ export { default as OfflineAudioContext } from './core/OfflineAudioContext';
 export { default as OscillatorNode } from './core/OscillatorNode';
 export { default as PeriodicWave } from './core/PeriodicWave';
 export { default as StereoPannerNode } from './core/StereoPannerNode';
+export { default as PannerNode } from './core/PannerNode';
 export { default as WaveShaperNode } from './core/WaveShaperNode';
 
 export * from './errors';
diff --git a/packages/react-native-audio-api/src/api.web.ts b/packages/react-native-audio-api/src/api.web.ts
index c334ba3aa..d9436cc67 100644
--- a/packages/react-native-audio-api/src/api.web.ts
+++ b/packages/react-native-audio-api/src/api.web.ts
@@ -18,6 +18,7 @@ export { default as MediaElementAudioSourceNode } from './web-core/MediaElementA
 export type { MediaElementAudioSourceOptions } from './web-core/MediaElementAudioSourceNode.web';
 export { default as OscillatorNode } from './web-core/OscillatorNode.web';
 export { default as StereoPannerNode } from './web-core/StereoPannerNode.web';
+export { default as PannerNode } from './web-core/PannerNode.web';
 export { default as ConstantSourceNode } from './web-core/ConstantSourceNode.web';
 export { default as ConvolverNode } from './web-core/ConvolverNode.web';
 export { default as PeriodicWave } from './web-core/PeriodicWave.web';
diff --git a/packages/react-native-audio-api/src/core/BaseAudioContext.ts b/packages/react-native-audio-api/src/core/BaseAudioContext.ts
index d47251a11..e84d656c6 100644
--- a/packages/react-native-audio-api/src/core/BaseAudioContext.ts
+++ b/packages/react-native-audio-api/src/core/BaseAudioContext.ts
@@ -4,6 +4,7 @@ import {
   ContextState,
   DecodeDataInput,
   AudioBufferQueueSourceOptions,
+  PannerOptions,
 } from '../types';
 import AnalyserNode from './AnalyserNode';
 import AudioBuffer from './AudioBuffer';
@@ -23,6 +24,7 @@ import IIRFilterNode from './IIRFilterNode';
 import OscillatorNode from './OscillatorNode';
 import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
+import PannerNode from './PannerNode';
 import WaveShaperNode from './WaveShaperNode';
 
 export default class BaseAudioContext {
@@ -91,6 +93,10 @@ export default class BaseAudioContext {
     return new StereoPannerNode(this);
   }
 
+  createPanner(options?: PannerOptions): PannerNode {
+    return new PannerNode(this, options);
+  }
+
   createBiquadFilter(): BiquadFilterNode {
     return new BiquadFilterNode(this);
   }
diff --git a/packages/react-native-audio-api/src/core/PannerNode.ts b/packages/react-native-audio-api/src/core/PannerNode.ts
new file mode 100644
index 000000000..9c9814af1
--- /dev/null
+++ b/packages/react-native-audio-api/src/core/PannerNode.ts
@@ -0,0 +1,121 @@
+import { IPannerNode } from '../jsi-interfaces';
+import { DistanceModelType, PannerOptions, PanningModelType } from '../types';
+import { InvalidStateError, NotSupportedError, RangeError } from '../errors';
+import { PannerOptionsValidator } from '../utils/validation';
+import AudioNode from './AudioNode';
+import AudioParam from './AudioParam';
+import type BaseAudioContext from './BaseAudioContext';
+
+export default class PannerNode extends AudioNode {
+  readonly positionX: AudioParam;
+  readonly positionY: AudioParam;
+  readonly positionZ: AudioParam;
+  readonly orientationX: AudioParam;
+  readonly orientationY: AudioParam;
+  readonly orientationZ: AudioParam;
+
+  constructor(context: BaseAudioContext, options?: PannerOptions) {
+    PannerOptionsValidator.validate(options);
+    const panner: IPannerNode = context.context.createPanner(options || {});
+    super(context, panner);
+    this.positionX = new AudioParam(panner.positionX, context, this);
+    this.positionY = new AudioParam(panner.positionY, context, this);
+    this.positionZ = new AudioParam(panner.positionZ, context, this);
+    this.orientationX = new AudioParam(panner.orientationX, context, this);
+    this.orientationY = new AudioParam(panner.orientationY, context, this);
+    this.orientationZ = new AudioParam(panner.orientationZ, context, this);
+  }
+
+  public get panningModel(): PanningModelType {
+    return (this.node as IPannerNode).panningModel;
+  }
+
+  public set panningModel(value: PanningModelType) {
+    if (value === 'HRTF') {
+      throw new NotSupportedError(
+        "panningModel 'HRTF' is not supported yet; use 'equalpower'"
+      );
+    }
+    (this.node as IPannerNode).panningModel = value;
+  }
+
+  public get distanceModel(): DistanceModelType {
+    return (this.node as IPannerNode).distanceModel;
+  }
+
+  public set distanceModel(value: DistanceModelType) {
+    (this.node as IPannerNode).distanceModel = value;
+  }
+
+  public get refDistance(): number {
+    return (this.node as IPannerNode).refDistance;
+  }
+
+  public set refDistance(value: number) {
+    if (value < 0) {
+      throw new RangeError('refDistance must be non-negative');
+    }
+    (this.node as IPannerNode).refDistance = value;
+  }
+
+  public get maxDistance(): number {
+    return (this.node as IPannerNode).maxDistance;
+  }
+
+  public set maxDistance(value: number) {
+    if (value <= 0) {
+      throw new RangeError('maxDistance must be positive');
+    }
+    (this.node as IPannerNode).maxDistance = value;
+  }
+
+  public get rolloffFactor(): number {
+    return (this.node as IPannerNode).rolloffFactor;
+  }
+
+  public set rolloffFactor(value: number) {
+    if (value < 0) {
+      throw new RangeError('rolloffFactor must be non-negative');
+    }
+    (this.node as IPannerNode).rolloffFactor = value;
+  }
+
+  public get coneInnerAngle(): number {
+    return (this.node as IPannerNode).coneInnerAngle;
+  }
+
+  public set coneInnerAngle(value: number) {
+    (this.node as IPannerNode).coneInnerAngle = value;
+  }
+
+  public get coneOuterAngle(): number {
+    return (this.node as IPannerNode).coneOuterAngle;
+  }
+
+  public set coneOuterAngle(value: number) {
+    (this.node as IPannerNode).coneOuterAngle = value;
+  }
+
+  public get coneOuterGain(): number {
+    return (this.node as IPannerNode).coneOuterGain;
+  }
+
+  public set coneOuterGain(value: number) {
+    if (value < 0 || value > 1) {
+      throw new InvalidStateError('coneOuterGain must be between 0 and 1');
+    }
+    (this.node as IPannerNode).coneOuterGain = value;
+  }
+
+  public setPosition(x: number, y: number, z: number): void {
+    this.positionX.value = x;
+    this.positionY.value = y;
+    this.positionZ.value = z;
+  }
+
+  public setOrientation(x: number, y: number, z: number): void {
+    this.orientationX.value = x;
+    this.orientationY.value = y;
+    this.orientationZ.value = z;
+  }
+}
diff --git a/packages/react-native-audio-api/src/jsi-interfaces.ts b/packages/react-native-audio-api/src/jsi-interfaces.ts
index 6fb1e6d05..42136198c 100644
--- a/packages/react-native-audio-api/src/jsi-interfaces.ts
+++ b/packages/react-native-audio-api/src/jsi-interfaces.ts
@@ -24,6 +24,9 @@ import type {
   OverSampleType,
   Result,
   StereoPannerOptions,
+  PannerOptions,
+  PanningModelType,
+  DistanceModelType,
   WaveShaperOptions,
   AudioFileSourceOptions,
 } from './types';
@@ -54,6 +57,7 @@ export interface IBaseAudioContext {
   createStereoPanner(
     stereoPannerOptions: StereoPannerOptions
   ): IStereoPannerNode;
+  createPanner(pannerOptions: PannerOptions): IPannerNode;
   createBiquadFilter: (
     biquadFilterOptions: BiquadFilterOptions
   ) => IBiquadFilterNode;
@@ -138,6 +142,23 @@ export interface IStereoPannerNode extends IAudioNode {
   readonly pan: IAudioParam;
 }
 
+export interface IPannerNode extends IAudioNode {
+  readonly positionX: IAudioParam;
+  readonly positionY: IAudioParam;
+  readonly positionZ: IAudioParam;
+  readonly orientationX: IAudioParam;
+  readonly orientationY: IAudioParam;
+  readonly orientationZ: IAudioParam;
+  panningModel: PanningModelType;
+  distanceModel: DistanceModelType;
+  refDistance: number;
+  maxDistance: number;
+  rolloffFactor: number;
+  coneInnerAngle: number;
+  coneOuterAngle: number;
+  coneOuterGain: number;
+}
+
 export interface IBiquadFilterNode extends IAudioNode {
   readonly frequency: IAudioParam;
   readonly detune: IAudioParam;
diff --git a/packages/react-native-audio-api/src/mock/index.ts b/packages/react-native-audio-api/src/mock/index.ts
index 7b85feed3..2ef84d273 100644
--- a/packages/react-native-audio-api/src/mock/index.ts
+++ b/packages/react-native-audio-api/src/mock/index.ts
@@ -29,6 +29,9 @@ import {
   OscillatorOptions,
   PeriodicWaveOptions,
   StereoPannerOptions,
+  PannerOptions,
+  PanningModelType,
+  DistanceModelType,
   WaveShaperOptions,
 } from '../types';
 import { toFloat32Array } from '../utils';
@@ -500,6 +503,163 @@ class StereoPannerNodeMock extends AudioNodeMock {
   }
 }
 
+class PannerNodeMock extends AudioNodeMock {
+  readonly positionX: AudioParamMock;
+  readonly positionY: AudioParamMock;
+  readonly positionZ: AudioParamMock;
+  readonly orientationX: AudioParamMock;
+  readonly orientationY: AudioParamMock;
+  readonly orientationZ: AudioParamMock;
+  private _panningModel: PanningModelType = 'equalpower';
+  private _distanceModel: DistanceModelType = 'inverse';
+  private _refDistance = 1;
+  private _maxDistance = 10000;
+  private _rolloffFactor = 1;
+  private _coneInnerAngle = 360;
+  private _coneOuterAngle = 360;
+  private _coneOuterGain = 0;
+
+  constructor(context: BaseAudioContextMock, options?: PannerOptions) {
+    super(context, {});
+    this.positionX = new AudioParamMock({}, context);
+    this.positionY = new AudioParamMock({}, context);
+    this.positionZ = new AudioParamMock({}, context);
+    this.orientationX = new AudioParamMock({}, context);
+    this.orientationY = new AudioParamMock({}, context);
+    this.orientationZ = new AudioParamMock({}, context);
+    this.orientationX.value = 1;
+
+    if (options?.panningModel !== undefined) {
+      if (options.panningModel === 'HRTF') {
+        throw new NotSupportedErrorMock(
+          "panningModel 'HRTF' is not supported yet; use 'equalpower'"
+        );
+      }
+      this._panningModel = options.panningModel;
+    }
+    if (options?.distanceModel !== undefined) {
+      this._distanceModel = options.distanceModel;
+    }
+    if (options?.positionX !== undefined) {
+      this.positionX.value = options.positionX;
+    }
+    if (options?.positionY !== undefined) {
+      this.positionY.value = options.positionY;
+    }
+    if (options?.positionZ !== undefined) {
+      this.positionZ.value = options.positionZ;
+    }
+    if (options?.orientationX !== undefined) {
+      this.orientationX.value = options.orientationX;
+    }
+    if (options?.orientationY !== undefined) {
+      this.orientationY.value = options.orientationY;
+    }
+    if (options?.orientationZ !== undefined) {
+      this.orientationZ.value = options.orientationZ;
+    }
+    if (options?.refDistance !== undefined) {
+      this._refDistance = options.refDistance;
+    }
+    if (options?.maxDistance !== undefined) {
+      this._maxDistance = options.maxDistance;
+    }
+    if (options?.rolloffFactor !== undefined) {
+      this._rolloffFactor = options.rolloffFactor;
+    }
+    if (options?.coneInnerAngle !== undefined) {
+      this._coneInnerAngle = options.coneInnerAngle;
+    }
+    if (options?.coneOuterAngle !== undefined) {
+      this._coneOuterAngle = options.coneOuterAngle;
+    }
+    if (options?.coneOuterGain !== undefined) {
+      this._coneOuterGain = options.coneOuterGain;
+    }
+  }
+
+  get panningModel(): PanningModelType {
+    return this._panningModel;
+  }
+
+  set panningModel(value: PanningModelType) {
+    if (value === 'HRTF') {
+      throw new NotSupportedErrorMock(
+        "panningModel 'HRTF' is not supported yet; use 'equalpower'"
+      );
+    }
+    this._panningModel = value;
+  }
+
+  get distanceModel(): DistanceModelType {
+    return this._distanceModel;
+  }
+
+  set distanceModel(value: DistanceModelType) {
+    this._distanceModel = value;
+  }
+
+  get refDistance(): number {
+    return this._refDistance;
+  }
+
+  set refDistance(value: number) {
+    this._refDistance = value;
+  }
+
+  get maxDistance(): number {
+    return this._maxDistance;
+  }
+
+  set maxDistance(value: number) {
+    this._maxDistance = value;
+  }
+
+  get rolloffFactor(): number {
+    return this._rolloffFactor;
+  }
+
+  set rolloffFactor(value: number) {
+    this._rolloffFactor = value;
+  }
+
+  get coneInnerAngle(): number {
+    return this._coneInnerAngle;
+  }
+
+  set coneInnerAngle(value: number) {
+    this._coneInnerAngle = value;
+  }
+
+  get coneOuterAngle(): number {
+    return this._coneOuterAngle;
+  }
+
+  set coneOuterAngle(value: number) {
+    this._coneOuterAngle = value;
+  }
+
+  get coneOuterGain(): number {
+    return this._coneOuterGain;
+  }
+
+  set coneOuterGain(value: number) {
+    this._coneOuterGain = value;
+  }
+
+  setPosition(x: number, y: number, z: number): void {
+    this.positionX.value = x;
+    this.positionY.value = y;
+    this.positionZ.value = z;
+  }
+
+  setOrientation(x: number, y: number, z: number): void {
+    this.orientationX.value = x;
+    this.orientationY.value = y;
+    this.orientationZ.value = z;
+  }
+}
+
 class OscillatorNodeMock extends AudioScheduledSourceNodeMock {
   private _type: OscillatorType = 'sine';
   readonly frequency: AudioParamMock;
@@ -785,6 +945,10 @@ class BaseAudioContextMock {
     return new StereoPannerNodeMock(this, options);
   }
 
+  createPanner(options?: PannerOptions): PannerNodeMock {
+    return new PannerNodeMock(this, options);
+  }
+
   createWaveShaper(options?: WaveShaperOptions): WaveShaperNodeMock {
     return new WaveShaperNodeMock(this, options);
   }
@@ -1205,6 +1369,7 @@ export const OfflineAudioContext = OfflineAudioContextMock;
 export const OscillatorNode = OscillatorNodeMock;
 export const RecorderAdapterNode = RecorderAdapterNodeMock;
 export const StereoPannerNode = StereoPannerNodeMock;
+export const PannerNode = PannerNodeMock;
 export const WaveShaperNode = WaveShaperNodeMock;
 export const PeriodicWave = PeriodicWaveMock;
 
@@ -1258,6 +1423,7 @@ export type OfflineAudioContext = OfflineAudioContextMock;
 export type OscillatorNode = OscillatorNodeMock;
 export type RecorderAdapterNode = RecorderAdapterNodeMock;
 export type StereoPannerNode = StereoPannerNodeMock;
+export type PannerNode = PannerNodeMock;
 export type WaveShaperNode = WaveShaperNodeMock;
 export type PeriodicWave = PeriodicWaveMock;
 
@@ -1290,6 +1456,9 @@ export {
   OscillatorOptions,
   PeriodicWaveOptions,
   StereoPannerOptions,
+  PannerOptions,
+  PanningModelType,
+  DistanceModelType,
   WaveShaperOptions,
 };
 
@@ -1318,6 +1487,7 @@ export default {
   OscillatorNode: OscillatorNodeMock,
   RecorderAdapterNode: RecorderAdapterNodeMock,
   StereoPannerNode: StereoPannerNodeMock,
+  PannerNode: PannerNodeMock,
   WaveShaperNode: WaveShaperNodeMock,
   PeriodicWave: PeriodicWaveMock,
 
diff --git a/packages/react-native-audio-api/src/types.ts b/packages/react-native-audio-api/src/types.ts
index 7afdae22c..f61867322 100644
--- a/packages/react-native-audio-api/src/types.ts
+++ b/packages/react-native-audio-api/src/types.ts
@@ -146,6 +146,27 @@ export interface StereoPannerOptions extends AudioNodeOptions {
   pan?: number;
 }
 
+export type PanningModelType = 'equalpower' | 'HRTF';
+
+export type DistanceModelType = 'linear' | 'inverse' | 'exponential';
+
+export interface PannerOptions extends AudioNodeOptions {
+  panningModel?: PanningModelType;
+  distanceModel?: DistanceModelType;
+  positionX?: number;
+  positionY?: number;
+  positionZ?: number;
+  orientationX?: number;
+  orientationY?: number;
+  orientationZ?: number;
+  refDistance?: number;
+  maxDistance?: number;
+  rolloffFactor?: number;
+  coneInnerAngle?: number;
+  coneOuterAngle?: number;
+  coneOuterGain?: number;
+}
+
 export interface AnalyserOptions extends AudioNodeOptions {
   fftSize?: number;
   minDecibels?: number;
diff --git a/packages/react-native-audio-api/src/utils/validation/index.ts b/packages/react-native-audio-api/src/utils/validation/index.ts
index e21a0a3d0..87343f8d5 100644
--- a/packages/react-native-audio-api/src/utils/validation/index.ts
+++ b/packages/react-native-audio-api/src/utils/validation/index.ts
@@ -16,6 +16,8 @@ export {
 
 export { OscillatorOptionsValidator } from './oscillator';
 
+export { PannerOptionsValidator } from './panner';
+
 export { PeriodicWaveOptionsValidator } from './periodicWave';
 
 export { validateWaveShaperCurve } from './waveShaper';
diff --git a/packages/react-native-audio-api/src/utils/validation/panner.ts b/packages/react-native-audio-api/src/utils/validation/panner.ts
new file mode 100644
index 000000000..172516091
--- /dev/null
+++ b/packages/react-native-audio-api/src/utils/validation/panner.ts
@@ -0,0 +1,35 @@
+import { InvalidStateError, NotSupportedError, RangeError } from '../../errors';
+import type { OptionsValidator, PannerOptions } from '../../types';
+
+export const PannerOptionsValidator: OptionsValidator<PannerOptions> = {
+  validate(options?: PannerOptions): void {
+    if (!options) {
+      return;
+    }
+
+    if (options.panningModel === 'HRTF') {
+      throw new NotSupportedError(
+        "panningModel 'HRTF' is not supported yet; use 'equalpower'"
+      );
+    }
+
+    if (options.refDistance !== undefined && options.refDistance < 0) {
+      throw new RangeError('refDistance cannot be set to a negative value');
+    }
+
+    if (options.maxDistance !== undefined && options.maxDistance <= 0) {
+      throw new RangeError('maxDistance cannot be set to a non-positive value');
+    }
+
+    if (options.rolloffFactor !== undefined && options.rolloffFactor < 0) {
+      throw new RangeError('rolloffFactor cannot be set to a negative value');
+    }
+
+    if (
+      options.coneOuterGain !== undefined &&
+      (options.coneOuterGain < 0 || options.coneOuterGain > 1)
+    ) {
+      throw new InvalidStateError('coneOuterGain must be in [0, 1]');
+    }
+  },
+};
diff --git a/packages/react-native-audio-api/src/web-core/AudioContext.web.ts b/packages/react-native-audio-api/src/web-core/AudioContext.web.ts
index 220b4a85d..086959413 100644
--- a/packages/react-native-audio-api/src/web-core/AudioContext.web.ts
+++ b/packages/react-native-audio-api/src/web-core/AudioContext.web.ts
@@ -18,6 +18,7 @@ import MediaElementAudioSourceNode from './MediaElementAudioSourceNode.web';
 import OscillatorNode from './OscillatorNode.web';
 import PeriodicWave from './PeriodicWave.web';
 import StereoPannerNode from './StereoPannerNode.web';
+import PannerNode from './PannerNode.web';
 import ConstantSourceNode from './ConstantSourceNode.web';
 import WaveShaperNode from './WaveShaperNode.web';
 
@@ -76,6 +77,10 @@ export default class AudioContext implements BaseAudioContext {
     return new StereoPannerNode(this);
   }
 
+  createPanner(): PannerNode {
+    return new PannerNode(this);
+  }
+
   createBiquadFilter(): BiquadFilterNode {
     return new BiquadFilterNode(this);
   }
diff --git a/packages/react-native-audio-api/src/web-core/BaseAudioContext.web.ts b/packages/react-native-audio-api/src/web-core/BaseAudioContext.web.ts
index fbe7d7043..61c795f34 100644
--- a/packages/react-native-audio-api/src/web-core/BaseAudioContext.web.ts
+++ b/packages/react-native-audio-api/src/web-core/BaseAudioContext.web.ts
@@ -15,6 +15,7 @@ import IIRFilterNode from './IIRFilterNode.web';
 import OscillatorNode from './OscillatorNode.web';
 import PeriodicWave from './PeriodicWave.web';
 import StereoPannerNode from './StereoPannerNode.web';
+import PannerNode from './PannerNode.web';
 import WaveShaperNode from './WaveShaperNode.web';
 
 export default interface BaseAudioContext {
@@ -31,6 +32,7 @@ export default interface BaseAudioContext {
   createGain(): GainNode;
   createDelay(maxDelayTime?: number): DelayNode;
   createStereoPanner(): StereoPannerNode;
+  createPanner(): PannerNode;
   createBiquadFilter(): BiquadFilterNode;
   createIIRFilter(feedforward: number[], feedback: number[]): IIRFilterNode;
   createConvolver(): ConvolverNode;
diff --git a/packages/react-native-audio-api/src/web-core/OfflineAudioContext.web.ts b/packages/react-native-audio-api/src/web-core/OfflineAudioContext.web.ts
index 0084dad5e..967b87d55 100644
--- a/packages/react-native-audio-api/src/web-core/OfflineAudioContext.web.ts
+++ b/packages/react-native-audio-api/src/web-core/OfflineAudioContext.web.ts
@@ -13,6 +13,7 @@ import GainNode from './GainNode.web';
 import OscillatorNode from './OscillatorNode.web';
 import PeriodicWave from './PeriodicWave.web';
 import StereoPannerNode from './StereoPannerNode.web';
+import PannerNode from './PannerNode.web';
 import ConstantSourceNode from './ConstantSourceNode.web';
 import WaveShaperNode from './WaveShaperNode.web';
 
@@ -82,6 +83,10 @@ export default class OfflineAudioContext implements BaseAudioContext {
     return new StereoPannerNode(this);
   }
 
+  createPanner(): PannerNode {
+    return new PannerNode(this);
+  }
+
   createBiquadFilter(): BiquadFilterNode {
     return new BiquadFilterNode(this);
   }
diff --git a/packages/react-native-audio-api/src/web-core/PannerNode.web.ts b/packages/react-native-audio-api/src/web-core/PannerNode.web.ts
new file mode 100644
index 000000000..d79b216f2
--- /dev/null
+++ b/packages/react-native-audio-api/src/web-core/PannerNode.web.ts
@@ -0,0 +1,98 @@
+import { DistanceModelType, PannerOptions, PanningModelType } from '../types';
+import AudioNode from './AudioNode.web';
+import AudioParam from './AudioParam.web';
+import BaseAudioContext from './BaseAudioContext.web';
+
+export default class PannerNode extends AudioNode {
+  readonly positionX: AudioParam;
+  readonly positionY: AudioParam;
+  readonly positionZ: AudioParam;
+  readonly orientationX: AudioParam;
+  readonly orientationY: AudioParam;
+  readonly orientationZ: AudioParam;
+
+  constructor(context: BaseAudioContext, pannerOptions?: PannerOptions) {
+    const panner = new globalThis.PannerNode(context.context, pannerOptions);
+    super(context, panner);
+    this.positionX = new AudioParam(panner.positionX, context);
+    this.positionY = new AudioParam(panner.positionY, context);
+    this.positionZ = new AudioParam(panner.positionZ, context);
+    this.orientationX = new AudioParam(panner.orientationX, context);
+    this.orientationY = new AudioParam(panner.orientationY, context);
+    this.orientationZ = new AudioParam(panner.orientationZ, context);
+  }
+
+  get panningModel(): PanningModelType {
+    return (this.node as globalThis.PannerNode)
+      .panningModel as PanningModelType;
+  }
+
+  set panningModel(value: PanningModelType) {
+    (this.node as globalThis.PannerNode).panningModel = value;
+  }
+
+  get distanceModel(): DistanceModelType {
+    return (this.node as globalThis.PannerNode)
+      .distanceModel as DistanceModelType;
+  }
+
+  set distanceModel(value: DistanceModelType) {
+    (this.node as globalThis.PannerNode).distanceModel = value;
+  }
+
+  get refDistance(): number {
+    return (this.node as globalThis.PannerNode).refDistance;
+  }
+
+  set refDistance(value: number) {
+    (this.node as globalThis.PannerNode).refDistance = value;
+  }
+
+  get maxDistance(): number {
+    return (this.node as globalThis.PannerNode).maxDistance;
+  }
+
+  set maxDistance(value: number) {
+    (this.node as globalThis.PannerNode).maxDistance = value;
+  }
+
+  get rolloffFactor(): number {
+    return (this.node as globalThis.PannerNode).rolloffFactor;
+  }
+
+  set rolloffFactor(value: number) {
+    (this.node as globalThis.PannerNode).rolloffFactor = value;
+  }
+
+  get coneInnerAngle(): number {
+    return (this.node as globalThis.PannerNode).coneInnerAngle;
+  }
+
+  set coneInnerAngle(value: number) {
+    (this.node as globalThis.PannerNode).coneInnerAngle = value;
+  }
+
+  get coneOuterAngle(): number {
+    return (this.node as globalThis.PannerNode).coneOuterAngle;
+  }
+
+  set coneOuterAngle(value: number) {
+    (this.node as globalThis.PannerNode).coneOuterAngle = value;
+  }
+
+  get coneOuterGain(): number {
+    return (this.node as globalThis.PannerNode).coneOuterGain;
+  }
+
+  set coneOuterGain(value: number) {
+    (this.node as globalThis.PannerNode).coneOuterGain = value;
+  }
+
+  setPosition(x: number, y: number, z: number): void {
+    (this.node as globalThis.PannerNode).setPosition(x, y, z);
+  }
+
+  setOrientation(x: number, y: number, z: number): void {
+    (this.node as globalThis.PannerNode).setOrientation(x, y, z);
+  }
+}
diff --git a/packages/react-native-audio-api/wpt_tests/wpt-api.js b/packages/react-native-audio-api/wpt_tests/wpt-api.js
index 5e6b30507..4e0453ca4 100644
--- a/packages/react-native-audio-api/wpt_tests/wpt-api.js
+++ b/packages/react-native-audio-api/wpt_tests/wpt-api.js
@@ -37,6 +37,7 @@ const WEB_AUDIO_CLASSES = [
   'OscillatorNode',
   'PeriodicWave',
   'StereoPannerNode',
+  'PannerNode',
   'WaveShaperNode',
 ];
 
diff --git a/packages/react-native-audio-worklets/.clangd b/packages/react-native-audio-worklets/.clangd
index e735c6397..5e1975bf6 100644
--- a/packages/react-native-audio-worklets/.clangd
+++ b/packages/react-native-audio-worklets/.clangd
@@ -1,10 +1,9 @@
-Documentation:
-  CommentFormat: Doxygen
-
 CompileFlags:
   Add:
     - -std=c++20
     - -Wall
+    - -Icommon/cpp
+    - -I../react-native-audio-api/common/cpp
 
 Diagnostics:
   ClangTidy: