Skip to content

Reanimated

@symbiote-native/reanimated brings react-native-reanimated 4.7 and react-native-worklets 0.13 to every SymbioteNative adapter. It is neither a native view wrapper like the slider nor a native module wrapper like sensors. The native half of Reanimated is not wrapped at all: it stays upstream’s own, in your app, and runs against the engine’s tree as it is.

What this package replaces is the React-only JS half, the hooks and the createAnimatedComponent wrapper. In their place are bindings to the engine that any framework can call.

Every adapter carries the whole export list of upstream 4.7.1, with upstream’s signatures. A test compares each name with the entry of each adapter. A name that upstream adds on a bump fails the build here before it reaches you.

Terminal window
npx @symbiote-native/cli new my-app --reanimated
npx @symbiote-native/cli add --reanimated # inside an existing app

The CLI layer installs the three packages and puts the worklets plugin last in babel.config.js. By hand, the app lists both native packages next to this one, pinned to the versions this release was built against:

Terminal window
npm install @symbiote-native/reanimated react-native-reanimated@4.7.1 react-native-worklets@0.13.0
// babel.config.js: the worklets plugin goes last
module.exports = {
presets: ['module:@react-native/babel-preset'],
plugins: ['react-native-worklets/plugin'],
};

Then run pod install in ios/, rebuild, and start Metro once with --reset-cache. react-native stays an explicit top-level dependency of the app, as for every SymbioteNative package.

A shared value lives on both threads. An animated style reads it inside a worklet and the UI thread repaints the node every frame, with no render on the JS side.

import { useEffect } from 'react';
import Animated, {
useSharedValue,
useAnimatedStyle,
withSpring,
} from '@symbiote-native/reanimated/react';
export function Box() {
const x = useSharedValue(0);
const style = useAnimatedStyle(() => {
'worklet';
return { transform: [{ translateX: x.value }] };
});
useEffect(() => {
x.value = withSpring(100);
}, [x]);
return <Animated.View className="box" style={style} />;
}

Animated.View, Animated.Text and Animated.Image are the host tags themselves, so a plain <view style={style} /> takes an animated style too.

Every adapter names the hooks exactly as React does. There is no create* or inject* form, because the worklet callback is upstream’s code and reads x.value the same way everywhere.

Reactive values in Vue, Svelte, Solid and Angular

Section titled “Reactive values in Vue, Svelte, Solid and Angular”

Setup runs once in these four frameworks. So a changing prop or signal is read inside the updater, the way the framework reads it: props.scale in Vue, Svelte and Solid, scale() for an Angular signal. The hook follows what the updater reads and starts the mapper again over a fresh copy of the closure when it changes.

React runs the component again on every render, so the updater closes over the latest props and there is nothing to follow by hand.

const style = useAnimatedStyle(() => {
'worklet';
return { opacity: visible ? 1 : 0 };
});

A value copied into a plain variable outside the updater is frozen (const visible = props.visible). That is those frameworks’ own rule, not a limit of the package. A reactive value cannot be followed in an event handler or a frame callback, so pass it through a shared value instead.

entering, exiting, layout and sharedTransitionTag work on the animated tags as upstream’s do. The prop names and the builders (FadeIn, FlipOutXDown, LinearTransition, Keyframe) are upstream’s. What differs per framework is only how a tag takes them.

import Animated, { FadeIn, FadeOut } from '@symbiote-native/reanimated/react';
{isShown && (
<Animated.View className="tile" entering={FadeIn} exiting={FadeOut} />
)}

Presets chain like upstream’s: FadeIn.delay(150).duration(400). A custom animation is a Keyframe, and layout takes the transitions (LinearTransition, FadingTransition, SequencedTransition, JumpingTransition, CurvedTransition, EntryExitTransition). LayoutAnimationConfig skips the entering animation of what mounts together with it.

Derived values, reactions, scroll and measure

Section titled “Derived values, reactions, scroll and measure”

These hooks have upstream’s signatures and behave the same in every adapter. What changes is where they are called and how the JS side keeps its state. Outside React every callback carries the 'worklet' directive, and Angular calls the hooks from a factory run in a field initializer.

import {
Extrapolation,
interpolate,
scrollTo,
runOnUI,
useAnimatedReaction,
useAnimatedRef,
useAnimatedScrollHandler,
useDerivedValue,
useSharedValue,
} from '@symbiote-native/reanimated/react';
import { scheduleOnRN } from 'react-native-worklets';
const progress = useSharedValue(0);
const [quarter, setQuarter] = useState(0);
// A value computed from another, on the UI thread
const angle = useDerivedValue(() =>
interpolate(progress.value, [0, 1], [0, 360], Extrapolation.CLAMP),
);
// A side effect when a value crosses a line, reported back to the JS thread
useAnimatedReaction(
() => Math.floor(progress.value * 4),
(now, before) => {
if (now !== before) scheduleOnRN(setQuarter, now);
},
);
// A scroll handler that writes to a shared value, and a ref the UI thread can scroll
const scrollRef = useAnimatedRef();
const onScroll = useAnimatedScrollHandler({
onScroll: event => {
progress.value = event.contentOffset.y / 400;
},
});
const toTop = () => runOnUI(() => { 'worklet'; scrollTo(scrollRef, 0, 0, true); })();

An animated ref goes to a scroll view as ref in React, Vue, Svelte and Solid, and as [animatedRef] on Angular’s AnimatedScrollView. The Components tabs below show each form.

useAnimatedProps writes a native prop that is not a style, such as the text of TextInput. That TextInput is exported next to Animated, because the adapters’ text input is a tag and there is no component to wrap.

The thread helpers scheduleOnUI, scheduleOnRN, scheduleOnRuntime and createWorkletRuntime come from react-native-worklets as in upstream. The older runOnUI and runOnJS names stay on this package.

A stylesheet runs on the UI thread through Reanimated’s CSS layer. These are wired: animation*, transition*, @keyframes (also from another file) and the onCSS* callbacks. So are the node states :hover, :focus, :focus-within, :active and :active-deepest.

@keyframes pulse {
from { opacity: 1; }
to { opacity: 0.4; }
}
.dot {
animation: pulse 1.2s ease-in-out infinite;
}
.bar {
transition: width 400ms ease-in-out;
}
.press:active {
opacity: 0.6;
}

The same through a style object, for a value computed at runtime:

import { css } from '@symbiote-native/reanimated/react';
const bounce = css.keyframes({
from: { transform: [{ translateY: 0 }] },
to: { transform: [{ translateY: -16 }] },
});
const styles = css.create({
ball: {
animationName: bounce,
animationDuration: '600ms',
animationDirection: 'alternate',
animationIterationCount: 'infinite',
animationTimingFunction: 'ease-in-out',
},
});

The style object and the onCSS* callbacks go on the node the way each framework writes a tag prop. The css helper is the same in all of them.

<Animated.View style={styles.ball} />
<Animated.View className="bar" onCSSTransitionEnd={() => setEnds(ends + 1)} />

A state works on the last compound of a selector only. :active here is Reanimated’s, not the press machine of Pressable. Do not put it on the same node as a style function that reads pressed.

The surface of upstream 4.7.1, name for name. @symbiote-native/reanimated is the core and holds everything with no component, ref or renderer in it. @symbiote-native/reanimated/<framework> adds what needs the framework and re-exports the core.

Same names and upstream signatures in /react, /vue, /svelte, /solid and /angular. Angular calls them in an injection context: a constructor, a field initializer, or runInInjectionContext.

Hook Signature Description
useSharedValue (initialValue: Value | (() => Value)) => SharedValue<Value> A value readable and writable on both threads; a function argument runs once for the initial
useDerivedValue (updater, dependencies?) => DerivedValue<Value> A read-only shared value recomputed on the UI thread whenever what its updater reads changes
useAnimatedStyle (updater, dependencies?) => AnimatedStyleHandle<Style> A style handle repainted from the UI thread; pass it as style of a tag
useAnimatedProps (updater, dependencies?, adapters?) => Partial<Props> Animated props that are not style, such as the text of a TextInput
useAnimatedReaction (prepare, react, dependencies?) => void Runs react(prepared, previous) on the UI thread when what prepare returns changes
useAnimatedRef () => AnimatedRef<TRef> A ref the UI thread can use with measure, scrollTo, dispatchCommand and setNativeProps
useAnimatedScrollHandler (handlers, dependencies?) => ScrollHandlerProcessed Worklet handlers for onScroll, onBeginDrag, onEndDrag and the momentum events
useScrollOffset (animatedRef, providedOffset?) => SharedValue<number> The scroll offset of a view as a shared value; useScrollViewOffset is the deprecated alias
useEvent (handler, eventNames?, rebuild?) => EventHandlerProcessed Builds a native event handler that runs as a worklet
useHandler (handlers, dependencies?) => UseHandlerContext The context and dependency tracking for a custom event hook built on useEvent
useComposedEventHandler (handlers) => ComposedHandlerProcessed Combines several processed handlers into one prop
useFrameCallback (callback, autostart?) => FrameCallback A callback on every frame, with setActive to start and stop it
useAnimatedSensor (sensorType, userConfig?) => AnimatedSensor Device sensor readings as a shared value
useAnimatedKeyboard (options?) => AnimatedKeyboardInfo The keyboard height and state as shared values
useReducedMotion () => boolean Whether the system asks for reduced motion
useTimestamp (isActive?) => SharedValue<number> A clock shared value; where setup runs once the flag is read once, so the clock pauses itself
Function Signature Description
withTiming (toValue, config?, callback?) => T Animates to a value over a duration with an easing
withSpring (toValue, config?, callback?) => T Animates to a value with a spring
withDecay (config, callback?) => number Continues a velocity and slows down, optionally between clamp limits
withDelay (delayMs, animation, reduceMotion?) => T Starts the animation after a pause
withRepeat (animation, numberOfReps?, reverse?, callback?, reduceMotion?) => T Repeats an animation; -1 repeats forever
withSequence (...animations) => T Runs animations one after another
withClamp ({ min, max }, animation) => T Keeps an animation inside a range
cancelAnimation (sharedValue) => void Stops the animation of a shared value where it stands
defineAnimation (starting, factory) => T Builds an animation of your own, which the functions above are made of

Spring presets for withSpring: GentleSpringConfig, SnappySpringConfig, WigglySpringConfig, Reanimated3DefaultSpringConfig. Each has a duration-based twin: GentleSpringConfigWithDuration, SnappySpringConfigWithDuration, WigglySpringConfigWithDuration and Reanimated3DefaultSpringConfigWithDuration.

Name Description
Easing The easing namespace, including Easing.bezier
cubicBezier, linear, steps Easing factories for CSS timing functions
interpolate (value, inputRange, outputRange, type?) => number
interpolateColor (value, inputRange, outputRange, colorSpace?, options?) in RGB, HSV or LAB
Extrapolation, Extrapolate What happens outside the input range: CLAMP, EXTEND, IDENTITY
clamp (value, min, max) => number
processColor, convertToRGBA, isColor Color parsing helpers
contrastColor The readable text color for a background
PlatformColor, DynamicColorIOS Platform colors that survive the worklet boundary

All five adapters export every component below. The tabs after the table show how each framework writes them.

Name Props of its own Description
Animated.View, Text, Image the tag props listed below The host tags themselves; every tag takes an animated style
Animated.TextInput, TextInput animatedProps A text input tag that takes animatedProps
Animated.ScrollView scrollViewOffset, a ref Asks for a scroll event every frame and writes its offset
Animated.FlatList itemLayoutAnimation, skipEnteringExitingAnimations, cellRendererComponentStyle A FlatList whose rows take layout animations
createAnimatedComponent none Returns the component it is given
createCSSAnimatedComponent none Returns the component it is given
LayoutAnimationConfig skipEntering, skipExiting Skips the entering and exiting animations of its subtree
SharedTransitionBoundary isActive Scopes the shared element transitions of its subtree
PerformanceMonitor smoothingFrames Shows a JS and a UI frame rate readout
ReducedMotionConfig mode Overrides the reduced motion mode for the app while it is mounted

In React and Solid the cell style prop is spelled CellRendererComponentStyle, as in React Native. Vue, Svelte and Angular spell it cellRendererComponentStyle.

Props on a tag: entering, exiting, layout, animatedProps, sharedTransitionTag, sharedTransitionStyle, and the CSS callbacks onCSSAnimationStart, onCSSAnimationEnd, onCSSAnimationIteration, onCSSAnimationCancel, onCSSTransitionRun, onCSSTransitionStart, onCSSTransitionEnd and onCSSTransitionCancel.

import Animated, {
FadeIn,
LayoutAnimationConfig,
LinearTransition,
PerformanceMonitor,
ReduceMotion,
ReducedMotionConfig,
SharedTransitionBoundary,
} from '@symbiote-native/reanimated/react';
<ReducedMotionConfig mode={ReduceMotion.System} />
<PerformanceMonitor />
<LayoutAnimationConfig skipEntering skipExiting>
<Animated.View className="tile" entering={FadeIn} />
</LayoutAnimationConfig>
<SharedTransitionBoundary isActive={isFirst}>
<Animated.View className="box" sharedTransitionTag="box" />
</SharedTransitionBoundary>
<Animated.ScrollView ref={scrollRef} scrollViewOffset={offset} onScroll={onScroll}>
{rows.map(row => <view key={row} className="row" />)}
</Animated.ScrollView>
<Animated.FlatList
data={rows}
keyExtractor={keyOf}
renderItem={renderRow}
itemLayoutAnimation={LinearTransition}
CellRendererComponentStyle={tintOfRow}
skipEnteringExitingAnimations
/>
Group Names
Fade FadeIn, FadeInRight, FadeInLeft, FadeInUp, FadeInDown, FadeOut, FadeOutRight, FadeOutLeft, FadeOutUp, FadeOutDown
Slide SlideInRight, SlideInLeft, SlideInUp, SlideInDown, SlideOutRight, SlideOutLeft, SlideOutUp, SlideOutDown
Zoom ZoomIn, ZoomInRotate, ZoomInLeft, ZoomInRight, ZoomInUp, ZoomInDown, ZoomInEasyUp, ZoomInEasyDown, ZoomOut, ZoomOutRotate, ZoomOutLeft, ZoomOutRight, ZoomOutUp, ZoomOutDown, ZoomOutEasyUp, ZoomOutEasyDown
Bounce BounceIn, BounceInDown, BounceInUp, BounceInLeft, BounceInRight, BounceOut, BounceOutDown, BounceOutUp, BounceOutLeft, BounceOutRight
Flip FlipInXUp, FlipInYLeft, FlipInXDown, FlipInYRight, FlipInEasyX, FlipInEasyY, FlipOutXUp, FlipOutYLeft, FlipOutXDown, FlipOutYRight, FlipOutEasyX, FlipOutEasyY
Stretch StretchInX, StretchInY, StretchOutX, StretchOutY
Rotate RotateInDownLeft, RotateInDownRight, RotateInUpLeft, RotateInUpRight, RotateOutDownLeft, RotateOutDownRight, RotateOutUpLeft, RotateOutUpRight
LightSpeed LightSpeedInRight, LightSpeedInLeft, LightSpeedOutRight, LightSpeedOutLeft
Pinwheel PinwheelIn, PinwheelOut
Roll RollInLeft, RollInRight, RollOutLeft, RollOutRight
Layout transitions LinearTransition, FadingTransition, SequencedTransition, JumpingTransition, CurvedTransition, EntryExitTransition, Layout
Custom Keyframe, ReanimatedKeyframe, SharedTransition
Builders BaseAnimationBuilder, ComplexAnimationBuilder; chain .duration(), .delay(), .springify(), .easing(), .withCallback() and the rest from upstream
Name Signature Description
measure (animatedRef) => MeasuredDimensions | null Size and position of a view, called from a worklet
scrollTo (animatedRef, x, y, animated) => void Scrolls a view from a worklet
dispatchCommand (animatedRef, command, args?) => void Sends a native command such as focus to a view
setNativeProps (animatedRef, props) => void Writes props to a view from the UI thread
getRelativeCoords (animatedRef, absoluteX, absoluteY) => ComponentCoords | null Converts page coordinates to the coordinates inside a view
setGestureState (handlerTag, newState) => void Sets the state of a gesture handler by tag
getViewProp (viewTag, propName, component?) => Promise<T> Reads a prop back from the native side; needs the component on Fabric
runOnUI, runOnJS (fn) => (...args) => void Run a function on the UI runtime, or call back to the JS thread
runOnRuntime, createWorkletRuntime (workletRuntime, worklet) => WorkletFunction Run a worklet on a worklet runtime of your own
executeOnUIRuntimeSync (fn) => (...args) => R Run on the UI runtime and wait for the result
isWorkletFunction, makeShareableCloneRecursive see upstream Check a worklet, or make a value shareable between runtimes
makeMutable, isSharedValue (initial) => Mutable, (value) => boolean A shared value outside a hook; a guard for one
startMapper, stopMapper see upstream The mapper that keeps shared values and styles in step; the hooks use it for you
createAnimatedPropAdapter (adapter, nativeProps?) Adapts props for useAnimatedProps

These come from react-native-worklets, which the app already lists. Import them from there, as the Reanimated docs do. The older runOnUI, runOnJS and runOnRuntime stay on this package too.

Name Signature Description
scheduleOnUI (worklet, ...args) => void Runs a worklet on the UI runtime without waiting
scheduleOnRN (fun, ...args) => void Calls a JS function on the React Native runtime from a worklet
scheduleOnRuntime, scheduleOnRuntimeWithId (runtime, worklet, ...args) => void Runs a worklet on a worklet runtime without waiting
runOnUISync (worklet, ...args) => ReturnValue Runs on the UI runtime and returns the result
runOnUIAsync (worklet, ...args) => Promise<ReturnValue> Runs on the UI runtime and resolves with the result
runOnRuntimeSync, runOnRuntimeSyncWithId (runtime, worklet, ...args) => ReturnValue Runs on a worklet runtime and returns the result
runOnRuntimeAsync, runOnRuntimeAsyncWithId (runtime, worklet, ...args) => Promise<ReturnValue> Runs on a worklet runtime and resolves with the result
createWorkletRuntime (config?) => WorkletRuntime Creates a worklet runtime of your own
isWorkletFunction (value) => boolean Tells whether a function is a worklet
getRuntimeKind, RuntimeKind () => RuntimeKind Which kind of runtime the code runs on
isUIRuntime, isRNRuntime, isWorkerRuntime () => boolean Which runtime the code runs on, as a plain check
createSerializable, createSynchronizable (value) => ref Make a value that can cross between runtimes

Types: WorkletFunction, WorkletRuntime.

Name Description
configureReanimatedLogger, ReanimatedLogLevel Sets the level and strictness of Reanimated’s own warnings
enableLayoutAnimations Turns layout animations on or off
getStaticFeatureFlag Reads a flag baked into the native build
getDynamicFeatureFlag, setDynamicFeatureFlag Reads or sets a flag at runtime
ReduceMotion System, Always or Never, taken by animation functions
reanimatedVersion, isReanimated3, isConfigured Version and setup checks
getUseOfValueInStyleWarning Returns the text of the warning about a shared value used directly in a style
NativeEventsManager Upstream’s attach and detach logic; the engine’s own event binding does not use it

Enums: InterfaceOrientation, IOSReferenceFrame, KeyboardState, SensorType, LayoutAnimationType.

ScreenTransition, startScreenTransition and finishScreenTransition are exported with upstream’s signatures. They are not tied to @symbiote-native/navigation yet.

setUpTests, withReanimatedTimer, advanceAnimationByTime, advanceAnimationByFrame and getAnimatedStyle are upstream’s Jest helpers. The package’s own tests run under vitest, so use them only where your runner provides what they expect.

Every type of upstream’s entry is exported. The ones you will name most are SharedValue, DerivedValue, AnimatedRef, AnimatedStyle, AnimatedProps, WithTimingConfig, WithSpringConfig, WithDecayConfig, EntryOrExitLayoutType, ILayoutAnimationBuilder, ExitAnimationsValues, EntryAnimationsValues, LayoutAnimationsValues, ScrollEvent, MeasuredDimensions, FrameInfo, WorkletRuntime, AnimatableValue and CSSAnimationKeyframes. The full list, from the entry file:

AnimatableValue AnimatableValueObject AnimatedKeyboardInfo AnimatedKeyboardOptions AnimatedProps
AnimatedRef AnimatedScreenTransition AnimatedScrollViewProps AnimatedSensor AnimatedStyle
AnimatedTransform Animation AnimationCallback AnimationObject BaseLayoutAnimationConfig
CSSAnimationCallback CSSAnimationDelay CSSAnimationDirection CSSAnimationDuration CSSAnimationEvent
CSSAnimationFillMode CSSAnimationIterationCount CSSAnimationKeyframeSelector CSSAnimationKeyframes
CSSAnimationPlayState CSSAnimationProperties CSSAnimationSettings CSSAnimationTimingFunction
CSSCallbackProps CSSGradientStop CSSKeyframesRule CSSLinearGradientProps CSSPseudoSelectorKey
CSSRadialGradientProps CSSStyle CSSTransitionCallback CSSTransitionDelay CSSTransitionDuration
CSSTransitionEvent CSSTransitionProperties CSSTransitionProperty CSSTransitionSettings
CSSTransitionShorthand CSSTransitionTimingFunction ComponentCoords DecayAnimation DelayAnimation
DerivedValue EasingFunction EasingFunctionFactory EntryAnimationsValues EntryExitAnimationFunction
EntryOrExitLayoutType EventHandler EventHandlerProcessed ExitAnimationsValues ExtrapolationConfig
ExtrapolationType FlatListPropsWithLayout FrameCallback FrameInfo GoBackGesture IEntryExitAnimationBuilder
ILayoutAnimationBuilder InterpolateHSV InterpolateRGB InterpolationOptions KeyframeProps LayoutAnimation
LayoutAnimationFunction LayoutAnimationStartFunction LayoutAnimationsValues LogData LogFunction
LoggerConfig MeasuredDimensions ParsedColorArray PerformanceMonitorProps ReanimatedEvent RepeatAnimation
ScreenTransitionConfig ScrollEvent ScrollHandler ScrollHandlerProcessed ScrollHandlers SensorConfig
SequenceAnimation SharedTransitionBoundaryProps SharedValue SpringAnimation StyleLayoutAnimation
StyleProps TimingAnimation TransformArrayItem UseHandlerContext Value3D ValueRotation WithDecayConfig
WithSpringConfig WithTimingConfig WorkletRuntime
  • Checked on an iOS simulator and on Android, in all five adapters (Vue in both TSX and SFC form).
  • Shared element transitions follow Reanimated’s own flag, off by default (see Installation).
  • animatedProps takes handles only. Upstream also copies a plain object into static props, which a normal prop does as well.
  • useTimestamp(isActive) reads its flag once in the frameworks where setup runs once.
  • A CSS state used in a style with no package registered throws in a dev bundle and the property is ignored in a release one.
  • react-native-gesture-handler is a separate package and is not part of this one.
  • “Failed to create a worklet”, or the hook throws that it needs a worklet. The worklets plugin is missing from babel.config.js, or it is not the last entry. Put react-native-worklets/plugin last, then restart Metro with --reset-cache, since a stale cache keeps the old transform.
  • “Native part of Reanimated doesn’t seem to be initialized”, or a mismatch between the JS and the native version. The app was not rebuilt after the install or an upgrade. Run pod install and rebuild; the JS, the native code and the plugin must all come from the same minor version.
  • “Unable to find a specification for RNWorklets” on iOS, or “Unable to resolve module react-native-worklets”. react-native-worklets is not installed. Add the version this release lists in its peers, ~0.13.0, next to react-native-reanimated ~4.7.1.
  • The box jumps instead of animating. Assigning x.value = 100 sets the value at once. Assign the result of an animation function: x.value = withTiming(100).
  • The style does not follow a prop in Vue, Svelte, Solid or Angular. The prop is read outside the updater, so only its first value reached the UI thread. Read it inside the updater, or move it into a shared value.
  • Shared element transitions do nothing. The ENABLE_SHARED_ELEMENT_TRANSITIONS flag is off. It is part of the native build, so a rebuild is needed after you set it.
  • [entering] fails to compile in an Angular template. A host tag takes layout animations only through [symbioteHostProps]; imports lists classes, never a tag name.
  • “Reduced motion setting is enabled on this device”. It is a development warning and safe to ignore. Silence it with LogBox.ignoreLogs, or turn the setting off on the device.
  • An exiting animation never plays, or an animation jumps to its end, on one device. The system’s reduced motion setting is on. Then withTiming and withSpring return the target value at once, an entering animation reaches its end instantly, and exiting animations and shared transitions are omitted. Pass ReduceMotion.Never to the animations that must always run, such as FadeIn.reduceMotion(ReduceMotion.Never), and use useReducedMotion() to choose a gentler one.
  • A tile with entering flickers on iOS when its animated style returns a transform. Reported in Reanimated 4 and open upstream. Upstream advises against animating the same properties with a layout animation and an animated style on one node. Put the layout animation on a wrapper view instead.
  • A release build with a development bundle fails. Reanimated does not support that pairing; bundle in release mode too.
  • Does createAnimatedComponent wrap my component? No, it returns the component you give it. Tags are already animated, so there is nothing to wrap.

Sources: Reanimated troubleshooting, Reanimated accessibility guide, Reanimated compatibility table, software-mansion/react-native-reanimated#4737, software-mansion/react-native-reanimated#7354.

@symbiote-native/reanimated ships no native code. The native half of Reanimated and Worklets stays upstream’s and is listed in your app, so the app’s own autolinking picks it up.

The JS half is split in two. Everything without a component, ref or renderer in it is upstream’s code, re-exported: animations, easing, interpolation, colors, the layout animation builders, the worklets API. The hooks are the package’s own thin controllers over upstream’s *Common helpers, bound to the engine instead of to a React component.

packages/reanimated/src/
├── core/ shared controllers over the upstream helpers, no framework in them
├── register.ts the engine claims, imported bare so a release build keeps them
├── react/ hooks/ @symbiote-native/reanimated/react
├── vue/ composables/ @symbiote-native/reanimated/vue
├── svelte/ runes/ @symbiote-native/reanimated/svelte
├── solid/ primitives/ @symbiote-native/reanimated/solid
└── angular/ services/ @symbiote-native/reanimated/angular

Animated.View is the host tag itself. So an animated style, entering and the CSS props reach the node through the engine’s prop claim, which takes those props out of the Fabric payload and hands them to Reanimated. That is why the same node works in every framework (see how it works).

A framework whose setup runs once follows what an updater reads and restarts the mapper over a fresh copy of the closure. This is why a value read outside the updater is frozen.