Was macht React Native Reanimated?
Überblick
Reanimated führt Animationen auf dem nativen UI-Thread aus, sodass sie mit 60fps (oder der Bildwiederholrate des Displays) laufen, selbst wenn der JavaScript-Thread ausgelastet ist. Es verwendet "Worklets": kleine JavaScript-Funktionen, die über JSI auf dem UI-Thread ausgeführt werden. Es ist der Standard für produktionsreife Animationen in React Native: gestengesteuerte Interaktionen, Layout-Übergänge, scrollbasierte Effekte und geteilte Elementübergänge.
Diese Fähigkeit zielt auf Reanimated 4 (4.7.0, September 2026). Version 4 funktioniert nur mit der Neuen Architektur, verschiebt Worklets in das separate Paket react-native-worklets und fügt CSS-ähnliche Übergänge und Animationen hinzu. Apps, die noch auf der alten Architektur laufen, bleiben bei 3.x, das nicht mehr aktiv gewartet wird.
Wann verwenden
- Jede Animation in React Native, die über einfache Opazität/Transformation hinausgeht
- Gestengesteuerte Interaktionen (Wischen zum Löschen, Ziehen zum Neuanordnen, Pinch-to-Zoom)
- Scrollgesteuerte Animationen (Parallax-Header, klebrige Elemente)
- Layout-Animationen (Elemente, die in Listen ein- oder austreten)
- Geteilte Elementübergänge zwischen Bildschirmen (experimentell in 4.x)
Anleitung
Einrichtung
# Expo: installiert die vom SDK festgelegten Versionen (SDK 57: Reanimated 4.5, Worklets 0.10, Gesture Handler 2.32)
npx expo install react-native-reanimated react-native-worklets react-native-gesture-handler
npx expo prebuild # nur für Development Builds: generiert ios/ und android/ neu
# React Native Community CLI
npm install react-native-reanimated react-native-worklets react-native-gesture-handler
cd ios && pod install && cd ..
npm start -- --reset-cache
- Expo:
babel-preset-expofügt das Worklets-Babel-Plugin automatisch hinzu; nicht inbabel.config.jsaufführen. - Community CLI: füge
'react-native-worklets/plugin'als letzten Eintrag derpluginsinbabel.config.jshinzu. Der Reanimated-3-Namereact-native-reanimated/pluginfunktioniert in 4.x noch, ist aber die veraltete Schreibweise. - Jede Reanimated-Nebenversion akzeptiert spezifische
react-native-worklets- und React-Native-Versionen (4.7 benötigt Worklets 0.13 und RN 0.86–0.88); vor einem manuellen Upgrade die Kompatibilitätstabelle prüfen. - Für Gesten die App-Wurzel in
GestureHandlerRootViewvonreact-native-gesture-handlermitstyle={{ flex: 1 }}einwickeln.
Shared Values und Animierte Styles
// components/FadeIn.tsx — Basis-Animation mit Shared Values
import Animated, { useSharedValue, useAnimatedStyle, withTiming, withSpring } from "react-native-reanimated";
import { type ReactNode, useEffect } from "react";
export function FadeInCard({ children }: { children: ReactNode }) {
const opacity = useSharedValue(0);
const translateY = useSharedValue(20);
useEffect(() => {
opacity.value = withTiming(1, { duration: 600 });
translateY.value = withSpring(0);
}, []);
const animatedStyle = useAnimatedStyle(() => ({
opacity: opacity.value,
transform: [{ translateY: translateY.value }],
}));
return <Animated.View style={[{ backgroundColor: "white", padding: 16 }, animatedStyle]}>{children}</Animated.View>;
}
.value nur in Effekten, Ereignisbehandlern und Worklets lesen und schreiben, niemals während des Renderings. Mit dem React Compiler opacity.get() und opacity.set(1) anstelle von .value verwenden.
Gesten-Animationen
// components/SwipeToDelete.tsx — Wischgeste mit Animation
import Animated, { useSharedValue, useAnimatedStyle, withSpring } from "react-native-reanimated";
import { Gesture, GestureDetector } from "react-native-gesture-handler";
import { scheduleOnRN } from "react-native-worklets";
import type { ReactNode } from "react";
export function SwipeToDelete({ onDelete, children }: { onDelete: () => void; children: ReactNode }) {
const translateX = useSharedValue(0);
const pan = Gesture.Pan()
.onUpdate((event) => {
translateX.value = Math.min(0, event.translationX); // nur nach links wischen erlauben
})
.onEnd((event) => {
if (event.translationX < -150) {
translateX.value = withSpring(-400);
scheduleOnRN(onDelete); // eine JS-Thread-Funktion vom UI-Thread aus aufrufen
} else {
translateX.value = withSpring(0); // zurückschnappen
}
});
const animatedStyle = useAnimatedStyle(() => ({ transform: [{ translateX: translateX.value }] }));
return (
<GestureDetector gesture={pan}>
<Animated.View style={animatedStyle}>{children}</Animated.View>
</GestureDetector>
);
}
scheduleOnRN(fn, ...args) ersetzt runOnJS(fn)(...args), das in 4.x veraltet ist. Gesture.Pan() ist die Gesture-Handler-2-Builder-API, die Expo SDK 57 installiert; Gesture Handler 3 behält sie bei und fügt Hooks hinzu (usePanGesture({ onUpdate, onDeactivate }), wobei onStart/onEnd in onActivate/onDeactivate umbenannt sind).
Layout-Animationen
// components/AnimatedList.tsx — Elemente animieren automatisch ein/aus
import Animated, { FadeInDown, FadeOutLeft, LinearTransition } from "react-native-reanimated";
import { Pressable, Text } from "react-native";
type Item = { id: string; title: string };
export function AnimatedList({ items, onRemove }: { items: Item[]; onRemove: (id: string) => void }) {
return (
<Animated.FlatList
data={items}
keyExtractor={(item) => item.id}
itemLayoutAnimation={LinearTransition} // verbleibende Zeilen gleiten an Ort und Stelle; nur einzelne Spalte
renderItem={({ item, index }) => (
<Animated.View
entering={FadeInDown.delay(index * 100).springify()}
exiting={FadeOutLeft.duration(300)}
style={{ backgroundColor: "white", padding: 16, marginVertical: 4, borderRadius: 8 }}
>
<Text>{item.title}</Text>
<Pressable onPress={() => onRemove(item.id)}><Text style={{ color: "#dc2626" }}>Entfernen</Text></Pressable>
</Animated.View>
)}
/>
);
}
Scrollgesteuerte Animationen
// components/ParallaxHeader.tsx — Parallax-Effekt beim Scrollen
import Animated, {
useAnimatedScrollHandler, useSharedValue, useAnimatedStyle, interpolate, Extrapolation,
} from "react-native-reanimated";
import { Text } from "react-native";
export function ParallaxHeader() {
const scrollY = useSharedValue(0);
const scrollHandler = useAnimatedScrollHandler({
onScroll: (event) => { scrollY.value = event.contentOffset.y; },
});
const headerStyle = useAnimatedStyle(() => ({
height: interpolate(scrollY.value, [-100, 0, 200], [400, 300, 100], Extrapolation.CLAMP),
opacity: interpolate(scrollY.value, [0, 200], [1, 0.3], Extrapolation.CLAMP),
}));
return (
<>
<Animated.View style={[{ backgroundColor: "#2563eb" }, headerStyle]}>
<Text style={{ color: "white", fontSize: 28, fontWeight: "bold" }}>Wegelogbuch</Text>
</Animated.View>
<Animated.ScrollView onScroll={scrollHandler}>{/* Inhalt */}</Animated.ScrollView>
</>
);
}
Wenn nur der Offset benötigt wird, gibt useScrollOffset(animatedRef) (in 3.x useScrollViewOffset genannt) ihn als Shared Value ohne Handler zurück.
CSS-Übergänge und geteilte Elemente (Reanimated 4)
// eine Zustandsänderung animiert von selbst: kein Shared Value, kein Hook
<Animated.View
style={{
height: 80,
width: expanded ? 240 : 120,
backgroundColor: expanded ? "#16a34a" : "#2563eb",
transitionProperty: ["width", "backgroundColor"],
transitionDuration: 300,
}}
/>
// dasselbe Tag auf zwei Bildschirmen eines nativen Stacks animiert das Element zwischen ihnen
<Animated.Image sharedTransitionTag="trail-42-photo" source={{ uri: photoUrl }} style={{ width: 120, height: 120 }} />
Geteilte Elementübergänge sind in 4.x experimentell und standardmäßig deaktiviert. Aktiviere sie mit "reanimated": { "staticFeatureFlags": { "ENABLE_SHARED_ELEMENT_TRANSITIONS": true } } in der package.json der App (4.2+), dann die native App neu erstellen; statische Flags können in Expo Go nicht geändert werden.
Beispiele
Beispiel 1: Karten-Swipe-Interface erstellen
Benutzeraufforderung: "Erstelle ein Tinder-ähnliches Karten-Swipe-Interface mit flüssigen Animationen."
// components/SwipeCard.tsx
import Animated, { interpolate, useAnimatedStyle, useSharedValue, withSpring, withTiming } from "react-native-reanimated";
import { Gesture, GestureDetector } from "react-native-gesture-handler";
import { scheduleOnRN } from "react-native-worklets";
import { useWindowDimensions } from "react-native";
import type { ReactNode } from "react";
type Props = { children: ReactNode; onSwipe: (direction: "left" | "right") => void };
export function SwipeCard({ children, onSwipe }: Props) {
const { width } = useWindowDimensions();
const x = useSharedValue(0);
const y = useSharedValue(0);
const pan = Gesture.Pan()
.onUpdate((e) => { x.value = e.translationX; y.value = e.translationY; })
.onEnd((e) => {
if (Math.abs(e.translationX) > width * 0.3) {
const direction = e.translationX > 0 ? "right" : "left";
x.value = withTiming(Math.sign(e.translationX) * width * 1.5, { duration: 200 }, (finished) => {
if (finished) scheduleOnRN(onSwipe, direction); // Karte im React-Zustand entfernen
});
} else {
x.value = withSpring(0);
y.value = withSpring(0);
}
});
const style = useAnimatedStyle(() => ({
transform: [{ translateX: x.value }, { translateY: y.value }, { rotate: `${interpolate(x.value, [-width, 0, width], [-15, 0, 15])}deg` }],
}));
return (
<GestureDetector gesture={pan}>
<Animated.View style={style}>{children}</Animated.View>
</GestureDetector>
);
}
Ergebnis: Die Karte folgt dem Finger und neigt sich um bis zu 15°. Wird sie über 30% der Bildschirmbreite losgelassen, fliegt sie weg und onSwipe("left" | "right") wird auf dem JS-Thread ausgeführt; andernfalls springt sie in die Mitte zurück.
Beispiel 2: Animiertes Bottom Sheet
Benutzeraufforderung: "Erstelle ein Bottom Sheet, das hochgezogen werden kann und an Positionen einrastet."
// components/BottomSheet.tsx
import Animated, { useAnimatedStyle, useSharedValue, withSpring } from "react-native-reanimated";
import { Gesture, GestureDetector } from "react-native-gesture-handler";
import { useWindowDimensions } from "react-native";
import type { ReactNode } from "react";
export function BottomSheet({ children }: { children: ReactNode }) {
const { height } = useWindowDimensions();
const snapPoints = [height * 0.1, height * 0.5, height * 0.85]; // oberer Rand: offen, halb, Vorschau
const top = useSharedValue(snapPoints[2]);
const start = useSharedValue(0);
const pan = Gesture.Pan()
.onBegin(() => { start.value = top.value; })
.onUpdate((e) => { top.value = Math.max(snapPoints[0], start.value + e.translationY); })
.onEnd((e) => {
const projected = top.value + e.velocityY * 0.2; // wo der Wurf landen würde
const target = snapPoints.reduce((a, b) => (Math.abs(b - projected) < Math.abs(a - projected) ? b : a));
top.value = withSpring(target, { velocity: e.velocityY });
});
const style = useAnimatedStyle(() => ({ transform: [{ translateY: top.value }] }));
const sheet = { position: "absolute", left: 0, right: 0, top: 0, height, backgroundColor: "white" } as const;
return (
<GestureDetector gesture={pan}>
<Animated.View style={[sheet, style]}>{children}</Animated.View>
</GestureDetector>
);
}
Ergebnis: Das Sheet beginnt in der Vorschauposition, folgt dem Ziehen und springt beim Loslassen zum nächstgelegenen der drei Einrastpunkte, unter Berücksichtigung der Wurfgeschwindigkeit.
Richtlinien
- Shared Values für Animationszustand —
useSharedValuelebt auf dem UI-Thread; eine Änderung führt kein erneutes Rendern der Komponente durch useAnimatedStylefür dynamische Styles — wird auf dem UI-Thread neu berechnetwithSpringfür natürliche Bewegung —withTimingfür präzise Dauer. Version 4 hat die Spring-Standardwerte geändert (Dämpfung 120, Steifigkeit 900) und behandeltdurationals wahrnehmbar;Reanimated3DefaultSpringConfigstellt das alte Gefühl wieder herscheduleOnRNzum Aufruf von JS aus Worklets — eine Funktion übergeben, die im Komponenten- oder Modulbereich definiert wurde, nicht eine, die innerhalb des Worklets erstellt wurde- Gesture-Handler-Integration —
Gesture.Pan(),Gesture.Pinch()usw.; inline übergebene Callbacks werden automatisch workletisiert, ein in einer Variable gespeicherter Callback benötigt eine'worklet';-Direktive - Layout-Animationen sind deklarativ —
entering-,exiting-Props auf Animated-Komponenten interpolatezur Wertezuordnung — Scrollposition auf Opazität, Skalierung usw. abbilden;Extrapolation.CLAMPübergeben, um an den Bereichsgrenzen anzuhalten- Worklets-Babel-Plugin muss zuletzt kommen — und nach Änderung der Babel-Konfiguration den Metro-Cache leeren
- Keine großen Objekte in Worklets erfassen — erfasste Werte werden in die UI-Laufzeit kopiert; Shared Values, Primitive und kleine, einfache Objekte übergeben
- Upgrade von 3.x — zuerst die Neue Architektur aktivieren,
react-native-workletsinstallieren, das Babel-Plugin umbenennen unduseAnimatedGestureHandler,useWorkletCallbackundcombineTransitionersetzen, die entfernt wurden - Wann nicht verwenden — ein einmaliges Ein- oder Ausblenden, das nie blockiert, kann mit der eingebauten
Animated-API von React Native bleiben (CSS-Übergänge auf natives Systemen kommen von Reanimated selbst); Reanimated 4 kann nicht in einer App auf der alten Architektur installiert werden