diff --git a/apps/example/ios/Podfile.lock b/apps/example/ios/Podfile.lock
index 66198b1fb4..e84916c103 100644
--- a/apps/example/ios/Podfile.lock
+++ b/apps/example/ios/Podfile.lock
@@ -2162,77 +2162,77 @@ SPEC CHECKSUMS:
   fmt: a40bb5bd0294ea969aaaba240a927bd33d878cdd
   glog: eb93e2f488219332457c3c4eafd2738ddc7e80b8
   hermes-engine: b417d2b2aee3b89b58e63e23a51e02be91dc876d
-  RCT-Folly: e78785aa9ba2ed998ea4151e314036f6c49e6d82
+  RCT-Folly: 36fe2295e44b10d831836cc0d1daec5f8abcf809
   RCTDeprecation: b2eecf2d60216df56bc5e6be5f063826d3c1ee35
   RCTRequired: 78522de7dc73b81f3ed7890d145fa341f5bb32ea
   RCTTypeSafety: c135dd2bf50402d87fd12884cbad5d5e64850edd
   React: b229c49ed5898dab46d60f61ed5a0bfa2ee2fadb
   React-callinvoker: 2ac508e92c8bd9cf834cc7d7787d94352e4af58f
-  React-Core: 325b4f6d9162ae8b9a6ff42fe78e260eb124180d
-  React-CoreModules: 558041e5258f70cd1092f82778d07b8b2ff01897
-  React-cxxreact: 8fff17cbe76e6a8f9991b59552e1235429f9c74b
+  React-Core: 13cdd1558d0b3f6d9d5a22e14d89150280e79f02
+  React-CoreModules: b07a6744f48305405e67c845ebf481b6551b712a
+  React-cxxreact: 1055a86c66ac35b4e80bd5fb766aed5f494dfff4
   React-debug: 0a5fcdbacc6becba0521e910c1bcfdb20f32a3f6
-  React-defaultsnativemodule: 618dc50a0fad41b489997c3eb7aba3a74479fd14
-  React-domnativemodule: 7ba599afb6c2a7ec3eb6450153e2efe0b8747e9a
-  React-Fabric: 252112089d2c63308f4cbfade4010b6606db67d1
-  React-FabricComponents: 3c0f75321680d14d124438ab279c64ec2a3d13c4
-  React-FabricImage: 728b8061cdec2857ca885fd605ee03ad43ffca98
+  React-defaultsnativemodule: 4bb28fc97fee5be63a9ebf8f7a435cfe8ba69459
+  React-domnativemodule: b36a11c2597243d7563985028c51ece988d8ae33
+  React-Fabric: afc561718f25b2cd800b709d934101afe376a12c
+  React-FabricComponents: f4e0a4e18a27bf6d39cbf2a0b42f37a92fa4e37f
+  React-FabricImage: 37d8e8b672eda68a19d71143eb65148084efb325
   React-featureflags: 19682e02ef5861d96b992af16a19109c3dfc1200
-  React-featureflagsnativemodule: 23528c7e7d50782b7ef0804168ba40bbaf1e86ab
-  React-graphics: fefe48f71bfe6f48fd037f59e8277b12e91b6be1
-  React-hermes: a9a0c8377627b5506ef9a7b6f60a805c306e3f51
-  React-idlecallbacksnativemodule: 7e2b6a3b70e042f89cd91dbd73c479bb39a72a7e
-  React-ImageManager: e3300996ac2e2914bf821f71e2f2c92ae6e62ae2
-  React-jserrorhandler: fa75876c662e5d7e79d6efc763fc9f4c88e26986
-  React-jsi: f3f51595cc4c089037b536368f016d4742bf9cf7
-  React-jsiexecutor: cca6c232db461e2fd213a11e9364cfa6fdaa20eb
-  React-jsinspector: 2bd4c9fddf189d6ec2abf4948461060502582bef
-  React-jsinspectortracing: a417d8a0ad481edaa415734b4dac81e3e5ee7dc6
-  React-jsitracing: 1ff7172c5b0522cbf6c98d82bdbb160e49b5804e
-  React-logger: 018826bfd51b9f18e87f67db1590bc510ad20664
-  React-Mapbuffer: 3c11cee7737609275c7b66bd0b1de475f094cedf
-  React-microtasksnativemodule: 843f352b32aacbe13a9c750190d34df44c3e6c2c
-  react-native-safe-area-context: 0f14bce545abcdfbff79ce2e3c78c109f0be283e
-  react-native-skia: 30909a8b54c5d383b5c424468e9824372199116e
-  react-native-slider: 310d3f89edd6ca8344a974bfe83a29a3fbb60e5a
-  React-NativeModulesApple: 88433b6946778bea9c153e27b671de15411bf225
-  React-perflogger: 9e8d3c0dc0194eb932162812a168aa5dc662f418
-  React-performancetimeline: 5a2d6efef52bdcefac079c7baa30934978acd023
+  React-featureflagsnativemodule: d7cddf6d907b4e5ab84f9e744b7e88461656e48c
+  React-graphics: b0f78580cdaf5800d25437e3d41cc6c3d83b7aea
+  React-hermes: 71186f872c932e4574d5feb3ed754dda63a0b3bd
+  React-idlecallbacksnativemodule: dd2af19cdd3bc55149d17a2409ed72b694dfbe9c
+  React-ImageManager: a77dde8d5aa6a2b6962c702bf3a47695ef0aa32b
+  React-jserrorhandler: 9c14e89f12d5904257a79aaf84a70cd2e5ac07ba
+  React-jsi: 0775a66820496769ad83e629f0f5cce621a57fc7
+  React-jsiexecutor: 2cf5ba481386803f3c88b85c63fa102cba5d769e
+  React-jsinspector: 8052d532bb7a98b6e021755674659802fb140cc5
+  React-jsinspectortracing: bdd8fd0adcb4813663562e7874c5842449df6d8a
+  React-jsitracing: 2bab3bf55de3d04baf205def375fa6643c47c794
+  React-logger: 795cd5055782db394f187f9db0477d4b25b44291
+  React-Mapbuffer: 0502faf46cab8fb89cfc7bf3e6c6109b6ef9b5de
+  React-microtasksnativemodule: 663bc64e3a96c5fc91081923ae7481adc1359a78
+  react-native-safe-area-context: 286b3e7b5589795bb85ffc38faf4c0706c48a092
+  react-native-skia: 6be4bd020c4c2489aed4b2b24f9548e56b143d48
+  react-native-slider: 27263d134d55db948a4706f1e47d0ec88fb354dd
+  React-NativeModulesApple: 16fbd5b040ff6c492dacc361d49e63cba7a6a7a1
+  React-perflogger: ab51b7592532a0ea45bf6eed7e6cae14a368b678
+  React-performancetimeline: bc2e48198ec814d578ac8401f65d78a574358203
   React-RCTActionSheet: 592674cf61142497e0e820688f5a696e41bf16dd
-  React-RCTAnimation: e6d669872f9b3b4ab9527aab283b7c49283236b7
-  React-RCTAppDelegate: de2343fe08be4c945d57e0ecce44afcc7dd8fc03
-  React-RCTBlob: 3e2dce94c56218becc4b32b627fc2293149f798d
-  React-RCTFabric: cac2c033381d79a5956e08550b0220cb2d78ea93
-  React-RCTFBReactNativeSpec: d10ca5e0ccbfeac8c047361fedf8e4ac653887b6
-  React-RCTImage: dc04b176c022d12a8f55ae7a7279b1e091066ae0
-  React-RCTLinking: 88f5e37fe4f26fbc80791aa2a5f01baf9b9a3fd5
-  React-RCTNetwork: f213693565efbd698b8e9c18d700a514b49c0c8e
-  React-RCTSettings: a2d32a90c45a3575568cad850abc45924999b8a5
-  React-RCTText: 54cdcd1cbf6f6a91dc6317f5d2c2b7fc3f6bf7a0
-  React-RCTVibration: 11dae0e7f577b5807bb7d31e2e881eb46f854fd4
+  React-RCTAnimation: 8fbb8dba757b49c78f4db403133ab6399a4ce952
+  React-RCTAppDelegate: 7f88baa8cb4e5d6c38bb4d84339925c70c9ac864
+  React-RCTBlob: f89b162d0fe6b570a18e755eb16cbe356d3c6d17
+  React-RCTFabric: 8ad6d875abe6e87312cef90e4b15ef7f6bed72e6
+  React-RCTFBReactNativeSpec: 8c29630c2f379c729300e4c1e540f3d1b78d1936
+  React-RCTImage: ccac9969940f170503857733f9a5f63578e106e1
+  React-RCTLinking: d82427bbf18415a3732105383dff119131cadd90
+  React-RCTNetwork: 12ad4d0fbde939e00251ca5ca890da2e6825cc3c
+  React-RCTSettings: e7865bf9f455abf427da349c855f8644b5c39afa
+  React-RCTText: 2cdfd88745059ec3202a0842ea75a956c7d6f27d
+  React-RCTVibration: a3a1458e6230dfd64b3768ebc0a4aac430d9d508
   React-rendererconsistency: 64e897e00d2568fd8dfe31e2496f80e85c0aaad1
-  React-rendererdebug: 41ce452460c44bba715d9e41d5493a96de277764
+  React-rendererdebug: a3f6d3ae7d2fa0035885026756281c07ee32479e
   React-rncore: 58748c2aa445f56b99e5118dad0aedb51c40ce9f
-  React-RuntimeApple: 7785ed0d8ae54da65a88736bb63ca97608a6d933
-  React-RuntimeCore: 6029ea70bc77f98cfd43ebe69217f14e93ba1f12
+  React-RuntimeApple: f0fda7bacabd32daa099cfda8f07466c30acd149
+  React-RuntimeCore: 683ee0b6a76d4b4bf6fbf83a541895b4887cc636
   React-runtimeexecutor: a188df372373baf5066e6e229177836488799f80
-  React-RuntimeHermes: a264609c28b796edfffc8ae4cb8fad1773ab948b
-  React-runtimescheduler: 23ec3a1e0fb1ec752d1a9c1fb15258c30bfc7222
+  React-RuntimeHermes: 907c8e9bec13ea6466b94828c088c24590d4d0b6
+  React-runtimescheduler: a2e2a39125dd6426b5d8b773f689d660cd7c5f60
   React-timing: bb220a53a795ed57976a4855c521f3de2f298fe5
-  React-utils: 3b054aaebe658fc710a8d239d0e4b9fd3e0b78f9
-  ReactAppDependencyProvider: a1fb08dfdc7ebc387b2e54cfc9decd283ed821d8
-  ReactCodegen: e232f8db3a40721044ec81b9388f95a7afaad36a
-  ReactCommon: 0c097b53f03d6bf166edbcd0915da32f3015dd90
-  ReactNativeHost: 1b6ccdcfc87bb31e772a5b3c3ca3b09c90954328
-  ReactTestApp-DevSupport: ea18f446cff64b6c9a3e28788600c82ecf51bde6
+  React-utils: 300d8bbb6555dcffaca71e7a0663201b5c7edbbc
+  ReactAppDependencyProvider: f2e81d80afd71a8058589e19d8a134243fa53f17
+  ReactCodegen: 50b6e45bbbef9b39d9798820cdbe87bfc7922e22
+  ReactCommon: 3d39389f8e2a2157d5c999f8fba57bd1c8f226f0
+  ReactNativeHost: e96154926221741f253f2c1ded13c6959c5c3d43
+  ReactTestApp-DevSupport: 6994b53b5b81139a8ce63e0776c726c95de079a1
   ReactTestApp-Resources: 1bd9ff10e4c24f2ad87101a32023721ae923bccf
-  RNGestureHandler: dcb1b1db024f3744b03af56d132f4f72c4c27195
-  RNReanimated: d5f33d14a4d1da33a02d89124de233a64b3aaeaa
-  RNScreens: 790123c4a28783d80a342ce42e8c7381bed62db1
-  RNSVG: 8126581b369adf6a0004b6a6cab1a55e3002d5b0
+  RNGestureHandler: 66e593addd8952725107cfaa4f5e3378e946b541
+  RNReanimated: 858fe25904af44131b8b608a5005b64778609a6a
+  RNScreens: 0f01bbed9bd8045a8d58e4b46993c28c7f498f3c
+  RNSVG: 8588ee1ca9b2e6fd2c99466e35b3db0e9f81bb40
   SocketRocket: d4aabe649be1e368d1318fdf28a022d714d65748
-  Yoga: afd04ff05ebe0121a00c468a8a3c8080221cb14c
+  Yoga: 9b7fb56e7b08cde60e2153344fa6afbd88e5d99f
 
 PODFILE CHECKSUM: 87506345285a0371afb28b9c3e6daaa999c214f3
 
-COCOAPODS: 1.16.2
+COCOAPODS: 1.15.2
diff --git a/apps/example/jestSetup.js b/apps/example/jestSetup.js
index 8dbb8b0e16..7211b24dd2 100644
--- a/apps/example/jestSetup.js
+++ b/apps/example/jestSetup.js
@@ -20,6 +20,11 @@ jest.mock("react-native-reanimated", () => {
   MockReanimated.scrollTo = () => {};
   MockReanimated.useFrameCallback = () => {};
   MockReanimated.convertToRGBA = () => {};
+  MockReanimated.configureReanimatedLogger = () => {};
+  MockReanimated.ReanimatedLogLevel = {
+    warn: 1,
+    error: 2,
+  };
   return MockReanimated;
 });
 
diff --git a/apps/example/src/Examples/API/List.tsx b/apps/example/src/Examples/API/List.tsx
index eb1052b978..8133b6c2eb 100644
--- a/apps/example/src/Examples/API/List.tsx
+++ b/apps/example/src/Examples/API/List.tsx
@@ -114,6 +114,14 @@ export const examples = [
     screen: "StressTest",
     title: "🔥 Stress Test",
   },
+  {
+    screen: "StressTest2",
+    title: "🔥 Stress Test 2",
+  },
+  {
+    screen: "StressTest3",
+    title: "🔥 Stress Test 3",
+  },
 ] as const;
 
 const styles = StyleSheet.create({
diff --git a/apps/example/src/Examples/API/Routes.ts b/apps/example/src/Examples/API/Routes.ts
index 24ca14c661..07e0723907 100644
--- a/apps/example/src/Examples/API/Routes.ts
+++ b/apps/example/src/Examples/API/Routes.ts
@@ -27,4 +27,6 @@ export type Routes = {
   Paragraphs2: undefined;
   Skottie: undefined;
   StressTest: undefined;
+  StressTest2: undefined;
+  StressTest3: undefined;
 };
diff --git a/apps/example/src/Examples/API/StressTest2.tsx b/apps/example/src/Examples/API/StressTest2.tsx
new file mode 100644
index 0000000000..9c04ed1f74
--- /dev/null
+++ b/apps/example/src/Examples/API/StressTest2.tsx
@@ -0,0 +1,150 @@
+import type { Dispatch, SetStateAction } from "react";
+import React, { useState, useRef, useEffect } from "react";
+import { Button, ScrollView, StyleSheet } from "react-native";
+import type { SkImage, SkPicture, SkSize } from "@shopify/react-native-skia";
+import { Canvas, Image, Skia } from "@shopify/react-native-skia";
+import {
+  configureReanimatedLogger,
+  ReanimatedLogLevel,
+  runOnJS,
+  runOnUI,
+  useSharedValue,
+  type SharedValue,
+} from "react-native-reanimated";
+
+// This is the default configuration
+configureReanimatedLogger({
+  level: ReanimatedLogLevel.error,
+  strict: false, // Reanimated runs in strict mode by default
+});
+
+const drawPicture = (
+  picture: SkPicture,
+  texture: SharedValue<SkImage | null>,
+  size: SkSize
+) => {
+  "worklet";
+  const surface = Skia.Surface.MakeOffscreen(size.width, size.height);
+  if (!surface) {
+    console.error("Could not create surface");
+    return;
+  }
+  const canvas = surface.getCanvas();
+  canvas.drawPicture(picture);
+  surface.flush();
+  texture.value = surface.makeImageSnapshot();
+};
+
+const usePictureAsTexture = (picture: SkPicture | null, size: SkSize) => {
+  const texture = useSharedValue<SkImage | null>(null);
+  useEffect(() => {
+    if (!picture) {
+      texture.value = null;
+      return;
+    }
+    runOnUI(drawPicture)(picture, texture, size);
+  }, [picture, size, texture]);
+  return texture;
+};
+
+const makeTexture = (content: SharedValue<SkImage | null>) => {
+  "worklet";
+
+  const texture = Skia.Surface.MakeOffscreen(400, 400)!;
+  const canvas = texture.getCanvas();
+  for (let i = 0; i < 1000; i++) {
+    const paint = Skia.Paint();
+    paint.setColor(
+      Float32Array.from([Math.random(), Math.random(), Math.random(), 1])
+    );
+
+    const x = (i % 20) * 20;
+    const y = Math.floor(i / 20) * 8;
+
+    canvas.drawCircle(x, y, 3, paint);
+  }
+  content.value = texture.makeImageSnapshot();
+};
+
+const createPictureWithGPUResources = (
+  content: SharedValue<SkImage | null>,
+  setPicture: Dispatch<SetStateAction<SkPicture | null>>
+) => {
+  "worklet";
+  makeTexture(content);
+  const rec = Skia.PictureRecorder();
+  const canvas = rec.beginRecording(Skia.XYWHRect(0, 0, 400, 400));
+  if (content.value) {
+    canvas.drawImage(content.value, 0, 0);
+  }
+  const result = rec.finishRecordingAsPicture();
+  runOnJS(setPicture)(result);
+};
+
+export const StressTest2 = () => {
+  const content = useSharedValue<SkImage | null>(null);
+  const [picture, setPicture] = useState<SkPicture | null>(null);
+  const texture = usePictureAsTexture(picture, {
+    width: 400,
+    height: 400,
+  });
+
+  const [isRunning, setIsRunning] = useState(false);
+  const intervalRef = useRef<unknown>(-1);
+
+  useEffect(() => {
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current as number);
+      }
+    };
+  }, []);
+
+  const startStressTest = () => {
+    if (isRunning) return;
+
+    setIsRunning(true);
+
+    // Use setInterval to rapidly update the picture, triggering React re-renders
+    intervalRef.current = setInterval(() => {
+      runOnUI(createPictureWithGPUResources)(content, setPicture);
+    }, 32) as unknown; // ~60fps to stress the system and trigger the race condition
+  };
+
+  const stopStressTest = () => {
+    if (intervalRef.current) {
+      clearInterval(intervalRef.current as number);
+    }
+    setIsRunning(false);
+  };
+
+  return (
+    <ScrollView style={styles.container}>
+      <Canvas
+        style={{
+          width: 400,
+          height: 400,
+          borderColor: "red",
+          borderWidth: 2,
+        }}
+      >
+        {/* Use Image with texture as described in crash scenario */}
+        <Image image={texture} x={0} y={0} width={400} height={400} />
+      </Canvas>
+      <Button
+        onPress={isRunning ? stopStressTest : startStressTest}
+        title={
+          isRunning
+            ? "Stop GPU Resource Crash Test"
+            : "Start GPU Resource Crash Test"
+        }
+      />
+    </ScrollView>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+  },
+});
diff --git a/apps/example/src/Examples/API/StressTest3.tsx b/apps/example/src/Examples/API/StressTest3.tsx
new file mode 100644
index 0000000000..dfcddb1741
--- /dev/null
+++ b/apps/example/src/Examples/API/StressTest3.tsx
@@ -0,0 +1,144 @@
+import type { Dispatch, SetStateAction } from "react";
+import React, { useState, useRef, useEffect } from "react";
+import { Button, ScrollView, StyleSheet } from "react-native";
+import type { SkImage, SkPicture } from "@shopify/react-native-skia";
+import { Canvas, Skia, usePictureAsTexture } from "@shopify/react-native-skia";
+import {
+  configureReanimatedLogger,
+  ReanimatedLogLevel,
+  runOnJS,
+  runOnUI,
+  useSharedValue,
+  type SharedValue,
+} from "react-native-reanimated";
+
+// This is the default configuration
+configureReanimatedLogger({
+  level: ReanimatedLogLevel.error,
+  strict: false, // Reanimated runs in strict mode by default
+});
+
+const makeTexture = (content: SharedValue<SkImage | null>) => {
+  "worklet";
+
+  const texture = Skia.Surface.MakeOffscreen(400, 400)!;
+  const canvas = texture.getCanvas();
+  for (let i = 0; i < 1000; i++) {
+    const paint = Skia.Paint();
+    paint.setColor(
+      Float32Array.from([Math.random(), Math.random(), Math.random(), 1])
+    );
+
+    const x = (i % 20) * 20;
+    const y = Math.floor(i / 20) * 8;
+
+    canvas.drawCircle(x, y, 3, paint);
+  }
+  content.value = texture.makeImageSnapshot();
+};
+
+const createPictureWithGPUResources = (
+  content: SharedValue<SkImage | null>,
+  setPicture: Dispatch<SetStateAction<SkPicture | null>>
+) => {
+  "worklet";
+  makeTexture(content);
+  const rec = Skia.PictureRecorder();
+  const canvas = rec.beginRecording(Skia.XYWHRect(0, 0, 400, 400));
+  if (content.value) {
+    canvas.drawImage(content.value, 0, 0);
+  }
+  const result = rec.finishRecordingAsPicture();
+  runOnJS(setPicture)(result);
+};
+
+export const StressTest3 = () => {
+  const content = useSharedValue<SkImage | null>(null);
+  const [picture, setPicture] = useState<SkPicture | null>(null);
+  const texture = usePictureAsTexture(picture, {
+    width: 400,
+    height: 400,
+  });
+
+  const [isRunning, setIsRunning] = useState(false);
+  const intervalRef = useRef<unknown>(-1);
+
+  useEffect(() => {
+    return () => {
+      // Cleanup interval on unmount
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current as number);
+      }
+    };
+  }, []);
+
+  const startStressTest = () => {
+    if (isRunning) return;
+
+    setIsRunning(true);
+
+    // Use setInterval to rapidly update the picture, triggering React re-renders
+    intervalRef.current = setInterval(() => {
+      runOnUI(createPictureWithGPUResources)(content, setPicture);
+    }, 32) as unknown; // ~60fps to stress the system and trigger the race condition
+  };
+
+  const stopStressTest = () => {
+    if (intervalRef.current) {
+      clearInterval(intervalRef.current as number);
+    }
+    setIsRunning(false);
+  };
+
+  return (
+    <ScrollView style={styles.container}>
+      <Canvas
+        style={{
+          width: 400,
+          height: 400,
+          borderColor: "red",
+          borderWidth: 2,
+        }}
+      >
+        {/* Use Image with texture as described in crash scenario */}
+      </Canvas>
+      <RasterCanvas image={texture} />
+      <Button
+        onPress={isRunning ? stopStressTest : startStressTest}
+        title={
+          isRunning
+            ? "Stop GPU Resource Crash Test"
+            : "Start GPU Resource Crash Test"
+        }
+      />
+    </ScrollView>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+  },
+});
+
+interface FrameProps {
+  image: SharedValue<SkImage | null>;
+}
+
+const frame = ({ image }: FrameProps) => {
+  const surface = Skia.Surface.MakeOffscreen(400, 400)!;
+  const canvas = surface.getCanvas();
+  if (image.value) {
+    canvas.drawImage(image.value.makeNonTextureImage(), 0, 0);
+  }
+  surface.flush();
+  surface.makeImageSnapshot();
+  requestAnimationFrame(() => frame({ image }));
+};
+
+const RasterCanvas = (props: FrameProps) => {
+  useEffect(() => {
+    frame(props);
+  }, [props]);
+  return null;
+};
diff --git a/apps/example/src/Examples/API/index.tsx b/apps/example/src/Examples/API/index.tsx
index 4abf58b871..baf63d2224 100644
--- a/apps/example/src/Examples/API/index.tsx
+++ b/apps/example/src/Examples/API/index.tsx
@@ -30,6 +30,8 @@ import { Paragraphs } from "./Paragraphs";
 import { Paragraphs2 } from "./Paragraphs2";
 import { Skottie } from "./Skottie";
 import { StressTest } from "./StressTest";
+import { StressTest2 } from "./StressTest2";
+import { StressTest3 } from "./StressTest3";
 
 const Stack = createNativeStackNavigator<Routes>();
 export const API = () => {
@@ -232,6 +234,20 @@ export const API = () => {
           title: "🔥 Stress Test",
         }}
       />
+      <Stack.Screen
+        name="StressTest2"
+        component={StressTest2}
+        options={{
+          title: "🔥 Stress Test 2",
+        }}
+      />
+      <Stack.Screen
+        name="StressTest3"
+        component={StressTest3}
+        options={{
+          title: "🔥 Stress Test 3",
+        }}
+      />
     </Stack.Navigator>
   );
 };
diff --git a/apps/example/src/Examples/Filters/Filters.tsx b/apps/example/src/Examples/Filters/Filters.tsx
index 0100e65d69..f8764b2ac3 100644
--- a/apps/example/src/Examples/Filters/Filters.tsx
+++ b/apps/example/src/Examples/Filters/Filters.tsx
@@ -1,13 +1,13 @@
 import React from "react";
 import { Pressable, useWindowDimensions } from "react-native";
 import {
-  useImage,
   Canvas,
   ImageShader,
   Skia,
   Shader,
   mix,
   Fill,
+  useImageAsTexture,
 } from "@shopify/react-native-skia";
 import { useDerivedValue } from "react-native-reanimated";
 
@@ -32,7 +32,7 @@ export const Filters = () => {
     [progress]
   );
 
-  const image = useImage(require("../../assets/oslo.jpg"));
+  const image = useImageAsTexture(require("../../assets/oslo.jpg"));
 
   return (
     <Pressable style={{ width, height }} onPress={() => setState((i) => i + 1)}>
diff --git a/packages/skia/android/CMakeLists.txt b/packages/skia/android/CMakeLists.txt
index 1e6014e2ee..a3a2d50571 100644
--- a/packages/skia/android/CMakeLists.txt
+++ b/packages/skia/android/CMakeLists.txt
@@ -126,6 +126,8 @@ add_library(
         "${PROJECT_SOURCE_DIR}/../cpp/api/third_party/CSSColorParser.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/api/third_party/base64.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/api/third_party/SkottieUtils.cpp"
+
+        "${PROJECT_SOURCE_DIR}/../cpp/api/JsiSkDispatcher.cpp"
         ${BACKEND_SOURCES}
 )
 
diff --git a/packages/skia/apple/SkiaCVPixelBufferUtils.mm b/packages/skia/apple/SkiaCVPixelBufferUtils.mm
index d477acdf1b..1cc8e108a5 100644
--- a/packages/skia/apple/SkiaCVPixelBufferUtils.mm
+++ b/packages/skia/apple/SkiaCVPixelBufferUtils.mm
@@ -30,12 +30,16 @@
 #include <TargetConditionals.h>
 #if TARGET_RT_BIG_ENDIAN
 #define FourCC2Str(fourcc)                                                     \
-  (const char[]){*((char *)&fourcc), *(((char *)&fourcc) + 1),                 \
-                 *(((char *)&fourcc) + 2), *(((char *)&fourcc) + 3), 0}
+  (const char[]) {                                                             \
+    *((char *)&fourcc), *(((char *)&fourcc) + 1), *(((char *)&fourcc) + 2),    \
+        *(((char *)&fourcc) + 3), 0                                            \
+  }
 #else
 #define FourCC2Str(fourcc)                                                     \
-  (const char[]){*(((char *)&fourcc) + 3), *(((char *)&fourcc) + 2),           \
-                 *(((char *)&fourcc) + 1), *(((char *)&fourcc) + 0), 0}
+  (const char[]) {                                                             \
+    *(((char *)&fourcc) + 3), *(((char *)&fourcc) + 2),                        \
+        *(((char *)&fourcc) + 1), *(((char *)&fourcc) + 0), 0                  \
+  }
 #endif
 
 // pragma MARK: TextureHolder
diff --git a/packages/skia/cpp/api/JsiSkCanvas.h b/packages/skia/cpp/api/JsiSkCanvas.h
index c010abf0b8..a6c49a4a93 100644
--- a/packages/skia/cpp/api/JsiSkCanvas.h
+++ b/packages/skia/cpp/api/JsiSkCanvas.h
@@ -34,6 +34,7 @@
 #include "include/core/SkRegion.h"
 #include "include/core/SkSurface.h"
 #include "include/core/SkTypeface.h"
+#include "include/gpu/ganesh/GrDirectContext.h"
 
 #pragma clang diagnostic pop
 
@@ -68,6 +69,7 @@ class JsiSkCanvas : public JsiSkHostObject {
 
   JSI_HOST_FUNCTION(drawImage) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    validateImageForDrawing(runtime, image);
     auto x = arguments[1].asNumber();
     auto y = arguments[2].asNumber();
     std::shared_ptr<SkPaint> paint;
@@ -80,6 +82,7 @@ class JsiSkCanvas : public JsiSkHostObject {
 
   JSI_HOST_FUNCTION(drawImageRect) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    validateImageForDrawing(runtime, image);
     auto src = JsiSkRect::fromValue(runtime, arguments[1]);
     auto dest = JsiSkRect::fromValue(runtime, arguments[2]);
     auto paint = JsiSkPaint::fromValue(runtime, arguments[3]);
@@ -92,6 +95,7 @@ class JsiSkCanvas : public JsiSkHostObject {
 
   JSI_HOST_FUNCTION(drawImageCubic) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    validateImageForDrawing(runtime, image);
     auto x = arguments[1].asNumber();
     auto y = arguments[2].asNumber();
     float B = arguments[3].asNumber();
@@ -108,6 +112,7 @@ class JsiSkCanvas : public JsiSkHostObject {
 
   JSI_HOST_FUNCTION(drawImageOptions) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    validateImageForDrawing(runtime, image);
     auto x = arguments[1].asNumber();
     auto y = arguments[2].asNumber();
     auto fm = (SkFilterMode)arguments[3].asNumber();
@@ -124,6 +129,7 @@ class JsiSkCanvas : public JsiSkHostObject {
 
   JSI_HOST_FUNCTION(drawImageNine) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    validateImageForDrawing(runtime, image);
     auto center = JsiSkRect::fromValue(runtime, arguments[1]);
     auto dest = JsiSkRect::fromValue(runtime, arguments[2]);
     auto fm = (SkFilterMode)arguments[3].asNumber();
@@ -140,6 +146,7 @@ class JsiSkCanvas : public JsiSkHostObject {
 
   JSI_HOST_FUNCTION(drawImageRectCubic) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    validateImageForDrawing(runtime, image);
     auto src = JsiSkRect::fromValue(runtime, arguments[1]);
     auto dest = JsiSkRect::fromValue(runtime, arguments[2]);
     float B = arguments[3].asNumber();
@@ -159,6 +166,7 @@ class JsiSkCanvas : public JsiSkHostObject {
 
   JSI_HOST_FUNCTION(drawImageRectOptions) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    validateImageForDrawing(runtime, image);
     auto src = JsiSkRect::fromValue(runtime, arguments[1]);
     auto dest = JsiSkRect::fromValue(runtime, arguments[2]);
     auto filter = (SkFilterMode)arguments[3].asNumber();
@@ -695,6 +703,20 @@ class JsiSkCanvas : public JsiSkHostObject {
   SkCanvas *getCanvas() { return _canvas; }
 
 private:
+  void validateImageForDrawing(jsi::Runtime &runtime,
+                               const sk_sp<SkImage> image) {
+#if !defined(SK_GRAPHITE)
+    auto ctx = getContext()->getDirectContext();
+    if (!ctx) {
+      throw jsi::JSError(runtime, "No GPU context available");
+    }
+    if (image && !image->isValid(ctx->asRecorder())) {
+      throw jsi::JSError(
+          runtime, "image used in drawImage() does not belong to this context");
+    }
+#endif
+  }
+
   SkCanvas *_canvas;
 };
 } // namespace RNSkia
diff --git a/packages/skia/cpp/api/JsiSkDispatcher.cpp b/packages/skia/cpp/api/JsiSkDispatcher.cpp
new file mode 100644
index 0000000000..47b83595cd
--- /dev/null
+++ b/packages/skia/cpp/api/JsiSkDispatcher.cpp
@@ -0,0 +1,9 @@
+#include "JsiSkDispatcher.h"
+
+namespace RNSkia {
+
+// Thread-local storage definition
+thread_local std::shared_ptr<Dispatcher::DispatcherData>
+    Dispatcher::_threadDispatcher;
+
+} // namespace RNSkia
\ No newline at end of file
diff --git a/packages/skia/cpp/api/JsiSkDispatcher.h b/packages/skia/cpp/api/JsiSkDispatcher.h
new file mode 100644
index 0000000000..bfecd22310
--- /dev/null
+++ b/packages/skia/cpp/api/JsiSkDispatcher.h
@@ -0,0 +1,149 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <thread>
+#include <unordered_map>
+
+namespace RNSkia {
+
+/**
+ * Thread-local dispatcher for managing deferred operations.
+ * Each thread gets its own dispatcher instance for queueing operations
+ * to be executed on that specific thread.
+ */
+class Dispatcher {
+private:
+  using Operation = std::function<void()>;
+
+  struct DispatcherData {
+    std::queue<Operation> operationQueue;
+    std::mutex queueMutex;
+  };
+
+  // Thread-local storage for dispatcher data
+  static thread_local std::shared_ptr<DispatcherData> _threadDispatcher;
+
+  // Global registry of all dispatchers by thread ID
+  static inline std::mutex _registryMutex;
+  static inline std::unordered_map<std::thread::id,
+                                   std::weak_ptr<DispatcherData>>
+      _dispatcherRegistry;
+
+  std::shared_ptr<DispatcherData> _data;
+  std::thread::id _threadId;
+
+public:
+  Dispatcher() : _threadId(std::this_thread::get_id()) {
+    // Get or create dispatcher data for current thread
+    if (!_threadDispatcher) {
+      _threadDispatcher = std::make_shared<DispatcherData>();
+
+      // Register in global registry
+      std::lock_guard<std::mutex> lock(_registryMutex);
+      _dispatcherRegistry[_threadId] = _threadDispatcher;
+    }
+    _data = _threadDispatcher;
+  }
+
+  /**
+   * Get the dispatcher for the current thread.
+   * Creates one if it doesn't exist.
+   */
+  static std::shared_ptr<Dispatcher> getDispatcher() {
+    return std::make_shared<Dispatcher>();
+  }
+
+  /**
+   * Get the dispatcher for a specific thread.
+   * Returns nullptr if that thread doesn't have a dispatcher.
+   */
+  static std::shared_ptr<Dispatcher> getDispatcher(std::thread::id threadId) {
+    std::lock_guard<std::mutex> lock(_registryMutex);
+    auto it = _dispatcherRegistry.find(threadId);
+    if (it != _dispatcherRegistry.end()) {
+      if (auto data = it->second.lock()) {
+        auto dispatcher = std::make_shared<Dispatcher>();
+        dispatcher->_data = data;
+        dispatcher->_threadId = threadId;
+        return dispatcher;
+      }
+    }
+    return nullptr;
+  }
+
+  /**
+   * Queue an operation to be executed on the dispatcher's thread.
+   * The operation will be executed when processQueue() is called on that
+   * thread.
+   */
+  void run(Operation op) {
+    if (!_data)
+      return;
+
+    std::lock_guard<std::mutex> lock(_data->queueMutex);
+    _data->operationQueue.push(std::move(op));
+  }
+
+  /**
+   * Process all pending operations for the current thread.
+   * Must be called from the thread that owns this dispatcher.
+   * Returns the number of operations processed.
+   */
+  size_t processQueue() {
+    if (!_data)
+      return 0;
+
+    // Only process if we're on the correct thread
+    if (std::this_thread::get_id() != _threadId) {
+      return 0;
+    }
+
+    std::queue<Operation> operations;
+    {
+      std::lock_guard<std::mutex> lock(_data->queueMutex);
+      operations.swap(_data->operationQueue);
+    }
+
+    size_t count = operations.size();
+    while (!operations.empty()) {
+      auto &op = operations.front();
+      op();
+      operations.pop();
+    }
+
+    return count;
+  }
+
+  /**
+   * Get the number of pending operations.
+   */
+  size_t getPendingCount() const {
+    if (!_data)
+      return 0;
+
+    std::lock_guard<std::mutex> lock(_data->queueMutex);
+    return _data->operationQueue.size();
+  }
+
+  /**
+   * Clean up dispatcher for a thread that's shutting down.
+   */
+  static void cleanup() {
+    if (_threadDispatcher) {
+      // Process any remaining operations
+      auto dispatcher = getDispatcher();
+      dispatcher->processQueue();
+
+      // Remove from registry
+      std::lock_guard<std::mutex> lock(_registryMutex);
+      _dispatcherRegistry.erase(std::this_thread::get_id());
+
+      _threadDispatcher.reset();
+    }
+  }
+};
+
+} // namespace RNSkia
\ No newline at end of file
diff --git a/packages/skia/cpp/api/JsiSkImage.h b/packages/skia/cpp/api/JsiSkImage.h
index 6066e491c0..042d4cf945 100644
--- a/packages/skia/cpp/api/JsiSkImage.h
+++ b/packages/skia/cpp/api/JsiSkImage.h
@@ -4,11 +4,11 @@
 #include <string>
 #include <utility>
 
+#include "JsiSkDispatcher.h"
 #include "JsiSkHostObjects.h"
 #include "JsiSkImageInfo.h"
 #include "JsiSkMatrix.h"
 #include "JsiSkShader.h"
-#include "JsiSkThreadSafeDeletion.h"
 #include "third_party/base64.h"
 
 #include "JsiTextureInfo.h"
@@ -63,7 +63,7 @@ inline SkSamplingOptions SamplingOptionsFromValue(jsi::Runtime &runtime,
 
 class JsiSkImage : public JsiSkWrappingSkPtrHostObject<SkImage> {
 private:
-  ThreadSafeDeletion<SkImage> _deletionHandler;
+  std::shared_ptr<Dispatcher> _dispatcher;
 
 public:
   // TODO-API: Properties?
@@ -258,6 +258,10 @@ class JsiSkImage : public JsiSkWrappingSkPtrHostObject<SkImage> {
     return JsiTextureInfo::toValue(runtime, texInfo);
   }
 
+  JSI_HOST_FUNCTION(isTextureBacked) {
+    return jsi::Value(getObject()->isTextureBacked());
+  }
+
   EXPORT_JSI_API_TYPENAME(JsiSkImage, Image)
 
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkImage, width),
@@ -270,27 +274,41 @@ class JsiSkImage : public JsiSkWrappingSkPtrHostObject<SkImage> {
                        JSI_EXPORT_FUNC(JsiSkImage, readPixels),
                        JSI_EXPORT_FUNC(JsiSkImage, makeNonTextureImage),
                        JSI_EXPORT_FUNC(JsiSkImage, getNativeTextureUnstable),
+                       JSI_EXPORT_FUNC(JsiSkImage, isTextureBacked),
                        JSI_EXPORT_FUNC(JsiSkImage, dispose))
 
   JsiSkImage(std::shared_ptr<RNSkPlatformContext> context,
              const sk_sp<SkImage> image)
       : JsiSkWrappingSkPtrHostObject<SkImage>(std::move(context),
                                               std::move(image)) {
-    // Drain any pending deletions when creating new images
-    ThreadSafeDeletion<SkImage>::drainDeletionQueue();
+    // Get the dispatcher for the current thread
+    _dispatcher = Dispatcher::getDispatcher();
+    // Process any pending operations
+    _dispatcher->processQueue();
   }
 
   ~JsiSkImage() override {
-    // Handle thread-safe deletion
-    _deletionHandler.handleDeletion(getObject());
-    // Always clear the object to prevent base class destructor from deleting it
-    // handleDeletion takes full responsibility for the object's lifetime
+    // Queue deletion on the creation thread if needed
+    auto image = getObject();
+    if (image && _dispatcher) {
+      _dispatcher->run([image]() {
+        // Image will be deleted when this lambda is destroyed
+      });
+    }
+    // Clear the object to prevent base class destructor from deleting it
     setObject(nullptr);
   }
 
   size_t getMemoryPressure() const override {
     auto image = getObject();
-    return image ? image->imageInfo().computeMinByteSize() : 0;
+    if (image) {
+      if (image->isTextureBacked()) {
+        return image->textureSize();
+      } else {
+        return image->imageInfo().computeMinByteSize();
+      }
+    }
+    return 0;
   }
 };
 
diff --git a/packages/skia/cpp/api/JsiSkPicture.h b/packages/skia/cpp/api/JsiSkPicture.h
index 042551a2d1..68acaba937 100644
--- a/packages/skia/cpp/api/JsiSkPicture.h
+++ b/packages/skia/cpp/api/JsiSkPicture.h
@@ -3,6 +3,7 @@
 #include <memory>
 
 #include "JsiSkData.h"
+#include "JsiSkDispatcher.h"
 #include "JsiSkHostObjects.h"
 #include "JsiSkMatrix.h"
 #include "JsiSkRect.h"
@@ -20,10 +21,30 @@ namespace RNSkia {
 namespace jsi = facebook::jsi;
 
 class JsiSkPicture : public JsiSkWrappingSkPtrHostObject<SkPicture> {
+private:
+  std::shared_ptr<Dispatcher> _dispatcher;
+
 public:
   JsiSkPicture(std::shared_ptr<RNSkPlatformContext> context,
                const sk_sp<SkPicture> picture)
-      : JsiSkWrappingSkPtrHostObject<SkPicture>(context, picture) {}
+      : JsiSkWrappingSkPtrHostObject<SkPicture>(context, picture) {
+    // Get the dispatcher for the current thread
+    _dispatcher = Dispatcher::getDispatcher();
+    // Process any pending operations
+    _dispatcher->processQueue();
+  }
+
+  ~JsiSkPicture() override {
+    // Queue deletion on the creation thread if needed
+    auto picture = getObject();
+    if (picture && _dispatcher) {
+      _dispatcher->run([picture]() {
+        // Picture will be deleted when this lambda is destroyed
+      });
+    }
+    // Clear the object to prevent base class destructor from deleting it
+    setObject(nullptr);
+  }
 
   JSI_HOST_FUNCTION(makeShader) {
     auto tmx = (SkTileMode)arguments[0].asNumber();
diff --git a/packages/skia/cpp/api/JsiSkSurface.h b/packages/skia/cpp/api/JsiSkSurface.h
index 82cfe7e66c..f369b57817 100644
--- a/packages/skia/cpp/api/JsiSkSurface.h
+++ b/packages/skia/cpp/api/JsiSkSurface.h
@@ -5,8 +5,8 @@
 
 #include <jsi/jsi.h>
 
+#include "JsiSkDispatcher.h"
 #include "JsiSkHostObjects.h"
-#include "JsiSkThreadSafeDeletion.h"
 #include "JsiTextureInfo.h"
 
 #include "JsiSkCanvas.h"
@@ -30,23 +30,28 @@ namespace jsi = facebook::jsi;
 
 class JsiSkSurface : public JsiSkWrappingSkPtrHostObject<SkSurface> {
 private:
-  ThreadSafeDeletion<SkSurface> _deletionHandler;
+  std::shared_ptr<Dispatcher> _dispatcher;
 
 public:
   JsiSkSurface(std::shared_ptr<RNSkPlatformContext> context,
                sk_sp<SkSurface> surface)
       : JsiSkWrappingSkPtrHostObject<SkSurface>(std::move(context),
-                                                std::move(surface)),
-        _deletionHandler() {
-    // Drain any pending deletions when creating new surfaces
-    ThreadSafeDeletion<SkSurface>::drainDeletionQueue();
+                                                std::move(surface)) {
+    // Get the dispatcher for the current thread
+    _dispatcher = Dispatcher::getDispatcher();
+    // Process any pending operations
+    _dispatcher->processQueue();
   }
 
   ~JsiSkSurface() override {
-    // Handle thread-safe deletion
-    _deletionHandler.handleDeletion(getObject());
-    // Always clear the object to prevent base class destructor from deleting it
-    // handleDeletion takes full responsibility for the object's lifetime
+    // Queue deletion on the creation thread if needed
+    auto surface = getObject();
+    if (surface && _dispatcher) {
+      _dispatcher->run([surface]() {
+        // Surface will be deleted when this lambda is destroyed
+      });
+    }
+    // Clear the object to prevent base class destructor from deleting it
     setObject(nullptr);
   }
 
diff --git a/packages/skia/cpp/api/JsiSkThreadSafeDeletion.h b/packages/skia/cpp/api/JsiSkThreadSafeDeletion.h
deleted file mode 100644
index ab905f7f15..0000000000
--- a/packages/skia/cpp/api/JsiSkThreadSafeDeletion.h
+++ /dev/null
@@ -1,105 +0,0 @@
-#pragma once
-
-#include <functional>
-#include <memory>
-#include <mutex>
-#include <queue>
-#include <thread>
-
-// Define this to disable thread-safe deletion (for testing purposes)
-// #define DISABLE_THREAD_SAFE_DELETION
-
-namespace RNSkia {
-
-/**
- * Utility class for managing thread-safe deletion of Skia objects.
- * Ensures objects are deleted on the thread that created them.
- */
-template <typename T> class ThreadSafeDeletion {
-private:
-  struct DeletionItem {
-    sk_sp<T> object;
-    std::thread::id creationThreadId;
-  };
-
-  static inline std::mutex _queueMutex;
-  static inline std::queue<DeletionItem> _deletionQueue;
-
-  std::thread::id _creationThreadId;
-
-public:
-  ThreadSafeDeletion() : _creationThreadId(std::this_thread::get_id()) {}
-
-  /**
-   * Handles deletion of the object. If we're on the wrong thread,
-   * queues it for later deletion. Otherwise, allows immediate deletion.
-   * The object is always considered handled after this call.
-   */
-  void handleDeletion(sk_sp<T> object) {
-    if (!object) {
-      return;
-    }
-
-#ifdef DISABLE_THREAD_SAFE_DELETION
-    // When disabled, allow immediate deletion
-    // This will likely cause crashes when objects are deleted on wrong thread
-    return;
-#else
-    // Always try to drain the queue when handling deletions
-    drainDeletionQueue();
-
-    // Check if we're on the creation thread
-    if (std::this_thread::get_id() != _creationThreadId) {
-      // Queue for deletion on the correct thread
-      std::lock_guard<std::mutex> lock(_queueMutex);
-      _deletionQueue.push({object, _creationThreadId});
-      return;
-    }
-
-    // We're on the correct thread, allow immediate deletion via destructor
-    return;
-#endif
-  }
-
-  /**
-   * Drains the deletion queue for objects created on the current thread.
-   * Should be called periodically (e.g., when creating new objects).
-   */
-  static void drainDeletionQueue() {
-#ifndef DISABLE_THREAD_SAFE_DELETION
-    auto currentThreadId = std::this_thread::get_id();
-    std::queue<DeletionItem> remainingItems;
-
-    std::lock_guard<std::mutex> lock(_queueMutex);
-
-    // Process all items in the queue
-    while (!_deletionQueue.empty()) {
-      auto item = _deletionQueue.front();
-      _deletionQueue.pop();
-
-      // If this item belongs to the current thread, let it be deleted
-      if (item.creationThreadId == currentThreadId) {
-        // The sk_sp destructor will handle the cleanup
-        // Just let it go out of scope
-      } else {
-        // Keep items that belong to other threads
-        remainingItems.push(item);
-      }
-    }
-
-    // Put back items that couldn't be deleted
-    _deletionQueue = std::move(remainingItems);
-#endif
-  }
-
-  /**
-   * Returns the number of items waiting for deletion.
-   * Useful for debugging and testing.
-   */
-  static size_t getPendingDeletionCount() {
-    std::lock_guard<std::mutex> lock(_queueMutex);
-    return _deletionQueue.size();
-  }
-};
-
-} // namespace RNSkia
diff --git a/packages/skia/cpp/api/recorder/Drawings.h b/packages/skia/cpp/api/recorder/Drawings.h
index e44af9bb56..9fd18e886b 100644
--- a/packages/skia/cpp/api/recorder/Drawings.h
+++ b/packages/skia/cpp/api/recorder/Drawings.h
@@ -6,6 +6,7 @@
 #include "Convertor.h"
 #include "DrawingCtx.h"
 #include "ImageFit.h"
+#include "RNSkPlatformContext.h"
 
 namespace RNSkia {
 
@@ -468,10 +469,11 @@ struct ImageCmdProps {
 class ImageCmd : public Command {
 public:
   ImageCmdProps props;
+  std::shared_ptr<RNSkPlatformContext> _context;
 
-  ImageCmd(jsi::Runtime &runtime, const jsi::Object &object,
-           Variables &variables)
-      : Command(CommandType::DrawImage) {
+  ImageCmd(std::shared_ptr<RNSkPlatformContext> context, jsi::Runtime &runtime,
+           const jsi::Object &object, Variables &variables)
+      : Command(CommandType::DrawImage), _context(context) {
     convertProperty(runtime, object, "rect", props.rect, variables);
     convertProperty(runtime, object, "image", props.image, variables);
     convertProperty(runtime, object, "sampling", props.sampling, variables);
@@ -484,6 +486,17 @@ class ImageCmd : public Command {
     convertProperty(runtime, object, "rect", props.rect, variables);
   }
 
+  ~ImageCmd() {
+    if (props.image.has_value()) {
+      auto image = props.image.value();
+      if (image) {
+        _context->runOnMainThread([image]() {
+          // Image will be deleted when this lambda is destroyed on main thread
+        });
+      }
+    }
+  }
+
   void draw(DrawingCtx *ctx) {
     auto [x, y, width, height, rect, fit, image, sampling] = props;
     if (image.has_value()) {
@@ -784,13 +797,24 @@ struct PictureCmdProps {
 class PictureCmd : public Command {
 public:
   PictureCmdProps props;
+  std::shared_ptr<RNSkPlatformContext> _context;
 
-  PictureCmd(jsi::Runtime &runtime, const jsi::Object &object,
+  PictureCmd(std::shared_ptr<RNSkPlatformContext> context,
+             jsi::Runtime &runtime, const jsi::Object &object,
              Variables &variables)
-      : Command(CommandType::DrawPicture) {
+      : Command(CommandType::DrawPicture), _context(context) {
     convertProperty(runtime, object, "picture", props.picture, variables);
   }
 
+  ~PictureCmd() {
+    auto picture = props.picture;
+    if (picture) {
+      _context->runOnMainThread([picture]() {
+        // Picture will be deleted when this lambda is destroyed on main thread
+      });
+    }
+  }
+
   void draw(DrawingCtx *ctx) { ctx->canvas->drawPicture(props.picture); }
 };
 
@@ -914,10 +938,11 @@ struct AtlasCmdProps {
 class AtlasCmd : public Command {
 public:
   AtlasCmdProps props;
+  std::shared_ptr<RNSkPlatformContext> _context;
 
-  AtlasCmd(jsi::Runtime &runtime, const jsi::Object &object,
-           Variables &variables)
-      : Command(CommandType::DrawAtlas) {
+  AtlasCmd(std::shared_ptr<RNSkPlatformContext> context, jsi::Runtime &runtime,
+           const jsi::Object &object, Variables &variables)
+      : Command(CommandType::DrawAtlas), _context(context) {
     convertProperty(runtime, object, "image", props.image, variables);
     convertProperty(runtime, object, "sprites", props.sprites, variables);
     convertProperty(runtime, object, "transforms", props.transforms, variables);
@@ -926,6 +951,15 @@ class AtlasCmd : public Command {
     convertProperty(runtime, object, "sampling", props.sampling, variables);
   }
 
+  ~AtlasCmd() {
+    auto image = props.image;
+    if (image) {
+      _context->runOnMainThread([image]() {
+        // Image will be deleted when this lambda is destroyed on main thread
+      });
+    }
+  }
+
   void draw(DrawingCtx *ctx) {
     if (props.image) {
       // Validate transforms and sprites have the same size
@@ -956,4 +990,4 @@ class AtlasCmd : public Command {
   }
 };
 
-} // namespace RNSkia
+} // namespace RNSkia
\ No newline at end of file
diff --git a/packages/skia/cpp/api/recorder/JsiRecorder.h b/packages/skia/cpp/api/recorder/JsiRecorder.h
index 9bb8d4f6e9..3be22ca5a6 100644
--- a/packages/skia/cpp/api/recorder/JsiRecorder.h
+++ b/packages/skia/cpp/api/recorder/JsiRecorder.h
@@ -22,7 +22,9 @@ class JsiRecorder : public JsiSkWrappingSharedPtrHostObject<Recorder> {
 public:
   JsiRecorder(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkWrappingSharedPtrHostObject(std::move(context),
-                                         std::make_shared<Recorder>()) {}
+                                         std::make_shared<Recorder>()) {
+    getObject()->_context = getContext();
+  }
 
   JSI_HOST_FUNCTION(savePaint) {
     getObject()->savePaint(runtime, arguments[0].asObject(runtime),
diff --git a/packages/skia/cpp/api/recorder/RNRecorder.h b/packages/skia/cpp/api/recorder/RNRecorder.h
index 3fac339158..1c3c9f7998 100644
--- a/packages/skia/cpp/api/recorder/RNRecorder.h
+++ b/packages/skia/cpp/api/recorder/RNRecorder.h
@@ -15,6 +15,7 @@
 #include "ImageFilters.h"
 #include "Paint.h"
 #include "PathEffects.h"
+#include "RNSkPlatformContext.h"
 #include "Shaders.h"
 
 namespace RNSkia {
@@ -24,8 +25,10 @@ class Recorder {
   std::vector<std::unique_ptr<Command>> commands;
 
 public:
+  std::shared_ptr<RNSkPlatformContext> _context;
   Variables variables;
 
+  Recorder() = default;
   ~Recorder() = default;
 
   void savePaint(jsi::Runtime &runtime, const jsi::Object &props,
@@ -216,7 +219,8 @@ class Recorder {
   }
 
   void drawImage(jsi::Runtime &runtime, const jsi::Object &props) {
-    commands.push_back(std::make_unique<ImageCmd>(runtime, props, variables));
+    commands.push_back(
+        std::make_unique<ImageCmd>(_context, runtime, props, variables));
   }
 
   void drawPoints(jsi::Runtime &runtime, const jsi::Object &props) {
@@ -255,7 +259,8 @@ class Recorder {
   }
 
   void drawPicture(jsi::Runtime &runtime, const jsi::Object &props) {
-    commands.push_back(std::make_unique<PictureCmd>(runtime, props, variables));
+    commands.push_back(
+        std::make_unique<PictureCmd>(_context, runtime, props, variables));
   }
 
   void drawImageSVG(jsi::Runtime &runtime, const jsi::Object &props) {
@@ -269,7 +274,8 @@ class Recorder {
   }
 
   void drawAtlas(jsi::Runtime &runtime, const jsi::Object &props) {
-    commands.push_back(std::make_unique<AtlasCmd>(runtime, props, variables));
+    commands.push_back(
+        std::make_unique<AtlasCmd>(_context, runtime, props, variables));
   }
 
   void drawSkottie(jsi::Runtime &runtime, const jsi::Object &props) {
@@ -646,4 +652,4 @@ class Recorder {
   }
 };
 
-} // namespace RNSkia
+} // namespace RNSkia
\ No newline at end of file
diff --git a/packages/skia/src/external/reanimated/textures.tsx b/packages/skia/src/external/reanimated/textures.tsx
index e0f42f4147..3cc9fd48ac 100644
--- a/packages/skia/src/external/reanimated/textures.tsx
+++ b/packages/skia/src/external/reanimated/textures.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useMemo, useState } from "react";
+import { useEffect, useState } from "react";
 import type { DependencyList, ReactElement } from "react";
 import type { SharedValue } from "react-native-reanimated";
 
@@ -8,21 +8,45 @@ import type {
   SkPicture,
   SkSize,
 } from "../../skia/types";
-import {
-  drawAsImageFromPicture,
-  drawAsPicture,
-} from "../../renderer/Offscreen";
+import { drawAsPicture } from "../../renderer/Offscreen";
 import { Skia, useImage } from "../../skia";
+import { Platform } from "../../Platform";
 
 import Rea from "./ReanimatedProxy";
 
+const createTextureFromImage = (
+  texture: SharedValue<SkImage | null>,
+  image: SkImage
+) => {
+  "worklet";
+  const surface = Skia.Surface.MakeOffscreen(image.width(), image.height());
+  if (!surface) {
+    texture.value = null;
+    return;
+  }
+  const canvas = surface.getCanvas();
+  canvas.drawImage(image, 0, 0);
+  surface.flush();
+  texture.value = surface.makeImageSnapshot();
+  if (Platform.OS === "web") {
+    texture.value = texture.value.makeNonTextureImage();
+  }
+};
+
 const createTexture = (
   texture: SharedValue<SkImage | null>,
   picture: SkPicture,
   size: SkSize
 ) => {
   "worklet";
-  texture.value = drawAsImageFromPicture(picture, size);
+  const surface = Skia.Surface.MakeOffscreen(size.width, size.height)!;
+  const canvas = surface.getCanvas();
+  canvas.drawPicture(picture);
+  surface.flush();
+  texture.value = surface.makeImageSnapshot();
+  if (Platform.OS === "web") {
+    texture.value = texture.value.makeNonTextureImage();
+  }
 };
 
 export const useTexture = (
@@ -61,26 +85,11 @@ export const usePictureAsTexture = (
 
 export const useImageAsTexture = (source: DataSourceParam) => {
   const image = useImage(source);
-  const size = useMemo(() => {
-    if (image) {
-      return { width: image.width(), height: image.height() };
-    }
-    return { width: 0, height: 0 };
-  }, [image]);
-  const picture = useMemo(() => {
-    if (image) {
-      const recorder = Skia.PictureRecorder();
-      const canvas = recorder.beginRecording({
-        x: 0,
-        y: 0,
-        width: size.width,
-        height: size.height,
-      });
-      canvas.drawImage(image, 0, 0);
-      return recorder.finishRecordingAsPicture();
-    } else {
-      return null;
+  const texture = Rea.useSharedValue<SkImage | null>(null);
+  useEffect(() => {
+    if (image !== null) {
+      Rea.runOnUI(createTextureFromImage)(texture, image);
     }
-  }, [size, image]);
-  return usePictureAsTexture(picture, size);
+  }, [image, texture]);
+  return texture;
 };
diff --git a/packages/skia/src/renderer/Offscreen.tsx b/packages/skia/src/renderer/Offscreen.tsx
index 6b3facb38e..7a644c49f8 100644
--- a/packages/skia/src/renderer/Offscreen.tsx
+++ b/packages/skia/src/renderer/Offscreen.tsx
@@ -5,7 +5,6 @@ import { Skia } from "../skia";
 import { Platform } from "../Platform";
 import { SkiaSGRoot } from "../sksg/Reconciler";
 
-// We call it main thread because on web main is JS thread
 export const isOnMainThread = () => {
   "worklet";
   return (
@@ -36,10 +35,5 @@ export const drawAsImageFromPicture = (picture: SkPicture, size: SkSize) => {
   canvas.drawPicture(picture);
   surface.flush();
   const image = surface.makeImageSnapshot();
-  // If we are not on the main thread or if we are on Web, we need to make the image non-texture.
-  if (!isOnMainThread() || Platform.OS === "web") {
-    return image.makeNonTextureImage();
-  } else {
-    return image;
-  }
+  return image.makeNonTextureImage();
 };
diff --git a/packages/skia/src/sksg/Recorder/ReanimatedRecorder.ts b/packages/skia/src/sksg/Recorder/ReanimatedRecorder.ts
index 017df683f8..af79648505 100644
--- a/packages/skia/src/sksg/Recorder/ReanimatedRecorder.ts
+++ b/packages/skia/src/sksg/Recorder/ReanimatedRecorder.ts
@@ -32,6 +32,10 @@ import type {
 import type { AnimatedProps } from "../../renderer";
 import { isSharedValue } from "../utils";
 
+/**
+ * Currently the recorder only work if the GPU resources (e.g Images) are owned by the main thread.
+ * It will crash otherwise on Ganesh (iOS/Android).
+ */
 export class ReanimatedRecorder implements BaseRecorder {
   private values = new Set<SharedValue<unknown>>();
   private recorder: JsiRecorder;