software-mansion/react-native-reanimated
React Native Reanimated
This project is a cross-platform animation library for React Native that provides a declarative engine for building high-performance user interfaces. It functions by offloading animation logic and interaction processing to the native UI thread, ensuring that visual transitions remain smooth and responsive even when the main application thread is under heavy load.
The library distinguishes itself through a specialized architecture that transforms standard functions into units capable of executing directly on the native thread. It utilizes shared-memory synchronization to maintain consistent data values between the application logic and the native environment, enabling real-time updates without bridge latency. By employing a physics-based interpolation engine, the system simulates natural motion, inertial deceleration, and spring-based transitions that mimic real-world physical behavior.
The framework covers a broad range of interactive capabilities, including gesture-driven interface design, sensor-based motion, and dynamic layout management. It provides mechanisms to track hardware sensor data and virtual keyboard states, allowing interface elements to adjust automatically to device movement or on-screen input changes. These features are supported by a node-based system that caches evaluations to optimize performance and maintain high frame rates during complex interactions.
Features
- React Native Libraries - Provides a high-performance, gesture-driven animation library specifically for the React Native ecosystem.
- Native Thread Animation Engines - Reanimated runs animation logic on a separate thread to ensure smooth performance and prevent frame drops during complex interactions.
- Cross-Platform UI Frameworks - Provides a cross-platform framework for building fluid, physics-based motion and interactive interfaces.
- Declarative Animations - Implements a declarative animation engine that offloads heavy computation to the native thread for high-performance UI updates.
- UI Animations - Provides a high-performance animation engine that offloads logic to the native UI thread for fluid mobile transitions.
- Worklet Compilers - Transforms standard functions into specialized units that execute directly on the UI thread.
- Native Execution Offloading - Offloads animation logic and interaction processing to the native UI thread for high-performance execution.
- Build-Time Transformations - Transforms standard functions into native-executable bytecode units during the build process to enable high-performance UI thread execution.
- UI Thread Responsiveness - Offloads animation logic to a dedicated native thread to maintain high frame rates and interface responsiveness.
- Physics-Based Property Interpolators - Calculates physics-based motion, including springs and friction, on the UI thread for natural interface transitions.
- Gesture Interaction Frameworks - Enables gesture-driven interface design by mapping touch inputs to physics-based motion and inertial deceleration.
- Gesture Handling - Captures and processes touch events directly on the native layer to drive animations without bridge latency.
- Thread-Safe Communication Channels - Provides thread-safe data structures for real-time value synchronization between JavaScript and native UI threads.
- Declarative Scene Graphs - Represents animation logic as a reactive directed graph that maps state changes to native view property updates.
- Animation Components - Executes complex visual transitions on the native thread to ensure smooth motion.
- Physics-Based Animation Libraries - Triggers smooth movements between values using spring-based physics to mimic real-world motion.
- Touch Gesture Detectors - Attaches gesture definitions to interface components to capture and respond to touch interactions like taps and pans.
- Touch Gesture Handlers - Processes touch input events to drive fluid, tactile animations for responsive navigation.
- State Synchronization Handlers - Maintains shared data values between application logic and native environments to drive real-time updates.
- Sensor-to-UI Mappers - Maps real-time hardware sensor data to visual properties for physically reactive interface motion.
- Multi-threaded Execution - Executes animation logic in parallel threads to offload heavy computations from the main thread.
- Physics-Based Animations - Calculates momentum-based movement after gesture release to simulate physical friction and natural stopping behavior.
- Component Transitions - Applies motion effects to elements as they enter or exit the screen to create smooth visual transitions.
- Physics-Based Interactions - Integrates real-time device sensor data into physics-based interaction models for immersive user interfaces.
- Motion Sensor Readers - Polls hardware sensors like accelerometers and gyroscopes to drive interactive, motion-responsive animations.
- Keyboard Management - Manages UI layout adjustments to accommodate virtual keyboard visibility and movement.
- Node Result Caches - Caches computed output values of animation nodes within a single frame to prevent redundant execution.
- Keyboard Input Synchronizers - Tracks virtual keyboard visibility and height to synchronize layout elements and prevent content overlap.
- Animation Properties - Updates component styles and layout values using timing or spring functions to respond to state changes.
- Layout Animation Engines - Animates visual shifts when elements enter or leave the screen to maintain consistent interface flow.
- Layout Animation Utilities - Updates component styles and positions dynamically to maintain visual consistency during layout changes.
