diff --git a/.cspell-wordlist.txt b/.cspell-wordlist.txt
index f1d55b4c98..e90a9b0d50 100644
--- a/.cspell-wordlist.txt
+++ b/.cspell-wordlist.txt
@@ -183,3 +183,8 @@ Synchronizable
 stringifying
 hɛloʊ
 wɜːld
+webrtc
+fishjam
+Fishjam
+deinitialize
+Deinitialize
diff --git a/apps/computer-vision/app.json b/apps/computer-vision/app.json
index 4fcbca2ce3..c2cfc3e45a 100644
--- a/apps/computer-vision/app.json
+++ b/apps/computer-vision/app.json
@@ -17,7 +17,8 @@
       "supportsTablet": true,
       "bundleIdentifier": "com.anonymous.computervision",
       "infoPlist": {
-        "NSCameraUsageDescription": "Process photo from camera"
+        "NSCameraUsageDescription": "Process photo from camera",
+        "NSMicrophoneUsageDescription": "Required for audio processing"
       }
     },
     "android": {
@@ -26,7 +27,12 @@
         "backgroundColor": "#ffffff"
       },
       "package": "com.anonymous.computervision",
-      "permissions": ["android.permission.CAMERA"]
+      "permissions": [
+        "android.permission.CAMERA",
+        "android.permission.INTERNET",
+        "android.permission.RECORD_AUDIO",
+        "android.permission.ACCESS_NETWORK_STATE"
+      ]
     },
     "web": {
       "favicon": "./assets/icons/favicon.png"
diff --git a/packages/react-native-executorch-webrtc/README.md b/packages/react-native-executorch-webrtc/README.md
new file mode 100644
index 0000000000..711fa74522
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/README.md
@@ -0,0 +1,91 @@
+# react-native-executorch-webrtc
+
+Real-time background blur for Fishjam WebRTC applications, powered by ExecuTorch segmentation models.
+
+This package provides GPU-accelerated background blur effects using on-device ExecuTorch models for foreground / background segmentation.
+
+## Requirements
+
+- iOS 13.0+
+- Android SDK 26+
+- Peer dependencies:
+- `@fishjam-cloud/react-native-client`
+- `@fishjam-cloud/react-native-webrtc`
+- `react-native-executorch`
+
+## Installation
+
+```bash
+yarn add react-native-executorch-webrtc
+```
+
+For iOS:
+```bash
+cd ios && pod install
+```
+
+## Usage
+
+### With Fishjam SDK
+
+```tsx
+import { useBackgroundBlur } from 'react-native-executorch-webrtc';
+import { useCamera } from '@fishjam-cloud/react-native-client';
+
+function VideoCall() {
+  const [blurEnabled, setBlurEnabled] = useState(true);
+
+  const { blurMiddleware } = useBackgroundBlur({
+    // NOTE: you can use React Native Executorch's Resource Fetcher to download model files
+    modelUri: 'file:///path/to/selfie_segmenter.pte',
+    blurRadius: 15,
+  });
+
+  const { toggleCamera } = useCamera({
+    cameraTrackMiddleware: blurEnabled ? blurMiddleware : undefined,
+  });
+
+  return (
+    <Button
+      title={blurEnabled ? 'Disable Blur' : 'Enable Blur'}
+      onPress={() => setBlurEnabled(!blurEnabled)}
+    />
+  );
+}
+```
+
+## API
+
+### `useBackgroundBlur(options)`
+
+React hook that provides camera track middleware for background blur.
+
+**Options:**
+- `modelUri`: `string` - Path to the ExecuTorch segmentation model (.pte file)
+- `blurRadius`: `number` (optional, default: 12) - Blur intensity
+
+**Returns:**
+- `blurMiddleware`: `TrackMiddleware` - Middleware function for use with Fishjam's `useCamera`
+
+### Blur Radius
+
+The `blurRadius` can be updated dynamically without reinitializing:
+
+```tsx
+const { blurMiddleware } = useBackgroundBlur({
+  modelUri: modelPath,
+  blurRadius: intensity,
+});
+```
+
+## Platform Notes
+
+### iOS
+Uses Core Image for GPU-accelerated blur compositing.
+
+### Android
+Uses OpenGL ES shaders for blur and compositing. OpenMP is used for parallel CPU operations.
+
+## License
+
+MIT
diff --git a/packages/react-native-executorch-webrtc/android/CMakeLists.txt b/packages/react-native-executorch-webrtc/android/CMakeLists.txt
new file mode 100644
index 0000000000..73375ba4c3
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/android/CMakeLists.txt
@@ -0,0 +1,78 @@
+cmake_minimum_required(VERSION 3.13)
+project(react-native-executorch-webrtc)
+
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+# Paths to react-native-executorch
+set(RN_EXECUTORCH_DIR "${CMAKE_SOURCE_DIR}/../../react-native-executorch")
+set(RN_EXECUTORCH_THIRD_PARTY "${RN_EXECUTORCH_DIR}/third-party/include")
+
+# Add our JNI bridge source files
+file(GLOB SOURCES "src/main/cpp/*.cpp")
+
+add_library(
+  ${CMAKE_PROJECT_NAME}
+  SHARED
+  ${SOURCES}
+)
+
+# Find packages - ReactAndroid provides JSI headers
+find_package(ReactAndroid REQUIRED CONFIG)
+find_package(fbjni REQUIRED CONFIG)
+find_package(react-native-executorch REQUIRED CONFIG)
+
+# Include headers
+target_include_directories(
+  ${CMAKE_PROJECT_NAME}
+  PRIVATE
+  "${RN_EXECUTORCH_DIR}/common"
+  "${RN_EXECUTORCH_THIRD_PARTY}"
+)
+
+# Find prebuilt libraries
+find_library(LOG_LIB log)
+find_library(ANDROID_LIB android)
+
+# Import ExecuTorch library
+set(LIBS_DIR "${RN_EXECUTORCH_DIR}/third-party/android/libs")
+add_library(executorch SHARED IMPORTED)
+set_target_properties(executorch PROPERTIES
+  IMPORTED_LOCATION "${LIBS_DIR}/executorch/${ANDROID_ABI}/libexecutorch.so")
+
+# OpenCV libraries
+set(OPENCV_LIBS
+  "${LIBS_DIR}/opencv/${ANDROID_ABI}/libopencv_core.a"
+  "${LIBS_DIR}/opencv/${ANDROID_ABI}/libopencv_imgproc.a"
+)
+
+# OpenCV third-party libraries (arm64 specific)
+if(ANDROID_ABI STREQUAL "arm64-v8a")
+  set(OPENCV_THIRD_PARTY_LIBS
+    "${LIBS_DIR}/opencv-third-party/${ANDROID_ABI}/libkleidicv_hal.a"
+    "${LIBS_DIR}/opencv-third-party/${ANDROID_ABI}/libkleidicv_thread.a"
+    "${LIBS_DIR}/opencv-third-party/${ANDROID_ABI}/libkleidicv.a"
+  )
+else()
+  set(OPENCV_THIRD_PARTY_LIBS "")
+endif()
+
+# OpenMP for OpenCV parallel operations
+target_link_options(${CMAKE_PROJECT_NAME} PRIVATE -fopenmp -static-openmp)
+
+# Link against libraries
+target_link_libraries(
+  ${CMAKE_PROJECT_NAME}
+  ${LOG_LIB}
+  ${ANDROID_LIB}
+  ReactAndroid::jsi
+  ReactAndroid::reactnative
+  fbjni::fbjni
+  react-native-executorch::react-native-executorch
+  ${OPENCV_LIBS}
+  ${OPENCV_THIRD_PARTY_LIBS}
+  executorch
+)
+
+# Ensure react-native-executorch symbols are exported (needed for BaseModel/BaseSemanticSegmentation)
+target_link_options(${CMAKE_PROJECT_NAME} PRIVATE -Wl,--no-as-needed)
diff --git a/packages/react-native-executorch-webrtc/android/build.gradle b/packages/react-native-executorch-webrtc/android/build.gradle
new file mode 100644
index 0000000000..bdda915ef0
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/android/build.gradle
@@ -0,0 +1,72 @@
+buildscript {
+    ext.kotlin_version = '1.9.0'
+
+    repositories {
+        google()
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.2.2'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+    namespace 'com.executorch.webrtc'
+    compileSdkVersion 34
+
+    buildFeatures {
+        prefab true
+    }
+
+    defaultConfig {
+        minSdkVersion 26
+        targetSdkVersion 34
+
+        externalNativeBuild {
+            cmake {
+                cppFlags "-std=c++20"
+                arguments "-DANDROID_STL=c++_shared"
+            }
+        }
+
+        ndk {
+            // Only build for architectures where OpenCV/ExecuTorch libraries exist
+            abiFilters 'arm64-v8a'
+        }
+    }
+
+    externalNativeBuild {
+        cmake {
+            path "CMakeLists.txt"
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = '17'
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    implementation 'com.facebook.react:react-native:+'
+
+    // WebRTC classes - provided by app via autolinking
+    compileOnly project(':fishjam-cloud_react-native-webrtc')
+    // ExecuTorch for vision model processing
+    compileOnly project(':react-native-executorch')
+}
diff --git a/packages/react-native-executorch-webrtc/android/gradle/wrapper/gradle-wrapper.jar b/packages/react-native-executorch-webrtc/android/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000000..980502d167
Binary files /dev/null and b/packages/react-native-executorch-webrtc/android/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/packages/react-native-executorch-webrtc/android/gradle/wrapper/gradle-wrapper.properties b/packages/react-native-executorch-webrtc/android/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000000..128196a7a3
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/android/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.0-milestone-1-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/packages/react-native-executorch-webrtc/android/gradlew b/packages/react-native-executorch-webrtc/android/gradlew
new file mode 100755
index 0000000000..faf93008b7
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/android/gradlew
@@ -0,0 +1,251 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"
diff --git a/packages/react-native-executorch-webrtc/android/gradlew.bat b/packages/react-native-executorch-webrtc/android/gradlew.bat
new file mode 100644
index 0000000000..9d21a21834
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/android/gradlew.bat
@@ -0,0 +1,94 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/packages/react-native-executorch-webrtc/android/src/main/AndroidManifest.xml b/packages/react-native-executorch-webrtc/android/src/main/AndroidManifest.xml
new file mode 100644
index 0000000000..f691675edd
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/android/src/main/AndroidManifest.xml
@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.executorch.webrtc">
+    <uses-sdk android:minSdkVersion="26" />
+</manifest>
diff --git a/packages/react-native-executorch-webrtc/android/src/main/cpp/FrameProcessorBridge.cpp b/packages/react-native-executorch-webrtc/android/src/main/cpp/FrameProcessorBridge.cpp
new file mode 100644
index 0000000000..2f60b458b9
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/android/src/main/cpp/FrameProcessorBridge.cpp
@@ -0,0 +1,216 @@
+#include <android/log.h>
+#include <chrono>
+#include <cmath>
+#include <jni.h>
+#include <memory>
+#include <opencv2/opencv.hpp>
+#include <set>
+#include <string>
+#include <vector>
+
+// Use BaseSemanticSegmentation from react-native-executorch
+#include <rnexecutorch/host_objects/JSTensorViewIn.h>
+#include <rnexecutorch/models/semantic_segmentation/BaseSemanticSegmentation.h>
+
+#define LOG_TAG "ExecutorchWebRTC-JNI"
+#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+using namespace rnexecutorch;
+using namespace rnexecutorch::models::semantic_segmentation;
+
+// Global segmentation model instance (reuses react-native-executorch's
+// implementation)
+static std::unique_ptr<BaseSemanticSegmentation> g_segmentation = nullptr;
+static bool g_modelLoaded = false;
+static std::string g_modelPath;
+
+// Model input dimensions (dynamically read from model)
+static int g_modelHeight = 256;
+static int g_modelWidth = 256;
+
+// Pre-allocated buffers
+static cv::Mat g_resizedRgb;
+
+// Debug logging rate limiter
+static long long g_lastDebugLogTime = 0;
+
+extern "C" {
+
+/**
+ * Load the segmentation model using BaseSemanticSegmentation
+ */
+JNIEXPORT jboolean JNICALL
+Java_com_executorch_webrtc_ExecutorchFrameProcessor_loadModel(
+    JNIEnv *env, jobject thiz, jstring modelPath) {
+  const char *pathChars = env->GetStringUTFChars(modelPath, nullptr);
+  if (pathChars == nullptr) {
+    LOGE("Failed to get model path string");
+    return JNI_FALSE;
+  }
+
+  g_modelPath = std::string(pathChars);
+  env->ReleaseStringUTFChars(modelPath, pathChars);
+
+  LOGD("Loading segmentation model via BaseSemanticSegmentation: %s",
+       g_modelPath.c_str());
+
+  try {
+    // Create BaseSemanticSegmentation with:
+    // - modelSource: path to .pte file
+    // - normMean: empty (uses default 0, which means /255.0 normalization)
+    // - normStd: empty (uses default 1)
+    // - allClasses: ["foreground", "background"] for binary segmentation
+    // - callInvoker: nullptr (we don't need JSI operations)
+    std::vector<float> normMean = {}; // Default normalization
+    std::vector<float> normStd = {};
+    std::vector<std::string> allClasses = {"foreground", "background"};
+
+    g_segmentation = std::make_unique<BaseSemanticSegmentation>(
+        g_modelPath, normMean, normStd, allClasses, nullptr);
+
+    // Get model input size from shape [N, C, H, W]
+    auto inputShapes = g_segmentation->getAllInputShapes();
+    if (!inputShapes.empty() && inputShapes[0].size() >= 4) {
+      g_modelHeight = inputShapes[0][inputShapes[0].size() - 2];
+      g_modelWidth = inputShapes[0][inputShapes[0].size() - 1];
+    }
+
+    LOGD("Model input size: %dx%d", g_modelWidth, g_modelHeight);
+
+    // Pre-allocate buffers
+    g_resizedRgb = cv::Mat(g_modelHeight, g_modelWidth, CV_8UC3);
+
+    g_modelLoaded = true;
+    LOGD("Segmentation model loaded successfully via "
+         "BaseSemanticSegmentation!");
+    return JNI_TRUE;
+  } catch (const std::exception &e) {
+    LOGE("Failed to load model: %s", e.what());
+    g_modelLoaded = false;
+    g_segmentation.reset();
+    return JNI_FALSE;
+  }
+}
+
+/**
+ * Run segmentation on RGBA pixels, returns grayscale mask (0-255 bytes).
+ * Used by GL-based blur pipeline.
+ */
+JNIEXPORT jbyteArray JNICALL
+Java_com_executorch_webrtc_ExecutorchFrameProcessor_runSegmentation(
+    JNIEnv *env, jobject thiz, jbyteArray rgbaData, jint width, jint height,
+    jint rotation) {
+
+  if (!g_modelLoaded || !g_segmentation) {
+    LOGE("Model not loaded, cannot run segmentation");
+    return nullptr;
+  }
+
+  jbyte *rgbaPtr = env->GetByteArrayElements(rgbaData, nullptr);
+  if (!rgbaPtr) {
+    LOGE("Failed to get RGBA data pointer");
+    return nullptr;
+  }
+
+  try {
+    // Convert RGBA to RGB (OpenCV expects BGR, but we'll convert to RGB for
+    // model)
+    cv::Mat rgba(height, width, CV_8UC4, reinterpret_cast<uint8_t *>(rgbaPtr));
+    cv::Mat rgb;
+    cv::cvtColor(rgba, rgb, cv::COLOR_RGBA2RGB);
+
+    // Apply rotation for model inference
+    cv::Mat rgbRotated;
+    if (rotation == 90) {
+      cv::rotate(rgb, rgbRotated, cv::ROTATE_90_CLOCKWISE);
+    } else if (rotation == 180) {
+      cv::rotate(rgb, rgbRotated, cv::ROTATE_180);
+    } else if (rotation == 270) {
+      cv::rotate(rgb, rgbRotated, cv::ROTATE_90_COUNTERCLOCKWISE);
+    } else {
+      rgbRotated = rgb;
+    }
+
+    // Run segmentation model
+    JSTensorViewIn pixelData;
+    pixelData.dataPtr = rgbRotated.data;
+    pixelData.sizes = {rgbRotated.rows, rgbRotated.cols, 3};
+    pixelData.scalarType = executorch::aten::ScalarType::Byte;
+
+    std::set<std::string, std::less<>> classesOfInterest = {"foreground"};
+    auto result =
+        g_segmentation->generateFromPixels(pixelData, classesOfInterest, false);
+
+    // Extract mask
+    cv::Mat mask;
+    if (result.classBuffers && result.classBuffers->count("foreground")) {
+      auto &fgBuffer = result.classBuffers->at("foreground");
+      auto *fgData = reinterpret_cast<float *>(fgBuffer->data());
+      mask = cv::Mat(g_modelHeight, g_modelWidth, CV_32FC1, fgData).clone();
+    } else {
+      LOGE("No foreground mask in result");
+      env->ReleaseByteArrayElements(rgbaData, rgbaPtr, JNI_ABORT);
+      return nullptr;
+    }
+
+    // Rotate mask back to original orientation
+    cv::Mat maskRotated;
+    if (rotation == 90) {
+      cv::rotate(mask, maskRotated, cv::ROTATE_90_COUNTERCLOCKWISE);
+    } else if (rotation == 180) {
+      cv::rotate(mask, maskRotated, cv::ROTATE_180);
+    } else if (rotation == 270) {
+      cv::rotate(mask, maskRotated, cv::ROTATE_90_CLOCKWISE);
+    } else {
+      maskRotated = mask;
+    }
+
+    // Resize mask to input dimensions
+    cv::Mat maskResized;
+    cv::resize(maskRotated, maskResized, cv::Size(width, height), 0, 0,
+               cv::INTER_LINEAR);
+
+    // Convert float mask (0-1) to bytes (0-255)
+    cv::Mat maskBytes;
+    maskResized.convertTo(maskBytes, CV_8UC1, 255.0);
+
+    // Create output array
+    const int maskSize = width * height;
+    jbyteArray output = env->NewByteArray(maskSize);
+    if (!output) {
+      env->ReleaseByteArrayElements(rgbaData, rgbaPtr, JNI_ABORT);
+      return nullptr;
+    }
+
+    env->SetByteArrayRegion(output, 0, maskSize,
+                            reinterpret_cast<jbyte *>(maskBytes.data));
+
+    env->ReleaseByteArrayElements(rgbaData, rgbaPtr, JNI_ABORT);
+    return output;
+
+  } catch (const std::exception &e) {
+    LOGE("Segmentation failed: %s", e.what());
+    env->ReleaseByteArrayElements(rgbaData, rgbaPtr, JNI_ABORT);
+    return nullptr;
+  }
+}
+
+/**
+ * Unload the segmentation model and release all buffers
+ */
+JNIEXPORT void JNICALL
+Java_com_executorch_webrtc_ExecutorchFrameProcessor_unloadModel(JNIEnv *env,
+                                                                jobject thiz) {
+  LOGD("Unloading segmentation model and releasing resources");
+
+  g_segmentation.reset();
+  g_modelLoaded = false;
+  g_modelPath.clear();
+
+  // Release pre-allocated buffers
+  g_resizedRgb.release();
+
+  LOGD("Model unloaded and resources released");
+}
+} // extern "C"
diff --git a/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/ExecutorchFrameProcessor.kt b/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/ExecutorchFrameProcessor.kt
new file mode 100644
index 0000000000..1fea123e0e
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/ExecutorchFrameProcessor.kt
@@ -0,0 +1,316 @@
+package com.executorch.webrtc
+
+import android.graphics.Matrix
+import android.util.Log
+import com.executorch.webrtc.gl.GlBlurRenderer
+import com.oney.WebRTCModule.videoEffects.VideoFrameProcessor
+import org.webrtc.SurfaceTextureHelper
+import org.webrtc.TextureBufferImpl
+import org.webrtc.VideoFrame
+import org.webrtc.YuvConverter
+import java.nio.ByteBuffer
+
+/**
+ * WebRTC frame processor that applies background blur using GPU shaders + ExecuTorch segmentation.
+ * Uses MaskPostProcessor for temporal smoothing (EMA) and edge refinement.
+ *
+ * Architecture matches fishjam's BackgroundBlurProcessor but uses ExecuTorch for mask generation
+ * instead of ML Kit.
+ */
+class ExecutorchFrameProcessor : VideoFrameProcessor {
+  companion object {
+    private const val TAG = "ExecutorchFrameProcessor"
+    private const val LOG_INTERVAL_FRAMES = 30
+
+    @Volatile
+    private var pendingBlurRadius: Float = -1f
+
+    @JvmStatic
+    fun setBlurRadius(radius: Float) {
+      pendingBlurRadius = radius
+    }
+  }
+
+  private val renderer = GlBlurRenderer()
+  private val maskPostProcessor = MaskPostProcessor()
+
+  @Volatile
+  private var isProcessing = false
+  private var lastProcessedFrame: VideoFrame? = null
+  private var yuvConverter: YuvConverter? = null
+
+  private var modelLoaded = false
+  private var loadedModelPath: String? = null
+  private var rgbaBuffer: ByteArray? = null
+
+  // Timing measurements
+  private var frameCount = 0
+  private var totalTimeAccumulator = 0L
+  private var inferenceTimeAccumulator = 0L
+  private var maskPostProcessTimeAccumulator = 0L
+  private var gpuTimeAccumulator = 0L
+
+  init {
+    Log.d(TAG, "ExecutorchFrameProcessor created")
+    tryLoadModel()
+  }
+
+  private fun tryLoadModel() {
+    val configuredPath = ExecutorchWebRTC.modelPath ?: return
+    if (modelLoaded && loadedModelPath == configuredPath) return
+
+    try {
+      Log.d(TAG, "Loading segmentation model: $configuredPath")
+      val success = loadModel(configuredPath)
+      if (success) {
+        modelLoaded = true
+        loadedModelPath = configuredPath
+        Log.d(TAG, "Model loaded successfully!")
+      }
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to load model", e)
+    }
+  }
+
+  // JNI: Load the segmentation model
+  private external fun loadModel(modelPath: String): Boolean
+
+  // JNI: Run segmentation on RGBA pixels, returns grayscale mask
+  private external fun runSegmentation(
+    rgbaData: ByteArray,
+    width: Int,
+    height: Int,
+    rotation: Int,
+  ): ByteArray?
+
+  // JNI: Unload model and release native resources
+  private external fun unloadModel()
+
+  override fun process(
+    frame: VideoFrame,
+    helper: SurfaceTextureHelper,
+  ): VideoFrame {
+    // Return cached frame if busy
+    if (isProcessing) {
+      if (lastProcessedFrame != null) {
+        lastProcessedFrame!!.retain()
+        return lastProcessedFrame!!
+      }
+      frame.retain()
+      return frame
+    }
+
+    val buffer = frame.buffer
+    if (buffer !is VideoFrame.TextureBuffer) {
+      frame.retain()
+      return frame
+    }
+
+    isProcessing = true
+    return try {
+      val result = processFrame(frame, buffer, helper)
+      // Cache processed frame
+      lastProcessedFrame?.release()
+      result.retain()
+      lastProcessedFrame = result
+      result
+    } catch (e: Exception) {
+      Log.e(TAG, "Error processing frame", e)
+      frame.retain()
+      frame
+    } finally {
+      isProcessing = false
+    }
+  }
+
+  private fun processFrame(
+    frame: VideoFrame,
+    textureBuffer: VideoFrame.TextureBuffer,
+    helper: SurfaceTextureHelper,
+  ): VideoFrame {
+    val totalStartTime = System.nanoTime()
+
+    applyPendingBlurRadius()
+    if (!modelLoaded) tryLoadModel()
+
+    val width = textureBuffer.width
+    val height = textureBuffer.height
+
+    renderer.ensureSetup(width, height)
+    if (yuvConverter == null) {
+      yuvConverter = YuvConverter()
+    }
+
+    // Convert transform matrix for GL
+    val transformMatrix = convertToGlMatrix(textureBuffer.transformMatrix)
+    val isOes = textureBuffer.type == VideoFrame.TextureBuffer.Type.OES
+
+    val gpuStartTime = System.nanoTime()
+
+    // 1. Render input texture to RGBA FBO
+    renderer.renderToRgbaFbo(textureBuffer.textureId, transformMatrix, isOes)
+
+    // 2. Render downscaled for segmentation
+    renderer.renderDownscaled()
+
+    // 3. Read pixels for segmentation
+    val segPixels = renderer.readSegmentationPixels()
+    val segW = renderer.segmentationWidth
+    val segH = renderer.segmentationHeight
+
+    // 4. Run segmentation (via JNI)
+    val inferenceStartTime = System.nanoTime()
+    val rawMask = runSegmentationOnPixels(segPixels, segW, segH, frame.rotation)
+    val inferenceEndTime = System.nanoTime()
+
+    if (rawMask != null) {
+      // 5. Post-process mask (morphology + EMA) - blur now on GPU
+      val maskPostProcessStartTime = System.nanoTime()
+      val processedMask = maskPostProcessor.process(rawMask, segW, segH)
+      val maskPostProcessEndTime = System.nanoTime()
+      maskPostProcessTimeAccumulator += (maskPostProcessEndTime - maskPostProcessStartTime)
+
+      // 6. Upload processed mask to GPU
+      renderer.uploadMask(processedMask, segW, segH)
+    }
+
+    // 7. Render blur
+    renderer.renderBlur()
+
+    // 8. Render composite (blend original + blurred using mask)
+    renderer.renderComposite()
+
+    val gpuEndTime = System.nanoTime()
+
+    // 9. Create output TextureBuffer
+    val outputBuffer =
+      TextureBufferImpl(
+        width,
+        height,
+        VideoFrame.TextureBuffer.Type.RGB,
+        renderer.outputTextureId,
+        Matrix(),
+        helper.handler,
+        yuvConverter,
+        null,
+      )
+
+    val totalEndTime = System.nanoTime()
+
+    // Accumulate timing measurements
+    totalTimeAccumulator += (totalEndTime - totalStartTime)
+    inferenceTimeAccumulator += (inferenceEndTime - inferenceStartTime)
+    gpuTimeAccumulator += (gpuEndTime - gpuStartTime) - (inferenceEndTime - inferenceStartTime)
+    frameCount++
+
+    // Log averages every LOG_INTERVAL_FRAMES frames
+    if (frameCount >= LOG_INTERVAL_FRAMES) {
+      val avgTotalMs = (totalTimeAccumulator / frameCount) / 1_000_000.0
+      val avgInferenceMs = (inferenceTimeAccumulator / frameCount) / 1_000_000.0
+      val avgMaskPostProcessMs = (maskPostProcessTimeAccumulator / frameCount) / 1_000_000.0
+      val avgGpuMs = (gpuTimeAccumulator / frameCount) / 1_000_000.0
+      val fps = 1000.0 / avgTotalMs
+
+      Log.d(
+        TAG,
+        String.format(
+          "Avg over %d frames: Total=%.2fms (%.1f FPS) | Inference=%.2fms | MaskCPU=%.2fms | GPU=%.2fms",
+          frameCount,
+          avgTotalMs,
+          fps,
+          avgInferenceMs,
+          avgMaskPostProcessMs,
+          avgGpuMs,
+        ),
+      )
+
+      // Reset accumulators
+      frameCount = 0
+      totalTimeAccumulator = 0L
+      inferenceTimeAccumulator = 0L
+      maskPostProcessTimeAccumulator = 0L
+      gpuTimeAccumulator = 0L
+    }
+
+    return VideoFrame(outputBuffer, frame.rotation, frame.timestampNs)
+  }
+
+  private fun applyPendingBlurRadius() {
+    val radius = pendingBlurRadius
+    if (radius < 0f) return
+    pendingBlurRadius = -1f
+    renderer.setBlurRadius(radius)
+  }
+
+  private fun runSegmentationOnPixels(
+    pixels: ByteBuffer,
+    width: Int,
+    height: Int,
+    rotation: Int,
+  ): ByteArray? {
+    if (!modelLoaded) {
+      val result = ByteArray(width * height)
+      result.fill(0)
+      return result
+    }
+
+    // Convert ByteBuffer to ByteArray for JNI
+    val size = width * height * 4
+    if (rgbaBuffer == null || rgbaBuffer!!.size < size) {
+      rgbaBuffer = ByteArray(size)
+    }
+    pixels.rewind()
+    pixels.get(rgbaBuffer!!, 0, size)
+
+    return runSegmentation(rgbaBuffer!!, width, height, rotation)
+  }
+
+  private fun convertToGlMatrix(androidMatrix: android.graphics.Matrix): FloatArray {
+    val values = FloatArray(9)
+    androidMatrix.getValues(values)
+    // Convert 3x3 to 4x4 matrix for GL
+    return floatArrayOf(
+      values[0],
+      values[3],
+      0f,
+      values[6],
+      values[1],
+      values[4],
+      0f,
+      values[7],
+      0f,
+      0f,
+      1f,
+      0f,
+      values[2],
+      values[5],
+      0f,
+      values[8],
+    )
+  }
+
+  fun release() {
+    Log.d(TAG, "Releasing ExecutorchFrameProcessor resources")
+
+    // Release GPU resources
+    renderer.release()
+    yuvConverter?.release()
+    yuvConverter = null
+
+    // Release cached frame
+    lastProcessedFrame?.release()
+    lastProcessedFrame = null
+
+    // Unload native model and buffers
+    if (modelLoaded) {
+      unloadModel()
+      modelLoaded = false
+      loadedModelPath = null
+    }
+
+    // Clear buffers
+    rgbaBuffer = null
+
+    Log.d(TAG, "ExecutorchFrameProcessor resources released")
+  }
+}
diff --git a/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/ExecutorchFrameProcessorFactory.kt b/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/ExecutorchFrameProcessorFactory.kt
new file mode 100644
index 0000000000..3d7d2bda6a
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/ExecutorchFrameProcessorFactory.kt
@@ -0,0 +1,33 @@
+package com.executorch.webrtc
+
+import com.oney.WebRTCModule.videoEffects.VideoFrameProcessor
+import com.oney.WebRTCModule.videoEffects.VideoFrameProcessorFactoryInterface
+
+/**
+ * Factory for creating ExecutorchFrameProcessor instances.
+ * Required by react-native-webrtc's ProcessorProvider system.
+ */
+class ExecutorchFrameProcessorFactory : VideoFrameProcessorFactoryInterface {
+  companion object {
+    private val activeProcessors = mutableListOf<ExecutorchFrameProcessor>()
+
+    /**
+     * Release all active processors and clear the list
+     */
+    @JvmStatic
+    fun releaseAll() {
+      synchronized(activeProcessors) {
+        activeProcessors.forEach { it.release() }
+        activeProcessors.clear()
+      }
+    }
+  }
+
+  override fun build(): VideoFrameProcessor {
+    val processor = ExecutorchFrameProcessor()
+    synchronized(activeProcessors) {
+      activeProcessors.add(processor)
+    }
+    return processor
+  }
+}
diff --git a/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/ExecutorchWebRTC.kt b/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/ExecutorchWebRTC.kt
new file mode 100644
index 0000000000..dd49fca850
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/ExecutorchWebRTC.kt
@@ -0,0 +1,60 @@
+package com.executorch.webrtc
+
+import android.util.Log
+import com.oney.WebRTCModule.videoEffects.ProcessorProvider
+
+/**
+ * Main entry point for ExecuTorch WebRTC integration.
+ * Registers the background blur processor with react-native-webrtc.
+ */
+object ExecutorchWebRTC {
+  private const val TAG = "ExecutorchWebRTC"
+  const val PROCESSOR_NAME = "executorchBackgroundBlur"
+
+  // Configuration for background removal
+  var modelPath: String? = null
+
+  /**
+   * Registers the frame processor with react-native-webrtc.
+   */
+  fun registerProcessors() {
+    try {
+      ProcessorProvider.addProcessor(PROCESSOR_NAME, ExecutorchFrameProcessorFactory())
+      Log.d(TAG, "Registered processor: $PROCESSOR_NAME")
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to register $PROCESSOR_NAME", e)
+    }
+  }
+
+  /**
+   * Configure the segmentation model for background removal
+   */
+  fun configureModel(path: String) {
+    Log.d(TAG, "configureModel called with path: $path")
+    modelPath = path
+    Log.d(TAG, "Model path configured - processor will load model on next frame")
+  }
+
+  /**
+   * Set the blur radius dynamically
+   */
+  fun setBlurRadius(radius: Float) {
+    ExecutorchFrameProcessor.setBlurRadius(radius)
+  }
+
+  /**
+   * Deinitialize and release all resources
+   */
+  fun deinitialize() {
+    Log.d(TAG, "Deinitializing ExecutorchWebRTC")
+    modelPath = null
+    ExecutorchFrameProcessorFactory.releaseAll()
+    Log.d(TAG, "ExecutorchWebRTC deinitialized")
+  }
+
+  /**
+   * Gets the processor name to use in JavaScript.
+   * Use this when calling videoTrack._setVideoEffects(['...'])
+   */
+  fun getProcessorName(): String = PROCESSOR_NAME
+}
diff --git a/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/ExecutorchWebRTCModule.kt b/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/ExecutorchWebRTCModule.kt
new file mode 100644
index 0000000000..0312a5a442
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/ExecutorchWebRTCModule.kt
@@ -0,0 +1,75 @@
+package com.executorch.webrtc
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.module.annotations.ReactModule
+
+/**
+ * Native module for ExecuTorch WebRTC background blur.
+ * API compatible with @fishjam-cloud/react-native-webrtc-background-blur.
+ */
+@ReactModule(name = ExecutorchWebRTCModule.NAME)
+class ExecutorchWebRTCModule(
+  reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+  companion object {
+    init {
+      System.loadLibrary("executorch")
+      System.loadLibrary("react-native-executorch-webrtc")
+    }
+
+    const val NAME = "ExecutorchWebRTC"
+    private var processorsRegistered = false
+  }
+
+  init {
+    // Auto-register the processor when the module is loaded
+    if (!processorsRegistered) {
+      ExecutorchWebRTC.registerProcessors()
+      processorsRegistered = true
+    }
+  }
+
+  override fun getName(): String = NAME
+
+  /**
+   * Initialize background blur with the segmentation model.
+   * @param modelPath Path to the .pte model file
+   */
+  @ReactMethod
+  fun initialize(modelPath: String) {
+    ExecutorchWebRTC.configureModel(modelPath)
+  }
+
+  /**
+   * Deinitialize and release resources.
+   */
+  @ReactMethod
+  fun deinitialize() {
+    ExecutorchWebRTC.deinitialize()
+  }
+
+  /**
+   * Set the blur radius/intensity.
+   * @param radius Blur sigma value (default 12.0)
+   */
+  @ReactMethod
+  fun setBlurRadius(radius: Double) {
+    ExecutorchWebRTC.setBlurRadius(radius.toFloat())
+  }
+
+  /**
+   * Check if background blur is available on this device.
+   */
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun isAvailable(): Boolean {
+    return true // Always available on Android with ExecuTorch
+  }
+
+  /**
+   * Get the processor name for use with _setVideoEffect().
+   */
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun getProcessorName(): String = ExecutorchWebRTC.PROCESSOR_NAME
+}
diff --git a/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/ExecutorchWebRTCPackage.kt b/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/ExecutorchWebRTCPackage.kt
new file mode 100644
index 0000000000..2b63e88243
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/ExecutorchWebRTCPackage.kt
@@ -0,0 +1,12 @@
+package com.executorch.webrtc
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class ExecutorchWebRTCPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> = listOf(ExecutorchWebRTCModule(reactContext))
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> = emptyList()
+}
diff --git a/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/MaskPostProcessor.java b/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/MaskPostProcessor.java
new file mode 100644
index 0000000000..3328a9dd15
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/MaskPostProcessor.java
@@ -0,0 +1,163 @@
+package com.executorch.webrtc;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * Post-processes segmentation masks for temporal stability.
+ * Applies morphological cleaning and EMA temporal smoothing.
+ * Gaussian blur is handled on GPU for better performance.
+ */
+public class MaskPostProcessor {
+
+    private static final float BINARIZE_THRESHOLD = 0.5f;
+    private static final float EMA_ALPHA = 0.5f;  // 50% history for responsive mask
+
+    private float[] smoothedMask;
+    private float[] tempA;
+    private float[] rawFloatMask;
+    private int maskWidth;
+    private int maskHeight;
+    private boolean hasHistory;
+
+    private ByteBuffer outputBuffer;
+    private int outputBufferCapacity;
+
+    public MaskPostProcessor() {
+    }
+
+    /**
+     * Process a byte mask (0-255) from ExecuTorch segmentation.
+     * Returns processed mask as ByteBuffer ready for GPU upload.
+     * Note: Gaussian blur is done on GPU after upload for better performance.
+     */
+    public ByteBuffer process(byte[] rawMask, int w, int h) {
+        ensureBuffers(w, h);
+        int len = w * h;
+
+        // Convert byte mask (0-255) to float mask (0-1)
+        for (int i = 0; i < len; i++) {
+            rawFloatMask[i] = (rawMask[i] & 0xFF) / 255.0f;
+        }
+
+        // Apply morphological cleaning (binarize + erode + dilate) to remove noise
+        morphologicalClean(rawFloatMask, tempA, w, h);
+
+        // Apply EMA temporal smoothing (keeps soft values, no hard threshold)
+        applyEmaSmoothing(tempA, len);
+
+        // Convert to bytes for GPU upload (blur will be done on GPU)
+        convertMaskToBytes(smoothedMask, len);
+
+        return outputBuffer;
+    }
+
+    public void reset() {
+        hasHistory = false;
+    }
+
+    private void ensureBuffers(int w, int h) {
+        if (w != maskWidth || h != maskHeight) {
+            int len = w * h;
+            smoothedMask = new float[len];
+            tempA = new float[len];
+            rawFloatMask = new float[len];
+            maskWidth = w;
+            maskHeight = h;
+            hasHistory = false;
+        }
+
+        int requiredCapacity = w * h;
+        if (outputBuffer == null || outputBufferCapacity < requiredCapacity) {
+            outputBuffer = ByteBuffer.allocateDirect(requiredCapacity);
+            outputBuffer.order(ByteOrder.nativeOrder());
+            outputBufferCapacity = requiredCapacity;
+        }
+    }
+
+    private static void binarizeInPlace(float[] mask, int len) {
+        for (int i = 0; i < len; i++) {
+            mask[i] = mask[i] > BINARIZE_THRESHOLD ? 1.0f : 0.0f;
+        }
+    }
+
+    private void morphologicalClean(float[] src, float[] dst, int w, int h) {
+        int len = w * h;
+        binarizeInPlace(src, len);
+        erode(src, dst, w, h);
+        dilate(dst, src, w, h);
+        System.arraycopy(src, 0, dst, 0, len);
+    }
+
+    private void erode(float[] src, float[] dst, int w, int h) {
+        for (int y = 0; y < h; y++) {
+            for (int x = 0; x < w; x++) {
+                float min = 1.0f;
+                for (int dy = -1; dy <= 1; dy++) {
+                    int ny = y + dy;
+                    if (ny < 0 || ny >= h) {
+                        min = 0.0f;
+                        continue;
+                    }
+                    for (int dx = -1; dx <= 1; dx++) {
+                        int nx = x + dx;
+                        if (nx < 0 || nx >= w) {
+                            min = 0.0f;
+                            continue;
+                        }
+                        float v = src[ny * w + nx];
+                        if (v < min) {
+                            min = v;
+                        }
+                    }
+                }
+                dst[y * w + x] = min;
+            }
+        }
+    }
+
+    private void dilate(float[] src, float[] dst, int w, int h) {
+        for (int y = 0; y < h; y++) {
+            for (int x = 0; x < w; x++) {
+                float max = 0.0f;
+                for (int dy = -1; dy <= 1; dy++) {
+                    int ny = y + dy;
+                    if (ny < 0 || ny >= h) continue;
+                    for (int dx = -1; dx <= 1; dx++) {
+                        int nx = x + dx;
+                        if (nx < 0 || nx >= w) continue;
+                        float v = src[ny * w + nx];
+                        if (v > max) max = v;
+                    }
+                }
+                dst[y * w + x] = max;
+            }
+        }
+    }
+
+    private void applyEmaSmoothing(float[] current, int len) {
+        float oneMinusAlpha = 1.0f - EMA_ALPHA;
+        if (!hasHistory) {
+            System.arraycopy(current, 0, smoothedMask, 0, len);
+            hasHistory = true;
+        } else {
+            for (int i = 0; i < len; i++) {
+                smoothedMask[i] = EMA_ALPHA * smoothedMask[i] + oneMinusAlpha * current[i];
+            }
+        }
+    }
+
+    private void convertMaskToBytes(float[] source, int length) {
+        outputBuffer.clear();
+        for (int i = 0; i < length; i++) {
+            float value = source[i];
+            if (value < 0f) {
+                value = 0f;
+            } else if (value > 1f) {
+                value = 1f;
+            }
+            outputBuffer.put((byte) (value * 255f));
+        }
+        outputBuffer.rewind();
+    }
+}
diff --git a/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/gl/FullscreenQuad.java b/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/gl/FullscreenQuad.java
new file mode 100644
index 0000000000..9f9f8f86dc
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/gl/FullscreenQuad.java
@@ -0,0 +1,39 @@
+package com.executorch.webrtc.gl;
+
+import android.opengl.GLES20;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+
+public class FullscreenQuad {
+    private static final float[] QUAD_COORDS = {-1f, -1f, 1f, -1f, -1f, 1f, 1f, 1f};
+    private static final float[] TEX_COORDS = {0f, 0f, 1f, 0f, 0f, 1f, 1f, 1f};
+
+    private final FloatBuffer quadBuffer = createFloatBuffer(QUAD_COORDS);
+    private final FloatBuffer texBuffer = createFloatBuffer(TEX_COORDS);
+
+    public void draw(GlProgram program) {
+        int posLoc = program.getAttributeLocation("aPosition");
+        int texLoc = program.getAttributeLocation("aTexCoord");
+
+        quadBuffer.position(0);
+        texBuffer.position(0);
+
+        GLES20.glEnableVertexAttribArray(posLoc);
+        GLES20.glVertexAttribPointer(posLoc, 2, GLES20.GL_FLOAT, false, 0, quadBuffer);
+        GLES20.glEnableVertexAttribArray(texLoc);
+        GLES20.glVertexAttribPointer(texLoc, 2, GLES20.GL_FLOAT, false, 0, texBuffer);
+        GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
+        GLES20.glDisableVertexAttribArray(posLoc);
+        GLES20.glDisableVertexAttribArray(texLoc);
+    }
+
+    private static FloatBuffer createFloatBuffer(float[] data) {
+        ByteBuffer bb = ByteBuffer.allocateDirect(data.length * 4);
+        bb.order(ByteOrder.nativeOrder());
+        FloatBuffer fb = bb.asFloatBuffer();
+        fb.put(data);
+        fb.position(0);
+        return fb;
+    }
+}
diff --git a/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/gl/GlBlurRenderer.java b/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/gl/GlBlurRenderer.java
new file mode 100644
index 0000000000..1fb85f5695
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/gl/GlBlurRenderer.java
@@ -0,0 +1,364 @@
+package com.executorch.webrtc.gl;
+
+import android.opengl.GLES11Ext;
+import android.opengl.GLES20;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * OpenGL-based blur renderer for WebRTC video frames.
+ * Handles texture conversion, downscaling for segmentation, Gaussian blur, and compositing.
+ * Both background blur and mask edge blur are done on GPU for performance.
+ */
+public class GlBlurRenderer {
+
+    private static final String VERTEX_SHADER =
+            "attribute vec4 aPosition;\n" +
+            "attribute vec2 aTexCoord;\n" +
+            "varying vec2 vTexCoord;\n" +
+            "uniform mat4 uTexMatrix;\n" +
+            "void main() {\n" +
+            "  gl_Position = aPosition;\n" +
+            "  vTexCoord = (uTexMatrix * vec4(aTexCoord, 0.0, 1.0)).xy;\n" +
+            "}\n";
+
+    private static final String VERTEX_SHADER_SIMPLE =
+            "attribute vec4 aPosition;\n" +
+            "attribute vec2 aTexCoord;\n" +
+            "varying vec2 vTexCoord;\n" +
+            "void main() {\n" +
+            "  gl_Position = aPosition;\n" +
+            "  vTexCoord = aTexCoord;\n" +
+            "}\n";
+
+    private static final String FRAGMENT_OES_TO_RGBA =
+            "#extension GL_OES_EGL_image_external : require\n" +
+            "precision mediump float;\n" +
+            "varying vec2 vTexCoord;\n" +
+            "uniform samplerExternalOES uTexture;\n" +
+            "void main() {\n" +
+            "  gl_FragColor = texture2D(uTexture, vTexCoord);\n" +
+            "}\n";
+
+    private static final String FRAGMENT_PASSTHROUGH =
+            "precision mediump float;\n" +
+            "varying vec2 vTexCoord;\n" +
+            "uniform sampler2D uTexture;\n" +
+            "void main() {\n" +
+            "  gl_FragColor = texture2D(uTexture, vTexCoord);\n" +
+            "}\n";
+
+    // Converts luminance (grayscale) texture to RGBA for blur processing
+    private static final String FRAGMENT_LUMINANCE_TO_RGBA =
+            "precision mediump float;\n" +
+            "varying vec2 vTexCoord;\n" +
+            "uniform sampler2D uTexture;\n" +
+            "void main() {\n" +
+            "  float lum = texture2D(uTexture, vTexCoord).r;\n" +
+            "  gl_FragColor = vec4(lum, lum, lum, 1.0);\n" +
+            "}\n";
+
+    private static final String FRAGMENT_BLUR =
+            "precision mediump float;\n" +
+            "varying vec2 vTexCoord;\n" +
+            "uniform sampler2D uTexture;\n" +
+            "uniform vec2 uDirection;\n" +
+            "uniform float uWeights[9];\n" +
+            "uniform float uOffsets[9];\n" +
+            "void main() {\n" +
+            "  vec4 color = texture2D(uTexture, vTexCoord) * uWeights[0];\n" +
+            "  for (int i = 1; i < 9; i++) {\n" +
+            "    vec2 off = uDirection * uOffsets[i];\n" +
+            "    color += texture2D(uTexture, vTexCoord + off) * uWeights[i];\n" +
+            "    color += texture2D(uTexture, vTexCoord - off) * uWeights[i];\n" +
+            "  }\n" +
+            "  gl_FragColor = color;\n" +
+            "}\n";
+
+    private static final String FRAGMENT_COMPOSITE =
+            "precision mediump float;\n" +
+            "varying vec2 vTexCoord;\n" +
+            "uniform sampler2D uOriginal;\n" +
+            "uniform sampler2D uBlurred;\n" +
+            "uniform sampler2D uMask;\n" +
+            "void main() {\n" +
+            "  vec4 original = texture2D(uOriginal, vTexCoord);\n" +
+            "  vec4 blurred = texture2D(uBlurred, vTexCoord);\n" +
+            "  float mask = texture2D(uMask, vTexCoord).r;\n" +
+            "  gl_FragColor = vec4(mix(blurred.rgb, original.rgb, mask), 1.0);\n" +
+            "}\n";
+
+    private static final int SEGMENTATION_WIDTH = 256;
+    private static final int SEGMENTATION_HEIGHT = 144;
+    private static final int BLUR_DOWNSCALE = 1;  // Full resolution for better quality
+
+    // Mask blur settings (larger sigma for smooth edges)
+    private static final float MASK_BLUR_SIGMA = 5.0f;
+
+    private final FullscreenQuad quad = new FullscreenQuad();
+
+    private GlProgram oesProgram;
+    private GlProgram rgbProgram;
+    private GlProgram passthroughProgram;
+    private GlProgram luminanceToRgbaProgram;
+    private GlProgram blurProgram;
+    private GlProgram compositeProgram;
+
+    private GlFramebuffer rgbaFramebuffer;
+    private GlFramebuffer segmentationFramebuffer;
+    private GlFramebuffer blurFramebufferA;
+    private GlFramebuffer blurFramebufferB;
+    private GlFramebuffer outputFramebuffer;
+
+    // Mask blur framebuffers (at mask resolution)
+    private GlFramebuffer maskBlurFboA;
+    private GlFramebuffer maskBlurFboB;
+    private int maskTexture;
+    private int currentMaskWidth;
+    private int currentMaskHeight;
+
+    private int currentWidth;
+    private int currentHeight;
+    private boolean initialized;
+
+    // Background blur kernel
+    private final float[] blurWeights = new float[9];
+    private final float[] blurOffsets = new float[9];
+
+    // Mask blur kernel (separate, larger sigma)
+    private final float[] maskBlurWeights = new float[9];
+    private final float[] maskBlurOffsets = new float[9];
+
+    private ByteBuffer segPixelBuffer;
+
+    public GlBlurRenderer() {
+        computeGaussianKernel(12.0f, blurWeights, blurOffsets);
+        computeGaussianKernel(MASK_BLUR_SIGMA, maskBlurWeights, maskBlurOffsets);
+    }
+
+    public void ensureSetup(int width, int height) {
+        if (initialized && width == currentWidth && height == currentHeight) {
+            return;
+        }
+
+        if (initialized) {
+            releaseGlResources();
+        }
+
+        currentWidth = width;
+        currentHeight = height;
+
+        oesProgram = new GlProgram(VERTEX_SHADER, FRAGMENT_OES_TO_RGBA);
+        rgbProgram = new GlProgram(VERTEX_SHADER, FRAGMENT_PASSTHROUGH);
+        passthroughProgram = new GlProgram(VERTEX_SHADER_SIMPLE, FRAGMENT_PASSTHROUGH);
+        luminanceToRgbaProgram = new GlProgram(VERTEX_SHADER_SIMPLE, FRAGMENT_LUMINANCE_TO_RGBA);
+        blurProgram = new GlProgram(VERTEX_SHADER_SIMPLE, FRAGMENT_BLUR);
+        compositeProgram = new GlProgram(VERTEX_SHADER_SIMPLE, FRAGMENT_COMPOSITE);
+
+        rgbaFramebuffer = new GlFramebuffer(width, height);
+        segmentationFramebuffer = new GlFramebuffer(SEGMENTATION_WIDTH, SEGMENTATION_HEIGHT);
+
+        int blurWidth = Math.max(1, width / BLUR_DOWNSCALE);
+        int blurHeight = Math.max(1, height / BLUR_DOWNSCALE);
+        blurFramebufferA = new GlFramebuffer(blurWidth, blurHeight);
+        blurFramebufferB = new GlFramebuffer(blurWidth, blurHeight);
+        outputFramebuffer = new GlFramebuffer(width, height);
+
+        maskTexture = GlFramebuffer.createTexture2D();
+        // Mask blur FBOs will be created on first mask upload
+
+        initialized = true;
+    }
+
+    public void renderToRgbaFbo(int textureId, float[] transformMatrix, boolean isOes) {
+        rgbaFramebuffer.bind();
+        GlProgram program = isOes ? oesProgram : rgbProgram;
+        program.use();
+        program.setUniformMatrix4("uTexMatrix", transformMatrix);
+        int target = isOes ? GLES11Ext.GL_TEXTURE_EXTERNAL_OES : GLES20.GL_TEXTURE_2D;
+        program.bindTexture("uTexture", 0, textureId, target);
+        quad.draw(program);
+        GlFramebuffer.unbind();
+    }
+
+    public void renderDownscaled() {
+        drawTexture(passthroughProgram, rgbaFramebuffer.getTextureId(), segmentationFramebuffer);
+    }
+
+    public ByteBuffer readSegmentationPixels() {
+        int requiredCapacity = SEGMENTATION_WIDTH * SEGMENTATION_HEIGHT * 4;
+        if (segPixelBuffer == null || segPixelBuffer.capacity() < requiredCapacity) {
+            segPixelBuffer = ByteBuffer.allocateDirect(requiredCapacity);
+            segPixelBuffer.order(ByteOrder.nativeOrder());
+        }
+        segPixelBuffer.clear();
+        segmentationFramebuffer.readPixels(segPixelBuffer);
+        segPixelBuffer.rewind();
+        return segPixelBuffer;
+    }
+
+    public void uploadMask(ByteBuffer maskData, int maskWidth, int maskHeight) {
+        // Upload raw mask to texture
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, maskTexture);
+        GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_LUMINANCE,
+                maskWidth, maskHeight, 0,
+                GLES20.GL_LUMINANCE, GLES20.GL_UNSIGNED_BYTE, maskData);
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+
+        // Ensure mask blur FBOs exist at correct size
+        if (maskBlurFboA == null || currentMaskWidth != maskWidth || currentMaskHeight != maskHeight) {
+            if (maskBlurFboA != null) maskBlurFboA.release();
+            if (maskBlurFboB != null) maskBlurFboB.release();
+            maskBlurFboA = new GlFramebuffer(maskWidth, maskHeight);
+            maskBlurFboB = new GlFramebuffer(maskWidth, maskHeight);
+            currentMaskWidth = maskWidth;
+            currentMaskHeight = maskHeight;
+        }
+
+        // Convert luminance to RGBA for blur processing
+        drawTexture(luminanceToRgbaProgram, maskTexture, maskBlurFboA);
+
+        // Blur the mask on GPU (horizontal + vertical passes)
+        float texelX = 1.0f / maskWidth;
+        float texelY = 1.0f / maskHeight;
+
+        // First blur pass
+        renderMaskBlurPass(maskBlurFboA.getTextureId(), maskBlurFboB, texelX, 0.0f);
+        renderMaskBlurPass(maskBlurFboB.getTextureId(), maskBlurFboA, 0.0f, texelY);
+
+        // Second blur pass for stronger smoothing
+        renderMaskBlurPass(maskBlurFboA.getTextureId(), maskBlurFboB, texelX, 0.0f);
+        renderMaskBlurPass(maskBlurFboB.getTextureId(), maskBlurFboA, 0.0f, texelY);
+    }
+
+    public void renderBlur() {
+        int blurWidth = blurFramebufferA.getWidth();
+        int blurHeight = blurFramebufferA.getHeight();
+        drawTexture(passthroughProgram, rgbaFramebuffer.getTextureId(), blurFramebufferA);
+
+        // First blur pass (horizontal + vertical)
+        renderBlurPass(blurFramebufferA.getTextureId(), blurFramebufferB, 1.0f / blurWidth, 0.0f);
+        renderBlurPass(blurFramebufferB.getTextureId(), blurFramebufferA, 0.0f, 1.0f / blurHeight);
+
+        // Second blur pass for stronger effect
+        renderBlurPass(blurFramebufferA.getTextureId(), blurFramebufferB, 1.0f / blurWidth, 0.0f);
+        renderBlurPass(blurFramebufferB.getTextureId(), blurFramebufferA, 0.0f, 1.0f / blurHeight);
+    }
+
+    public void renderComposite() {
+        if (maskBlurFboA == null) return;
+
+        outputFramebuffer.bind();
+        compositeProgram.use();
+        compositeProgram.bindTexture("uOriginal", 0, rgbaFramebuffer.getTextureId(), GLES20.GL_TEXTURE_2D);
+        compositeProgram.bindTexture("uBlurred", 1, blurFramebufferA.getTextureId(), GLES20.GL_TEXTURE_2D);
+        // Use the GPU-blurred mask
+        compositeProgram.bindTexture("uMask", 2, maskBlurFboA.getTextureId(), GLES20.GL_TEXTURE_2D);
+        quad.draw(compositeProgram);
+        GlFramebuffer.unbind();
+    }
+
+    public int getOutputTextureId() {
+        return outputFramebuffer.getTextureId();
+    }
+
+    public int getSegmentationWidth() {
+        return SEGMENTATION_WIDTH;
+    }
+
+    public int getSegmentationHeight() {
+        return SEGMENTATION_HEIGHT;
+    }
+
+    public void release() {
+        if (!initialized) {
+            return;
+        }
+        releaseGlResources();
+        segPixelBuffer = null;
+        initialized = false;
+    }
+
+    private void renderBlurPass(int inputTexture, GlFramebuffer outputFbo, float dirX, float dirY) {
+        outputFbo.bind();
+        blurProgram.use();
+        blurProgram.bindTexture("uTexture", 0, inputTexture, GLES20.GL_TEXTURE_2D);
+        blurProgram.setUniform2f("uDirection", dirX, dirY);
+        blurProgram.setUniform1fv("uWeights", blurWeights);
+        blurProgram.setUniform1fv("uOffsets", blurOffsets);
+        quad.draw(blurProgram);
+        GlFramebuffer.unbind();
+    }
+
+    private void renderMaskBlurPass(int inputTexture, GlFramebuffer outputFbo, float dirX, float dirY) {
+        outputFbo.bind();
+        blurProgram.use();
+        blurProgram.bindTexture("uTexture", 0, inputTexture, GLES20.GL_TEXTURE_2D);
+        blurProgram.setUniform2f("uDirection", dirX, dirY);
+        blurProgram.setUniform1fv("uWeights", maskBlurWeights);
+        blurProgram.setUniform1fv("uOffsets", maskBlurOffsets);
+        quad.draw(blurProgram);
+        GlFramebuffer.unbind();
+    }
+
+    private void drawTexture(GlProgram program, int textureId, GlFramebuffer outputFbo) {
+        outputFbo.bind();
+        program.use();
+        program.bindTexture("uTexture", 0, textureId, GLES20.GL_TEXTURE_2D);
+        quad.draw(program);
+        GlFramebuffer.unbind();
+    }
+
+    public void setBlurRadius(float sigma) {
+        computeGaussianKernel(sigma, blurWeights, blurOffsets);
+    }
+
+    private void computeGaussianKernel(float sigma, float[] weights, float[] offsets) {
+        float sum = 0;
+        for (int i = 0; i < 9; i++) {
+            offsets[i] = (float) i;
+            weights[i] = (float) (Math.exp(-(i * i) / (2.0 * sigma * sigma))
+                    / (Math.sqrt(2.0 * Math.PI) * sigma));
+            sum += (i == 0) ? weights[i] : 2.0f * weights[i];
+        }
+        for (int i = 0; i < 9; i++) {
+            weights[i] /= sum;
+        }
+    }
+
+    private void releaseGlResources() {
+        if (rgbaFramebuffer != null) rgbaFramebuffer.release();
+        if (segmentationFramebuffer != null) segmentationFramebuffer.release();
+        if (blurFramebufferA != null) blurFramebufferA.release();
+        if (blurFramebufferB != null) blurFramebufferB.release();
+        if (outputFramebuffer != null) outputFramebuffer.release();
+        if (maskBlurFboA != null) maskBlurFboA.release();
+        if (maskBlurFboB != null) maskBlurFboB.release();
+
+        int[] textures = {maskTexture};
+        GLES20.glDeleteTextures(1, textures, 0);
+        maskTexture = 0;
+
+        if (oesProgram != null) oesProgram.release();
+        if (rgbProgram != null) rgbProgram.release();
+        if (passthroughProgram != null) passthroughProgram.release();
+        if (luminanceToRgbaProgram != null) luminanceToRgbaProgram.release();
+        if (blurProgram != null) blurProgram.release();
+        if (compositeProgram != null) compositeProgram.release();
+
+        rgbaFramebuffer = null;
+        segmentationFramebuffer = null;
+        blurFramebufferA = null;
+        blurFramebufferB = null;
+        outputFramebuffer = null;
+        maskBlurFboA = null;
+        maskBlurFboB = null;
+        oesProgram = null;
+        rgbProgram = null;
+        passthroughProgram = null;
+        luminanceToRgbaProgram = null;
+        blurProgram = null;
+        compositeProgram = null;
+    }
+}
diff --git a/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/gl/GlFramebuffer.java b/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/gl/GlFramebuffer.java
new file mode 100644
index 0000000000..a763e5ec90
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/gl/GlFramebuffer.java
@@ -0,0 +1,66 @@
+package com.executorch.webrtc.gl;
+
+import android.opengl.GLES20;
+import java.nio.ByteBuffer;
+
+public class GlFramebuffer {
+    private final int width;
+    private final int height;
+    private final int framebufferId;
+    private final int textureId;
+
+    public GlFramebuffer(int width, int height) {
+        this.width = width;
+        this.height = height;
+
+        textureId = createTexture2D();
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textureId);
+        GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA,
+                width, height, 0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, null);
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+
+        int[] fboId = new int[1];
+        GLES20.glGenFramebuffers(1, fboId, 0);
+        framebufferId = fboId[0];
+        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, framebufferId);
+        GLES20.glFramebufferTexture2D(GLES20.GL_FRAMEBUFFER, GLES20.GL_COLOR_ATTACHMENT0,
+                GLES20.GL_TEXTURE_2D, textureId, 0);
+        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);
+    }
+
+    public void bind() {
+        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, framebufferId);
+        GLES20.glViewport(0, 0, width, height);
+    }
+
+    public static void unbind() {
+        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);
+    }
+
+    public void readPixels(ByteBuffer outputBuffer) {
+        bind();
+        GLES20.glReadPixels(0, 0, width, height, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, outputBuffer);
+        unbind();
+    }
+
+    public int getTextureId() { return textureId; }
+    public int getWidth() { return width; }
+    public int getHeight() { return height; }
+
+    public void release() {
+        GLES20.glDeleteTextures(1, new int[]{textureId}, 0);
+        GLES20.glDeleteFramebuffers(1, new int[]{framebufferId}, 0);
+    }
+
+    public static int createTexture2D() {
+        int[] texId = new int[1];
+        GLES20.glGenTextures(1, texId, 0);
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, texId[0]);
+        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);
+        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
+        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
+        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+        return texId[0];
+    }
+}
diff --git a/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/gl/GlProgram.java b/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/gl/GlProgram.java
new file mode 100644
index 0000000000..79e38b7c91
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/android/src/main/java/com/executorch/webrtc/gl/GlProgram.java
@@ -0,0 +1,83 @@
+package com.executorch.webrtc.gl;
+
+import android.opengl.GLES20;
+import java.util.HashMap;
+import java.util.Map;
+
+public class GlProgram {
+    private final int programId;
+    private final Map<String, Integer> attributeLocations = new HashMap<>();
+    private final Map<String, Integer> uniformLocations = new HashMap<>();
+
+    public GlProgram(String vertexSource, String fragmentSource) {
+        int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexSource);
+        int fragmentShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource);
+        programId = GLES20.glCreateProgram();
+        GLES20.glAttachShader(programId, vertexShader);
+        GLES20.glAttachShader(programId, fragmentShader);
+        GLES20.glLinkProgram(programId);
+        GLES20.glDeleteShader(vertexShader);
+        GLES20.glDeleteShader(fragmentShader);
+    }
+
+    public void use() {
+        GLES20.glUseProgram(programId);
+    }
+
+    public int getAttributeLocation(String name) {
+        Integer loc = attributeLocations.get(name);
+        if (loc == null) {
+            loc = GLES20.glGetAttribLocation(programId, name);
+            attributeLocations.put(name, loc);
+        }
+        return loc;
+    }
+
+    public void setUniformMatrix4(String name, float[] matrix) {
+        GLES20.glUniformMatrix4fv(getUniformLocation(name), 1, false, matrix, 0);
+    }
+
+    public void setUniform1i(String name, int value) {
+        GLES20.glUniform1i(getUniformLocation(name), value);
+    }
+
+    public void setUniform2f(String name, float x, float y) {
+        GLES20.glUniform2f(getUniformLocation(name), x, y);
+    }
+
+    public void setUniform1f(String name, float value) {
+        GLES20.glUniform1f(getUniformLocation(name), value);
+    }
+
+    public void setUniform1fv(String name, float[] values) {
+        GLES20.glUniform1fv(getUniformLocation(name), values.length, values, 0);
+    }
+
+    public void bindTexture(String uniformName, int textureUnit, int textureId, int textureTarget) {
+        GLES20.glActiveTexture(GLES20.GL_TEXTURE0 + textureUnit);
+        GLES20.glBindTexture(textureTarget, textureId);
+        setUniform1i(uniformName, textureUnit);
+    }
+
+    public void release() {
+        GLES20.glDeleteProgram(programId);
+        attributeLocations.clear();
+        uniformLocations.clear();
+    }
+
+    private int getUniformLocation(String name) {
+        Integer loc = uniformLocations.get(name);
+        if (loc == null) {
+            loc = GLES20.glGetUniformLocation(programId, name);
+            uniformLocations.put(name, loc);
+        }
+        return loc;
+    }
+
+    private static int loadShader(int type, String source) {
+        int shader = GLES20.glCreateShader(type);
+        GLES20.glShaderSource(shader, source);
+        GLES20.glCompileShader(shader);
+        return shader;
+    }
+}
diff --git a/packages/react-native-executorch-webrtc/ios/ExecutorchFrameProcessor.h b/packages/react-native-executorch-webrtc/ios/ExecutorchFrameProcessor.h
new file mode 100644
index 0000000000..cbc9632954
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/ios/ExecutorchFrameProcessor.h
@@ -0,0 +1,19 @@
+#import <Foundation/Foundation.h>
+#import <WebRTC/RTCVideoCapturer.h>
+#import <WebRTC/RTCVideoFrame.h>
+
+@protocol VideoFrameProcessorDelegate
+- (RTCVideoFrame *)capturer:(RTCVideoCapturer *)capturer
+       didCaptureVideoFrame:(RTCVideoFrame *)frame;
+@end
+
+@interface ExecutorchFrameProcessor : NSObject <VideoFrameProcessorDelegate>
+
++ (instancetype)sharedInstance;
+
+- (void)configureWithModelPath:(NSString *)modelPath;
+- (void)setBlurRadius:(float)blurRadius;
+- (void)unloadModel;
+- (BOOL)isAvailable;
+
+@end
diff --git a/packages/react-native-executorch-webrtc/ios/ExecutorchFrameProcessor.mm b/packages/react-native-executorch-webrtc/ios/ExecutorchFrameProcessor.mm
new file mode 100644
index 0000000000..a639644112
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/ios/ExecutorchFrameProcessor.mm
@@ -0,0 +1,526 @@
+#import "ExecutorchFrameProcessor.h"
+#import <CoreImage/CoreImage.h>
+#import <CoreVideo/CoreVideo.h>
+#import <WebRTC/RTCCVPixelBuffer.h>
+#import <WebRTC/RTCI420Buffer.h>
+#import <WebRTC/RTCYUVPlanarBuffer.h>
+
+#import <opencv2/opencv.hpp>
+#import <rnexecutorch/host_objects/JSTensorViewIn.h>
+#import <rnexecutorch/models/semantic_segmentation/BaseSemanticSegmentation.h>
+
+using namespace rnexecutorch;
+using namespace rnexecutorch::models::semantic_segmentation;
+
+@implementation ExecutorchFrameProcessor {
+  // ExecuTorch model
+  std::unique_ptr<BaseSemanticSegmentation> _segmentation;
+  BOOL _modelLoaded;
+  int _modelWidth;
+  int _modelHeight;
+
+  // Core Image context for GPU-accelerated processing
+  CIContext *_ciContext;
+  float _blurRadius;
+
+  // Pixel buffer pool for efficient output allocation
+  CVPixelBufferPoolRef _outputPool;
+  size_t _poolWidth;
+  size_t _poolHeight;
+
+  // Frame dropping
+  RTCVideoFrame *_lastProcessedFrame;
+  BOOL _isProcessing;
+  BOOL _ready;
+
+  // Temporal smoothing (EMA)
+  cv::Mat _previousMask;
+  float _emaAlpha;
+
+  // Timing
+  int _frameCount;
+  NSTimeInterval _lastLogTime;
+  NSTimeInterval _totalProcessingTime;
+}
+
++ (instancetype)sharedInstance {
+  static ExecutorchFrameProcessor *instance = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    instance = [[ExecutorchFrameProcessor alloc] init];
+  });
+  return instance;
+}
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _modelLoaded = NO;
+    _modelWidth = 256;
+    _modelHeight = 256;
+    _blurRadius = 12.0f;
+    _isProcessing = NO;
+    _ready = NO;
+    _emaAlpha = 0.5f;
+    _frameCount = 0;
+    _lastLogTime = 0;
+    _totalProcessingTime = 0;
+
+    // Create Core Image context with GPU rendering
+    _ciContext = [CIContext contextWithOptions:@{
+      kCIContextUseSoftwareRenderer : @NO,
+    }];
+  }
+  return self;
+}
+
+- (void)configureWithModelPath:(NSString *)modelPath {
+  NSLog(@"[ExecutorchFrameProcessor] Loading model from: %@", modelPath);
+
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    @try {
+      std::vector<float> normMean = {};
+      std::vector<float> normStd = {};
+      std::vector<std::string> allClasses = {"foreground", "background"};
+
+      self->_segmentation = std::make_unique<BaseSemanticSegmentation>(
+          std::string([modelPath UTF8String]), normMean, normStd, allClasses,
+          nullptr);
+
+      auto inputShapes = self->_segmentation->getAllInputShapes();
+      if (!inputShapes.empty() && inputShapes[0].size() >= 4) {
+        self->_modelHeight = inputShapes[0][inputShapes[0].size() - 2];
+        self->_modelWidth = inputShapes[0][inputShapes[0].size() - 1];
+      }
+
+      self->_modelLoaded = YES;
+      self->_ready = YES;
+      NSLog(@"[ExecutorchFrameProcessor] Model loaded! Size: %dx%d",
+            self->_modelWidth, self->_modelHeight);
+    } @catch (NSException *exception) {
+      NSLog(@"[ExecutorchFrameProcessor] Failed to load model: %@",
+            exception.reason);
+      self->_modelLoaded = NO;
+    }
+  });
+}
+
+- (void)setBlurRadius:(float)blurRadius {
+  _blurRadius = blurRadius;
+}
+
+- (void)unloadModel {
+  _segmentation.reset();
+  _modelLoaded = NO;
+  _ready = NO;
+  _previousMask.release();
+
+  // Release cached frame
+  _lastProcessedFrame = nil;
+
+  // Release pixel buffer pool
+  if (_outputPool) {
+    CVPixelBufferPoolRelease(_outputPool);
+    _outputPool = NULL;
+    _poolWidth = 0;
+    _poolHeight = 0;
+  }
+
+  NSLog(@"[ExecutorchFrameProcessor] Model unloaded and resources released");
+}
+
+- (BOOL)isAvailable {
+  return YES;
+}
+
+#pragma mark - VideoFrameProcessorDelegate
+
+- (RTCVideoFrame *)capturer:(RTCVideoCapturer *)capturer
+       didCaptureVideoFrame:(RTCVideoFrame *)frame {
+  if (!_ready || !_modelLoaded) {
+    return frame;
+  }
+
+  // Frame dropping when busy
+  if (_isProcessing) {
+    return _lastProcessedFrame ?: frame;
+  }
+
+  _isProcessing = YES;
+  RTCVideoFrame *result = [self processFrame:frame];
+  _lastProcessedFrame = result;
+  _isProcessing = NO;
+  return result;
+}
+
+#pragma mark - Core Pipeline
+
+- (RTCVideoFrame *)processFrame:(RTCVideoFrame *)frame {
+  NSTimeInterval startTime = [[NSDate date] timeIntervalSince1970];
+
+  // Get CVPixelBuffer from frame
+  CVPixelBufferRef inputPixelBuffer = NULL;
+
+  if ([frame.buffer isKindOfClass:[RTCCVPixelBuffer class]]) {
+    inputPixelBuffer = ((RTCCVPixelBuffer *)frame.buffer).pixelBuffer;
+  } else {
+    // Convert I420 to CVPixelBuffer if needed
+    inputPixelBuffer = [self createPixelBufferFromI420:frame.buffer];
+    if (!inputPixelBuffer) {
+      return frame;
+    }
+  }
+
+  size_t width = CVPixelBufferGetWidth(inputPixelBuffer);
+  size_t height = CVPixelBufferGetHeight(inputPixelBuffer);
+
+  // Run ExecuTorch segmentation to get mask
+  CIImage *maskImage = [self generateMaskForPixelBuffer:inputPixelBuffer
+                                               rotation:frame.rotation];
+  if (!maskImage) {
+    if (![frame.buffer isKindOfClass:[RTCCVPixelBuffer class]]) {
+      CVPixelBufferRelease(inputPixelBuffer);
+    }
+    return frame;
+  }
+
+  // Ensure output pool exists
+  [self ensurePoolForWidth:width height:height];
+
+  // Create output buffer
+  CVPixelBufferRef outputBuffer = NULL;
+  if (CVPixelBufferPoolCreatePixelBuffer(kCFAllocatorDefault, _outputPool,
+                                         &outputBuffer) != kCVReturnSuccess) {
+    if (![frame.buffer isKindOfClass:[RTCCVPixelBuffer class]]) {
+      CVPixelBufferRelease(inputPixelBuffer);
+    }
+    return frame;
+  }
+
+  // Core Image processing
+  CIImage *original = [CIImage imageWithCVPixelBuffer:inputPixelBuffer];
+
+  // Scale mask to match input size
+  CGFloat scaleX = (CGFloat)width / maskImage.extent.size.width;
+  CGFloat scaleY = (CGFloat)height / maskImage.extent.size.height;
+  CIImage *scaledMask = [maskImage
+      imageByApplyingTransform:CGAffineTransformMakeScale(scaleX, scaleY)];
+
+  // Apply Gaussian blur to background
+  CIFilter *blurFilter = [CIFilter filterWithName:@"CIGaussianBlur"];
+  [blurFilter setValue:[original imageByClampingToExtent]
+                forKey:kCIInputImageKey];
+  [blurFilter setValue:@(_blurRadius) forKey:kCIInputRadiusKey];
+  CIImage *blurred =
+      [blurFilter.outputImage imageByCroppingToRect:original.extent];
+
+  // Blend: foreground (mask=white) stays sharp, background gets blurred
+  CIFilter *blendFilter = [CIFilter filterWithName:@"CIBlendWithMask"];
+  [blendFilter setValue:original forKey:kCIInputImageKey];
+  [blendFilter setValue:blurred forKey:kCIInputBackgroundImageKey];
+  [blendFilter setValue:scaledMask forKey:kCIInputMaskImageKey];
+  CIImage *composited = blendFilter.outputImage;
+
+  // Render to output buffer
+  CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+  [_ciContext render:composited
+      toCVPixelBuffer:outputBuffer
+               bounds:original.extent
+           colorSpace:colorSpace];
+  CGColorSpaceRelease(colorSpace);
+
+  // Create output frame
+  RTCCVPixelBuffer *rtcBuffer =
+      [[RTCCVPixelBuffer alloc] initWithPixelBuffer:outputBuffer];
+  RTCVideoFrame *outputFrame =
+      [[RTCVideoFrame alloc] initWithBuffer:rtcBuffer
+                                   rotation:frame.rotation
+                                timeStampNs:frame.timeStampNs];
+
+  CVPixelBufferRelease(outputBuffer);
+  if (![frame.buffer isKindOfClass:[RTCCVPixelBuffer class]]) {
+    CVPixelBufferRelease(inputPixelBuffer);
+  }
+
+  // Logging
+  NSTimeInterval endTime = [[NSDate date] timeIntervalSince1970];
+  _totalProcessingTime += (endTime - startTime);
+  _frameCount++;
+
+  if (endTime - _lastLogTime > 1.0) {
+    double avgMs = (_totalProcessingTime / _frameCount) * 1000.0;
+    double fps = _frameCount / (endTime - _lastLogTime);
+    NSLog(@"[ExecutorchFrameProcessor] Avg: %.1fms (%.1f FPS)", avgMs, fps);
+    _lastLogTime = endTime;
+    _frameCount = 0;
+    _totalProcessingTime = 0;
+  }
+
+  return outputFrame;
+}
+
+#pragma mark - Segmentation
+
+- (CIImage *)generateMaskForPixelBuffer:(CVPixelBufferRef)pixelBuffer
+                               rotation:(RTCVideoRotation)rotation {
+  if (!_modelLoaded || !_segmentation) {
+    return nil;
+  }
+
+  size_t width = CVPixelBufferGetWidth(pixelBuffer);
+  size_t height = CVPixelBufferGetHeight(pixelBuffer);
+
+  // Lock pixel buffer and convert to RGB for model
+  CVPixelBufferLockBaseAddress(pixelBuffer, kCVPixelBufferLock_ReadOnly);
+
+  OSType format = CVPixelBufferGetPixelFormatType(pixelBuffer);
+  cv::Mat rgbMat;
+
+  if (format == kCVPixelFormatType_32BGRA) {
+    // Direct BGRA access
+    void *baseAddress = CVPixelBufferGetBaseAddress(pixelBuffer);
+    size_t bytesPerRow = CVPixelBufferGetBytesPerRow(pixelBuffer);
+    cv::Mat bgraMat((int)height, (int)width, CV_8UC4, baseAddress, bytesPerRow);
+    cv::cvtColor(bgraMat, rgbMat, cv::COLOR_BGRA2RGB);
+  } else if (format == kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange ||
+             format == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange) {
+    // NV12 format - convert via I420
+    cv::Mat yMat((int)height, (int)width, CV_8UC1,
+                 CVPixelBufferGetBaseAddressOfPlane(pixelBuffer, 0),
+                 CVPixelBufferGetBytesPerRowOfPlane(pixelBuffer, 0));
+    cv::Mat uvMat((int)height / 2, (int)width / 2, CV_8UC2,
+                  CVPixelBufferGetBaseAddressOfPlane(pixelBuffer, 1),
+                  CVPixelBufferGetBytesPerRowOfPlane(pixelBuffer, 1));
+
+    cv::Mat yuvMat((int)height * 3 / 2, (int)width, CV_8UC1);
+    yMat.copyTo(yuvMat(cv::Rect(0, 0, (int)width, (int)height)));
+
+    // Deinterleave UV
+    std::vector<cv::Mat> uvChannels;
+    cv::split(uvMat, uvChannels);
+    uvChannels[0].copyTo(
+        yuvMat(cv::Rect(0, (int)height, (int)width / 2, (int)height / 2)));
+    uvChannels[1].copyTo(yuvMat(cv::Rect((int)width / 2, (int)height,
+                                         (int)width / 2, (int)height / 2)));
+
+    cv::cvtColor(yuvMat, rgbMat, cv::COLOR_YUV2RGB_I420);
+  } else {
+    CVPixelBufferUnlockBaseAddress(pixelBuffer, kCVPixelBufferLock_ReadOnly);
+    return nil;
+  }
+
+  CVPixelBufferUnlockBaseAddress(pixelBuffer, kCVPixelBufferLock_ReadOnly);
+
+  // Rotate for model inference
+  cv::Mat rgbRotated;
+  if (rotation == RTCVideoRotation_90) {
+    cv::rotate(rgbMat, rgbRotated, cv::ROTATE_90_CLOCKWISE);
+  } else if (rotation == RTCVideoRotation_180) {
+    cv::rotate(rgbMat, rgbRotated, cv::ROTATE_180);
+  } else if (rotation == RTCVideoRotation_270) {
+    cv::rotate(rgbMat, rgbRotated, cv::ROTATE_90_COUNTERCLOCKWISE);
+  } else {
+    rgbRotated = rgbMat;
+  }
+
+  // Run ExecuTorch segmentation
+  cv::Mat mask;
+  try {
+    JSTensorViewIn pixelData;
+    pixelData.dataPtr = rgbRotated.data;
+    pixelData.sizes = {rgbRotated.rows, rgbRotated.cols, 3};
+    pixelData.scalarType = executorch::aten::ScalarType::Byte;
+
+    std::set<std::string, std::less<>> classesOfInterest = {"foreground"};
+    auto result =
+        _segmentation->generateFromPixels(pixelData, classesOfInterest, false);
+
+    if (result.classBuffers && result.classBuffers->count("foreground")) {
+      auto &fgBuffer = result.classBuffers->at("foreground");
+      auto *fgData = reinterpret_cast<float *>(fgBuffer->data());
+      mask = cv::Mat(_modelHeight, _modelWidth, CV_32FC1, fgData).clone();
+    } else {
+      return nil;
+    }
+  } catch (const std::exception &e) {
+    NSLog(@"[ExecutorchFrameProcessor] Segmentation failed: %s", e.what());
+    return nil;
+  }
+
+  // Rotate mask back
+  cv::Mat maskRotated;
+  if (rotation == RTCVideoRotation_90) {
+    cv::rotate(mask, maskRotated, cv::ROTATE_90_COUNTERCLOCKWISE);
+  } else if (rotation == RTCVideoRotation_180) {
+    cv::rotate(mask, maskRotated, cv::ROTATE_180);
+  } else if (rotation == RTCVideoRotation_270) {
+    cv::rotate(mask, maskRotated, cv::ROTATE_90_CLOCKWISE);
+  } else {
+    maskRotated = mask;
+  }
+
+  // EMA temporal smoothing to reduce flickering
+  if (_previousMask.empty() || _previousMask.size() != maskRotated.size()) {
+    _previousMask = maskRotated.clone();
+  } else {
+    // Blend current mask with previous: smoothed = alpha * current + (1 -
+    // alpha) * previous
+    cv::addWeighted(maskRotated, _emaAlpha, _previousMask, 1.0f - _emaAlpha, 0,
+                    maskRotated);
+    _previousMask = maskRotated.clone();
+  }
+
+  // Morphological operations to clean up mask edges
+  cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
+  cv::erode(maskRotated, maskRotated, kernel, cv::Point(-1, -1), 1);
+  cv::dilate(maskRotated, maskRotated, kernel, cv::Point(-1, -1), 1);
+
+  // Blur mask edges for smooth transition (match Android: sigma=5.0)
+  cv::GaussianBlur(maskRotated, maskRotated, cv::Size(0, 0), 5.0);
+
+  // Convert to 8-bit grayscale
+  cv::Mat mask8u;
+  maskRotated.convertTo(mask8u, CV_8UC1, 255.0);
+
+  // Create CIImage from mask
+  CVPixelBufferRef maskPixelBuffer = [self createGrayscalePixelBuffer:mask8u];
+  if (!maskPixelBuffer) {
+    return nil;
+  }
+
+  CIImage *maskCIImage = [CIImage imageWithCVPixelBuffer:maskPixelBuffer];
+  CVPixelBufferRelease(maskPixelBuffer);
+
+  return maskCIImage;
+}
+
+#pragma mark - Helpers
+
+- (CVPixelBufferRef)createPixelBufferFromI420:(id<RTCVideoFrameBuffer>)buffer {
+  id<RTCI420Buffer> i420 = [buffer toI420];
+  if (!i420) {
+    return NULL;
+  }
+
+  int width = [i420 width];
+  int height = [i420 height];
+  int strideY = [i420 strideY];
+  int strideU = [i420 strideU];
+  int strideV = [i420 strideV];
+  const uint8_t *dataY = [i420 dataY];
+  const uint8_t *dataU = [i420 dataU];
+  const uint8_t *dataV = [i420 dataV];
+
+  NSDictionary *attrs = @{
+    (id)kCVPixelBufferPixelFormatTypeKey : @(kCVPixelFormatType_32BGRA),
+    (id)kCVPixelBufferWidthKey : @(width),
+    (id)kCVPixelBufferHeightKey : @(height),
+    (id)kCVPixelBufferIOSurfacePropertiesKey : @{},
+  };
+
+  CVPixelBufferRef pixelBuffer = NULL;
+  CVReturn result = CVPixelBufferCreate(
+      kCFAllocatorDefault, width, height, kCVPixelFormatType_32BGRA,
+      (__bridge CFDictionaryRef)attrs, &pixelBuffer);
+  if (result != kCVReturnSuccess) {
+    return NULL;
+  }
+
+  // Convert I420 to BGRA using OpenCV
+  cv::Mat i420Mat(height * 3 / 2, width, CV_8UC1);
+
+  // Copy Y plane
+  for (int row = 0; row < height; row++) {
+    memcpy(i420Mat.ptr(row), dataY + row * strideY, width);
+  }
+
+  // Copy U and V planes
+  uint8_t *uvDst = i420Mat.data + (height * width);
+  int uvHeight = height / 2;
+  int uvWidth = width / 2;
+  for (int row = 0; row < uvHeight; row++) {
+    memcpy(uvDst + row * uvWidth, dataU + row * strideU, uvWidth);
+  }
+  for (int row = 0; row < uvHeight; row++) {
+    memcpy(uvDst + uvHeight * uvWidth + row * uvWidth, dataV + row * strideV,
+           uvWidth);
+  }
+
+  cv::Mat bgraMat;
+  cv::cvtColor(i420Mat, bgraMat, cv::COLOR_YUV2BGRA_I420);
+
+  CVPixelBufferLockBaseAddress(pixelBuffer, 0);
+  void *dst = CVPixelBufferGetBaseAddress(pixelBuffer);
+  size_t dstBytesPerRow = CVPixelBufferGetBytesPerRow(pixelBuffer);
+
+  for (int row = 0; row < height; row++) {
+    memcpy((uint8_t *)dst + row * dstBytesPerRow, bgraMat.ptr(row), width * 4);
+  }
+
+  CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
+  return pixelBuffer;
+}
+
+- (CVPixelBufferRef)createGrayscalePixelBuffer:(cv::Mat &)grayMat {
+  int width = grayMat.cols;
+  int height = grayMat.rows;
+
+  NSDictionary *attrs = @{
+    (id)kCVPixelBufferPixelFormatTypeKey : @(kCVPixelFormatType_OneComponent8),
+    (id)kCVPixelBufferWidthKey : @(width),
+    (id)kCVPixelBufferHeightKey : @(height),
+    (id)kCVPixelBufferIOSurfacePropertiesKey : @{},
+  };
+
+  CVPixelBufferRef pixelBuffer = NULL;
+  CVReturn result = CVPixelBufferCreate(
+      kCFAllocatorDefault, width, height, kCVPixelFormatType_OneComponent8,
+      (__bridge CFDictionaryRef)attrs, &pixelBuffer);
+  if (result != kCVReturnSuccess) {
+    return NULL;
+  }
+
+  CVPixelBufferLockBaseAddress(pixelBuffer, 0);
+  void *dst = CVPixelBufferGetBaseAddress(pixelBuffer);
+  size_t dstBytesPerRow = CVPixelBufferGetBytesPerRow(pixelBuffer);
+
+  for (int row = 0; row < height; row++) {
+    memcpy((uint8_t *)dst + row * dstBytesPerRow, grayMat.ptr(row), width);
+  }
+
+  CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
+  return pixelBuffer;
+}
+
+- (void)ensurePoolForWidth:(size_t)width height:(size_t)height {
+  if (_poolWidth == width && _poolHeight == height && _outputPool) {
+    return;
+  }
+
+  if (_outputPool) {
+    CVPixelBufferPoolRelease(_outputPool);
+    _outputPool = NULL;
+  }
+
+  _poolWidth = width;
+  _poolHeight = height;
+
+  NSDictionary *attrs = @{
+    (id)kCVPixelBufferPixelFormatTypeKey : @(kCVPixelFormatType_32BGRA),
+    (id)kCVPixelBufferWidthKey : @(width),
+    (id)kCVPixelBufferHeightKey : @(height),
+    (id)kCVPixelBufferIOSurfacePropertiesKey : @{},
+    (id)kCVPixelBufferMetalCompatibilityKey : @YES,
+  };
+
+  CVPixelBufferPoolCreate(kCFAllocatorDefault, NULL,
+                          (__bridge CFDictionaryRef)attrs, &_outputPool);
+}
+
+- (void)dealloc {
+  if (_outputPool) {
+    CVPixelBufferPoolRelease(_outputPool);
+  }
+}
+
+@end
diff --git a/packages/react-native-executorch-webrtc/ios/ExecutorchWebRTC.h b/packages/react-native-executorch-webrtc/ios/ExecutorchWebRTC.h
new file mode 100644
index 0000000000..ddc6f1f28e
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/ios/ExecutorchWebRTC.h
@@ -0,0 +1,5 @@
+#import <React/RCTBridgeModule.h>
+
+@interface ExecutorchWebRTC : NSObject <RCTBridgeModule>
+
+@end
diff --git a/packages/react-native-executorch-webrtc/ios/ExecutorchWebRTC.mm b/packages/react-native-executorch-webrtc/ios/ExecutorchWebRTC.mm
new file mode 100644
index 0000000000..ad4dd113d7
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/ios/ExecutorchWebRTC.mm
@@ -0,0 +1,69 @@
+#import "ExecutorchWebRTC.h"
+#import "ExecutorchFrameProcessor.h"
+#include "ProcessorProvider.h"
+
+@implementation ExecutorchWebRTC
+
+RCT_EXPORT_MODULE()
+
+static BOOL _processorRegistered = NO;
+static NSString *const PROCESSOR_NAME = @"executorchBackgroundBlur";
+
++ (void)registerProcessorIfNeeded {
+  if (!_processorRegistered) {
+    _processorRegistered = YES;
+    ExecutorchFrameProcessor *processor =
+        [ExecutorchFrameProcessor sharedInstance];
+    [ProcessorProvider addProcessor:processor forName:PROCESSOR_NAME];
+    NSLog(@"[ExecutorchWebRTC] Registered %@ processor", PROCESSOR_NAME);
+  }
+}
+
+#pragma mark - Fishjam-compatible API
+
+RCT_EXPORT_METHOD(initialize : (NSString *)modelPath) {
+  NSLog(@"[ExecutorchWebRTC] initialize: %@", modelPath);
+
+  [ExecutorchWebRTC registerProcessorIfNeeded];
+
+  // Remove file:// prefix if present
+  NSString *cleanPath = modelPath;
+  if ([modelPath hasPrefix:@"file://"]) {
+    cleanPath = [modelPath substringFromIndex:7];
+  }
+
+  [[ExecutorchFrameProcessor sharedInstance] configureWithModelPath:cleanPath];
+}
+
+RCT_EXPORT_METHOD(deinitialize) {
+  NSLog(@"[ExecutorchWebRTC] deinitialize");
+  [[ExecutorchFrameProcessor sharedInstance] unloadModel];
+}
+
+RCT_EXPORT_METHOD(setBlurRadius : (double)radius) {
+  [[ExecutorchFrameProcessor sharedInstance] setBlurRadius:(float)radius];
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(isAvailable) {
+  return @([[ExecutorchFrameProcessor sharedInstance] isAvailable]);
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getProcessorName) {
+  return PROCESSOR_NAME;
+}
+
+#pragma mark - Legacy API (for backward compatibility)
+
+RCT_EXPORT_METHOD(setup) { [ExecutorchWebRTC registerProcessorIfNeeded]; }
+
+RCT_EXPORT_METHOD(configureBackgroundRemoval : (NSString *)modelPath) {
+  [self initialize:modelPath];
+}
+
+RCT_EXPORT_METHOD(configureBackgroundBlur : (NSString *)
+                      modelPath blurIntensity : (int)intensity) {
+  [self initialize:modelPath];
+  [self setBlurRadius:intensity];
+}
+
+@end
diff --git a/packages/react-native-executorch-webrtc/package.json b/packages/react-native-executorch-webrtc/package.json
new file mode 100644
index 0000000000..d205d318cb
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/package.json
@@ -0,0 +1,48 @@
+{
+  "name": "react-native-executorch-webrtc",
+  "version": "0.1.0",
+  "description": "ExecuTorch WebRTC frame processor integration for react-native-webrtc",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./lib/index.js",
+      "types": "./lib/index.d.ts"
+    }
+  },
+  "files": [
+    "lib",
+    "android",
+    "ios",
+    "react-native.config.js",
+    "react-native-executorch-webrtc.podspec",
+    "README.md"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/software-mansion/react-native-executorch.git",
+    "directory": "packages/react-native-executorch-webrtc"
+  },
+  "scripts": {
+    "prepare": "tsc",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "clean": "del-cli lib"
+  },
+  "peerDependencies": {
+    "@fishjam-cloud/react-native-client": "*",
+    "@fishjam-cloud/react-native-webrtc": "*",
+    "react": "*",
+    "react-native": "*",
+    "react-native-executorch": "*"
+  },
+  "devDependencies": {
+    "@fishjam-cloud/react-native-webrtc": "^0.25.8",
+    "@types/react": "~19.1.10",
+    "react": "19.1.0",
+    "react-native": "0.81.5",
+    "react-native-executorch": "workspace:*",
+    "typescript": "~5.9.2"
+  }
+}
diff --git a/packages/react-native-executorch-webrtc/react-native-executorch-webrtc.podspec b/packages/react-native-executorch-webrtc/react-native-executorch-webrtc.podspec
new file mode 100644
index 0000000000..95417ef2e0
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/react-native-executorch-webrtc.podspec
@@ -0,0 +1,35 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "react-native-executorch-webrtc"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["repository"]["url"]
+  s.license      = package["license"]
+  s.authors      = "Software Mansion"
+
+  s.platforms    = { :ios => "13.0" }
+  s.source       = { :git => package["repository"]["url"], :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm}"
+
+  # react-native-executorch exposes rnexecutorch/* headers via its header_dir.
+  # However, executorch SDK headers and internal headers don't propagate to
+  # dependent pods, so we need to add them here.
+  rne_path = '${PODS_ROOT}/../../node_modules/react-native-executorch'
+
+  s.pod_target_xcconfig = {
+    "USE_HEADERMAP" => "YES",
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    "HEADER_SEARCH_PATHS" => "\"#{rne_path}/third-party/include\" \"#{rne_path}/common\""
+  }
+
+  s.dependency "React-Core"
+  s.dependency "react-native-executorch"
+  s.dependency "opencv-rne", "~> 4.11.0"
+  s.dependency 'FishjamReactNativeWebrtc'
+
+  install_modules_dependencies(s)
+end
diff --git a/packages/react-native-executorch-webrtc/react-native.config.js b/packages/react-native-executorch-webrtc/react-native.config.js
new file mode 100644
index 0000000000..f2400c7368
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/react-native.config.js
@@ -0,0 +1,13 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        sourceDir: './android',
+        packageImportPath:
+          'import com.executorch.webrtc.ExecutorchWebRTCPackage;',
+        packageInstance: 'new ExecutorchWebRTCPackage()',
+      },
+      ios: {},
+    },
+  },
+};
diff --git a/packages/react-native-executorch-webrtc/src/BackgroundBlur.ts b/packages/react-native-executorch-webrtc/src/BackgroundBlur.ts
new file mode 100644
index 0000000000..af888dd812
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/src/BackgroundBlur.ts
@@ -0,0 +1,61 @@
+import NativeBackgroundBlur from './NativeBackgroundBlur';
+
+let initialized = false;
+
+/**
+ * Initialize the background blur processor with ExecuTorch segmentation model.
+ * Must be called before using the blur middleware.
+ * @param modelPath Path to the .pte segmentation model file
+ * @example
+ * ```ts
+ * import { initializeBackgroundBlur } from '@executorch/react-native-executorch-webrtc';
+ *
+ * // Initialize with your model
+ * initializeBackgroundBlur('/path/to/selfie_segmenter.pte');
+ * ```
+ */
+export const initializeBackgroundBlur = (modelPath: string): void => {
+  if (!NativeBackgroundBlur) {
+    console.warn(
+      '[ExecutorchWebRTC] Native module not available. Is the package properly linked?'
+    );
+    return;
+  }
+
+  if (initialized) {
+    console.warn('[ExecutorchWebRTC] Background blur already initialized');
+    return;
+  }
+
+  NativeBackgroundBlur.initialize(modelPath);
+  initialized = true;
+};
+
+/**
+ * Deinitialize and release background blur resources.
+ * @example
+ * ```ts
+ * import { deinitializeBackgroundBlur } from '@executorch/react-native-executorch-webrtc';
+ *
+ * deinitializeBackgroundBlur();
+ * ```
+ */
+export const deinitializeBackgroundBlur = (): void => {
+  if (!NativeBackgroundBlur) {
+    return;
+  }
+
+  if (!initialized) {
+    return;
+  }
+
+  NativeBackgroundBlur.deinitialize();
+  initialized = false;
+};
+
+/**
+ * Check if background blur has been initialized
+ */
+export const isBackgroundBlurInitialized = (): boolean => {
+  return initialized;
+};
diff --git a/packages/react-native-executorch-webrtc/src/NativeBackgroundBlur.ts b/packages/react-native-executorch-webrtc/src/NativeBackgroundBlur.ts
new file mode 100644
index 0000000000..38d51cf2e2
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/src/NativeBackgroundBlur.ts
@@ -0,0 +1,33 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  /**
+   * Initialize the background blur processor with a segmentation model
+   * @param modelPath Path to the .pte segmentation model file
+   */
+  initialize(modelPath: string): void;
+
+  /**
+   * Deinitialize and release resources
+   */
+  deinitialize(): void;
+
+  /**
+   * Set the blur radius/intensity
+   * @param radius Blur sigma value (default: 12.0)
+   */
+  setBlurRadius(radius: number): void;
+
+  /**
+   * Check if background blur is available on this device
+   */
+  isAvailable(): boolean;
+
+  /**
+   * Get the processor name to use with _setVideoEffect
+   */
+  getProcessorName(): string;
+}
+
+export default TurboModuleRegistry.get<Spec>('ExecutorchWebRTC');
diff --git a/packages/react-native-executorch-webrtc/src/index.ts b/packages/react-native-executorch-webrtc/src/index.ts
new file mode 100644
index 0000000000..96086ec472
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/src/index.ts
@@ -0,0 +1,23 @@
+/**
+ * ExecuTorch WebRTC Background Blur
+ *
+ * This package provides background blur/removal for WebRTC video calls
+ * using ExecuTorch segmentation models. API is compatible with
+ * @fishjam-cloud/react-native-webrtc-background-blur.
+ * @packageDocumentation
+ */
+
+export { useBackgroundBlur } from './useBackgroundBlur';
+export type {
+  UseBackgroundBlurOptions,
+  TrackMiddleware,
+} from './useBackgroundBlur';
+
+export {
+  initializeBackgroundBlur,
+  deinitializeBackgroundBlur,
+  isBackgroundBlurInitialized,
+} from './BackgroundBlur';
+
+export type { Spec as BackgroundBlurSpec } from './NativeBackgroundBlur';
+export { default as NativeBackgroundBlur } from './NativeBackgroundBlur';
diff --git a/packages/react-native-executorch-webrtc/src/useBackgroundBlur.ts b/packages/react-native-executorch-webrtc/src/useBackgroundBlur.ts
new file mode 100644
index 0000000000..b19842184e
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/src/useBackgroundBlur.ts
@@ -0,0 +1,125 @@
+import { useCallback, useEffect, useRef } from 'react';
+import { Platform } from 'react-native';
+import NativeBackgroundBlur from './NativeBackgroundBlur';
+import {
+  initializeBackgroundBlur,
+  deinitializeBackgroundBlur,
+} from './BackgroundBlur';
+
+/**
+ * Extended MediaStreamTrack with WebRTC video effects API
+ */
+type NativeMediaStreamTrack = MediaStreamTrack & {
+  _setVideoEffect: (name: string) => void;
+  _setVideoEffects: (names: string[] | null) => void;
+};
+
+/**
+ * Middleware function type compatible with Fishjam SDK
+ */
+export type TrackMiddleware = (track: MediaStreamTrack) => {
+  track: MediaStreamTrack;
+  onClear: () => void;
+};
+
+/**
+ * Options for useBackgroundBlur hook
+ */
+export type UseBackgroundBlurOptions = {
+  /**
+   * Path to the ExecuTorch segmentation model (.pte file)
+   * Required for initialization
+   */
+  modelUri: string;
+
+  /**
+   * Blur intensity/radius (default: 12)
+   */
+  blurRadius?: number;
+};
+
+const PROCESSOR_NAME = 'executorchBackgroundBlur';
+
+/**
+ * Hook to enable background blur on WebRTC video tracks.
+ * Compatible with Fishjam SDK's TrackMiddleware interface.
+ * @param options Configuration options including model path and blur radius
+ * @returns Object containing blurMiddleware for use with Fishjam SDK
+ * @example
+ * ```tsx
+ * import { useBackgroundBlur } from '@executorch/react-native-executorch-webrtc';
+ *
+ * function VideoCall() {
+ *   const { blurMiddleware } = useBackgroundBlur({
+ *     modelUri: 'file:///path/to/selfie_segmenter.pte',
+ *     blurRadius: 15,
+ *   });
+ *
+ *   // Use with Fishjam SDK
+ *   const { toggleCamera } = useCamera({
+ *     cameraTrackMiddleware: blurMiddleware,
+ *   });
+ *
+ *   // Or use directly with a track
+ *   const applyBlur = (track: MediaStreamTrack) => {
+ *     const { onClear } = blurMiddleware(track);
+ *     // Call onClear() to remove the effect
+ *   };
+ * }
+ * ```
+ */
+export function useBackgroundBlur(options: UseBackgroundBlurOptions): {
+  blurMiddleware: TrackMiddleware;
+} {
+  const { modelUri, blurRadius = 12 } = options;
+  const initializedRef = useRef(false);
+
+  useEffect(() => {
+    if (!NativeBackgroundBlur) {
+      console.warn('[useBackgroundBlur] Native module not available');
+      return;
+    }
+
+    if (!initializedRef.current && modelUri) {
+      initializeBackgroundBlur(modelUri);
+      initializedRef.current = true;
+    }
+
+    return () => {
+      deinitializeBackgroundBlur();
+      initializedRef.current = false;
+    };
+  }, [modelUri]);
+
+  // Update blur radius when it changes
+  useEffect(() => {
+    if (!NativeBackgroundBlur) {
+      console.warn('[useBackgroundBlur] Native module not available');
+      return;
+    }
+
+    NativeBackgroundBlur.setBlurRadius(blurRadius);
+  }, [blurRadius]);
+
+  const blurMiddleware: TrackMiddleware = useCallback(
+    (track: MediaStreamTrack) => {
+      const nativeTrack = track as NativeMediaStreamTrack;
+
+      // Apply the video effect
+      nativeTrack._setVideoEffect(PROCESSOR_NAME);
+
+      return {
+        track,
+        onClear: () => {
+          // Android expects null to disable, iOS expects empty array
+          nativeTrack._setVideoEffects(
+            Platform.OS === 'ios' ? [] : (null as any)
+          );
+        },
+      };
+    },
+    []
+  );
+
+  return { blurMiddleware };
+}
diff --git a/packages/react-native-executorch-webrtc/tsconfig.json b/packages/react-native-executorch-webrtc/tsconfig.json
new file mode 100644
index 0000000000..cadd2509aa
--- /dev/null
+++ b/packages/react-native-executorch-webrtc/tsconfig.json
@@ -0,0 +1,28 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "lib",
+    "declaration": true,
+    "declarationMap": true,
+    "tsBuildInfoFile": "./lib/typescript/tsconfig.tsbuildinfo",
+    "composite": true,
+    "allowJs": false,
+    "allowUnreachableCode": false,
+    "allowUnusedLabels": false,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitReturns": true,
+    "noStrictGenericChecks": false,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noUncheckedIndexedAccess": true,
+    "strict": true,
+    "types": ["react", "node"]
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "lib"]
+}
diff --git a/yarn.lock b/yarn.lock
index a817f061a7..fbec123671 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2850,6 +2850,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@fishjam-cloud/react-native-webrtc@npm:^0.25.8":
+  version: 0.25.8
+  resolution: "@fishjam-cloud/react-native-webrtc@npm:0.25.8"
+  dependencies:
+    base64-js: "npm:1.5.1"
+    debug: "npm:4.3.4"
+  peerDependencies:
+    react-native: "*"
+  checksum: 10/e88ad3b8355191f83d35fa2f51208d38f0dda7e90aad1e2f3a02036726a3ed922008422c1051e7a6f45c8027eeefa8dbf0be75cb65ccdd980b80a55a251fbcee
+  languageName: node
+  linkType: hard
+
 "@gar/promise-retry@npm:^1.0.0":
   version: 1.0.2
   resolution: "@gar/promise-retry@npm:1.0.2"
@@ -6533,7 +6545,7 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"base64-js@npm:^1.2.3, base64-js@npm:^1.3.1, base64-js@npm:^1.5.1":
+"base64-js@npm:1.5.1, base64-js@npm:^1.2.3, base64-js@npm:^1.3.1, base64-js@npm:^1.5.1":
   version: 1.5.1
   resolution: "base64-js@npm:1.5.1"
   checksum: 10/669632eb3745404c2f822a18fc3a0122d2f9a7a13f7fb8b5823ee19d1d2ff9ee5b52c53367176ea4ad093c332fd5ab4bd0ebae5a8e27917a4105a4cfc86b1005
@@ -7690,6 +7702,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"debug@npm:4.3.4":
+  version: 4.3.4
+  resolution: "debug@npm:4.3.4"
+  dependencies:
+    ms: "npm:2.1.2"
+  peerDependenciesMeta:
+    supports-color:
+      optional: true
+  checksum: 10/0073c3bcbd9cb7d71dd5f6b55be8701af42df3e56e911186dfa46fac3a5b9eb7ce7f377dd1d3be6db8977221f8eb333d945216f645cf56f6b688cd484837d255
+  languageName: node
+  linkType: hard
+
 "debug@npm:^3.1.0":
   version: 3.2.7
   resolution: "debug@npm:3.2.7"
@@ -13287,6 +13311,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"ms@npm:2.1.2":
+  version: 2.1.2
+  resolution: "ms@npm:2.1.2"
+  checksum: 10/673cdb2c3133eb050c745908d8ce632ed2c02d85640e2edb3ace856a2266a813b30c613569bf3354fdf4ea7d1a1494add3bfa95e2713baa27d0c2c71fc44f58f
+  languageName: node
+  linkType: hard
+
 "ms@npm:2.1.3, ms@npm:^2.1.1, ms@npm:^2.1.3":
   version: 2.1.3
   resolution: "ms@npm:2.1.3"
@@ -14488,6 +14519,25 @@ __metadata:
   languageName: unknown
   linkType: soft
 
+"react-native-executorch-webrtc@workspace:packages/react-native-executorch-webrtc":
+  version: 0.0.0-use.local
+  resolution: "react-native-executorch-webrtc@workspace:packages/react-native-executorch-webrtc"
+  dependencies:
+    "@fishjam-cloud/react-native-webrtc": "npm:^0.25.8"
+    "@types/react": "npm:~19.1.10"
+    react: "npm:19.1.0"
+    react-native: "npm:0.81.5"
+    react-native-executorch: "workspace:*"
+    typescript: "npm:~5.9.2"
+  peerDependencies:
+    "@fishjam-cloud/react-native-client": "*"
+    "@fishjam-cloud/react-native-webrtc": "*"
+    react: "*"
+    react-native: "*"
+    react-native-executorch: "*"
+  languageName: unknown
+  linkType: soft
+
 "react-native-executorch@workspace:*, react-native-executorch@workspace:packages/react-native-executorch":
   version: 0.0.0-use.local
   resolution: "react-native-executorch@workspace:packages/react-native-executorch"