diff --git a/apps/common-app/src/examples/Distorted/Distorted.tsx b/apps/common-app/src/examples/Distorted/Distorted.tsx
new file mode 100644
index 000000000..579508c72
--- /dev/null
+++ b/apps/common-app/src/examples/Distorted/Distorted.tsx
@@ -0,0 +1,103 @@
+import React, { useCallback, useEffect, useState, FC } from 'react';
+import { ActivityIndicator } from 'react-native';
+import {
+  AudioContext,
+  AudioNode,
+  AudioBuffer,
+  AudioBufferSourceNode,
+} from 'react-native-audio-api';
+import { Container, Button } from '../../components';
+import { presetEffects } from '../../utils/effects';
+
+const URL = 'https://files.catbox.moe/s2i1wn.flac';
+
+const Distorted: FC = () => {
+  const [isPlaying, setIsPlaying] = useState(false);
+  const [isLoading, setIsLoading] = useState(false);
+  const [buffer, setBuffer] = useState<AudioBuffer | null>(null);
+
+  const aCtxRef = React.useRef<AudioContext | null>(null);
+  const effectsMap = React.useRef<Map<string, AudioNode> | null>(null);
+  const sourceNodeRef = React.useRef<AudioBufferSourceNode | null>(null);
+
+  const fetchAudioBuffer = useCallback(async () => {
+    setIsLoading(true);
+
+    if (!aCtxRef.current) {
+      aCtxRef.current = new AudioContext();
+    }
+    const audioContext = aCtxRef.current;
+
+    effectsMap.current = presetEffects.distorted(audioContext);
+
+    const audioBuffer = await fetch(URL, {
+      headers: {
+        'User-Agent':
+          'Mozilla/5.0 (Android; Mobile; rv:122.0) Gecko/122.0 Firefox/122.0',
+      },
+    })
+      .then((response) => response.arrayBuffer())
+      .then((arrayBuffer) => audioContext.decodeAudioData(arrayBuffer))
+      .catch((error) => {
+        console.error('Error decoding audio data source:', error);
+        return null;
+      });
+
+    setBuffer(audioBuffer);
+
+    setIsLoading(false);
+  }, []);
+
+  const togglePlayPause = useCallback(async () => {
+    if (!aCtxRef.current) {
+      return;
+    }
+
+    if (buffer === null) {
+      fetchAudioBuffer();
+      return;
+    }
+
+    if (isPlaying) {
+      sourceNodeRef.current?.stop();
+    } else {
+      await aCtxRef.current.resume();
+      sourceNodeRef.current = aCtxRef.current.createBufferSource();
+      sourceNodeRef.current.buffer = buffer;
+
+      let previousNode: AudioNode = sourceNodeRef.current;
+      effectsMap.current?.forEach((node) => {
+        previousNode.connect(node);
+        previousNode = node;
+      });
+
+      previousNode.connect(aCtxRef.current.destination);
+
+      sourceNodeRef.current.start();
+    }
+
+    setIsPlaying((prev) => !prev);
+  }, [isPlaying, buffer, fetchAudioBuffer]);
+
+  useEffect(() => {
+    fetchAudioBuffer();
+
+    return () => {
+      aCtxRef.current?.close();
+      aCtxRef.current = null;
+    };
+  }, [fetchAudioBuffer]);
+
+  return (
+    <Container centered>
+      {isLoading && <ActivityIndicator color="#FFFFFF" />}
+      <Button
+        title={isPlaying ? 'Stop' : 'Play'}
+        onPress={togglePlayPause}
+        disabled={isLoading}
+      />
+    </Container>
+  );
+};
+
+export default Distorted;
diff --git a/apps/common-app/src/examples/Distorted/index.tsx b/apps/common-app/src/examples/Distorted/index.tsx
new file mode 100644
index 000000000..9f70fd280
--- /dev/null
+++ b/apps/common-app/src/examples/Distorted/index.tsx
@@ -0,0 +1 @@
+export { default } from './Distorted';
diff --git a/apps/common-app/src/examples/index.ts b/apps/common-app/src/examples/index.ts
index ac4da5d1f..71ab4ea45 100644
--- a/apps/common-app/src/examples/index.ts
+++ b/apps/common-app/src/examples/index.ts
@@ -11,6 +11,7 @@ import Record from './Record/Record';
 import PlaybackSpeed from './PlaybackSpeed/PlaybackSpeed';
 import Worklets from './Worklets/Worklets';
 import Streaming from './Streaming/Streaming';
+import Distorted from './Distorted/Distorted';
 
 type NavigationParamList = {
   Oscillator: undefined;
@@ -25,6 +26,7 @@ type NavigationParamList = {
   Record: undefined;
   Worklets: undefined;
   Streamer: undefined;
+  Distorted: undefined;
 };
 
 export type ExampleKey = keyof NavigationParamList;
@@ -104,4 +106,10 @@ export const Examples: Example[] = [
     subtitle: 'Stream audio from a URL',
     screen: Streaming,
   },
+  {
+    key: 'Distorted',
+    title: 'Distorted Audio',
+    subtitle: 'Apply non-linear distortion effect to audio',
+    screen: Distorted,
+  },
 ] as const;
diff --git a/apps/common-app/src/utils/effects.ts b/apps/common-app/src/utils/effects.ts
new file mode 100644
index 000000000..40365ff79
--- /dev/null
+++ b/apps/common-app/src/utils/effects.ts
@@ -0,0 +1,157 @@
+import {
+  AudioContext,
+  GainNode,
+  BiquadFilterNode,
+  ConvolverNode,
+  WaveShaperNode,
+  AudioNode,
+} from 'react-native-audio-api';
+
+export function createGainEffect(
+  audioContext: AudioContext,
+  gain: number = 1.0
+): GainNode {
+  const gainNode = audioContext.createGain();
+  gainNode.gain.setValueAtTime(gain, audioContext.currentTime);
+  return gainNode;
+}
+
+export function createLowPassFilter(
+  audioContext: AudioContext,
+  frequency: number = 1000
+): BiquadFilterNode {
+  const filter = audioContext.createBiquadFilter();
+  filter.type = 'lowpass';
+  filter.frequency.setValueAtTime(frequency, audioContext.currentTime);
+  filter.Q.setValueAtTime(1, audioContext.currentTime);
+  return filter;
+}
+
+export function createHighPassFilter(
+  audioContext: AudioContext,
+  frequency: number = 300
+): BiquadFilterNode {
+  const filter = audioContext.createBiquadFilter();
+  filter.type = 'highpass';
+  filter.frequency.setValueAtTime(frequency, audioContext.currentTime);
+  filter.Q.setValueAtTime(1, audioContext.currentTime);
+  return filter;
+}
+
+export function createSimpleReverb(
+  audioContext: AudioContext,
+  roomSize: number = 0.5,
+  decayTime: number = 2
+): ConvolverNode {
+  const convolver = audioContext.createConvolver();
+
+  const sampleRate = audioContext.sampleRate;
+  const length = sampleRate * decayTime;
+  const impulse = audioContext.createBuffer(2, length, sampleRate);
+
+  for (let channel = 0; channel < 2; channel++) {
+    const channelData = impulse.getChannelData(channel);
+    for (let i = 0; i < length; i++) {
+      const decay = Math.pow(1 - i / length, 2);
+      channelData[i] = (Math.random() * 2 - 1) * decay * roomSize;
+    }
+  }
+
+  convolver.buffer = impulse;
+  return convolver;
+}
+
+export function createOverdrive(
+  audioContext: AudioContext,
+  amount: number = 0.5
+): WaveShaperNode {
+  const waveShaper = audioContext.createWaveShaper();
+
+  const samples = 44100;
+  const curve = new Float32Array(samples);
+
+  const clampedAmount = Math.max(0, Math.min(1, amount));
+  const drive = 2 + clampedAmount * 30;
+
+  for (let i = 0; i < samples; i++) {
+    const x = (i * 2) / samples - 1;
+    const driven = x * drive;
+
+    let distorted;
+    if (driven > 0) {
+      distorted = Math.tanh(driven * 1.5) * 0.8;
+    } else {
+      distorted = Math.tanh(driven * 1.2) * 0.9;
+    }
+
+    const harmonics = Math.sin(driven * 3) * 0.1 * clampedAmount;
+
+    curve[i] = Math.max(-1, Math.min(1, distorted + harmonics)) * 3;
+  }
+
+  waveShaper.curve = curve;
+  waveShaper.oversample = '4x';
+
+  return waveShaper;
+}
+
+export function createBandPassFilter(
+  audioContext: AudioContext,
+  lowFreq: number = 800,
+  highFreq: number = 3000
+): BiquadFilterNode {
+  const filter = audioContext.createBiquadFilter();
+  filter.type = 'bandpass';
+
+  const centerFreq = Math.sqrt(lowFreq * highFreq);
+  filter.frequency.setValueAtTime(centerFreq, audioContext.currentTime);
+
+  const Q = centerFreq / (highFreq - lowFreq);
+  filter.Q.setValueAtTime(Q, audioContext.currentTime);
+
+  return filter;
+}
+
+export function createEffectsMap(
+  effects: { name: string; node: AudioNode }[]
+): Map<string, AudioNode> {
+  const effectsMap = new Map<string, AudioNode>();
+
+  effects.forEach(({ name, node }) => {
+    effectsMap.set(name, node);
+  });
+
+  return effectsMap;
+}
+
+export const presetEffects = {
+  ambient: (audioContext: AudioContext) =>
+    createEffectsMap([
+      { name: 'reverb', node: createSimpleReverb(audioContext, 0.3, 1.5) },
+      { name: 'lowpass', node: createLowPassFilter(audioContext, 8000) },
+    ]),
+
+  warm: (audioContext: AudioContext) =>
+    createEffectsMap([
+      { name: 'lowpass', node: createLowPassFilter(audioContext, 3000) },
+      { name: 'gain', node: createGainEffect(audioContext, 1.2) },
+    ]),
+
+  distorted: (audioContext: AudioContext) =>
+    createEffectsMap([
+      { name: 'overdrive', node: createOverdrive(audioContext, 0.85) },
+      { name: 'midpass', node: createBandPassFilter(audioContext, 800, 3000) },
+      { name: 'lowpass', node: createLowPassFilter(audioContext, 6000) },
+      { name: 'gain', node: createGainEffect(audioContext, 0.4) },
+    ]),
+
+  test: (audioContext: AudioContext) =>
+    createEffectsMap([
+      { name: 'gain', node: createGainEffect(audioContext, 0.3) },
+    ]),
+
+  overdrive_only: (audioContext: AudioContext) =>
+    createEffectsMap([
+      { name: 'overdrive', node: createOverdrive(audioContext, 0.9) },
+    ]),
+};
diff --git a/packages/audiodocs/docs/core/base-audio-context.mdx b/packages/audiodocs/docs/core/base-audio-context.mdx
index dd0dc9fa2..f7ce4b963 100644
--- a/packages/audiodocs/docs/core/base-audio-context.mdx
+++ b/packages/audiodocs/docs/core/base-audio-context.mdx
@@ -185,6 +185,12 @@ Creates [`StreamerNode`](/docs/sources/streamer-node).
 
 #### Returns `StreamerNode`.
 
+### `createWaveShaper`
+
+Creates [`WaveShaperNode`](/docs/effects/wave-shaper-node).
+
+#### Returns `WaveShaperNode`.
+
 ### `createWorkletNode` <MobileOnly />
 
 Creates [`WorkletNode`](/docs/worklets/worklet-node).
diff --git a/packages/audiodocs/docs/effects/wave-shaper-node.mdx b/packages/audiodocs/docs/effects/wave-shaper-node.mdx
new file mode 100644
index 000000000..bb277eb31
--- /dev/null
+++ b/packages/audiodocs/docs/effects/wave-shaper-node.mdx
@@ -0,0 +1,57 @@
+---
+sidebar_position: 6
+---
+
+import AudioNodePropsTable from "@site/src/components/AudioNodePropsTable"
+import { ReadOnly } from '@site/src/components/Badges';
+
+# WaveShaperNode
+
+The `WaveShaperNode` interface represents non-linear signal distortion effects.
+Non-linear distortion is commonly used for both subtle non-linear warming, or more obvious distortion effects.
+
+#### [`AudioNode`](/docs/core/audio-node#properties) properties
+
+<AudioNodePropsTable numberOfInputs={1} numberOfOutputs={1} channelCount={2} channelCountMode={"clamped-max"} channelInterpretation={"speakers"} />
+
+## Constructor
+
+[`BaseAudioContext.createWaveShaper()`](/docs/core/base-audio-context#createwaveshaper)
+
+## Properties
+
+It inherits all properties from [`AudioNode`](/docs/core/audio-node#properties).
+
+| Name | Type | Description |
+| :--: | :--: | :---------- |
+| `curve` | `Float32Array \| null` |  The shaping curve used for waveshaping effect. |
+| `oversample` | [`OverSampleType`](/docs/effects/wave-shaper-node#oversampletype) |  Specifies what type of oversampling should be used when applying shaping curve. |
+
+## Methods
+
+`WaveShaperNode` does not define any additional methods.
+It inherits all methods from [`AudioNode`](/docs/core/audio-node#methods).
+
+## Remarks
+
+#### `curve`
+- Default value is null
+- Contains at least two values.
+- Subsequent modifications of curve have no effects. To change the curve, assign a new Float32Array object to this property.
+
+#### `oversample`
+- Default value `none`
+- Value of `2x` or `4x` can increases quality of the effect, but in some cases it is better not to use oversampling for very accurate shaping curve.
+
+### `OverSampleType`
+
+<details>
+<summary>Type definitions</summary>
+
+```typescript
+// Do not oversample | Oversample two times | Oversample four times
+export type OverSampleType = 'none' | '2x' | '4x';
+```
+
+</details>
+
diff --git a/packages/audiodocs/docs/other/web-audio-api-coverage.mdx b/packages/audiodocs/docs/other/web-audio-api-coverage.mdx
index f273bddb5..ccc1aef78 100644
--- a/packages/audiodocs/docs/other/web-audio-api-coverage.mdx
+++ b/packages/audiodocs/docs/other/web-audio-api-coverage.mdx
@@ -26,6 +26,7 @@ sidebar_position: 2
 | OscillatorNode | ✅ |
 | PeriodicWave | ✅ |
 | StereoPannerNode | ✅ |
+| WaveShaperNode | ✅ |
 | AudioContext | 🚧 | Available props and methods: `close`, `suspend`, `resume` |
 | BaseAudioContext | 🚧 | Available props and methods: `currentTime`, `destination`, `sampleRate`, `state`, `decodeAudioData`, all create methods for available or partially implemented nodes |
 | AudioListener | ❌ |
@@ -42,7 +43,6 @@ sidebar_position: 2
 | MediaStreamAudioDestinationNode | ❌ |
 | MediaStreamAudioSourceNode | ❌ |
 | PannerNode | ❌ |
-| WaveShaperNode | ❌ |
 
 ### Description
 
diff --git a/packages/audiodocs/static/audio/music/guitar-sample.flac b/packages/audiodocs/static/audio/music/guitar-sample.flac
new file mode 100644
index 000000000..f594cf262
Binary files /dev/null and b/packages/audiodocs/static/audio/music/guitar-sample.flac differ
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 529782ee0..0e1b9a71f 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
@@ -10,6 +10,7 @@
 #include <audioapi/HostObjects/effects/IIRFilterNodeHostObject.h>
 #include <audioapi/HostObjects/effects/PeriodicWaveHostObject.h>
 #include <audioapi/HostObjects/effects/StereoPannerNodeHostObject.h>
+#include <audioapi/HostObjects/effects/WaveShaperNodeHostObject.h>
 #include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
 #include <audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.h>
 #include <audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.h>
@@ -55,7 +56,8 @@ BaseAudioContextHostObject::BaseAudioContextHostObject(
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBuffer),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createPeriodicWave),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createConvolver),
-      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createAnalyser));
+      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createAnalyser),
+      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createWaveShaper));
 }
 
 JSI_PROPERTY_GETTER_IMPL(BaseAudioContextHostObject, destination) {
@@ -297,4 +299,10 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createConvolver) {
   }
   return jsiObject;
 }
+
+JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWaveShaper) {
+  auto waveShaper = context_->createWaveShaper();
+  auto waveShaperHostObject = std::make_shared<WaveShaperNodeHostObject>(waveShaper);
+  return jsi::Object::createFromHostObject(runtime, waveShaperHostObject);
+}
 } // namespace audioapi
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 c2680bb7a..670bdac42 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
@@ -43,6 +43,7 @@ class BaseAudioContextHostObject : public JsiHostObject {
   JSI_HOST_FUNCTION_DECL(createPeriodicWave);
   JSI_HOST_FUNCTION_DECL(createAnalyser);
   JSI_HOST_FUNCTION_DECL(createConvolver);
+  JSI_HOST_FUNCTION_DECL(createWaveShaper);
 
   std::shared_ptr<BaseAudioContext> context_;
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WaveShaperNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WaveShaperNodeHostObject.cpp
new file mode 100644
index 000000000..01b225fbf
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WaveShaperNodeHostObject.cpp
@@ -0,0 +1,72 @@
+#include <audioapi/HostObjects/effects/WaveShaperNodeHostObject.h>
+#include <audioapi/core/effects/WaveShaperNode.h>
+#include <audioapi/jsi/AudioArrayBuffer.h>
+
+#include <memory>
+#include <string>
+
+namespace audioapi {
+
+WaveShaperNodeHostObject::WaveShaperNodeHostObject(const std::shared_ptr<WaveShaperNode> &node)
+    : AudioNodeHostObject(node) {
+  addGetters(
+      JSI_EXPORT_PROPERTY_GETTER(WaveShaperNodeHostObject, oversample),
+      JSI_EXPORT_PROPERTY_GETTER(WaveShaperNodeHostObject, curve));
+
+  addSetters(JSI_EXPORT_PROPERTY_SETTER(WaveShaperNodeHostObject, oversample));
+  addFunctions(JSI_EXPORT_FUNCTION(WaveShaperNodeHostObject, setCurve));
+}
+
+JSI_PROPERTY_GETTER_IMPL(WaveShaperNodeHostObject, oversample) {
+  auto waveShaperNode = std::static_pointer_cast<WaveShaperNode>(node_);
+  return jsi::String::createFromUtf8(runtime, waveShaperNode->getOversample());
+}
+
+JSI_PROPERTY_GETTER_IMPL(WaveShaperNodeHostObject, curve) {
+  auto waveShaperNode = std::static_pointer_cast<WaveShaperNode>(node_);
+  auto curve = waveShaperNode->getCurve();
+
+  if (curve == nullptr) {
+    return jsi::Value::null();
+  }
+
+  // copy AudioArray holding curve data to avoid subsequent modifications
+  auto audioArray = std::make_shared<AudioArray>(*curve);
+  auto audioArrayBuffer = std::make_shared<AudioArrayBuffer>(audioArray);
+  auto arrayBuffer = jsi::ArrayBuffer(runtime, audioArrayBuffer);
+
+  auto float32ArrayCtor = runtime.global().getPropertyAsFunction(runtime, "Float32Array");
+  auto float32Array = float32ArrayCtor.callAsConstructor(runtime, arrayBuffer).getObject(runtime);
+  float32Array.setExternalMemoryPressure(runtime, audioArrayBuffer->size());
+
+  return float32Array;
+}
+
+JSI_PROPERTY_SETTER_IMPL(WaveShaperNodeHostObject, oversample) {
+  auto waveShaperNode = std::static_pointer_cast<WaveShaperNode>(node_);
+  std::string type = value.asString(runtime).utf8(runtime);
+  waveShaperNode->setOversample(type);
+}
+
+JSI_HOST_FUNCTION_IMPL(WaveShaperNodeHostObject, setCurve) {
+  auto waveShaperNode = std::static_pointer_cast<WaveShaperNode>(node_);
+
+  if (args[0].isNull()) {
+    waveShaperNode->setCurve(std::shared_ptr<AudioArray>(nullptr));
+    return jsi::Value::undefined();
+  }
+
+  auto arrayBuffer =
+      args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+
+  auto curve = std::make_shared<AudioArray>(
+      reinterpret_cast<float *>(arrayBuffer.data(runtime)),
+      static_cast<size_t>(arrayBuffer.size(runtime) / sizeof(float)));
+
+  waveShaperNode->setCurve(curve);
+  thisValue.asObject(runtime).setExternalMemoryPressure(runtime, arrayBuffer.size(runtime));
+
+  return jsi::Value::undefined();
+}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WaveShaperNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WaveShaperNodeHostObject.h
new file mode 100644
index 000000000..cdddf01fe
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WaveShaperNodeHostObject.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class WaveShaperNode;
+
+class WaveShaperNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit WaveShaperNodeHostObject(const std::shared_ptr<WaveShaperNode> &node);
+
+  JSI_PROPERTY_GETTER_DECL(oversample);
+  JSI_PROPERTY_GETTER_DECL(curve);
+
+  JSI_PROPERTY_SETTER_DECL(oversample);
+  JSI_HOST_FUNCTION_DECL(setCurve);
+};
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
index 2e4723c2a..ab4785c98 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
@@ -6,6 +6,7 @@
 #include <audioapi/core/effects/GainNode.h>
 #include <audioapi/core/effects/IIRFilterNode.h>
 #include <audioapi/core/effects/StereoPannerNode.h>
+#include <audioapi/core/effects/WaveShaperNode.h>
 #include <audioapi/core/effects/WorkletNode.h>
 #include <audioapi/core/effects/WorkletProcessingNode.h>
 #include <audioapi/core/sources/AudioBuffer.h>
@@ -199,6 +200,12 @@ std::shared_ptr<ConvolverNode> BaseAudioContext::createConvolver(
   return convolver;
 }
 
+std::shared_ptr<WaveShaperNode> BaseAudioContext::createWaveShaper() {
+  auto waveShaper = std::make_shared<WaveShaperNode>(this);
+  nodeManager_->addProcessingNode(waveShaper);
+  return waveShaper;
+}
+
 AudioNodeManager *BaseAudioContext::getNodeManager() {
   return nodeManager_.get();
 }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
index 6f40ad7ee..090ed7ca6 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
@@ -36,6 +36,7 @@ class WorkletSourceNode;
 class WorkletNode;
 class WorkletProcessingNode;
 class StreamerNode;
+class WaveShaperNode;
 
 class BaseAudioContext {
  public:
@@ -86,6 +87,7 @@ class BaseAudioContext {
   std::shared_ptr<ConvolverNode> createConvolver(
       std::shared_ptr<AudioBuffer> buffer,
       bool disableNormalization);
+  std::shared_ptr<WaveShaperNode> createWaveShaper();
 
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
   [[nodiscard]] float getNyquistFrequency() const;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WaveShaperNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WaveShaperNode.cpp
new file mode 100644
index 000000000..163b0573b
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WaveShaperNode.cpp
@@ -0,0 +1,81 @@
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/effects/WaveShaperNode.h>
+#include <audioapi/dsp/VectorMath.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+
+#include <algorithm>
+#include <memory>
+#include <string>
+
+namespace audioapi {
+
+WaveShaperNode::WaveShaperNode(BaseAudioContext *context)
+    : AudioNode(context), oversample_(OverSampleType::OVERSAMPLE_NONE) {
+
+  waveShapers_.reserve(6);
+  for (int i = 0; i < channelCount_; i++) {
+    waveShapers_.push_back(std::make_unique<WaveShaper>(nullptr));
+  }
+
+  // to change after graph processing improvement - should be max
+  channelCountMode_ = ChannelCountMode::CLAMPED_MAX;
+  isInitialized_ = true;
+}
+
+std::string WaveShaperNode::getOversample() const {
+  return toString(oversample_.load(std::memory_order_acquire));
+}
+
+void WaveShaperNode::setOversample(const std::string &type) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  oversample_.store(fromString(type), std::memory_order_release);
+
+  for (int i = 0; i < waveShapers_.size(); i++) {
+    waveShapers_[i]->setOversample(fromString(type));
+  }
+}
+
+std::shared_ptr<AudioArray> WaveShaperNode::getCurve() const {
+  std::lock_guard<std::mutex> lock(mutex_);
+  return curve_;
+}
+
+void WaveShaperNode::setCurve(const std::shared_ptr<AudioArray> &curve) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  curve_ = curve;
+
+  for (int i = 0; i < waveShapers_.size(); i++) {
+    waveShapers_[i]->setCurve(curve);
+  }
+
+  curve_ = curve;
+}
+
+std::shared_ptr<AudioBus> WaveShaperNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  if (!isInitialized_) {
+    return processingBus;
+  }
+
+  std::unique_lock<std::mutex> lock(mutex_, std::try_to_lock);
+
+  if (!lock.owns_lock()) {
+    return processingBus;
+  }
+
+  if (curve_ == nullptr) {
+    return processingBus;
+  }
+
+  for (int channel = 0; channel < processingBus->getNumberOfChannels(); channel += 1) {
+    auto channelData = processingBus->getSharedChannel(channel);
+
+    waveShapers_[channel]->process(channelData);
+  }
+
+  return processingBus;
+}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WaveShaperNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WaveShaperNode.h
new file mode 100644
index 000000000..a5ab35b5a
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WaveShaperNode.h
@@ -0,0 +1,66 @@
+#pragma once
+
+#include <audioapi/core/AudioNode.h>
+#include <audioapi/core/types/OverSampleType.h>
+#include <audioapi/dsp/Resampler.h>
+#include <audioapi/dsp/WaveShaper.h>
+
+#include <algorithm>
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+
+class AudioBus;
+class AudioArray;
+
+class WaveShaperNode : public AudioNode {
+ public:
+  explicit WaveShaperNode(BaseAudioContext *context);
+
+  [[nodiscard]] std::string getOversample() const;
+  [[nodiscard]] std::shared_ptr<AudioArray> getCurve() const;
+
+  void setOversample(const std::string &type);
+  void setCurve(const std::shared_ptr<AudioArray> &curve);
+
+ protected:
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override;
+
+ private:
+  std::atomic<OverSampleType> oversample_;
+  std::shared_ptr<AudioArray> curve_{};
+  mutable std::mutex mutex_;
+
+  std::vector<std::unique_ptr<WaveShaper>> waveShapers_{};
+
+  static OverSampleType fromString(const std::string &type) {
+    std::string lowerType = type;
+    std::transform(lowerType.begin(), lowerType.end(), lowerType.begin(), ::tolower);
+
+    if (lowerType == "2x")
+      return OverSampleType::OVERSAMPLE_2X;
+    if (lowerType == "4x")
+      return OverSampleType::OVERSAMPLE_4X;
+
+    return OverSampleType::OVERSAMPLE_NONE;
+  }
+
+  static std::string toString(OverSampleType type) {
+    switch (type) {
+      case OverSampleType::OVERSAMPLE_2X:
+        return "2x";
+      case OverSampleType::OVERSAMPLE_4X:
+        return "4x";
+      default:
+        return "none";
+    }
+  }
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/types/OverSampleType.h b/packages/react-native-audio-api/common/cpp/audioapi/core/types/OverSampleType.h
new file mode 100644
index 000000000..ba5a723a8
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/types/OverSampleType.h
@@ -0,0 +1,7 @@
+#pragma once
+
+namespace audioapi {
+
+enum class OverSampleType { OVERSAMPLE_NONE = 0, OVERSAMPLE_2X = 2, OVERSAMPLE_4X = 4 };
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/dsp/Resampler.cpp b/packages/react-native-audio-api/common/cpp/audioapi/dsp/Resampler.cpp
new file mode 100644
index 000000000..8b78623af
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/dsp/Resampler.cpp
@@ -0,0 +1,209 @@
+/*
+ * Copyright (C) 2010 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1.  Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ * 2.  Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <audioapi/dsp/Resampler.h>
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+#include <memory>
+#include <numbers>
+
+#if defined(__ARM_NEON)
+#include <arm_neon.h>
+#endif
+
+// based on WebKit UpSampler and DownSampler implementation
+
+namespace audioapi {
+
+static constexpr float PI = std::numbers::pi_v<float>;
+
+// https://en.wikipedia.org/wiki/Window_function
+static float blackmanWindow(double x) {
+  double alpha = 0.16;
+  double a0 = 0.5 * (1.0 - alpha);
+  double a1 = 0.5;
+  double a2 = 0.5 * alpha;
+  double n = x / KERNEL_SIZE;
+  return static_cast<float>(a0 - a1 * std::cos(2.0 * PI * n) + a2 * std::cos(4.0 * PI * n));
+}
+
+Resampler::Resampler() {
+  kernel_ = std::make_shared<AudioArray>(KERNEL_SIZE);
+  stateBuffer_ = std::make_shared<AudioArray>(KERNEL_SIZE + MAX_BLOCK_SIZE);
+  stateBuffer_->zero();
+}
+
+float Resampler::computeConvolution(const float *stateStart, const float *kernelStart) {
+  float sum = 0.0f;
+  int k = 0;
+
+#ifdef __ARM_NEON
+  float32x4_t vSum = vdupq_n_f32(0.0f);
+
+  // process 4 samples at a time
+  for (; k <= KERNEL_SIZE - 4; k += 4) {
+    float32x4_t vState = vld1q_f32(stateStart + k);
+    float32x4_t vKernel = vld1q_f32(kernelStart + k);
+
+    // fused multiply-add: vSum += vState * vKernel
+    vSum = vmlaq_f32(vSum, vState, vKernel);
+  }
+
+  // horizontal reduction: Sum the 4 lanes of vSum into a single float
+  sum += vgetq_lane_f32(vSum, 0);
+  sum += vgetq_lane_f32(vSum, 1);
+  sum += vgetq_lane_f32(vSum, 2);
+  sum += vgetq_lane_f32(vSum, 3);
+#endif
+  for (; k < KERNEL_SIZE; ++k) {
+    sum += stateStart[k] * kernelStart[k];
+  }
+
+  return sum;
+}
+
+void Resampler::reset() {
+  if (stateBuffer_) {
+    stateBuffer_->zero();
+  }
+}
+
+UpSampler::UpSampler() : Resampler() {
+  initializeKernel();
+}
+
+void UpSampler::initializeKernel() {
+  auto kData = kernel_->getData();
+  int halfSize = KERNEL_SIZE / 2;
+  double subSampleOffset = -0.5;
+
+  for (int i = 0; i < KERNEL_SIZE; ++i) {
+    // we want to sample the sinc function halfway between integer points
+    auto x = static_cast<double>(i - halfSize) - subSampleOffset;
+
+    // https://en.wikipedia.org/wiki/Sinc_filter
+    // sets cutoff frequency to nyquist
+    double sinc = (std::abs(x) < 1e-9) ? 1.0 : std::sin(x * PI) / (x * PI);
+
+    // apply window in order smooth out the edges, because sinc extends to infinity in both directions
+    kData[i] = static_cast<float>(sinc * blackmanWindow(i - subSampleOffset));
+  }
+
+  // reverse kernel to match convolution implementation
+  std::reverse(kData, kData + KERNEL_SIZE);
+}
+
+void UpSampler::process(
+    const std::shared_ptr<AudioArray> &input,
+    const std::shared_ptr<AudioArray> &output) {
+
+  auto inputSize = input->getSize();
+  if (inputSize > MAX_BLOCK_SIZE)
+    return;
+  if (output->getSize() < inputSize * 2)
+    return;
+
+  const float *inputData = input->getData();
+  float *outputData = output->getData();
+  float *state = stateBuffer_->getData();
+  const float *kernel = kernel_->getData();
+
+  // move previous tail to front
+  std::memmove(state, state + inputSize, KERNEL_SIZE * sizeof(float));
+  // copy new input
+  std::memcpy(state + KERNEL_SIZE, inputData, inputSize * sizeof(float));
+
+  int halfKernel = KERNEL_SIZE / 2;
+
+  for (int i = 0; i < inputSize; ++i) {
+    int centerIdx = KERNEL_SIZE + i;
+
+    // direct copy for even samples
+    outputData[2 * i] = state[centerIdx - halfKernel];
+
+    // convolution for odd samples
+    outputData[2 * i + 1] = computeConvolution(&state[centerIdx - halfKernel], kernel);
+  }
+}
+
+DownSampler::DownSampler() : Resampler() {
+  initializeKernel();
+}
+
+void DownSampler::initializeKernel() {
+  auto kData = kernel_->getData();
+  int halfSize = KERNEL_SIZE / 2;
+
+  for (int i = 0; i < KERNEL_SIZE; ++i) {
+    // we want to sample the sinc function halfway between integer points
+    auto x = static_cast<double>(i - halfSize);
+
+    // https://en.wikipedia.org/wiki/Sinc_filter
+    // sets cutoff frequency to nyquist / 2
+    double sinc = (std::abs(x) < 1e-9) ? 1.0 : std::sin(x * PI * 0.5) / (x * PI * 0.5);
+    sinc *= 0.5;
+
+    // apply window in order smooth out the edges, because sinc extends to infinity in both directions
+    kData[i] = static_cast<float>(sinc * blackmanWindow(i));
+  }
+
+  // reverse kernel to match convolution implementation
+  std::reverse(kData, kData + KERNEL_SIZE);
+}
+
+void DownSampler::process(
+    const std::shared_ptr<AudioArray> &input,
+    const std::shared_ptr<AudioArray> &output) {
+  auto inputSize = input->getSize();
+  if (inputSize > MAX_BLOCK_SIZE * 2)
+    return;
+  if (output->getSize() < inputSize / 2)
+    return;
+
+  const float *inputData = input->getData();
+  float *outputData = output->getData();
+  float *state = stateBuffer_->getData();
+  const float *kernel = kernel_->getData();
+  int halfKernel = KERNEL_SIZE / 2;
+
+  // move history (shift by amount processed last time, which is inputSize)
+  std::memmove(state, state + inputSize, KERNEL_SIZE * sizeof(float));
+  // copy new input
+  std::memcpy(state + KERNEL_SIZE, inputData, inputSize * sizeof(float));
+
+  auto outputCount = inputSize / 2;
+
+  for (int i = 0; i < outputCount; ++i) {
+    int centerIdx = KERNEL_SIZE + (2 * i);
+
+    // convolution for downsampled samples
+    outputData[i] = computeConvolution(&state[centerIdx - halfKernel], kernel);
+  }
+}
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/dsp/Resampler.h b/packages/react-native-audio-api/common/cpp/audioapi/dsp/Resampler.h
new file mode 100644
index 000000000..1436de897
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/dsp/Resampler.h
@@ -0,0 +1,53 @@
+#pragma once
+
+#include <audioapi/utils/AudioArray.h>
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+constexpr int KERNEL_SIZE = 128;
+constexpr int MAX_BLOCK_SIZE = 1024;
+
+class Resampler {
+ public:
+  Resampler();
+  virtual ~Resampler() = default;
+
+  virtual void process(
+      const std::shared_ptr<AudioArray> &input,
+      const std::shared_ptr<AudioArray> &output) = 0;
+  void reset();
+
+ protected:
+  static float computeConvolution(const float *stateStart, const float *kernelStart);
+  virtual void initializeKernel() = 0;
+
+  std::shared_ptr<AudioArray> kernel_;
+  std::shared_ptr<AudioArray> stateBuffer_;
+};
+
+class UpSampler : public Resampler {
+ public:
+  UpSampler();
+
+  // N -> 2N
+  void process(const std::shared_ptr<AudioArray> &input, const std::shared_ptr<AudioArray> &output)
+      override;
+
+ protected:
+  void initializeKernel() final;
+};
+
+class DownSampler : public Resampler {
+ public:
+  DownSampler();
+
+  // N -> N / 2
+  void process(const std::shared_ptr<AudioArray> &input, const std::shared_ptr<AudioArray> &output)
+      override;
+
+ protected:
+  void initializeKernel() final;
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/dsp/WaveShaper.cpp b/packages/react-native-audio-api/common/cpp/audioapi/dsp/WaveShaper.cpp
new file mode 100644
index 000000000..476d4054b
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/dsp/WaveShaper.cpp
@@ -0,0 +1,105 @@
+#include <audioapi/core/utils/Constants.h>
+#include <audioapi/dsp/VectorMath.h>
+#include <audioapi/dsp/WaveShaper.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+
+#include <algorithm>
+#include <memory>
+#include <string>
+
+namespace audioapi {
+
+WaveShaper::WaveShaper(const std::shared_ptr<AudioArray> &curve) : curve_(curve) {
+  tempBuffer2x_ = std::make_shared<AudioArray>(RENDER_QUANTUM_SIZE * 2);
+  tempBuffer2x_->zero();
+  tempBuffer4x_ = std::make_shared<AudioArray>(RENDER_QUANTUM_SIZE * 4);
+  tempBuffer4x_->zero();
+
+  upSampler_ = std::make_unique<UpSampler>();
+  downSampler_ = std::make_unique<DownSampler>();
+  upSampler2_ = std::make_unique<UpSampler>();
+  downSampler2_ = std::make_unique<DownSampler>();
+}
+
+void WaveShaper::setCurve(const std::shared_ptr<AudioArray> &curve) {
+  curve_ = curve;
+}
+
+void WaveShaper::setOversample(OverSampleType type) {
+  oversample_ = type;
+
+  if (upSampler_) {
+    upSampler_->reset();
+  }
+
+  if (downSampler_) {
+    downSampler_->reset();
+  }
+
+  if (upSampler2_) {
+    upSampler2_->reset();
+  }
+
+  if (downSampler2_) {
+    downSampler2_->reset();
+  }
+}
+
+void WaveShaper::process(const std::shared_ptr<AudioArray> &channelData) {
+  if (curve_ == nullptr) {
+    return;
+  }
+
+  switch (oversample_) {
+    case OverSampleType::OVERSAMPLE_2X:
+      process2x(channelData);
+      break;
+    case OverSampleType::OVERSAMPLE_4X:
+      process4x(channelData);
+      break;
+    case OverSampleType::OVERSAMPLE_NONE:
+    default:
+      processNone(channelData);
+      break;
+  }
+}
+
+// based on https://webaudio.github.io/web-audio-api/#WaveShaperNode
+void WaveShaper::processNone(const std::shared_ptr<AudioArray> &channelData) {
+  auto curveArray = curve_->getData();
+  auto curveSize = curve_->getSize();
+
+  auto data = channelData->getData();
+
+  for (int i = 0; i < channelData->getSize(); i += 1) {
+    float v = (static_cast<float>(curveSize) - 1) * 0.5f * (data[i] + 1.0f);
+
+    if (v <= 0) {
+      data[i] = curveArray[0];
+    } else if (v >= static_cast<float>(curveSize) - 1) {
+      data[i] = curveArray[curveSize - 1];
+    } else {
+      auto k = std::floor(v);
+      auto f = v - k;
+      auto kIndex = static_cast<size_t>(k);
+      data[i] = (1 - f) * curveArray[kIndex] + f * curveArray[kIndex + 1];
+    }
+  }
+}
+
+void WaveShaper::process2x(const std::shared_ptr<AudioArray> &channelData) {
+  upSampler_->process(channelData, tempBuffer2x_);
+  processNone(tempBuffer2x_);
+  downSampler_->process(tempBuffer2x_, channelData);
+}
+
+void WaveShaper::process4x(const std::shared_ptr<AudioArray> &channelData) {
+  upSampler_->process(channelData, tempBuffer2x_);
+  upSampler2_->process(tempBuffer2x_, tempBuffer4x_);
+  processNone(tempBuffer4x_);
+  downSampler2_->process(tempBuffer4x_, tempBuffer2x_);
+  downSampler_->process(tempBuffer2x_, channelData);
+}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/dsp/WaveShaper.h b/packages/react-native-audio-api/common/cpp/audioapi/dsp/WaveShaper.h
new file mode 100644
index 000000000..ccedf3dc8
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/dsp/WaveShaper.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <audioapi/core/types/OverSampleType.h>
+#include <audioapi/dsp/Resampler.h>
+
+#include <algorithm>
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <string>
+
+namespace audioapi {
+
+class AudioBus;
+class AudioArray;
+
+class WaveShaper {
+ public:
+  explicit WaveShaper(const std::shared_ptr<AudioArray> &curve);
+
+  void process(const std::shared_ptr<AudioArray> &channelData);
+
+  void setCurve(const std::shared_ptr<AudioArray> &curve);
+  void setOversample(OverSampleType type);
+
+ private:
+  OverSampleType oversample_ = OverSampleType::OVERSAMPLE_NONE;
+  std::shared_ptr<AudioArray> curve_;
+
+  // stage 1 Filters (1x <-> 2x)
+  std::unique_ptr<UpSampler> upSampler_;
+  std::unique_ptr<DownSampler> downSampler_;
+
+  // stage 2 Filters (2x <-> 4x)
+  std::unique_ptr<UpSampler> upSampler2_;
+  std::unique_ptr<DownSampler> downSampler2_;
+
+  std::shared_ptr<AudioArray> tempBuffer2x_;
+  std::shared_ptr<AudioArray> tempBuffer4x_;
+
+  void processNone(const std::shared_ptr<AudioArray> &channelData);
+  void process2x(const std::shared_ptr<AudioArray> &channelData);
+  void process4x(const std::shared_ptr<AudioArray> &channelData);
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioArray.cpp b/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioArray.cpp
index 967a8ed65..0e321ed80 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioArray.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioArray.cpp
@@ -14,6 +14,11 @@ AudioArray::AudioArray(const AudioArray &other) : data_(nullptr), size_(0) {
   copy(&other);
 }
 
+AudioArray::AudioArray(const float *data, size_t size) : size_(size) {
+  data_ = new float[size_];
+  memcpy(data_, data, size_ * sizeof(float));
+}
+
 AudioArray::~AudioArray() {
   if (data_) {
     delete[] data_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioArray.h b/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioArray.h
index 6f17d23ed..9291f22ff 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioArray.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioArray.h
@@ -11,6 +11,12 @@ class AudioArray {
  public:
   explicit AudioArray(size_t size);
   AudioArray(const AudioArray &other);
+
+  /// @brief Construct AudioArray from raw float data
+  /// @param data Pointer to the float data
+  /// @param size Number of float samples
+  /// @note The data is copied, so it does not take ownership of the pointer
+  AudioArray(const float *data, size_t size);
   ~AudioArray();
 
   [[nodiscard]] size_t getSize() const;
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/effects/WaveShaperNodeTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/effects/WaveShaperNodeTest.cpp
new file mode 100644
index 000000000..5abee5ea9
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/effects/WaveShaperNodeTest.cpp
@@ -0,0 +1,75 @@
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/effects/WaveShaperNode.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <gtest/gtest.h>
+#include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
+
+using namespace audioapi;
+
+class WaveShaperNodeTest : public ::testing::Test {
+ protected:
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
+  std::unique_ptr<OfflineAudioContext> context;
+  static constexpr int sampleRate = 44100;
+
+  void SetUp() override {
+    eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
+    context = std::make_unique<OfflineAudioContext>(
+        2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
+  }
+};
+
+class TestableWaveShaperNode : public WaveShaperNode {
+ public:
+  explicit TestableWaveShaperNode(BaseAudioContext *context) : WaveShaperNode(context) {
+    testCurve_ = std::make_shared<AudioArray>(3);
+    auto data = testCurve_->getData();
+    data[0] = -2.0f;
+    data[1] = 0.0f;
+    data[2] = 2.0f;
+  }
+
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override {
+    return WaveShaperNode::processNode(processingBus, framesToProcess);
+  }
+
+  std::shared_ptr<AudioArray> testCurve_;
+};
+
+TEST_F(WaveShaperNodeTest, WaveShaperNodeCanBeCreated) {
+  auto waveShaper = context->createWaveShaper();
+  ASSERT_NE(waveShaper, nullptr);
+}
+
+TEST_F(WaveShaperNodeTest, NullCanBeAsignedToCurve) {
+  auto waveShaper = context->createWaveShaper();
+  ASSERT_NO_THROW(waveShaper->setCurve(nullptr));
+  ASSERT_EQ(waveShaper->getCurve(), nullptr);
+}
+
+TEST_F(WaveShaperNodeTest, NoneOverSamplingProcessesCorrectly) {
+  static constexpr int FRAMES_TO_PROCESS = 5;
+  auto waveShaper = std::make_shared<TestableWaveShaperNode>(context.get());
+  waveShaper->setOversample("none");
+  waveShaper->setCurve(waveShaper->testCurve_);
+
+  auto bus = std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
+  for (size_t i = 0; i < bus->getSize(); ++i) {
+    bus->getChannel(0)->getData()[i] = -1.0f + i * 0.5f;
+  }
+
+  auto resultBus = waveShaper->processNode(bus, FRAMES_TO_PROCESS);
+  auto curveData = waveShaper->testCurve_->getData();
+  auto resultData = resultBus->getChannel(0)->getData();
+
+  EXPECT_FLOAT_EQ(resultData[0], curveData[0]);
+  EXPECT_FLOAT_EQ(resultData[1], -1.0f);
+  EXPECT_FLOAT_EQ(resultData[2], 0.0f);
+  EXPECT_FLOAT_EQ(resultData[3], 1.0f);
+  EXPECT_FLOAT_EQ(resultData[4], curveData[2]);
+}
diff --git a/packages/react-native-audio-api/common/cpp/test/src/dsp/ResamplerTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/dsp/ResamplerTest.cpp
new file mode 100644
index 000000000..0b2030e92
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/test/src/dsp/ResamplerTest.cpp
@@ -0,0 +1,98 @@
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <audioapi/dsp/Resampler.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <gtest/gtest.h>
+#include <memory>
+
+using namespace audioapi;
+
+class ResamplerTest : public ::testing::Test {
+ protected:
+};
+
+class TestableUpSampler : public UpSampler {
+ public:
+  explicit TestableUpSampler() : UpSampler() {}
+
+  std::shared_ptr<AudioArray> getKernel() {
+    return kernel_;
+  }
+};
+
+class TestableDownSampler : public DownSampler {
+ public:
+  explicit TestableDownSampler() : DownSampler() {}
+
+  std::shared_ptr<AudioArray> getKernel() {
+    return kernel_;
+  }
+};
+
+TEST_F(ResamplerTest, UpSamplerCanBeCreated) {
+  auto upSampler = std::make_unique<UpSampler>();
+  ASSERT_NE(upSampler, nullptr);
+}
+
+TEST_F(ResamplerTest, DownSamplerCanBeCreated) {
+  auto downSampler = std::make_unique<DownSampler>();
+  ASSERT_NE(downSampler, nullptr);
+}
+
+TEST_F(ResamplerTest, UpSamplerKernelSymmetry) {
+  auto upSampler = std::make_unique<TestableUpSampler>();
+  auto kernel = upSampler->getKernel();
+
+  // check for symmetry around the center point
+  for (size_t i = 0; i < kernel->getSize() / 2; ++i) {
+    EXPECT_NEAR((*kernel)[i], (*kernel)[kernel->getSize() - 1 - i], 1e-6);
+  }
+}
+
+TEST_F(ResamplerTest, DownSamplerKernelSymmetry) {
+  auto downSampler = std::make_unique<TestableDownSampler>();
+  auto kernel = downSampler->getKernel();
+
+  // check for symmetry around the center point
+  // as the kernel size is even, we compare pairs around the center -> kernel[size/2 - 1]
+  // last value is skipped
+  for (size_t i = 0; i < kernel->getSize() / 2; ++i) {
+    EXPECT_NEAR((*kernel)[i], (*kernel)[kernel->getSize() - 2 - i], 1e-6);
+  }
+
+  EXPECT_FLOAT_EQ((*kernel)[kernel->getSize() / 2 - 1], 0.5f);
+}
+
+TEST_F(ResamplerTest, UpSamplerKernelSum) {
+  auto upSampler = std::make_unique<TestableUpSampler>();
+  auto kernel = upSampler->getKernel();
+
+  float sum = 0.0f;
+  for (size_t i = 0; i < kernel->getSize(); ++i) {
+    sum += (*kernel)[i];
+  }
+
+  EXPECT_NEAR(sum, 1.0f, 1e-6);
+}
+
+TEST_F(ResamplerTest, DownSamplerKernelSum) {
+  auto downSampler = std::make_unique<TestableDownSampler>();
+  auto kernel = downSampler->getKernel();
+
+  float sum = 0.0f;
+  for (size_t i = 0; i < kernel->getSize(); ++i) {
+    sum += (*kernel)[i];
+  }
+
+  EXPECT_NEAR(sum, 1.0f, 1e-6);
+}
+
+TEST_F(ResamplerTest, UpSamplerProcess) {
+  auto upSampler = std::make_unique<TestableUpSampler>();
+  //TODO: Implement process test
+}
+
+TEST_F(ResamplerTest, DownSamplerProcess) {
+  auto downSampler = std::make_unique<TestableDownSampler>();
+  //TODO: Implement process test
+}
diff --git a/packages/react-native-audio-api/src/api.ts b/packages/react-native-audio-api/src/api.ts
index 9a575300d..1d31bc1d7 100644
--- a/packages/react-native-audio-api/src/api.ts
+++ b/packages/react-native-audio-api/src/api.ts
@@ -75,6 +75,7 @@ export { default as StreamerNode } from './core/StreamerNode';
 export { default as ConstantSourceNode } from './core/ConstantSourceNode';
 export { default as AudioManager } from './system';
 export { default as ConvolverNode } from './core/ConvolverNode';
+export { default as WaveShaperNode } from './core/WaveShaperNode';
 export { default as useSystemVolume } from './hooks/useSystemVolume';
 export { decodeAudioData, decodePCMInBase64 } from './core/AudioDecoder';
 export { default as changePlaybackSpeed } from './core/AudioStretcher';
diff --git a/packages/react-native-audio-api/src/api.web.ts b/packages/react-native-audio-api/src/api.web.ts
index 292f86993..e3b4a9263 100644
--- a/packages/react-native-audio-api/src/api.web.ts
+++ b/packages/react-native-audio-api/src/api.web.ts
@@ -14,6 +14,7 @@ export { default as OscillatorNode } from './web-core/OscillatorNode';
 export { default as StereoPannerNode } from './web-core/StereoPannerNode';
 export { default as ConstantSourceNode } from './web-core/ConstantSourceNode';
 export { default as ConvolverNode } from './web-core/ConvolverNode';
+export { default as WaveShaperNode } from './web-core/WaveShaperNode';
 
 export * from './web-core/custom';
 
diff --git a/packages/react-native-audio-api/src/core/BaseAudioContext.ts b/packages/react-native-audio-api/src/core/BaseAudioContext.ts
index 8b51daf0e..773fe9fd9 100644
--- a/packages/react-native-audio-api/src/core/BaseAudioContext.ts
+++ b/packages/react-native-audio-api/src/core/BaseAudioContext.ts
@@ -30,6 +30,7 @@ import RecorderAdapterNode from './RecorderAdapterNode';
 import StereoPannerNode from './StereoPannerNode';
 import StreamerNode from './StreamerNode';
 import WorkletNode from './WorkletNode';
+import WaveShaperNode from './WaveShaperNode';
 import IIRFilterNode from './IIRFilterNode';
 import { decodeAudioData, decodePCMInBase64 } from './AudioDecoder';
 
@@ -338,4 +339,8 @@ export default class BaseAudioContext {
       this.context.createConvolver(buffer?.buffer, disableNormalization)
     );
   }
+
+  createWaveShaper(): WaveShaperNode {
+    return new WaveShaperNode(this, this.context.createWaveShaper());
+  }
 }
diff --git a/packages/react-native-audio-api/src/core/WaveShaperNode.ts b/packages/react-native-audio-api/src/core/WaveShaperNode.ts
new file mode 100644
index 000000000..069c4d52b
--- /dev/null
+++ b/packages/react-native-audio-api/src/core/WaveShaperNode.ts
@@ -0,0 +1,43 @@
+import AudioNode from './AudioNode';
+import { InvalidStateError } from '../errors';
+import { IWaveShaperNode } from '../interfaces';
+
+export default class WaveShaperNode extends AudioNode {
+  private isCurveSet: boolean = false;
+
+  get curve(): Float32Array | null {
+    if (!this.isCurveSet) {
+      return null;
+    }
+
+    return (this.node as IWaveShaperNode).curve;
+  }
+
+  get oversample(): OverSampleType {
+    return (this.node as IWaveShaperNode).oversample;
+  }
+
+  set curve(curve: Float32Array | null) {
+    if (curve !== null) {
+      if (this.isCurveSet) {
+        throw new InvalidStateError(
+          'The curve can only be set once and cannot be changed afterwards.'
+        );
+      }
+
+      if (curve.length < 2) {
+        throw new InvalidStateError(
+          'The curve must have at least two values if not null.'
+        );
+      }
+
+      this.isCurveSet = true;
+    }
+
+    (this.node as IWaveShaperNode).setCurve(curve);
+  }
+
+  set oversample(value: OverSampleType) {
+    (this.node as IWaveShaperNode).oversample = value;
+  }
+}
diff --git a/packages/react-native-audio-api/src/interfaces.ts b/packages/react-native-audio-api/src/interfaces.ts
index 342588fe9..5c1a763f4 100644
--- a/packages/react-native-audio-api/src/interfaces.ts
+++ b/packages/react-native-audio-api/src/interfaces.ts
@@ -6,6 +6,7 @@ import {
   ContextState,
   OscillatorType,
   WindowType,
+  OverSampleType,
 } from './types';
 
 // IMPORTANT: use only IClass, because it is a part of contract between cpp host object and js layer
@@ -86,6 +87,7 @@ export interface IBaseAudioContext {
     disableNormalization: boolean
   ) => IConvolverNode;
   createStreamer: () => IStreamerNode | null; // null when FFmpeg is not enabled
+  createWaveShaper: () => IWaveShaperNode;
 }
 
 export interface IAudioContext extends IBaseAudioContext {
@@ -279,6 +281,13 @@ export interface IWorkletSourceNode extends IAudioScheduledSourceNode {}
 
 export interface IWorkletProcessingNode extends IAudioNode {}
 
+export interface IWaveShaperNode extends IAudioNode {
+  readonly curve: Float32Array | null;
+  oversample: OverSampleType;
+
+  setCurve(curve: Float32Array | null): void;
+}
+
 export interface IAudioRecorder {
   start: () => void;
   stop: () => void;
@@ -308,7 +317,7 @@ export interface IAudioDecoder {
 
 export interface IAudioStretcher {
   changePlaybackSpeed: (
-    arrayBuffer: AudioBuffer,
+    arrayBuffer: IAudioBuffer,
     playbackSpeed: number
   ) => Promise<IAudioBuffer>;
 }
diff --git a/packages/react-native-audio-api/src/types.ts b/packages/react-native-audio-api/src/types.ts
index 740a7ad14..9e3bc7f93 100644
--- a/packages/react-native-audio-api/src/types.ts
+++ b/packages/react-native-audio-api/src/types.ts
@@ -57,6 +57,7 @@ export interface ConvolverNodeOptions {
   disableNormalization?: boolean;
 }
 
+export type OverSampleType = 'none' | '2x' | '4x';
 export interface IIRFilterNodeOptions {
   feedforward: number[];
   feedback: number[];
diff --git a/packages/react-native-audio-api/src/web-core/AudioContext.tsx b/packages/react-native-audio-api/src/web-core/AudioContext.tsx
index 6e704882e..abb5dcee6 100644
--- a/packages/react-native-audio-api/src/web-core/AudioContext.tsx
+++ b/packages/react-native-audio-api/src/web-core/AudioContext.tsx
@@ -22,6 +22,7 @@ import { ConvolverNodeOptions } from './ConvolverNodeOptions';
 
 import { globalWasmPromise, globalTag } from './custom/LoadCustomWasm';
 import ConstantSourceNode from './ConstantSourceNode';
+import WaveShaperNode from './WaveShaperNode';
 
 export default class AudioContext implements BaseAudioContext {
   readonly context: globalThis.AudioContext;
@@ -170,6 +171,10 @@ export default class AudioContext implements BaseAudioContext {
     return new AnalyserNode(this, this.context.createAnalyser());
   }
 
+  createWaveShaper(): WaveShaperNode {
+    return new WaveShaperNode(this, this.context.createWaveShaper());
+  }
+
   async decodeAudioDataSource(source: string): Promise<AudioBuffer> {
     const arrayBuffer = await fetch(source).then((response) =>
       response.arrayBuffer()
diff --git a/packages/react-native-audio-api/src/web-core/BaseAudioContext.tsx b/packages/react-native-audio-api/src/web-core/BaseAudioContext.tsx
index bc04f0e91..3fa8662c8 100644
--- a/packages/react-native-audio-api/src/web-core/BaseAudioContext.tsx
+++ b/packages/react-native-audio-api/src/web-core/BaseAudioContext.tsx
@@ -15,6 +15,7 @@ import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
 import ConstantSourceNode from './ConstantSourceNode';
 import ConvolverNode from './ConvolverNode';
+import WaveShaperNode from './WaveShaperNode';
 
 export default interface BaseAudioContext {
   readonly context: globalThis.BaseAudioContext;
@@ -43,6 +44,7 @@ export default interface BaseAudioContext {
     constraints?: PeriodicWaveConstraints
   ): PeriodicWave;
   createAnalyser(): AnalyserNode;
+  createWaveShaper(): WaveShaperNode;
   decodeAudioDataSource(source: string): Promise<AudioBuffer>;
   decodeAudioData(arrayBuffer: ArrayBuffer): Promise<AudioBuffer>;
 }
diff --git a/packages/react-native-audio-api/src/web-core/OfflineAudioContext.tsx b/packages/react-native-audio-api/src/web-core/OfflineAudioContext.tsx
index 86fbae9f4..7a6873419 100644
--- a/packages/react-native-audio-api/src/web-core/OfflineAudioContext.tsx
+++ b/packages/react-native-audio-api/src/web-core/OfflineAudioContext.tsx
@@ -18,6 +18,7 @@ import OscillatorNode from './OscillatorNode';
 import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
 import ConstantSourceNode from './ConstantSourceNode';
+import WaveShaperNode from './WaveShaperNode';
 
 import { globalWasmPromise, globalTag } from './custom/LoadCustomWasm';
 import ConvolverNode from './ConvolverNode';
@@ -176,6 +177,10 @@ export default class OfflineAudioContext implements BaseAudioContext {
     return new AnalyserNode(this, this.context.createAnalyser());
   }
 
+  createWaveShaper(): WaveShaperNode {
+    return new WaveShaperNode(this, this.context.createWaveShaper());
+  }
+
   async decodeAudioDataSource(source: string): Promise<AudioBuffer> {
     const arrayBuffer = await fetch(source).then((response) =>
       response.arrayBuffer()
diff --git a/packages/react-native-audio-api/src/web-core/WaveShaperNode.tsx b/packages/react-native-audio-api/src/web-core/WaveShaperNode.tsx
new file mode 100644
index 000000000..96addac2d
--- /dev/null
+++ b/packages/react-native-audio-api/src/web-core/WaveShaperNode.tsx
@@ -0,0 +1,42 @@
+import { InvalidStateError } from '../errors';
+import AudioNode from './AudioNode';
+
+export default class WaveShaperNode extends AudioNode {
+  private isCurveSet: boolean = false;
+
+  get curve(): Float32Array | null {
+    if (!this.isCurveSet) {
+      return null;
+    }
+
+    return (this.node as globalThis.WaveShaperNode).curve;
+  }
+
+  get oversample(): OverSampleType {
+    return (this.node as globalThis.WaveShaperNode).oversample;
+  }
+
+  set curve(curve: Float32Array | null) {
+    if (curve !== null) {
+      if (this.isCurveSet) {
+        throw new InvalidStateError(
+          'The curve can only be set once and cannot be changed afterwards.'
+        );
+      }
+
+      if (curve.length < 2) {
+        throw new InvalidStateError(
+          'The curve must have at least two values if not null.'
+        );
+      }
+
+      this.isCurveSet = true;
+    }
+
+    (this.node as globalThis.WaveShaperNode).curve = curve;
+  }
+
+  set oversample(value: OverSampleType) {
+    (this.node as globalThis.WaveShaperNode).oversample = value;
+  }
+}