@@ -1,5 +1,49 @@
 # CHANGELOG
 
+## v2.52.0 - 08 February 2026
+
+### Added
+- **Full Shader Support**: Complete implementation of shader modifiers for iOS and Android platforms
+- **Shader Overrides**: New `shaderOverrides` prop for real-time shader customization across both platforms
+- **Shader Propagation**: Intelligent shader propagation system down the node tree with proper timing
+- **Fragment Output Standardization**: Unified fragment shader outputs across platforms
+- **Texture Handling in Shaders**: Full texture support in shader overrides
+- **Animated Shader Support**: Uniform binding for animated shaders
+- **Material Animation Preservation**: Materials with animations are preserved during shader application
+- **Lighting Properties in Shaders**: Lighting properties are properly copied and maintained in custom shaders
+- **Material Sharing**: Materials now shared efficiently across instances for improved performance
+- **Depth-based AR Hit Testing**: Enhanced AR hit test functionality using depth information
+- **Monocular Depth Fallback**: Non-LiDAR devices now automatically fallback to monocular depth estimation
+- **Throttle Mechanism**: Added performance throttle to prevent system overload
+
+### Fixed
+- **iOS Memory Leaks** (Critical): Completely eliminated memory leaks on iOS platform (both viro and virocore)
+- **Portal Crashes** (Critical): Fixed crashes when unmounting portals on iOS
+- **Material Overflow**: Fixed cloned materials array overflow that caused crashes
+- **VRX Asset Loading**: Resolved VRX asset loading issues
+- **Monocular Depth Alignment**: Fixed monocular depth frame alignment issues
+- **Double Anchor Reference**: Fixed issue with creating duplicate anchor references
+- **Gravity Type Crash**: Fixed Android crash caused by incorrect gravity type definition (now correctly typed as 3D vector `[number, number, number]`)
+- **hitResultId**: Fixed hitResultId availability issue in AR hit tests
+- **Thread Locks**: Refactored implementation to avoid thread locks
+
+### Changed
+- **Depth Integration**: Improved depth integration with simplified logic
+
+### Removed
+- Debug logs and visualizations from production code
+- Spam/noisy logging
+
+### ViroCore Integration
+This release includes 21 commits from virocore focused on:
+- Native shader support and modifiers
+- Memory management improvements
+- Depth processing enhancements
+
+## v2.51.0 - 01 February 2026
+
+Previous release baseline for v2.52.0 changes.
+
 ## v2.43.6 - 08 October 2025
 
 - **Fixed pod install issues**: Adjusted ViroKit requirements
 
@@ -205,6 +205,17 @@ public void onObject3DLoaded(Object3D object, Object3D.Type type) {
                     setMaterials(mMaterials);
                 }
 
+                // Apply shader overrides if specified (preserves textures)
+                Log.d(TAG, "VRT3DObject loaded, mShaderOverrides: " +
+                      (mShaderOverrides != null ? mShaderOverrides.size() + " overrides" : "null"));
+                if (mShaderOverrides != null && !mShaderOverrides.isEmpty()) {
+                    Log.d(TAG, "Applying shader overrides recursively: " + mShaderOverrides);
+                    vrt3DObject.applyShaderOverridesRecursive(true);
+                    Log.d(TAG, "Shader overrides applied");
+                } else {
+                    Log.d(TAG, "No shader overrides to apply");
+                }
+
                 // Set the bitmasks recursively now that the tree is loaded
                 object.setLightReceivingBitMask(mLightReceivingBitMask);
                 object.setShadowCastingBitMask(mShadowCastingBitMask);
 
@@ -104,6 +104,23 @@ public void setMorphTargets(VRT3DObject object3d, @Nullable ReadableArray target
         object3d.setMorphTargets(targetList);
     }
 
+    @ReactProp(name = "shaderOverrides")
+    public void setShaderOverrides(VRT3DObject object3d, @Nullable ReadableArray shaderOverrides) {
+        if (shaderOverrides == null || shaderOverrides.size() <= 0) {
+            object3d.setShaderOverrides(null);
+            return;
+        }
+
+        List<String> shaderOverridesList = new ArrayList<>();
+        for (int i = 0; i < shaderOverrides.size(); i++) {
+            String materialName = shaderOverrides.getString(i);
+            if (materialName != null && !materialName.isEmpty()) {
+                shaderOverridesList.add(materialName);
+            }
+        }
+        object3d.setShaderOverrides(shaderOverridesList);
+    }
+
     @ReactProp(name = "type")
     public void setType(VRT3DObject object3d, @Nullable String type) {
         object3d.setType(type);
 
@@ -27,6 +27,7 @@
 import android.net.Uri;
 import android.util.Log;
 
+import com.facebook.react.bridge.Dynamic;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
@@ -162,6 +163,64 @@ public void deleteMaterials(ReadableArray materials) {
         }
     }
 
+    @ReactMethod
+    public void updateShaderUniform(String materialName, String uniformName, String uniformType, Dynamic value) {
+        Material material = getMaterial(materialName);
+        if (material == null) {
+            Log.w("VRTMaterialManager", "Cannot update shader uniform: material '" + materialName + "' not found");
+            return;
+        }
+
+        Object uniformValue = null;
+
+        if ("float".equalsIgnoreCase(uniformType)) {
+            float floatValue = (float) value.asDouble();
+            material.setShaderUniform(uniformName, floatValue);
+            uniformValue = floatValue;
+        } else if ("vec3".equalsIgnoreCase(uniformType)) {
+            ReadableArray arr = value.asArray();
+            if (arr != null && arr.size() >= 3) {
+                float x = (float) arr.getDouble(0);
+                float y = (float) arr.getDouble(1);
+                float z = (float) arr.getDouble(2);
+                material.setShaderUniform(uniformName, x, y, z);
+                uniformValue = new float[]{x, y, z};
+            }
+        } else if ("vec4".equalsIgnoreCase(uniformType)) {
+            ReadableArray arr = value.asArray();
+            if (arr != null && arr.size() >= 4) {
+                float x = (float) arr.getDouble(0);
+                float y = (float) arr.getDouble(1);
+                float z = (float) arr.getDouble(2);
+                float w = (float) arr.getDouble(3);
+                material.setShaderUniform(uniformName, x, y, z, w);
+                uniformValue = new float[]{x, y, z, w};
+            }
+        } else if ("mat4".equalsIgnoreCase(uniformType)) {
+            ReadableArray arr = value.asArray();
+            if (arr != null && arr.size() >= 16) {
+                float[] matrix = new float[16];
+                for (int i = 0; i < 16; i++) {
+                    matrix[i] = (float) arr.getDouble(i);
+                }
+                material.setShaderUniform(uniformName, matrix);
+                uniformValue = matrix;
+            }
+        }
+
+        // Propagate uniform updates to:
+        // 1. Shader override clones (for shaderOverrides on 3D models)
+        // 2. All geometries using this material directly (for materials prop)
+        if (uniformValue != null) {
+            com.viromedia.bridge.component.node.VRTNode.updateShaderOverrideUniform(
+                materialName, uniformName, uniformType, uniformValue);
+        }
+
+        // Refresh all nodes using this material directly (materials={["name"]} prop)
+        // This re-applies the material with updated uniforms to the geometry
+        com.viromedia.bridge.component.node.VRTNode.refreshNodesUsingMaterial(materialName);
+    }
+
     private void loadMaterials(ReadableMap newMaterials) {
         ReadableMapKeySetIterator iter = newMaterials.keySetIterator();
         while (iter.hasNextKey()) {
@@ -336,6 +395,12 @@ else if(materialPropertyName.equalsIgnoreCase("chromaKeyFilteringColor")) {
         parsePBRProperties(PBRProperties.ROUGHNESS, nativeMaterial, materialMap);
         parsePBRProperties(PBRProperties.AMBIENT_OCCLUSION_TEXTURE, nativeMaterial, materialMap);
 
+        // Parse shader modifiers
+        parseShaderModifiers(nativeMaterial, materialMap);
+
+        // Parse material/shader uniforms
+        parseShaderUniforms(nativeMaterial, materialMap);
+
         // We don't need to hold a Java texture reference after assigning the texture to the material.
         // Make an exception for the videoTexture as we use the nativeref to play,pause, loop the video.
         if (diffuseTexture != null && videoTexture == null) {
@@ -383,6 +448,157 @@ private void parsePBRProperties(PBRProperties property, Material material, Reada
         }
     }
 
+    private void parseShaderModifiers(Material material, ReadableMap materialMap) {
+        if (!materialMap.hasKey("shaderModifiers")) {
+            Log.d("VRTMaterialManager", "No shaderModifiers key in material map");
+            return;
+        }
+
+        ReadableMap modifiers = materialMap.getMap("shaderModifiers");
+        if (modifiers == null) {
+            Log.d("VRTMaterialManager", "shaderModifiers map is null");
+            return;
+        }
+
+        Log.d("VRTMaterialManager", "Parsing shader modifiers for material");
+
+        ReadableMapKeySetIterator iter = modifiers.keySetIterator();
+        while (iter.hasNextKey()) {
+            String entryPointName = iter.nextKey();
+            ReadableType type = modifiers.getType(entryPointName);
+
+            Log.d("VRTMaterialManager", "Processing entry point: " + entryPointName + ", type: " + type);
+
+            String modifierCode = null;
+
+            // Handle both string and dictionary formats
+            if (type == ReadableType.String) {
+                modifierCode = modifiers.getString(entryPointName);
+                Log.d("VRTMaterialManager", "String format, code length: " + (modifierCode != null ? modifierCode.length() : 0));
+            } else if (type == ReadableType.Map) {
+                ReadableMap modifierDict = modifiers.getMap(entryPointName);
+                String uniforms = modifierDict.hasKey("uniforms") ? modifierDict.getString("uniforms") : null;
+                String body = modifierDict.hasKey("body") ? modifierDict.getString("body") : null;
+
+                if (uniforms != null && uniforms.length() > 0) {
+                    modifierCode = uniforms + "\n" + (body != null ? body : "");
+                } else {
+                    modifierCode = body;
+                }
+
+                if (modifierCode == null) {
+                    Log.e("VRTMaterialManager", "Shader modifier dictionary must contain 'body' or 'uniforms' key");
+                    continue;
+                }
+                Log.d("VRTMaterialManager", "Map format, code length: " + modifierCode.length());
+            } else {
+                Log.e("VRTMaterialManager", "Shader modifier must be string or dictionary with 'body' key");
+                continue;
+            }
+
+            if (modifierCode != null && modifierCode.length() > 0) {
+                Log.d("VRTMaterialManager", "Calling material.addShaderModifier for entry point: " + entryPointName);
+                material.addShaderModifier(entryPointName, modifierCode);
+                Log.d("VRTMaterialManager", "Successfully added shader modifier");
+            }
+        }
+    }
+
+    private void parseShaderUniforms(Material material, ReadableMap materialMap) {
+        // Check for both "materialUniforms" and "shaderUniforms" keys
+        String[] uniformKeys = {"materialUniforms", "shaderUniforms"};
+
+        for (String uniformKey : uniformKeys) {
+            if (!materialMap.hasKey(uniformKey)) {
+                continue;
+            }
+
+            ReadableType type = materialMap.getType(uniformKey);
+
+            // Support array format: [{name, type, value}, ...]
+            if (type == ReadableType.Array) {
+                ReadableArray uniforms = materialMap.getArray(uniformKey);
+                for (int i = 0; i < uniforms.size(); i++) {
+                    if (uniforms.getType(i) != ReadableType.Map) {
+                        continue;
+                    }
+
+                    ReadableMap uniform = uniforms.getMap(i);
+                    if (!uniform.hasKey("name") || !uniform.hasKey("type")) {
+                        continue;
+                    }
+
+                    String name = uniform.getString("name");
+                    String uniformType = uniform.getString("type");
+                    setShaderUniform(material, name, uniformType, uniform);
+                }
+            }
+            // Support dictionary format: {uniformName: {type, value}}
+            else if (type == ReadableType.Map) {
+                ReadableMap uniforms = materialMap.getMap(uniformKey);
+                ReadableMapKeySetIterator iter = uniforms.keySetIterator();
+
+                while (iter.hasNextKey()) {
+                    String name = iter.nextKey();
+                    if (uniforms.getType(name) != ReadableType.Map) {
+                        continue;
+                    }
+
+                    ReadableMap uniform = uniforms.getMap(name);
+                    if (!uniform.hasKey("type")) {
+                        continue;
+                    }
+
+                    String uniformType = uniform.getString("type");
+                    setShaderUniform(material, name, uniformType, uniform);
+                }
+            }
+        }
+    }
+
+    private void setShaderUniform(Material material, String name, String type, ReadableMap uniformData) {
+        if (!uniformData.hasKey("value")) {
+            return;
+        }
+
+        Log.d("VRTMaterialManager", "Setting shader uniform: " + name + " of type: " + type);
+
+        if ("float".equalsIgnoreCase(type)) {
+            float value = (float) uniformData.getDouble("value");
+            material.setShaderUniform(name, value);
+            Log.d("VRTMaterialManager", "Set float uniform: " + name + " = " + value);
+        } else if ("vec3".equalsIgnoreCase(type)) {
+            ReadableArray arr = uniformData.getArray("value");
+            if (arr != null && arr.size() >= 3) {
+                float x = (float) arr.getDouble(0);
+                float y = (float) arr.getDouble(1);
+                float z = (float) arr.getDouble(2);
+                material.setShaderUniform(name, x, y, z);
+                Log.d("VRTMaterialManager", "Set vec3 uniform: " + name);
+            }
+        } else if ("vec4".equalsIgnoreCase(type)) {
+            ReadableArray arr = uniformData.getArray("value");
+            if (arr != null && arr.size() >= 4) {
+                float x = (float) arr.getDouble(0);
+                float y = (float) arr.getDouble(1);
+                float z = (float) arr.getDouble(2);
+                float w = (float) arr.getDouble(3);
+                material.setShaderUniform(name, x, y, z, w);
+                Log.d("VRTMaterialManager", "Set vec4 uniform: " + name);
+            }
+        } else if ("mat4".equalsIgnoreCase(type)) {
+            ReadableArray arr = uniformData.getArray("value");
+            if (arr != null && arr.size() >= 16) {
+                float[] matrix = new float[16];
+                for (int i = 0; i < 16; i++) {
+                    matrix[i] = (float) arr.getDouble(i);
+                }
+                material.setShaderUniform(name, matrix);
+                Log.d("VRTMaterialManager", "Set mat4 uniform: " + name);
+            }
+        }
+    }
+
     private Texture parseTexture(Image image, boolean sRGB, boolean mipmap,
                                  String name, ReadableMap materialMap) {
         Texture nativeTexture = new Texture(image, sRGB, mipmap);
 
@@ -15,6 +15,10 @@ import {
   ViroScale,
   ViroSource,
 } from "../Types/ViroUtils";
+import {
+  ViroShaderModifiers,
+  ViroShaderUniform,
+} from "../Material/ViroMaterials";
 import { NativeSyntheticEvent, ViewProps } from "react-native";
 
 export type ViroCommonProps = ViewProps & {
@@ -98,6 +102,10 @@ export type ViroObjectProps = {
   lightReceivingBitMask?: number;
   shadowCastingBitMask?: number;
 
+  shaderModifiers?: ViroShaderModifiers;
+  shaderOverrides?: string[];
+  materialUniforms?: { [key: string]: any } | ViroShaderUniform[];
+
   onTransformUpdate?: (position: Viro3DPoint) => void;
 
   /**