diff --git a/RNReanimated.podspec b/RNReanimated.podspec
index 8e539f565d5c..cbb4ddd1a554 100644
--- a/RNReanimated.podspec
+++ b/RNReanimated.podspec
@@ -86,8 +86,8 @@ Pod::Spec.new do |s|
     "Common/cpp/hidden_headers/**"
   ]
 
-  gcc_debug_definitions = "$(inherited)"
-  if $config[:react_native_minor_version] >= 73 || !is_release
+  gcc_debug_definitions =  "$(inherited)"
+  if config[:react_native_minor_version] >= 73 || !is_release
     gcc_debug_definitions << " HERMES_ENABLE_DEBUGGER=1"
   end
 
diff --git a/app/src/examples/RuntimeTests/ReanimatedRuntimeTestsRunner/RuntimeTestsApi.ts b/app/src/examples/RuntimeTests/ReanimatedRuntimeTestsRunner/RuntimeTestsApi.ts
new file mode 100644
index 000000000000..1c1dc72e273d
--- /dev/null
+++ b/app/src/examples/RuntimeTests/ReanimatedRuntimeTestsRunner/RuntimeTestsApi.ts
@@ -0,0 +1,230 @@
+import { makeMutable, runOnJS, runOnUI } from "react-native-reanimated";
+import { TestRunner } from "./TestRunner";
+import { TestComponent } from "./TestComponent";
+
+const testRunner = new TestRunner();
+
+export function describe(name: string, buildSuite: () => void) {
+  testRunner.describe(name, buildSuite);
+};
+
+export function beforeAll(job: () => void) {
+  testRunner.beforeAll(job);
+}
+
+export function beforeEach(job: () => void) {
+  testRunner.beforeEach(job);
+}
+
+export function afterEach(job: () => void) {
+  testRunner.afterEach(job);
+}
+
+export function afterAll(job: () => void) {
+  testRunner.afterAll(job);
+}
+
+export function test(name: string, testCase: () => void) {
+  testRunner.test(name, testCase);
+};
+
+export async function render(component: any) {
+  return testRunner.render(component);
+}
+
+function waitForPropertyValueChange(targetObject, targetProperty, initialValue = true) {
+  return new Promise((resolve) => {
+    const interval = setInterval(() => {
+      if (targetObject[targetProperty] != initialValue) {
+        clearInterval(interval);
+        resolve(targetObject[targetProperty]);
+      }
+    }, 10);
+  });
+}
+
+export function useTestRef(name: string): React.MutableRefObject<any> {
+  return testRunner.useTestRef(name);
+}
+
+export function getTestComponent(name: string): TestComponent {
+  return testRunner.getTestComponent(name);
+}
+
+export async function runTests() {
+  await testRunner.runTests();
+}
+
+export async function wait(delay: number) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, delay);
+  });
+}
+
+export function expect(value: any) {
+  return testRunner.expect(value);
+};
+
+export function configure(config: any) {
+  return testRunner.configure(config);
+}
+
+const lockObject = {
+  lock: false
+}
+function unlock() {
+  lockObject.lock = false;
+}
+async function runOnUiSync(worklet: () => void) {
+  lockObject.lock = true;
+  runOnUI(() => {
+    "worklet";
+    worklet();
+    runOnJS(unlock)();
+  })();
+  await waitForPropertyValueChange(lockObject, "lock", true);
+}
+
+export async function mockAnimationTimer() {
+  await runOnUiSync(() => {
+    "worklet";
+    global.mockedAnimationTimestamp = 0;
+    global.originalGetAnimationTimestamp = global._getAnimationTimestamp;
+    global._getAnimationTimestamp = () => {
+      const currentTimestamp = global.mockedAnimationTimestamp;
+      global.__frameTimestamp = currentTimestamp;
+      global.mockedAnimationTimestamp += 16;
+      return currentTimestamp;
+    };
+    let originalRequestAnimationFrame = global.requestAnimationFrame;
+    global.originalRequestAnimationFrame = originalRequestAnimationFrame;
+    (global as any).requestAnimationFrame = (callback) => {
+      originalRequestAnimationFrame(() => {
+        callback(global._getAnimationTimestamp());
+      });
+    }
+  })
+}
+
+export async function unmockAnimationTimer() {
+  await runOnUiSync(() => {
+    "worklet";
+    if (global.originalGetAnimationTimestamp) {
+      global._getAnimationTimestamp = global.originalGetAnimationTimestamp;
+      global.originalGetAnimationTimestamp = undefined;
+    }
+    if (global.originalRequestAnimationFrame) {
+      global.requestAnimationFrame = global.originalRequestAnimationFrame;
+      global.originalRequestAnimationFrame = undefined;
+    }
+    if (global.mockedAnimationTimestamp) {
+      global.mockedAnimationTimestamp = undefined;
+    }
+  });
+}
+
+export async function setAnimationTimestamp(timestamp: number) {
+  await runOnUiSync(() => {
+    "worklet";
+    global.mockedAnimationTimestamp = timestamp;
+  })
+}
+
+export async function advanceAnimationByTime(time: number) {
+  await runOnUiSync(() => {
+    "worklet";
+    global.mockedAnimationTimestamp += time;
+  })
+}
+
+export async function advanceAnimationByFrames(frameCount: number) {
+  await runOnUiSync(() => {
+    "worklet";
+    global.mockedAnimationTimestamp += frameCount * 16;
+  })
+}
+
+export async function recordAnimationUpdates(mergeOperations = true) {
+  const updates = makeMutable<any>(null);
+  await runOnUiSync(() => {
+    "worklet";
+    const originalUpdateProps = global._IS_FABRIC ? global._updatePropsFabric : global._updatePropsPaper;
+    global.originalUpdateProps = originalUpdateProps;
+    const mockedUpdateProps = mergeOperations
+      ? (operations) => {
+        if (updates.value == null) {
+          updates.value = [];
+        }
+        const newUpdates: any = [];
+        for (const operation of operations) {
+          newUpdates.push(operation.updates);
+        }
+        for (const newUpdate of newUpdates) {
+          updates.value.push(newUpdate);
+        }
+        updates.value = [...updates.value];
+        originalUpdateProps(operations);
+      }
+      : (operations) => {
+        if (updates.value == null) {
+          updates.value = {};
+        }
+        for (const operation of operations) {
+          if (updates.value[operation.tag] == undefined) {
+            updates.value[operation.tag] = [];
+          }
+          updates.value[operation.tag].push(updates.value[operation.tag]);
+        }
+        updates.value = operations;
+        originalUpdateProps(operations);
+      };
+
+    if (global._IS_FABRIC) {
+      global._updatePropsFabric = mockedUpdateProps;
+    } else {
+      global._updatePropsPaper = mockedUpdateProps;
+    }
+
+    const originalNotifyAboutProgress = global._notifyAboutProgress;
+    global.originalNotifyAboutProgress = originalNotifyAboutProgress;
+    global._notifyAboutProgress = mergeOperations
+      ? (tag, value, isSharedTransition) => {
+        if (updates.value == null) {
+          updates.value = [];
+        }
+        updates.value.push({... value});
+        updates.value = [...updates.value];
+        originalNotifyAboutProgress(tag, value, isSharedTransition);
+      }
+      : (tag, value, isSharedTransition) => {
+        if (updates.value == null) {
+          updates.value = {};
+        }
+        if (updates.value[tag] == undefined) {
+          updates.value[tag] = [];
+        }
+        updates.value[tag].push(value);
+        updates.value = { ...updates.value };
+        originalNotifyAboutProgress(tag, value, isSharedTransition);
+      }
+  });
+  return updates;
+}
+
+export async function stopRecordingAnimationUpdates() {
+  await runOnUiSync(() => {
+    "worklet";
+    if (global.originalUpdateProps) {
+      if (global._IS_FABRIC) {
+        global._updatePropsFabric = global.originalUpdateProps;
+      } else {
+        global._updatePropsPaper = global.originalUpdateProps;
+      }
+      global.originalUpdateProps = undefined;
+    }
+    if (global.originalNotifyAboutProgress) {
+      global._notifyAboutProgress = global.originalNotifyAboutProgress;
+      global.originalNotifyAboutProgress = undefined;
+    }
+  });
+}
diff --git a/app/src/examples/RuntimeTests/ReanimatedRuntimeTestsRunner/RuntimeTestsRunner.tsx b/app/src/examples/RuntimeTests/ReanimatedRuntimeTestsRunner/RuntimeTestsRunner.tsx
new file mode 100644
index 000000000000..25dcfdd63c12
--- /dev/null
+++ b/app/src/examples/RuntimeTests/ReanimatedRuntimeTestsRunner/RuntimeTestsRunner.tsx
@@ -0,0 +1,30 @@
+import { View, Button, StyleSheet, Text } from 'react-native';
+import React, { useEffect, useState } from 'react';
+import { runTests, configure } from './RuntimeTestsApi';
+
+let renderLock: { lock: boolean } = { lock: false };
+export default function RuntimeTestsRunner() {
+  const [component, renderComponent] = useState(false); 
+  useEffect(() => {
+    if (renderLock) {
+      renderLock.lock = false;
+    }
+  }, [component]);
+  return (
+    <View style={styles.container}>
+      <Button title="Run tests" onPress={async () => {
+        renderLock = configure({ render: renderComponent });
+        await runTests();
+      }} />
+      { component }
+      { !component && <Text> Press "Run tests" button to start tests </Text> }
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    flexDirection: 'column',
+  },
+});
diff --git a/app/src/examples/RuntimeTests/ReanimatedRuntimeTestsRunner/TestComponent.ts b/app/src/examples/RuntimeTests/ReanimatedRuntimeTestsRunner/TestComponent.ts
new file mode 100644
index 000000000000..6106171a10a8
--- /dev/null
+++ b/app/src/examples/RuntimeTests/ReanimatedRuntimeTestsRunner/TestComponent.ts
@@ -0,0 +1,19 @@
+import { findNodeHandle } from "react-native";
+import { getViewProp } from "react-native-reanimated";
+
+export class TestComponent {
+  private ref: React.MutableRefObject<any>;
+  constructor(ref: React.MutableRefObject<any>) {
+    this.ref = ref;
+  }
+  public getStyle(propName) {
+    return this.ref.current.props.style[propName];
+  }
+  public async getAnimatedStyle(propName) {
+    const tag = findNodeHandle(this.ref.current) ?? -1;
+    return getViewProp(tag, propName);
+  }
+  public getTag() {
+    return findNodeHandle(this.ref.current) ?? -1;
+  }
+};
diff --git a/app/src/examples/RuntimeTests/ReanimatedRuntimeTestsRunner/TestRunner.ts b/app/src/examples/RuntimeTests/ReanimatedRuntimeTestsRunner/TestRunner.ts
new file mode 100644
index 000000000000..7c80a9b00a76
--- /dev/null
+++ b/app/src/examples/RuntimeTests/ReanimatedRuntimeTestsRunner/TestRunner.ts
@@ -0,0 +1,157 @@
+import { useRef } from "react";
+import { TestCase, TestSuite } from "./types";
+import { TestComponent } from "./TestComponent";
+import { render, stopRecordingAnimationUpdates, unmockAnimationTimer } from "./RuntimeTestsApi";
+
+export class TestRunner {
+  private testSuites: TestSuite[] = [];
+  private currentTestSuite: TestSuite | null = null;
+  private currentTestCase: TestCase | null = null;
+  private renderHook: (component: any) => void = () => {};
+  private renderLock: { lock: boolean } = { lock: false };
+
+  public configure(config: { render: (component: any) => void }) {
+    this.renderHook = config.render;
+    return this.renderLock;
+  }
+
+  public async render(component: any) {
+    this.renderLock.lock = true;
+    this.renderHook(component);
+    return this.waitForPropertyValueChange(this.renderLock, "lock");
+  }
+
+  public describe(name: string, buildSuite: () => void) {
+    this.testSuites.push({
+      name,
+      buildSuite,
+      testCases: [],
+    });
+  };
+
+  public test(name: string, testCase: () => void) {
+    if (!this.currentTestSuite) {
+      throw new Error("Undefined test suite context");
+    }
+    this.currentTestSuite.testCases.push({
+      name,
+      testCase,
+      componentsRefs: {},
+      errors: [],
+    });
+  };
+
+  public useTestRef(name: string): React.MutableRefObject<any> {
+    const ref = useRef();
+    if (!this.currentTestCase) {
+      throw new Error("Undefined test case context");
+    }
+    this.currentTestCase.componentsRefs[name] = ref;
+    return ref;
+  }
+
+  public getTestComponent(name: string): TestComponent {
+    if (!this.currentTestCase) {
+      throw new Error("Undefined test case context");
+    }
+    return new TestComponent(this.currentTestCase.componentsRefs[name]);
+  }
+
+  public async runTests() {
+    for (const testSuite of this.testSuites) {
+      this.currentTestSuite = testSuite;
+      console.log(`+ Running test suite: ${testSuite.name}`);
+      console.log(testSuite)
+      testSuite.buildSuite();
+      if (testSuite.beforeAll) {
+        await testSuite.beforeAll();
+      }
+      for (const testCase of testSuite.testCases) {
+        this.currentTestCase = testCase;
+        console.log(`\t - Running test case: ${testCase.name}`);
+        if (testSuite.beforeEach) {
+          await testSuite.beforeEach();
+        }
+        await testCase.testCase();
+        if (testCase.errors.length > 0) {
+          console.error(testCase.errors);
+          console.log("\t -----------------------------------------------");
+        } else {
+          console.log("\t ✅ OK");
+          console.log("\t -----------------------------------------------");
+        }
+        if (testSuite.afterEach) {
+          await testSuite.afterEach();
+        }
+        this.currentTestCase = null;
+        await render(null);
+      }
+      if (testSuite.afterAll) {
+        await testSuite.afterAll();
+      }
+      this.currentTestSuite = null;
+    }
+    this.testSuites = [];
+    await unmockAnimationTimer();
+    await stopRecordingAnimationUpdates();
+    console.log("End of tests run 🏁");
+  }
+
+  public expect(value: any) {
+    if (!this.currentTestCase) {
+      throw new Error("Undefined test case context");
+    }
+    const errors = this.currentTestCase?.errors;
+    return {
+      toBe: (expected: any) => {
+        if (value !== expected) {
+          errors.push(`Expected ${value} received ${expected}`);
+        }
+      },
+      toMatchSnapshot: (expected: any) => {
+        if (JSON.stringify(value) !== JSON.stringify(expected)) {
+          errors.push(`Expected ${JSON.stringify(value)} received ${JSON.stringify(expected)}`);
+        }
+      }
+    };
+  };
+
+  public beforeAll(job: () => void) {
+    if (!this.currentTestSuite) {
+      throw new Error("Undefined test suite context");
+    }
+    this.currentTestSuite.beforeAll = job;
+  }
+
+  public afterAll(job: () => void) {
+    if (!this.currentTestSuite) {
+      throw new Error("Undefined test suite context");
+    }
+    this.currentTestSuite.afterAll = job;
+  }
+
+  public beforeEach(job: () => void) {
+    if (!this.currentTestSuite) {
+      throw new Error("Undefined test suite context");
+    }
+    this.currentTestSuite.beforeEach = job;
+  }
+
+  public afterEach(job: () => void) {
+    if (!this.currentTestSuite) {
+      throw new Error("Undefined test suite context");
+    }
+    this.currentTestSuite.afterEach = job;
+  }
+
+  private waitForPropertyValueChange(targetObject, targetProperty, initialValue = true) {
+    return new Promise((resolve) => {
+      const interval = setInterval(() => {
+        if (targetObject[targetProperty] != initialValue) {
+          clearInterval(interval);
+          resolve(targetObject[targetProperty]);
+        }
+      }, 10);
+    });
+  }
+}
diff --git a/app/src/examples/RuntimeTests/ReanimatedRuntimeTestsRunner/types.ts b/app/src/examples/RuntimeTests/ReanimatedRuntimeTestsRunner/types.ts
new file mode 100644
index 000000000000..7f3d6aa3e93c
--- /dev/null
+++ b/app/src/examples/RuntimeTests/ReanimatedRuntimeTestsRunner/types.ts
@@ -0,0 +1,16 @@
+export type TestCase = {
+  name: string;
+  testCase: () => void;
+  componentsRefs: Record<string, React.MutableRefObject<any>>;
+  errors: string[];
+}
+
+export type TestSuite = {
+  name: string;
+  buildSuite: () => void;
+  testCases: TestCase[];
+  beforeAll?: () => void;
+  afterAll?: () => void;
+  beforeEach?: () => void;
+  afterEach?: () => void;
+}
diff --git a/app/src/examples/RuntimeTests/RuntimeTestsExample.tsx b/app/src/examples/RuntimeTests/RuntimeTestsExample.tsx
new file mode 100644
index 000000000000..138d581649c2
--- /dev/null
+++ b/app/src/examples/RuntimeTests/RuntimeTestsExample.tsx
@@ -0,0 +1,12 @@
+import React from 'react';
+import RuntimeTestsRunner from './ReanimatedRuntimeTestsRunner/RuntimeTestsRunner';
+
+// load tests
+import './tests/Animations.test';
+
+export default function RuntimeTestsExample() {
+  return (
+    <RuntimeTestsRunner />
+  );
+}
+
diff --git a/app/src/examples/RuntimeTests/tests/Animations.test.tsx b/app/src/examples/RuntimeTests/tests/Animations.test.tsx
new file mode 100644
index 000000000000..ea80740c51d5
--- /dev/null
+++ b/app/src/examples/RuntimeTests/tests/Animations.test.tsx
@@ -0,0 +1,80 @@
+import React, { useEffect } from 'react';
+import { View } from 'react-native';
+import Animated, { useSharedValue, useAnimatedStyle, withTiming, FadeIn } from 'react-native-reanimated';
+import { describe, test, expect, render, useTestRef, getTestComponent, wait, mockAnimationTimer, recordAnimationUpdates } from '../ReanimatedRuntimeTestsRunner/RuntimeTestsApi';
+import { Snapshots } from './snapshots/Animations.snapshot';
+
+const AnimatedComponent = () => {
+  const widthSV = useSharedValue(0);
+  const ref = useTestRef('AnimatedComponent')
+
+  const style = useAnimatedStyle(() => {
+    return {
+      width: withTiming(widthSV.value, { duration: 500 }),
+    };
+  });
+
+  useEffect(() => {
+    widthSV.value = 100;
+  }, []);
+
+  return (
+    <View style={{ flex: 1, flexDirection: 'column', backgroundColor: 'red' }}>
+      <Animated.View
+        ref={ref}
+        style={[
+          { width: 0, height: 80, backgroundColor: 'black', margin: 30 },
+          style,
+        ]}
+      />
+    </View>
+  );
+};
+
+const LayoutAnimation = () => {
+  const ref = useTestRef('AnimatedComponent')
+
+  return (
+    <View style={{ flex: 1, flexDirection: 'column', backgroundColor: 'red' }}>
+      <Animated.View
+        ref={ref}
+        entering={FadeIn}
+        style={{ width: 50, height: 50, backgroundColor: 'black', margin: 30 }}
+      />
+    </View>
+  );
+};
+
+describe('Tests of animations', () => {
+
+  test('withTiming - expect error', async () => {
+    await render(<AnimatedComponent />);
+    const component = getTestComponent('AnimatedComponent');
+    await wait(600);
+    expect(await component.getAnimatedStyle('width')).toBe('123');
+  });
+
+  test('withTiming - expect pass', async () => {
+    await render(<AnimatedComponent />);
+    const component = getTestComponent('AnimatedComponent');
+    await wait(600);
+    expect(await component.getAnimatedStyle('width')).toBe('100');
+  });
+
+  test('withTiming - match snapshot', async () => {
+    await mockAnimationTimer();
+    const updates = await recordAnimationUpdates();
+    await render(<AnimatedComponent />);
+    await wait(600);
+    expect(updates.value).toMatchSnapshot(Snapshots.animation3);
+  });
+
+  test('layoutAnimation - entering', async () => {
+    await mockAnimationTimer();
+    const updates = await recordAnimationUpdates();
+    await render(<LayoutAnimation />);
+    await wait(600);
+    expect(updates.value).toMatchSnapshot(Snapshots.layoutAnimation);
+  });
+
+});
diff --git a/app/src/examples/RuntimeTests/tests/snapshots/Animations.snapshot.ts b/app/src/examples/RuntimeTests/tests/snapshots/Animations.snapshot.ts
new file mode 100644
index 000000000000..bedd9c0c728d
--- /dev/null
+++ b/app/src/examples/RuntimeTests/tests/snapshots/Animations.snapshot.ts
@@ -0,0 +1,4 @@
+export const Snapshots = {
+  animation3: [{"width": 0}, {"width": 0.20479999999999998}, {"width": 0.8191999999999999}, {"width": 1.8432}, {"width": 3.2767999999999997}, {"width": 5.12}, {"width": 7.3728}, {"width": 10.035200000000001}, {"width": 13.107199999999999}, {"width": 16.5888}, {"width": 20.48}, {"width": 24.780799999999996}, {"width": 29.4912}, {"width": 34.6112}, {"width": 40.140800000000006}, {"width": 46.08}, {"width": 52.371199999999995}, {"width": 58.41280000000001}, {"width": 64.0448}, {"width": 69.2672}, {"width": 74.08}, {"width": 78.48320000000001}, {"width": 82.4768}, {"width": 86.0608}, {"width": 89.2352}, {"width": 92}, {"width": 94.3552}, {"width": 96.3008}, {"width": 97.8368}, {"width": 98.9632}, {"width": 99.68}, {"width": 99.9872}, {"width": 100}],
+  layoutAnimation: [{"opacity": 0}, {"opacity": 0.02275555555555556}, {"opacity": 0.09102222222222224}, {"opacity": 0.2048}, {"opacity": 0.36408888888888896}, {"opacity": 0.5644444444444444}, {"opacity": 0.7408}, {"opacity": 0.8716444444444444}, {"opacity": 0.9569777777777778}, {"opacity": 0.9968}, {"opacity": 1}],
+};
diff --git a/app/src/examples/index.ts b/app/src/examples/index.ts
index 0f9c1c6890b9..0dc838086736 100644
--- a/app/src/examples/index.ts
+++ b/app/src/examples/index.ts
@@ -112,6 +112,7 @@ import WorkletRuntimeExample from './WorkletRuntimeExample';
 import NestedLayoutAnimationConfig from './LayoutAnimations/NestedLayoutAnimationConfig';
 import WithClampExample from './WithClampExample';
 import WorkletFactoryCrash from './WorkletFactoryCrashExample';
+import RuntimeTestsExample from './RuntimeTests/RuntimeTestsExample';
 import HabitsExample from './LayoutAnimations/HabitsExample';
 
 interface Example {
@@ -128,6 +129,11 @@ export const EXAMPLES: Record<string, Example> = {
     title: 'Empty',
     screen: EmptyExample,
   },
+  RuntimeTests: {
+    icon: '⚙️',
+    title: 'RuntimeTestsExample',
+    screen: RuntimeTestsExample,
+  },
   WorkletRuntimeExample: {
     icon: '🏃‍♂️',
     title: 'Worklet runtime',
diff --git a/apple/REANodesManager.mm b/apple/REANodesManager.mm
index ed36c9986cca..61d0a62e32f2 100644
--- a/apple/REANodesManager.mm
+++ b/apple/REANodesManager.mm
@@ -534,6 +534,14 @@ - (NSString *)obtainProp:(nonnull NSNumber *)viewTag propName:(nonnull NSString
   } else if ([propName isEqualToString:@"zIndex"]) {
     NSInteger zIndex = view.reactZIndex;
     result = [@(zIndex) stringValue];
+  } else if ([propName isEqualToString:@"width"]) {
+    result = [@(view.frame.size.width) stringValue];
+  } else if ([propName isEqualToString:@"height"]) {
+    result = [@(view.frame.size.height) stringValue];
+  } else if ([propName isEqualToString:@"top"]) {
+    result = [@(view.frame.origin.y) stringValue];
+  } else if ([propName isEqualToString:@"left"]) {
+    result = [@(view.frame.origin.x) stringValue];
   }
 
   return result;
diff --git a/src/reanimated2/hook/useAnimatedStyle.ts b/src/reanimated2/hook/useAnimatedStyle.ts
index 50bb193865bf..7f988269a500 100644
--- a/src/reanimated2/hook/useAnimatedStyle.ts
+++ b/src/reanimated2/hook/useAnimatedStyle.ts
@@ -200,6 +200,7 @@ function styleUpdater(
 
   if (hasAnimations) {
     const frame = (timestamp: Timestamp) => {
+      // console.log('styleUpdater', timestamp)
       const { animations, last, isAnimationCancelled } = state;
       if (isAnimationCancelled) {
         state.isAnimationRunning = false;