diff --git a/apps/common-app/src/apps/reanimated/examples/AndroidDrawPassExample.tsx b/apps/common-app/src/apps/reanimated/examples/AndroidDrawPassExample.tsx
new file mode 100644
index 000000000000..8b00d222d791
--- /dev/null
+++ b/apps/common-app/src/apps/reanimated/examples/AndroidDrawPassExample.tsx
@@ -0,0 +1,181 @@
+import { useNavigation } from '@react-navigation/native';
+import type { NativeStackNavigationProp } from '@react-navigation/native-stack';
+import { createNativeStackNavigator } from '@react-navigation/native-stack';
+import React, { useCallback } from 'react';
+import { Button, StyleSheet, Text, View } from 'react-native';
+import Animated, {
+  interpolate,
+  useAnimatedScrollHandler,
+  useAnimatedStyle,
+  useSharedValue,
+} from 'react-native-reanimated';
+
+type AndroidDrawPassParamList = {
+  Description: undefined;
+  ScrollList: undefined;
+};
+
+const Stack = createNativeStackNavigator<AndroidDrawPassParamList>();
+const LIST_ITEM_COUNT = 80;
+
+export default function AndroidDrawPassExample() {
+  return (
+    <View style={descriptionStyles.container}>
+      <Stack.Navigator>
+        <Stack.Screen name="Description" component={DescriptionScreen} />
+        <Stack.Screen name="ScrollList" component={ScrollListScreen} />
+      </Stack.Navigator>
+    </View>
+  );
+}
+
+function DescriptionScreen() {
+  const navigation =
+    useNavigation<NativeStackNavigationProp<AndroidDrawPassParamList>>();
+
+  return (
+    <View style={descriptionStyles.centered}>
+      <Text style={descriptionStyles.title}>Android Draw Pass Fix</Text>
+      <Text style={descriptionStyles.description}>
+        This example reproduces a bug that was fixed on Android where committing
+        updates during a draw pass caused a crash.
+      </Text>
+      <Text style={descriptionStyles.description}>
+        Previously, if you navigated to the scroll list and went back{' '}
+        <Text style={descriptionStyles.bold}>while actively scrolling</Text>,
+        the app would crash. This happened because Reanimated was attempting to
+        commit UI updates while Android was in the middle of a draw pass, and
+        sometimes React would have some hierarchy mutations queued up that would
+        get bundled with these updates, triggering the crash.
+      </Text>
+      <Text style={descriptionStyles.description}>
+        The fix detects when a draw pass is in progress and pushes only
+        non-layout updates through the synchronous update path, while layout
+        updates are deferred to the next frame. This ensures that we never
+        attempt to mutate the view hierarchy during a draw pass.
+      </Text>
+      <Button
+        title="Go to scroll list"
+        onPress={() => navigation.navigate('ScrollList')}
+      />
+    </View>
+  );
+}
+
+function ListItem({ index }: { index: number }) {
+  return (
+    <View style={listStyles.listItem}>
+      <Text>Item {index + 1}</Text>
+      <Text style={listStyles.listItemSubtext}>
+        Scroll fast and press Back — this used to crash on Android
+      </Text>
+    </View>
+  );
+}
+
+function ScrollListScreen() {
+  const scrollY = useSharedValue(0);
+
+  const scrollHandler = useAnimatedScrollHandler({
+    onScroll: (event) => {
+      scrollY.value = event.contentOffset.y;
+    },
+  });
+
+  const floatingBadgeStyle = useAnimatedStyle(() => {
+    const scale = interpolate(scrollY.value, [0, 100, 200], [1, 1.2, 0.9]);
+    const rotate = interpolate(scrollY.value, [0, 150, 300], [0, 5, -5]);
+
+    return {
+      width: 100,
+      transform: [{ scale }, { rotate: `${rotate}deg` }],
+    };
+  });
+
+  const renderItem = useCallback(
+    ({ item }: { item: number }) => <ListItem index={item} />,
+    []
+  );
+
+  const keyExtractor = useCallback((item: number) => `item-${item}`, []);
+  const data = Array.from({ length: LIST_ITEM_COUNT }, (_, index) => index);
+
+  return (
+    <View style={listStyles.container}>
+      <Animated.View style={[listStyles.floatingBadge, floatingBadgeStyle]}>
+        <Text style={listStyles.badgeText}>scrollY</Text>
+      </Animated.View>
+
+      <Animated.FlatList
+        data={data}
+        renderItem={renderItem}
+        keyExtractor={keyExtractor}
+        onScroll={scrollHandler}
+        scrollEventThrottle={16}
+        contentContainerStyle={listStyles.listContent}
+        showsVerticalScrollIndicator
+      />
+    </View>
+  );
+}
+
+const descriptionStyles = StyleSheet.create({
+  container: {
+    flex: 1,
+  },
+  centered: {
+    flex: 1,
+    alignItems: 'center',
+    gap: 16,
+    padding: 24,
+  },
+  title: {
+    fontSize: 20,
+    fontWeight: '700',
+    marginBottom: 4,
+  },
+  description: {
+    color: '#333',
+    fontSize: 15,
+    lineHeight: 22,
+  },
+  bold: {
+    fontWeight: '700',
+  },
+});
+
+const listStyles = StyleSheet.create({
+  container: {
+    flex: 1,
+  },
+  floatingBadge: {
+    position: 'absolute',
+    top: 100,
+    right: 20,
+    zIndex: 10,
+    paddingVertical: 8,
+    paddingHorizontal: 14,
+    borderRadius: 12,
+    backgroundColor: 'rgba(255, 149, 0, 0.9)',
+  },
+  badgeText: {
+    color: '#fff',
+    fontWeight: '600',
+  },
+  listContent: {
+    paddingTop: 24,
+    paddingBottom: 40,
+    paddingHorizontal: 20,
+  },
+  listItem: {
+    marginBottom: 8,
+    borderRadius: 8,
+    paddingVertical: 16,
+    paddingHorizontal: 12,
+    backgroundColor: 'rgba(128, 128, 128, 0.12)',
+  },
+  listItemSubtext: {
+    marginTop: 6,
+    opacity: 0.8,
+  },
+});
diff --git a/apps/common-app/src/apps/reanimated/examples/StickyHeaderExample.tsx b/apps/common-app/src/apps/reanimated/examples/StickyHeaderExample.tsx
index 1dbfe3f9e896..f43aab0a5f8c 100644
--- a/apps/common-app/src/apps/reanimated/examples/StickyHeaderExample.tsx
+++ b/apps/common-app/src/apps/reanimated/examples/StickyHeaderExample.tsx
@@ -24,7 +24,10 @@ export default function StickyHeaderExample() {
   });
 
   const animatedStyle = useAnimatedStyle(() => {
-    return { transform: [{ translateY: offset.value }] };
+    return {
+      transform: [{ translateY: offset.value }],
+      width: (offset.value % 200) + 100,
+    };
   });
 
   return (
diff --git a/apps/common-app/src/apps/reanimated/examples/index.ts b/apps/common-app/src/apps/reanimated/examples/index.ts
index 22efd7dc57fb..6bc4edc10ea2 100644
--- a/apps/common-app/src/apps/reanimated/examples/index.ts
+++ b/apps/common-app/src/apps/reanimated/examples/index.ts
@@ -160,6 +160,7 @@ import WorkletFactoryCrash from './WorkletFactoryCrashExample';
 import WorkletRuntimeExample from './WorkletRuntimeExample';
 import InstanceDiscoveryExample from './InstanceDiscoveryExample';
 import ShadowNodesCloningExample from './ShadowNodesCloningExample';
+import AndroidDrawPassExample from './AndroidDrawPassExample';
 
 export const REAPlatform = {
   IOS: 'ios',
@@ -204,6 +205,11 @@ export const EXAMPLES: Record<string, Example> = {
     title: 'Sync back to React',
     screen: SyncBackToReactExample,
   },
+  AndroidDrawPassExample: {
+    icon: '✍️',
+    title: 'Android Draw Pass',
+    screen: AndroidDrawPassExample,
+  },
   DetachAnimatedStylesExample: {
     icon: '⛓️‍💥',
     title: 'Detach animated styles',
diff --git a/apps/fabric-example/ios/Podfile.lock b/apps/fabric-example/ios/Podfile.lock
index 822f8d33a89b..e8e6b0526b50 100644
--- a/apps/fabric-example/ios/Podfile.lock
+++ b/apps/fabric-example/ios/Podfile.lock
@@ -2519,7 +2519,7 @@ EXTERNAL SOURCES:
 
 SPEC CHECKSUMS:
   FBLazyVector: c12d2108050e27952983d565a232f6f7b1ad5e69
-  hermes-engine: 53012435cc80627d41ad53d8c27ecc7efaef2f12
+  hermes-engine: f111e1a9cf7d7933bdceaf272d1777d0fb1d89ac
   MMKVCore: f2dd4c9befea04277a55e84e7812f930537993df
   NitroMmkv: 7fe66a61d5acab6516098a64f42af575595e7566
   NitroModules: 70861471ee1cc5616462aef869a164dac12db7b9
@@ -2531,7 +2531,7 @@ SPEC CHECKSUMS:
   React: 7ef36630d07638043a134a7dd2ec17e0be10fc3c
   React-callinvoker: af4e8fe1d60ab63dd8d74c2a68988064c2848954
   React-Core: c609976c034ba9556bef9850a571a71bd458d73f
-  React-Core-prebuilt: ea396d0e40644e9e46245e9b4b6db931b6be006b
+  React-Core-prebuilt: 71485c8868eb75b30e2f564f19187f96b53403ee
   React-CoreModules: 0ea85f3b3f4b8cbfb3afacd2ed85458fb878517a
   React-cxxreact: 6752bab77c0599d6136e2b8b9b64b4a7d316d401
   React-debug: 38389b86e3570558ec73dd4cbc0cd2f2eec47a51
@@ -2594,7 +2594,7 @@ SPEC CHECKSUMS:
   ReactAppDependencyProvider: 6b7e8d8d974ed13fb66698d82c30c5e70c1f7d3a
   ReactCodegen: 2fe81bae8e7b638d8d9b78c3dc1ccc1eeabfc613
   ReactCommon: 92b53b0bd7f7d86154dc9f512c1ea5dee717cc72
-  ReactNativeDependencies: 554aa4807a73d8b65ad8147af7b2d6042b7787be
+  ReactNativeDependencies: 5cedfcfef19b6597a3c9b4bfc42de85a7b3d39cc
   RNCAsyncStorage: 3a4f5e2777dae1688b781a487923a08569e27fe4
   RNCClipboard: 88d7eeb555d1183915f0885bdbc5c97eb6f7f3ba
   RNCMaskedView: d2578d41c59b936db122b2798ba37e4722d21035
diff --git a/packages/react-native-reanimated/Common/cpp/reanimated/Fabric/updates/UpdatesRegistry.cpp b/packages/react-native-reanimated/Common/cpp/reanimated/Fabric/updates/UpdatesRegistry.cpp
index 27387a23a80b..6b9403014e20 100644
--- a/packages/react-native-reanimated/Common/cpp/reanimated/Fabric/updates/UpdatesRegistry.cpp
+++ b/packages/react-native-reanimated/Common/cpp/reanimated/Fabric/updates/UpdatesRegistry.cpp
@@ -38,6 +38,18 @@ void UpdatesRegistry::flushUpdates(UpdatesBatch &updatesBatch) {
   }
 }
 
+UpdatesBatch UpdatesRegistry::getPendingUpdates() {
+  auto lock = std::lock_guard<std::mutex>{mutex_};
+  flushUpdatesToRegistry(updatesBatch_);
+
+  UpdatesBatch updatesBatch;
+  for (const auto &[tag, pair] : updatesRegistry_) {
+    const auto &[shadowNode, props] = pair;
+    updatesBatch.emplace_back(shadowNode, props);
+  }
+  return updatesBatch;
+}
+
 void UpdatesRegistry::collectProps(PropsMap &propsMap) {
   std::lock_guard<std::mutex> lock{mutex_};
 
diff --git a/packages/react-native-reanimated/Common/cpp/reanimated/Fabric/updates/UpdatesRegistry.h b/packages/react-native-reanimated/Common/cpp/reanimated/Fabric/updates/UpdatesRegistry.h
index cb0442e87204..295abe1b673a 100644
--- a/packages/react-native-reanimated/Common/cpp/reanimated/Fabric/updates/UpdatesRegistry.h
+++ b/packages/react-native-reanimated/Common/cpp/reanimated/Fabric/updates/UpdatesRegistry.h
@@ -46,6 +46,7 @@ class UpdatesRegistry {
 
   void flushUpdates(UpdatesBatch &updatesBatch);
   void collectProps(PropsMap &propsMap);
+  UpdatesBatch getPendingUpdates();
 
  protected:
   mutable std::mutex mutex_;
diff --git a/packages/react-native-reanimated/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.cpp b/packages/react-native-reanimated/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.cpp
index 0062693b74a3..69b01590e803 100644
--- a/packages/react-native-reanimated/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.cpp
+++ b/packages/react-native-reanimated/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.cpp
@@ -38,6 +38,83 @@ static inline std::shared_ptr<const ShadowNode> shadowNodeFromValue(
 }
 #endif
 
+namespace {
+
+#ifdef ANDROID
+constexpr bool shouldUseSynchronousUpdatesInPerformOperations() {
+  return StaticFeatureFlags::getFlag("ANDROID_SYNCHRONOUSLY_UPDATE_UI_PROPS") &&
+      !StaticFeatureFlags::getFlag("ENABLE_SHARED_ELEMENT_TRANSITIONS");
+}
+#elif __APPLE__
+constexpr bool shouldUseSynchronousUpdatesInPerformOperations() {
+  return StaticFeatureFlags::getFlag("IOS_SYNCHRONOUSLY_UPDATE_UI_PROPS") &&
+      !StaticFeatureFlags::getFlag("ENABLE_SHARED_ELEMENT_TRANSITIONS");
+}
+#else
+constexpr bool shouldUseSynchronousUpdatesInPerformOperations() {
+  return false;
+}
+#endif
+
+std::pair<UpdatesBatch, UpdatesBatch> partitionUpdates(
+    const UpdatesBatch &updatesBatch,
+    const std::unordered_set<std::string> &synchronousPropNames,
+    const bool shouldRequireIntegerColors = false,
+    const bool allowPartialViews = false) {
+  UpdatesBatch synchronousUpdatesBatch;
+  UpdatesBatch shadowTreeUpdatesBatch;
+
+  for (const auto &[shadowNode, props] : updatesBatch) {
+    if (allowPartialViews) {
+      folly::dynamic synchronousProps = folly::dynamic::object();
+      folly::dynamic shadowTreeProps = folly::dynamic::object();
+
+      for (const auto &[key, value] : props.items()) {
+        const auto keyStr = key.asString();
+        const bool isColorProp = keyStr == "color" || keyStr.find("Color") != std::string::npos;
+        const bool isSynchronous =
+            synchronousPropNames.contains(keyStr) && (!shouldRequireIntegerColors || !isColorProp || value.isInt());
+        if (isSynchronous) {
+          synchronousProps[keyStr] = value;
+        } else {
+          shadowTreeProps[keyStr] = value;
+        }
+      }
+
+      if (!synchronousProps.empty()) {
+        synchronousUpdatesBatch.emplace_back(shadowNode, std::move(synchronousProps));
+      }
+
+      if (!shadowTreeProps.empty()) {
+        shadowTreeUpdatesBatch.emplace_back(shadowNode, std::move(shadowTreeProps));
+      }
+    } else {
+      bool hasOnlySynchronousProps = true;
+
+      for (const auto &[key, value] : props.items()) {
+        const auto keyStr = key.asString();
+        const bool isColorProp = keyStr == "color" || keyStr.find("Color") != std::string::npos;
+        const bool isSynchronous =
+            synchronousPropNames.contains(keyStr) && (!shouldRequireIntegerColors || !isColorProp || value.isInt());
+        if (!isSynchronous) {
+          hasOnlySynchronousProps = false;
+          break;
+        }
+      }
+
+      if (hasOnlySynchronousProps) {
+        synchronousUpdatesBatch.emplace_back(shadowNode, props);
+      } else {
+        shadowTreeUpdatesBatch.emplace_back(shadowNode, props);
+      }
+    }
+  }
+
+  return {std::move(synchronousUpdatesBatch), std::move(shadowTreeUpdatesBatch)};
+}
+
+} // namespace
+
 ReanimatedModuleProxy::ReanimatedModuleProxy(
     const std::shared_ptr<WorkletsModuleProxy> &workletsModuleProxy,
     jsi::Runtime &rnRuntime,
@@ -556,7 +633,7 @@ bool ReanimatedModuleProxy::handleRawEvent(const RawEvent &rawEvent, double curr
   // (res == true), but for now handleEvent always returns false. Thankfully,
   // performOperations does not trigger a lot of code if there is nothing to
   // be done so this is fine for now.
-  performOperations(true);
+  performOperations();
   return res;
 }
 
@@ -605,15 +682,13 @@ double ReanimatedModuleProxy::getCssTimestamp() {
   return currentCssTimestamp_;
 }
 
-void ReanimatedModuleProxy::performOperations(const bool isTriggeredByEvent) {
+void ReanimatedModuleProxy::performOperations() {
   ReanimatedSystraceSection s("ReanimatedModuleProxy::performOperations");
 
-  if (!isTriggeredByEvent) {
-    auto flushRequestsCopy = std::move(layoutAnimationFlushRequests_);
-    for (const auto surfaceId : flushRequestsCopy) {
-      uiManager_->getShadowTreeRegistry().visit(
-          surfaceId, [](const ShadowTree &shadowTree) { shadowTree.notifyDelegatesOfUpdates(); });
-    }
+  auto flushRequestsCopy = std::move(layoutAnimationFlushRequests_);
+  for (const auto surfaceId : flushRequestsCopy) {
+    uiManager_->getShadowTreeRegistry().visit(
+        surfaceId, [](const ShadowTree &shadowTree) { shadowTree.notifyDelegatesOfUpdates(); });
   }
 
   jsi::Runtime &rt = workletsModuleProxy_->getUIWorkletRuntime()->getJSIRuntime();
@@ -647,479 +722,451 @@ void ReanimatedModuleProxy::performOperations(const bool isTriggeredByEvent) {
 
     shouldUpdateCssAnimations_ = false;
 
-#ifdef ANDROID
-    if constexpr (
-        StaticFeatureFlags::getFlag("ANDROID_SYNCHRONOUSLY_UPDATE_UI_PROPS") &&
-        !StaticFeatureFlags::getFlag("ENABLE_SHARED_ELEMENT_TRANSITIONS")) {
-      static const std::unordered_set<std::string> synchronousProps = {
-          "opacity",
-          "elevation",
-          "zIndex",
-          // "shadowOpacity", // not supported on Android
-          // "shadowRadius", // not supported on Android
-          "backgroundColor",
-          // "color", // TODO: fix animating color of Animated.Text
-          "tintColor",
-          "borderRadius",
-          "borderTopLeftRadius",
-          "borderTopRightRadius",
-          "borderTopStartRadius",
-          "borderTopEndRadius",
-          "borderBottomLeftRadius",
-          "borderBottomRightRadius",
-          "borderBottomStartRadius",
-          "borderBottomEndRadius",
-          "borderStartStartRadius",
-          "borderStartEndRadius",
-          "borderEndStartRadius",
-          "borderEndEndRadius",
-          "borderColor",
-          "borderTopColor",
-          "borderBottomColor",
-          "borderLeftColor",
-          "borderRightColor",
-          "borderStartColor",
-          "borderEndColor",
-          "transform",
-      };
+    if constexpr (shouldUseSynchronousUpdatesInPerformOperations()) {
+      applySynchronousUpdates(updatesBatch);
+    }
 
-      // NOTE: Keep in sync with NativeProxy.java
-      static constexpr auto CMD_START_OF_VIEW = 1;
-      static constexpr auto CMD_START_OF_TRANSFORM = 2;
-      static constexpr auto CMD_END_OF_TRANSFORM = 3;
-      static constexpr auto CMD_END_OF_VIEW = 4;
-
-      static constexpr auto CMD_OPACITY = 10;
-      static constexpr auto CMD_ELEVATION = 11;
-      static constexpr auto CMD_Z_INDEX = 12;
-      static constexpr auto CMD_SHADOW_OPACITY = 13;
-      static constexpr auto CMD_SHADOW_RADIUS = 14;
-      static constexpr auto CMD_BACKGROUND_COLOR = 15;
-      static constexpr auto CMD_COLOR = 16;
-      static constexpr auto CMD_TINT_COLOR = 17;
-
-      static constexpr auto CMD_BORDER_RADIUS = 20;
-      static constexpr auto CMD_BORDER_TOP_LEFT_RADIUS = 21;
-      static constexpr auto CMD_BORDER_TOP_RIGHT_RADIUS = 22;
-      static constexpr auto CMD_BORDER_TOP_START_RADIUS = 23;
-      static constexpr auto CMD_BORDER_TOP_END_RADIUS = 24;
-      static constexpr auto CMD_BORDER_BOTTOM_LEFT_RADIUS = 25;
-      static constexpr auto CMD_BORDER_BOTTOM_RIGHT_RADIUS = 26;
-      static constexpr auto CMD_BORDER_BOTTOM_START_RADIUS = 27;
-      static constexpr auto CMD_BORDER_BOTTOM_END_RADIUS = 28;
-      static constexpr auto CMD_BORDER_START_START_RADIUS = 29;
-      static constexpr auto CMD_BORDER_START_END_RADIUS = 30;
-      static constexpr auto CMD_BORDER_END_START_RADIUS = 31;
-      static constexpr auto CMD_BORDER_END_END_RADIUS = 32;
-
-      static constexpr auto CMD_BORDER_COLOR = 40;
-      static constexpr auto CMD_BORDER_TOP_COLOR = 41;
-      static constexpr auto CMD_BORDER_BOTTOM_COLOR = 42;
-      static constexpr auto CMD_BORDER_LEFT_COLOR = 43;
-      static constexpr auto CMD_BORDER_RIGHT_COLOR = 44;
-      static constexpr auto CMD_BORDER_START_COLOR = 45;
-      static constexpr auto CMD_BORDER_END_COLOR = 46;
-
-      static constexpr auto CMD_TRANSFORM_TRANSLATE_X = 100;
-      static constexpr auto CMD_TRANSFORM_TRANSLATE_Y = 101;
-      static constexpr auto CMD_TRANSFORM_SCALE = 102;
-      static constexpr auto CMD_TRANSFORM_SCALE_X = 103;
-      static constexpr auto CMD_TRANSFORM_SCALE_Y = 104;
-      static constexpr auto CMD_TRANSFORM_ROTATE = 105;
-      static constexpr auto CMD_TRANSFORM_ROTATE_X = 106;
-      static constexpr auto CMD_TRANSFORM_ROTATE_Y = 107;
-      static constexpr auto CMD_TRANSFORM_ROTATE_Z = 108;
-      static constexpr auto CMD_TRANSFORM_SKEW_X = 109;
-      static constexpr auto CMD_TRANSFORM_SKEW_Y = 110;
-      static constexpr auto CMD_TRANSFORM_MATRIX = 111;
-      static constexpr auto CMD_TRANSFORM_PERSPECTIVE = 112;
+    if ((updatesBatch.size() > 0) && updatesRegistryManager_->shouldReanimatedSkipCommit()) {
+      updatesRegistryManager_->pleaseCommitAfterPause();
+    }
+  }
 
-      static constexpr auto CMD_UNIT_DEG = 200;
-      static constexpr auto CMD_UNIT_RAD = 201;
-      static constexpr auto CMD_UNIT_PX = 202;
-      static constexpr auto CMD_UNIT_PERCENT = 203;
+  if (updatesRegistryManager_->shouldReanimatedSkipCommit()) {
+    // It may happen that `performOperations` is called on the UI thread
+    // while React Native tries to commit a new tree on the JS thread.
+    // In this case, we should skip the commit here and let React Native do
+    // it. The commit will include the current values from the updates manager
+    // which will be applied in ReanimatedCommitHook.
+    return;
+  }
 
-      const auto propNameToCommand = [](const std::string &name) {
-        if (name == "opacity")
-          return CMD_OPACITY;
+  commitUpdates(rt, updatesBatch);
 
-        if (name == "elevation")
-          return CMD_ELEVATION;
+  // Clear the entire cache after the commit
+  // (we don't know if the view is updated from outside of Reanimated
+  // so we have to clear the entire cache)
+  viewStylesRepository_->clearNodesCache();
+}
 
-        if (name == "zIndex")
-          return CMD_Z_INDEX;
+void ReanimatedModuleProxy::performNonLayoutOperations() {
+  ReanimatedSystraceSection s("ReanimatedModuleProxy::performNonLayoutOperations");
 
-        if (name == "shadowOpacity")
-          return CMD_SHADOW_OPACITY;
+  UpdatesBatch updatesBatch = animatedPropsRegistry_->getPendingUpdates();
 
-        if (name == "shadowRadius")
-          return CMD_SHADOW_RADIUS;
+  applySynchronousUpdates(updatesBatch, true);
+}
 
-        if (name == "backgroundColor")
-          return CMD_BACKGROUND_COLOR;
+void ReanimatedModuleProxy::applySynchronousUpdates(UpdatesBatch &updatesBatch, const bool allowPartialUpdates) {
+#ifdef ANDROID
+  static const std::unordered_set<std::string> synchronousProps = {
+      "opacity",
+      "elevation",
+      "zIndex",
+      // "shadowOpacity", // not supported on Android
+      // "shadowRadius", // not supported on Android
+      "backgroundColor",
+      // "color", // TODO: fix animating color of Animated.Text,
+      "tintColor",
+      "borderRadius",
+      "borderTopLeftRadius",
+      "borderTopRightRadius",
+      "borderTopStartRadius",
+      "borderTopEndRadius",
+      "borderBottomLeftRadius",
+      "borderBottomRightRadius",
+      "borderBottomStartRadius",
+      "borderBottomEndRadius",
+      "borderStartStartRadius",
+      "borderStartEndRadius",
+      "borderEndStartRadius",
+      "borderEndEndRadius",
+      "borderColor",
+      "borderTopColor",
+      "borderBottomColor",
+      "borderLeftColor",
+      "borderRightColor",
+      "borderStartColor",
+      "borderEndColor",
+      "transform",
+  };
 
-        if (name == "color")
-          return CMD_COLOR;
+  // NOTE: Keep in sync with NativeProxy.java
+  static constexpr auto CMD_START_OF_VIEW = 1;
+  static constexpr auto CMD_START_OF_TRANSFORM = 2;
+  static constexpr auto CMD_END_OF_TRANSFORM = 3;
+  static constexpr auto CMD_END_OF_VIEW = 4;
+
+  static constexpr auto CMD_OPACITY = 10;
+  static constexpr auto CMD_ELEVATION = 11;
+  static constexpr auto CMD_Z_INDEX = 12;
+  static constexpr auto CMD_SHADOW_OPACITY = 13;
+  static constexpr auto CMD_SHADOW_RADIUS = 14;
+  static constexpr auto CMD_BACKGROUND_COLOR = 15;
+  static constexpr auto CMD_COLOR = 16;
+  static constexpr auto CMD_TINT_COLOR = 17;
+
+  static constexpr auto CMD_BORDER_RADIUS = 20;
+  static constexpr auto CMD_BORDER_TOP_LEFT_RADIUS = 21;
+  static constexpr auto CMD_BORDER_TOP_RIGHT_RADIUS = 22;
+  static constexpr auto CMD_BORDER_TOP_START_RADIUS = 23;
+  static constexpr auto CMD_BORDER_TOP_END_RADIUS = 24;
+  static constexpr auto CMD_BORDER_BOTTOM_LEFT_RADIUS = 25;
+  static constexpr auto CMD_BORDER_BOTTOM_RIGHT_RADIUS = 26;
+  static constexpr auto CMD_BORDER_BOTTOM_START_RADIUS = 27;
+  static constexpr auto CMD_BORDER_BOTTOM_END_RADIUS = 28;
+  static constexpr auto CMD_BORDER_START_START_RADIUS = 29;
+  static constexpr auto CMD_BORDER_START_END_RADIUS = 30;
+  static constexpr auto CMD_BORDER_END_START_RADIUS = 31;
+  static constexpr auto CMD_BORDER_END_END_RADIUS = 32;
+
+  static constexpr auto CMD_BORDER_COLOR = 40;
+  static constexpr auto CMD_BORDER_TOP_COLOR = 41;
+  static constexpr auto CMD_BORDER_BOTTOM_COLOR = 42;
+  static constexpr auto CMD_BORDER_LEFT_COLOR = 43;
+  static constexpr auto CMD_BORDER_RIGHT_COLOR = 44;
+  static constexpr auto CMD_BORDER_START_COLOR = 45;
+  static constexpr auto CMD_BORDER_END_COLOR = 46;
+
+  static constexpr auto CMD_TRANSFORM_TRANSLATE_X = 100;
+  static constexpr auto CMD_TRANSFORM_TRANSLATE_Y = 101;
+  static constexpr auto CMD_TRANSFORM_SCALE = 102;
+  static constexpr auto CMD_TRANSFORM_SCALE_X = 103;
+  static constexpr auto CMD_TRANSFORM_SCALE_Y = 104;
+  static constexpr auto CMD_TRANSFORM_ROTATE = 105;
+  static constexpr auto CMD_TRANSFORM_ROTATE_X = 106;
+  static constexpr auto CMD_TRANSFORM_ROTATE_Y = 107;
+  static constexpr auto CMD_TRANSFORM_ROTATE_Z = 108;
+  static constexpr auto CMD_TRANSFORM_SKEW_X = 109;
+  static constexpr auto CMD_TRANSFORM_SKEW_Y = 110;
+  static constexpr auto CMD_TRANSFORM_MATRIX = 111;
+  static constexpr auto CMD_TRANSFORM_PERSPECTIVE = 112;
 
-        if (name == "tintColor")
-          return CMD_TINT_COLOR;
+  static constexpr auto CMD_UNIT_DEG = 200;
+  static constexpr auto CMD_UNIT_RAD = 201;
+  static constexpr auto CMD_UNIT_PX = 202;
+  static constexpr auto CMD_UNIT_PERCENT = 203;
 
-        if (name == "borderRadius")
-          return CMD_BORDER_RADIUS;
+  const auto propNameToCommand = [](const std::string &name) {
+    if (name == "opacity")
+      return CMD_OPACITY;
 
-        if (name == "borderTopLeftRadius")
-          return CMD_BORDER_TOP_LEFT_RADIUS;
+    if (name == "elevation")
+      return CMD_ELEVATION;
 
-        if (name == "borderTopRightRadius")
-          return CMD_BORDER_TOP_RIGHT_RADIUS;
+    if (name == "zIndex")
+      return CMD_Z_INDEX;
 
-        if (name == "borderTopStartRadius")
-          return CMD_BORDER_TOP_START_RADIUS;
+    if (name == "shadowOpacity")
+      return CMD_SHADOW_OPACITY;
 
-        if (name == "borderTopEndRadius")
-          return CMD_BORDER_TOP_END_RADIUS;
+    if (name == "shadowRadius")
+      return CMD_SHADOW_RADIUS;
 
-        if (name == "borderBottomLeftRadius")
-          return CMD_BORDER_BOTTOM_LEFT_RADIUS;
+    if (name == "backgroundColor")
+      return CMD_BACKGROUND_COLOR;
 
-        if (name == "borderBottomRightRadius")
-          return CMD_BORDER_BOTTOM_RIGHT_RADIUS;
-
-        if (name == "borderBottomStartRadius")
-          return CMD_BORDER_BOTTOM_START_RADIUS;
+    if (name == "color")
+      return CMD_COLOR;
 
-        if (name == "borderBottomEndRadius")
-          return CMD_BORDER_BOTTOM_END_RADIUS;
+    if (name == "tintColor")
+      return CMD_TINT_COLOR;
 
-        if (name == "borderStartStartRadius")
-          return CMD_BORDER_START_START_RADIUS;
+    if (name == "borderRadius")
+      return CMD_BORDER_RADIUS;
 
-        if (name == "borderStartEndRadius")
-          return CMD_BORDER_START_END_RADIUS;
+    if (name == "borderTopLeftRadius")
+      return CMD_BORDER_TOP_LEFT_RADIUS;
 
-        if (name == "borderEndStartRadius")
-          return CMD_BORDER_END_START_RADIUS;
+    if (name == "borderTopRightRadius")
+      return CMD_BORDER_TOP_RIGHT_RADIUS;
 
-        if (name == "borderEndEndRadius")
-          return CMD_BORDER_END_END_RADIUS;
+    if (name == "borderTopStartRadius")
+      return CMD_BORDER_TOP_START_RADIUS;
 
-        if (name == "borderColor")
-          return CMD_BORDER_COLOR;
+    if (name == "borderTopEndRadius")
+      return CMD_BORDER_TOP_END_RADIUS;
 
-        if (name == "borderTopColor")
-          return CMD_BORDER_TOP_COLOR;
+    if (name == "borderBottomLeftRadius")
+      return CMD_BORDER_BOTTOM_LEFT_RADIUS;
 
-        if (name == "borderBottomColor")
-          return CMD_BORDER_BOTTOM_COLOR;
+    if (name == "borderBottomRightRadius")
+      return CMD_BORDER_BOTTOM_RIGHT_RADIUS;
+
+    if (name == "borderBottomStartRadius")
+      return CMD_BORDER_BOTTOM_START_RADIUS;
 
-        if (name == "borderLeftColor")
-          return CMD_BORDER_LEFT_COLOR;
+    if (name == "borderBottomEndRadius")
+      return CMD_BORDER_BOTTOM_END_RADIUS;
 
-        if (name == "borderRightColor")
-          return CMD_BORDER_RIGHT_COLOR;
+    if (name == "borderStartStartRadius")
+      return CMD_BORDER_START_START_RADIUS;
 
-        if (name == "borderStartColor")
-          return CMD_BORDER_START_COLOR;
+    if (name == "borderStartEndRadius")
+      return CMD_BORDER_START_END_RADIUS;
 
-        if (name == "borderEndColor")
-          return CMD_BORDER_END_COLOR;
+    if (name == "borderEndStartRadius")
+      return CMD_BORDER_END_START_RADIUS;
 
-        if (name == "transform")
-          return CMD_START_OF_TRANSFORM; // TODO: use CMD_TRANSFORM?
+    if (name == "borderEndEndRadius")
+      return CMD_BORDER_END_END_RADIUS;
 
-        throw std::runtime_error("[Reanimated] Unsupported style: " + name);
-      };
+    if (name == "borderColor")
+      return CMD_BORDER_COLOR;
 
-      const auto transformNameToCommand = [](const std::string &name) {
-        if (name == "translateX")
-          return CMD_TRANSFORM_TRANSLATE_X;
+    if (name == "borderTopColor")
+      return CMD_BORDER_TOP_COLOR;
 
-        if (name == "translateY")
-          return CMD_TRANSFORM_TRANSLATE_Y;
+    if (name == "borderBottomColor")
+      return CMD_BORDER_BOTTOM_COLOR;
 
-        if (name == "scale")
-          return CMD_TRANSFORM_SCALE;
+    if (name == "borderLeftColor")
+      return CMD_BORDER_LEFT_COLOR;
 
-        if (name == "scaleX")
-          return CMD_TRANSFORM_SCALE_X;
+    if (name == "borderRightColor")
+      return CMD_BORDER_RIGHT_COLOR;
 
-        if (name == "scaleY")
-          return CMD_TRANSFORM_SCALE_Y;
+    if (name == "borderStartColor")
+      return CMD_BORDER_START_COLOR;
 
-        if (name == "rotate")
-          return CMD_TRANSFORM_ROTATE;
+    if (name == "borderEndColor")
+      return CMD_BORDER_END_COLOR;
 
-        if (name == "rotateX")
-          return CMD_TRANSFORM_ROTATE_X;
+    if (name == "transform")
+      return CMD_START_OF_TRANSFORM; // TODO: use CMD_TRANSFORM?
 
-        if (name == "rotateY")
-          return CMD_TRANSFORM_ROTATE_Y;
+    throw std::runtime_error("[Reanimated] Unsupported style: " + name);
+  };
 
-        if (name == "rotateZ")
-          return CMD_TRANSFORM_ROTATE_Z;
+  const auto transformNameToCommand = [](const std::string &name) {
+    if (name == "translateX")
+      return CMD_TRANSFORM_TRANSLATE_X;
 
-        if (name == "skewX")
-          return CMD_TRANSFORM_SKEW_X;
+    if (name == "translateY")
+      return CMD_TRANSFORM_TRANSLATE_Y;
 
-        if (name == "skewY")
-          return CMD_TRANSFORM_SKEW_Y;
+    if (name == "scale")
+      return CMD_TRANSFORM_SCALE;
 
-        if (name == "matrix")
-          return CMD_TRANSFORM_MATRIX;
+    if (name == "scaleX")
+      return CMD_TRANSFORM_SCALE_X;
 
-        if (name == "perspective")
-          return CMD_TRANSFORM_PERSPECTIVE;
+    if (name == "scaleY")
+      return CMD_TRANSFORM_SCALE_Y;
 
-        throw std::runtime_error("[Reanimated] Unsupported transform: " + name);
-      };
+    if (name == "rotate")
+      return CMD_TRANSFORM_ROTATE;
 
-      UpdatesBatch synchronousUpdatesBatch, shadowTreeUpdatesBatch;
+    if (name == "rotateX")
+      return CMD_TRANSFORM_ROTATE_X;
 
-      for (const auto &[shadowNode, props] : updatesBatch) {
-        bool hasOnlySynchronousProps = true;
-        for (const auto &[key, value] : props.items()) {
-          const auto keyStr = key.asString();
-          if (!synchronousProps.contains(keyStr) ||
-              ((keyStr == "color" || keyStr.find("Color") != std::string::npos) && !value.isInt())) {
-            hasOnlySynchronousProps = false;
-            break;
-          }
-        }
-        if (hasOnlySynchronousProps) {
-          synchronousUpdatesBatch.emplace_back(shadowNode, props);
-        } else {
-          shadowTreeUpdatesBatch.emplace_back(shadowNode, props);
-        }
-      }
+    if (name == "rotateY")
+      return CMD_TRANSFORM_ROTATE_Y;
 
-      if (!synchronousUpdatesBatch.empty()) {
-        std::vector<int> intBuffer;
-        std::vector<double> doubleBuffer;
-        intBuffer.reserve(1024);
-        doubleBuffer.reserve(1024);
-
-        for (const auto &[shadowNode, props] : synchronousUpdatesBatch) {
-          intBuffer.push_back(CMD_START_OF_VIEW);
-          intBuffer.push_back(shadowNode->getTag());
-          for (const auto &[key, value] : props.items()) {
-            const auto command = propNameToCommand(key.getString());
-            switch (command) {
-              case CMD_OPACITY:
-              case CMD_ELEVATION:
-              case CMD_Z_INDEX:
-              case CMD_SHADOW_OPACITY:
-              case CMD_SHADOW_RADIUS:
-                intBuffer.push_back(command);
-                doubleBuffer.push_back(value.asDouble());
-                break;
-
-              case CMD_BACKGROUND_COLOR:
-              case CMD_COLOR:
-              case CMD_TINT_COLOR:
-              case CMD_BORDER_COLOR:
-              case CMD_BORDER_TOP_COLOR:
-              case CMD_BORDER_BOTTOM_COLOR:
-              case CMD_BORDER_LEFT_COLOR:
-              case CMD_BORDER_RIGHT_COLOR:
-              case CMD_BORDER_START_COLOR:
-              case CMD_BORDER_END_COLOR:
-                intBuffer.push_back(command);
-                intBuffer.push_back(value.asInt());
-                break;
-
-              case CMD_BORDER_RADIUS:
-              case CMD_BORDER_TOP_LEFT_RADIUS:
-              case CMD_BORDER_TOP_RIGHT_RADIUS:
-              case CMD_BORDER_TOP_START_RADIUS:
-              case CMD_BORDER_TOP_END_RADIUS:
-              case CMD_BORDER_BOTTOM_LEFT_RADIUS:
-              case CMD_BORDER_BOTTOM_RIGHT_RADIUS:
-              case CMD_BORDER_BOTTOM_START_RADIUS:
-              case CMD_BORDER_BOTTOM_END_RADIUS:
-              case CMD_BORDER_START_START_RADIUS:
-              case CMD_BORDER_START_END_RADIUS:
-              case CMD_BORDER_END_START_RADIUS:
-              case CMD_BORDER_END_END_RADIUS:
-                intBuffer.push_back(command);
-                if (value.isDouble()) {
-                  intBuffer.push_back(CMD_UNIT_PX);
-                  doubleBuffer.push_back(value.getDouble());
-                } else if (value.isString()) {
-                  const auto &valueStr = value.getString();
-                  if (!valueStr.ends_with("%")) {
-                    throw std::runtime_error("[Reanimated] Border radius string must be a percentage");
-                  }
-                  intBuffer.push_back(CMD_UNIT_PERCENT);
-                  doubleBuffer.push_back(std::stof(valueStr.substr(0, -1)));
-                } else {
-                  throw std::runtime_error("[Reanimated] Border radius value must be either a number or a string");
-                }
-                break;
-
-              case CMD_START_OF_TRANSFORM:
-                intBuffer.push_back(command);
-                react_native_assert(value.isArray() && "[Reanimated] Transform value must be an array");
-                for (const auto &item : value) {
-                  react_native_assert(item.isObject() && "[Reanimated] Transform array item must be an object");
-                  react_native_assert(
-                      item.size() == 1 && "[Reanimated] Transform array item must have exactly one key-value pair");
-                  const auto transformCommand = transformNameToCommand(item.keys().begin()->getString());
-                  const auto &transformValue = *item.values().begin();
-                  switch (transformCommand) {
-                    case CMD_TRANSFORM_SCALE:
-                    case CMD_TRANSFORM_SCALE_X:
-                    case CMD_TRANSFORM_SCALE_Y:
-                    case CMD_TRANSFORM_PERSPECTIVE: {
-                      intBuffer.push_back(transformCommand);
-                      doubleBuffer.push_back(transformValue.asDouble());
-                      break;
-                    }
+    if (name == "rotateZ")
+      return CMD_TRANSFORM_ROTATE_Z;
 
-                    case CMD_TRANSFORM_TRANSLATE_X:
-                    case CMD_TRANSFORM_TRANSLATE_Y: {
-                      intBuffer.push_back(transformCommand);
-                      if (transformValue.isDouble()) {
-                        intBuffer.push_back(CMD_UNIT_PX);
-                        doubleBuffer.push_back(transformValue.getDouble());
-                      } else if (transformValue.isString()) {
-                        const auto &transformValueStr = transformValue.getString();
-                        if (!transformValueStr.ends_with("%")) {
-                          throw std::runtime_error("[Reanimated] String translate must be a percentage");
-                        }
-                        intBuffer.push_back(CMD_UNIT_PERCENT);
-                        doubleBuffer.push_back(std::stof(transformValueStr.substr(0, -1)));
-                      } else {
-                        throw std::runtime_error("[Reanimated] Translate value must be either a number or a string");
-                      }
-                      break;
-                    }
+    if (name == "skewX")
+      return CMD_TRANSFORM_SKEW_X;
 
-                    case CMD_TRANSFORM_ROTATE:
-                    case CMD_TRANSFORM_ROTATE_X:
-                    case CMD_TRANSFORM_ROTATE_Y:
-                    case CMD_TRANSFORM_ROTATE_Z:
-                    case CMD_TRANSFORM_SKEW_X:
-                    case CMD_TRANSFORM_SKEW_Y: {
-                      const auto &transformValueStr = transformValue.getString();
-                      intBuffer.push_back(transformCommand);
-                      if (transformValueStr.ends_with("deg")) {
-                        intBuffer.push_back(CMD_UNIT_DEG);
-                      } else if (transformValueStr.ends_with("rad")) {
-                        intBuffer.push_back(CMD_UNIT_RAD);
-                      } else {
-                        throw std::runtime_error("[Reanimated] Unsupported rotation unit: " + transformValueStr);
-                      }
-                      doubleBuffer.push_back(std::stof(transformValueStr.substr(0, -3)));
-                      break;
-                    }
+    if (name == "skewY")
+      return CMD_TRANSFORM_SKEW_Y;
+
+    if (name == "matrix")
+      return CMD_TRANSFORM_MATRIX;
+
+    if (name == "perspective")
+      return CMD_TRANSFORM_PERSPECTIVE;
 
-                    case CMD_TRANSFORM_MATRIX: {
-                      intBuffer.push_back(transformCommand);
-                      react_native_assert(transformValue.isArray() && "[Reanimated] Matrix must be an array");
-                      int size = transformValue.size();
-                      intBuffer.push_back(size);
-                      for (int i = 0; i < size; i++) {
-                        doubleBuffer.push_back(transformValue[i].asDouble());
-                      }
-                      break;
+    throw std::runtime_error("[Reanimated] Unsupported transform: " + name);
+  };
+
+  auto [synchronousUpdatesBatch, shadowTreeUpdatesBatch] =
+      partitionUpdates(updatesBatch, synchronousProps, true, allowPartialUpdates);
+
+  if (!synchronousUpdatesBatch.empty()) {
+    std::vector<int> intBuffer;
+    std::vector<double> doubleBuffer;
+    intBuffer.reserve(1024);
+    doubleBuffer.reserve(1024);
+
+    for (const auto &[shadowNode, props] : synchronousUpdatesBatch) {
+      intBuffer.push_back(CMD_START_OF_VIEW);
+      intBuffer.push_back(shadowNode->getTag());
+      for (const auto &[key, value] : props.items()) {
+        const auto command = propNameToCommand(key.getString());
+        switch (command) {
+          case CMD_OPACITY:
+          case CMD_ELEVATION:
+          case CMD_Z_INDEX:
+          case CMD_SHADOW_OPACITY:
+          case CMD_SHADOW_RADIUS:
+            intBuffer.push_back(command);
+            doubleBuffer.push_back(value.asDouble());
+            break;
+
+          case CMD_BACKGROUND_COLOR:
+          case CMD_COLOR:
+          case CMD_TINT_COLOR:
+          case CMD_BORDER_COLOR:
+          case CMD_BORDER_TOP_COLOR:
+          case CMD_BORDER_BOTTOM_COLOR:
+          case CMD_BORDER_LEFT_COLOR:
+          case CMD_BORDER_RIGHT_COLOR:
+          case CMD_BORDER_START_COLOR:
+          case CMD_BORDER_END_COLOR:
+            intBuffer.push_back(command);
+            intBuffer.push_back(value.asInt());
+            break;
+
+          case CMD_BORDER_RADIUS:
+          case CMD_BORDER_TOP_LEFT_RADIUS:
+          case CMD_BORDER_TOP_RIGHT_RADIUS:
+          case CMD_BORDER_TOP_START_RADIUS:
+          case CMD_BORDER_TOP_END_RADIUS:
+          case CMD_BORDER_BOTTOM_LEFT_RADIUS:
+          case CMD_BORDER_BOTTOM_RIGHT_RADIUS:
+          case CMD_BORDER_BOTTOM_START_RADIUS:
+          case CMD_BORDER_BOTTOM_END_RADIUS:
+          case CMD_BORDER_START_START_RADIUS:
+          case CMD_BORDER_START_END_RADIUS:
+          case CMD_BORDER_END_START_RADIUS:
+          case CMD_BORDER_END_END_RADIUS:
+            intBuffer.push_back(command);
+            if (value.isDouble()) {
+              intBuffer.push_back(CMD_UNIT_PX);
+              doubleBuffer.push_back(value.getDouble());
+            } else if (value.isString()) {
+              const auto &valueStr = value.getString();
+              if (!valueStr.ends_with("%")) {
+                throw std::runtime_error("[Reanimated] Border radius string must be a percentage");
+              }
+              intBuffer.push_back(CMD_UNIT_PERCENT);
+              doubleBuffer.push_back(std::stof(valueStr.substr(0, -1)));
+            } else {
+              throw std::runtime_error("[Reanimated] Border radius value must be either a number or a string");
+            }
+            break;
+
+          case CMD_START_OF_TRANSFORM:
+            intBuffer.push_back(command);
+            react_native_assert(value.isArray() && "[Reanimated] Transform value must be an array");
+            for (const auto &item : value) {
+              react_native_assert(item.isObject() && "[Reanimated] Transform array item must be an object");
+              react_native_assert(
+                  item.size() == 1 && "[Reanimated] Transform array item must have exactly one key-value pair");
+              const auto transformCommand = transformNameToCommand(item.keys().begin()->getString());
+              const auto &transformValue = *item.values().begin();
+              switch (transformCommand) {
+                case CMD_TRANSFORM_SCALE:
+                case CMD_TRANSFORM_SCALE_X:
+                case CMD_TRANSFORM_SCALE_Y:
+                case CMD_TRANSFORM_PERSPECTIVE: {
+                  intBuffer.push_back(transformCommand);
+                  doubleBuffer.push_back(transformValue.asDouble());
+                  break;
+                }
+                case CMD_TRANSFORM_TRANSLATE_X:
+                case CMD_TRANSFORM_TRANSLATE_Y: {
+                  intBuffer.push_back(transformCommand);
+                  if (transformValue.isDouble()) {
+                    intBuffer.push_back(CMD_UNIT_PX);
+                    doubleBuffer.push_back(transformValue.getDouble());
+                  } else if (transformValue.isString()) {
+                    const auto &transformValueStr = transformValue.getString();
+                    if (!transformValueStr.ends_with("%")) {
+                      throw std::runtime_error("[Reanimated] String translate must be a percentage");
                     }
+                    intBuffer.push_back(CMD_UNIT_PERCENT);
+                    doubleBuffer.push_back(std::stof(transformValueStr.substr(0, -1)));
+                  } else {
+                    throw std::runtime_error("[Reanimated] Translate value must be either a number or a string");
+                  }
+                  break;
+                }
+                case CMD_TRANSFORM_ROTATE:
+                case CMD_TRANSFORM_ROTATE_X:
+                case CMD_TRANSFORM_ROTATE_Y:
+                case CMD_TRANSFORM_ROTATE_Z:
+                case CMD_TRANSFORM_SKEW_X:
+                case CMD_TRANSFORM_SKEW_Y: {
+                  const auto &transformValueStr = transformValue.getString();
+                  intBuffer.push_back(transformCommand);
+                  if (transformValueStr.ends_with("deg")) {
+                    intBuffer.push_back(CMD_UNIT_DEG);
+                  } else if (transformValueStr.ends_with("rad")) {
+                    intBuffer.push_back(CMD_UNIT_RAD);
+                  } else {
+                    throw std::runtime_error("[Reanimated] Unsupported rotation unit: " + transformValueStr);
+                  }
+                  doubleBuffer.push_back(std::stof(transformValueStr.substr(0, -3)));
+                  break;
+                }
+                case CMD_TRANSFORM_MATRIX: {
+                  intBuffer.push_back(transformCommand);
+                  react_native_assert(transformValue.isArray() && "[Reanimated] Matrix must be an array");
+                  int size = transformValue.size();
+                  intBuffer.push_back(size);
+                  for (int i = 0; i < size; i++) {
+                    doubleBuffer.push_back(transformValue[i].asDouble());
                   }
+                  break;
                 }
-                intBuffer.push_back(CMD_END_OF_TRANSFORM);
-                break;
+              }
             }
-          }
-          intBuffer.push_back(CMD_END_OF_VIEW);
+            intBuffer.push_back(CMD_END_OF_TRANSFORM);
+            break;
         }
-        synchronouslyUpdateUIPropsFunction_(intBuffer, doubleBuffer);
       }
-
-      updatesBatch = std::move(shadowTreeUpdatesBatch);
+      intBuffer.push_back(CMD_END_OF_VIEW);
     }
+    synchronouslyUpdateUIPropsFunction_(intBuffer, doubleBuffer);
+  }
+
+  updatesBatch = std::move(shadowTreeUpdatesBatch);
 #endif // ANDROID
 
 #if __APPLE__
-    if constexpr (
-        StaticFeatureFlags::getFlag("IOS_SYNCHRONOUSLY_UPDATE_UI_PROPS") &&
-        !StaticFeatureFlags::getFlag("ENABLE_SHARED_ELEMENT_TRANSITIONS")) {
-      static const std::unordered_set<std::string> synchronousProps = {
-          "opacity",
-          "elevation",
-          "zIndex",
-          "shadowOpacity",
-          "shadowRadius",
-          "backgroundColor",
-          // "color", // TODO: fix animating color of Animated.Text
-          "tintColor",
-          "borderRadius",
-          "borderTopLeftRadius",
-          "borderTopRightRadius",
-          "borderTopStartRadius",
-          "borderTopEndRadius",
-          "borderBottomLeftRadius",
-          "borderBottomRightRadius",
-          "borderBottomStartRadius",
-          "borderBottomEndRadius",
-          "borderStartStartRadius",
-          "borderStartEndRadius",
-          "borderEndStartRadius",
-          "borderEndEndRadius",
-          "borderColor",
-          "borderTopColor",
-          "borderBottomColor",
-          "borderLeftColor",
-          "borderRightColor",
-          "borderStartColor",
-          "borderEndColor",
-          "transform",
-      };
-
-      UpdatesBatch synchronousUpdatesBatch, shadowTreeUpdatesBatch;
-
-      for (const auto &[shadowNode, props] : updatesBatch) {
-        bool hasOnlySynchronousProps = true;
-        for (const auto &key : props.keys()) {
-          const auto keyStr = key.asString();
-          if (!synchronousProps.contains(keyStr)) {
-            hasOnlySynchronousProps = false;
-            break;
-          }
-        }
-        if (hasOnlySynchronousProps) {
-          synchronousUpdatesBatch.emplace_back(shadowNode, props);
-        } else {
-          shadowTreeUpdatesBatch.emplace_back(shadowNode, props);
-        }
-      }
+  static const std::unordered_set<std::string> synchronousProps = {
+      "opacity",
+      "elevation",
+      "zIndex",
+      "shadowOpacity",
+      "shadowRadius",
+      "backgroundColor",
+      // "color", // TODO: fix animating color of Animated.Text
+      "tintColor",
+      "borderRadius",
+      "borderTopLeftRadius",
+      "borderTopRightRadius",
+      "borderTopStartRadius",
+      "borderTopEndRadius",
+      "borderBottomLeftRadius",
+      "borderBottomRightRadius",
+      "borderBottomStartRadius",
+      "borderBottomEndRadius",
+      "borderStartStartRadius",
+      "borderStartEndRadius",
+      "borderEndStartRadius",
+      "borderEndEndRadius",
+      "borderColor",
+      "borderTopColor",
+      "borderBottomColor",
+      "borderLeftColor",
+      "borderRightColor",
+      "borderStartColor",
+      "borderEndColor",
+      "transform",
+  };
 
-      for (const auto &[shadowNode, props] : synchronousUpdatesBatch) {
-        synchronouslyUpdateUIPropsFunction_(shadowNode->getTag(), props);
-      }
+  auto [synchronousUpdatesBatch, shadowTreeUpdatesBatch] =
+      partitionUpdates(updatesBatch, synchronousProps, false, allowPartialUpdates);
 
-      updatesBatch = std::move(shadowTreeUpdatesBatch);
-    }
-#endif // __APPLE__
-
-    if ((updatesBatch.size() > 0) && updatesRegistryManager_->shouldReanimatedSkipCommit()) {
-      updatesRegistryManager_->pleaseCommitAfterPause();
-    }
+  for (const auto &[shadowNode, props] : synchronousUpdatesBatch) {
+    synchronouslyUpdateUIPropsFunction_(shadowNode->getTag(), props);
   }
 
-  if (updatesRegistryManager_->shouldReanimatedSkipCommit()) {
-    // It may happen that `performOperations` is called on the UI thread
-    // while React Native tries to commit a new tree on the JS thread.
-    // In this case, we should skip the commit here and let React Native do
-    // it. The commit will include the current values from the updates manager
-    // which will be applied in ReanimatedCommitHook.
-    return;
-  }
-
-  commitUpdates(rt, updatesBatch);
-
-  // Clear the entire cache after the commit
-  // (we don't know if the view is updated from outside of Reanimated
-  // so we have to clear the entire cache)
-  viewStylesRepository_->clearNodesCache();
+  updatesBatch = std::move(shadowTreeUpdatesBatch);
+#endif // __APPLE__
 }
 
 void ReanimatedModuleProxy::requestFlushRegistry() {
diff --git a/packages/react-native-reanimated/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.h b/packages/react-native-reanimated/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.h
index 2500bc7f56c6..0960709a1dae 100644
--- a/packages/react-native-reanimated/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.h
+++ b/packages/react-native-reanimated/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.h
@@ -99,7 +99,8 @@ class ReanimatedModuleProxy : public ReanimatedModuleProxySpec,
   void maybeRunCSSLoop();
   double getCssTimestamp();
 
-  void performOperations(const bool isTriggeredByEvent);
+  void performOperations();
+  void performNonLayoutOperations();
 
   void setViewStyle(jsi::Runtime &rt, const jsi::Value &viewTag, const jsi::Value &viewStyle) override;
 
@@ -179,6 +180,7 @@ class ReanimatedModuleProxy : public ReanimatedModuleProxySpec,
 
  private:
   void commitUpdates(jsi::Runtime &rt, const UpdatesBatch &updatesBatch);
+  void applySynchronousUpdates(UpdatesBatch &updatesBatch, bool allowPartialUpdates = false);
 
   const bool isReducedMotion_;
   bool shouldFlushRegistry_ = false;
diff --git a/packages/react-native-reanimated/android/src/main/cpp/reanimated/android/NativeProxy.cpp b/packages/react-native-reanimated/android/src/main/cpp/reanimated/android/NativeProxy.cpp
index dca6300b97cc..c8dd73c22c32 100644
--- a/packages/react-native-reanimated/android/src/main/cpp/reanimated/android/NativeProxy.cpp
+++ b/packages/react-native-reanimated/android/src/main/cpp/reanimated/android/NativeProxy.cpp
@@ -112,8 +112,12 @@ bool NativeProxy::isAnyHandlerWaitingForEvent(const std::string &eventName, cons
   return reanimatedModuleProxy_->isAnyHandlerWaitingForEvent(eventName, emitterReactTag);
 }
 
-void NativeProxy::performOperations(const bool isTriggeredByEvent) {
-  reanimatedModuleProxy_->performOperations(isTriggeredByEvent);
+void NativeProxy::performOperations() {
+  reanimatedModuleProxy_->performOperations();
+}
+
+void NativeProxy::performNonLayoutOperations() {
+  reanimatedModuleProxy_->performNonLayoutOperations();
 }
 
 bool NativeProxy::getIsReducedMotion() {
@@ -127,6 +131,7 @@ void NativeProxy::registerNatives() {
        makeNativeMethod("installJSIBindings", NativeProxy::installJSIBindings),
        makeNativeMethod("isAnyHandlerWaitingForEvent", NativeProxy::isAnyHandlerWaitingForEvent),
        makeNativeMethod("performOperations", NativeProxy::performOperations),
+       makeNativeMethod("performNonLayoutOperations", NativeProxy::performNonLayoutOperations),
        makeNativeMethod("invalidateCpp", NativeProxy::invalidateCpp)});
 }
 
diff --git a/packages/react-native-reanimated/android/src/main/cpp/reanimated/android/NativeProxy.h b/packages/react-native-reanimated/android/src/main/cpp/reanimated/android/NativeProxy.h
index 25e3e2168591..14e0345d1411 100644
--- a/packages/react-native-reanimated/android/src/main/cpp/reanimated/android/NativeProxy.h
+++ b/packages/react-native-reanimated/android/src/main/cpp/reanimated/android/NativeProxy.h
@@ -55,7 +55,8 @@ class NativeProxy : public jni::HybridClass<NativeProxy>, std::enable_shared_fro
 
   double getAnimationTimestamp();
   bool isAnyHandlerWaitingForEvent(const std::string &eventName, const int emitterReactTag);
-  void performOperations(const bool isTriggeredByEvent);
+  void performOperations();
+  void performNonLayoutOperations();
   bool getIsReducedMotion();
   void requestRender(std::function<void(double)> onRender);
   void registerEventHandler();
diff --git a/packages/react-native-reanimated/android/src/main/java/com/swmansion/reanimated/DrawPassDetector.java b/packages/react-native-reanimated/android/src/main/java/com/swmansion/reanimated/DrawPassDetector.java
new file mode 100644
index 000000000000..0b9f28548f5c
--- /dev/null
+++ b/packages/react-native-reanimated/android/src/main/java/com/swmansion/reanimated/DrawPassDetector.java
@@ -0,0 +1,82 @@
+package com.swmansion.reanimated;
+
+import android.app.Activity;
+import android.os.Handler;
+import android.os.Looper;
+import android.view.View;
+import android.view.ViewTreeObserver;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.UiThreadUtil;
+import javax.annotation.Nullable;
+
+/** Tracks whether the current UI thread turn is inside a draw pass. */
+class DrawPassDetector {
+  private final ReactApplicationContext mContext;
+  private final Handler mHandler = new Handler(Looper.getMainLooper());
+  private final Runnable mClearRunnable = () -> mIsInDrawPass = false;
+  private boolean mIsInDrawPass = false;
+  @Nullable private View mDecorView = null;
+
+  private final ViewTreeObserver.OnDrawListener mOnDrawListener =
+      () -> {
+        mIsInDrawPass = true;
+        mHandler.postAtFrontOfQueue(mClearRunnable);
+      };
+
+  DrawPassDetector(ReactApplicationContext context) {
+    mContext = context;
+  }
+
+  void initialize() {
+    Activity activity = mContext.getCurrentActivity();
+    if (activity == null) {
+      return;
+    }
+
+    View decorView = activity.getWindow().getDecorView();
+    if (decorView == mDecorView) {
+      return;
+    }
+
+    // Decor view has changed (e.g. Activity recreated) — detach from the old one first.
+    if (mDecorView != null) {
+      ViewTreeObserver oldObserver = mDecorView.getViewTreeObserver();
+      if (oldObserver.isAlive()) {
+        oldObserver.removeOnDrawListener(mOnDrawListener);
+      }
+      mDecorView = null;
+    }
+
+    ViewTreeObserver observer = decorView.getViewTreeObserver();
+    if (!observer.isAlive()) {
+      return;
+    }
+
+    mDecorView = decorView;
+    observer.addOnDrawListener(mOnDrawListener);
+  }
+
+  boolean isInDrawPass() {
+    return mIsInDrawPass;
+  }
+
+  void invalidate() {
+    if (UiThreadUtil.isOnUiThread()) {
+      invalidateOnUiThread();
+    } else {
+      mHandler.post(this::invalidateOnUiThread);
+    }
+  }
+
+  private void invalidateOnUiThread() {
+    if (mDecorView != null) {
+      ViewTreeObserver observer = mDecorView.getViewTreeObserver();
+      if (observer.isAlive()) {
+        observer.removeOnDrawListener(mOnDrawListener);
+      }
+      mDecorView = null;
+    }
+    mHandler.removeCallbacks(mClearRunnable);
+    mIsInDrawPass = false;
+  }
+}
diff --git a/packages/react-native-reanimated/android/src/main/java/com/swmansion/reanimated/NativeProxy.java b/packages/react-native-reanimated/android/src/main/java/com/swmansion/reanimated/NativeProxy.java
index 0c64a0cc1adf..5ebe4f821ad9 100644
--- a/packages/react-native-reanimated/android/src/main/java/com/swmansion/reanimated/NativeProxy.java
+++ b/packages/react-native-reanimated/android/src/main/java/com/swmansion/reanimated/NativeProxy.java
@@ -110,7 +110,9 @@ private native HybridData initHybrid(
 
   public native boolean isAnyHandlerWaitingForEvent(String eventName, int emitterReactTag);
 
-  public native void performOperations(boolean isTriggeredByEvent);
+  public native void performOperations();
+
+  public native void performNonLayoutOperations();
 
   protected native void installJSIBindings();
 
@@ -503,7 +505,7 @@ public boolean getIsReducedMotion() {
   void maybeFlushUIUpdatesQueue() {
     UiThreadUtil.assertOnUiThread();
     if (!mNodesManager.isAnimationRunning()) {
-      mNodesManager.performOperations(false);
+      mNodesManager.performOperationsRespectingDrawPass();
     }
   }
 }
diff --git a/packages/react-native-reanimated/android/src/main/java/com/swmansion/reanimated/NodesManager.java b/packages/react-native-reanimated/android/src/main/java/com/swmansion/reanimated/NodesManager.java
index 52def06454a9..196022858b99 100644
--- a/packages/react-native-reanimated/android/src/main/java/com/swmansion/reanimated/NodesManager.java
+++ b/packages/react-native-reanimated/android/src/main/java/com/swmansion/reanimated/NodesManager.java
@@ -44,6 +44,7 @@ public interface OnAnimationFrame {
   private ConcurrentLinkedQueue<CopiedEvent> mEventQueue = new ConcurrentLinkedQueue<>();
   private double lastFrameTimeMs;
   private FabricUIManager mFabricUIManager;
+  private final DrawPassDetector mDrawPassDetector;
 
   public NativeProxy getNativeProxy() {
     return mNativeProxy;
@@ -57,6 +58,8 @@ public void invalidate() {
       mNativeProxy = null;
     }
 
+    mDrawPassDetector.invalidate();
+
     if (mFabricUIManager != null) {
       mFabricUIManager.getEventDispatcher().removeListener(this);
     }
@@ -69,6 +72,7 @@ public NodesManager(ReactApplicationContext context, WorkletsModule workletsModu
     assert uiManager != null;
     mCustomEventNamesResolver = uiManager::resolveCustomDirectEventName;
     mEventEmitter = context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class);
+    mDrawPassDetector = new DrawPassDetector(context);
 
     mReactChoreographer = ReactChoreographer.getInstance();
     mChoreographerCallback =
@@ -115,11 +119,33 @@ private void stopUpdatingOnAnimationFrame() {
     }
   }
 
-  public void performOperations(boolean isTriggeredByEvent) {
+  public void performOperations() {
     UiThreadUtil.assertOnUiThread();
     if (mNativeProxy != null) {
-      mNativeProxy.performOperations(isTriggeredByEvent);
+      mNativeProxy.performOperations();
+    }
+  }
+
+  void performNonLayoutOperations() {
+    UiThreadUtil.assertOnUiThread();
+    if (mNativeProxy != null) {
+      mNativeProxy.performNonLayoutOperations();
+    }
+  }
+
+  void performOperationsRespectingDrawPass() {
+    mDrawPassDetector.initialize();
+    if (isInDrawPass()) {
+      performNonLayoutOperations();
+      startUpdatingOnAnimationFrame();
+      return;
     }
+
+    performOperations();
+  }
+
+  boolean isInDrawPass() {
+    return mDrawPassDetector.isInDrawPass();
   }
 
   private void onAnimationFrame(long frameTimeNanos) {
@@ -130,6 +156,8 @@ private void onAnimationFrame(long frameTimeNanos) {
         Trace.beginSection("onAnimationFrame");
       }
 
+      mDrawPassDetector.initialize();
+
       double currentFrameTimeMs = frameTimeNanos / 1000000.;
       if (mSlowAnimationsEnabled) {
         currentFrameTimeMs =
@@ -155,7 +183,7 @@ private void onAnimationFrame(long frameTimeNanos) {
           }
         }
 
-        performOperations(false);
+        performOperations();
       }
 
       mCallbackPosted.set(false);
@@ -189,7 +217,7 @@ public void onEventDispatch(Event event) {
       // the UI thread.
       if (UiThreadUtil.isOnUiThread()) {
         handleEvent(event);
-        performOperations(true);
+        performOperationsRespectingDrawPass();
       } else {
         String eventName = mCustomEventNamesResolver.resolveCustomEventName(event.getEventName());
         int viewTag = event.getViewTag();
diff --git a/packages/react-native-reanimated/apple/reanimated/apple/native/NativeProxy.mm b/packages/react-native-reanimated/apple/reanimated/apple/native/NativeProxy.mm
index 19a4e2d6aa9e..793d28d72a33 100644
--- a/packages/react-native-reanimated/apple/reanimated/apple/native/NativeProxy.mm
+++ b/packages/react-native-reanimated/apple/reanimated/apple/native/NativeProxy.mm
@@ -46,7 +46,7 @@ - (void *)runtime;
   std::weak_ptr<ReanimatedModuleProxy> weakReanimatedModuleProxy = reanimatedModuleProxy; // to avoid retain cycle
   [nodesManager registerPerformOperations:^() {
     if (auto reanimatedModuleProxy = weakReanimatedModuleProxy.lock()) {
-      reanimatedModuleProxy->performOperations(false);
+      reanimatedModuleProxy->performOperations();
     }
   }];