March 22, 2026·10 min read

Reanimated: when the dependency is worth it

LayoutAnimation and the built-in Animated API get you far. Reanimated shines when you’re driving gestures on the UI thread and `useNativeDriver: true` isn’t enough. Don’t add it for a single opacity fade. Add it when profiling proves JS-thread animation is the bottleneck.

Bundle and native cost

Every heavy native dep is an upgrade tax. If design wants one fancy swipe, prototype with JS first; upgrade when frames drop.

Read breaking changes before major RN upgrades.

Worklets mentally

Code that runs in worklets has constraints—no arbitrary closures, know what’s shareable. The docs errors are usually telling the truth.

Keep gesture logic colocated with the component that owns the gesture.

Fallbacks

Reduce motion settings exist; respect system accessibility preferences when you animate for delight.

Test on Android; timing often differs from iOS.

Green flags for adopting Reanimated

You have interactive gestures that must stay at 60fps while JS is busy, shared element–style transitions tied to scroll position, or animations that cannot be expressed cleanly with Animated alone after a spike. Red flags: you only need opacity on a button, the team has no one comfortable debugging native build failures, or you have not profiled yet.

Budget upgrade time each RN release—animation libraries are high-churn compared to pure JS utilities.

Profiling before adopting

Measure frame rates and JS thread load on target interactions. If JS is idle during gestures, Reanimated may be unnecessary. If UI thread struggles, dig into native view updates before jumping to worklets. Use Flipper or platform tools appropriate to your versions—methodology evolves with RN releases.

Worklet constraints in practice

Understand shared values, closures, and threading rules—errors can be cryptic. Keep worklets small and test on both platforms; Android timing differs. Avoid capturing large objects accidentally. Version-pin Reanimated with compatible Gesture Handler releases to reduce mismatch bugs.

Bundle size and native upgrade costs

Every native dependency complicates Xcode and Gradle upgrades. Budget maintenance time each RN bump. Communicate costs to product when animations are ‘nice-to-have.’ Consider simpler animations if schedules are tight—shipping matters.

Accessibility and motion reduction

Respect reduced motion preferences—provide simplified transitions. Ensure gestures have non-gesture alternatives where needed for accessibility. Test with VoiceOver/TalkBack focus moves during animated transitions.

Fallbacks when worklets fail

Feature-flag complex animations; provide degraded experience if native module fails to load in rare edge cases. Log initialization errors distinctly. Do not block critical flows on animation success.

Team skills and documentation

Train multiple engineers on Reanimated basics—bus factor should not be one. Maintain internal examples for common patterns. Link upstream issue trackers when you hit framework bugs; contribute minimal reproductions to help fixes land faster.

Decision recap

Adopt when profiling proves UI-thread animation need, team can maintain native deps, and product values the polish. Skip when simple Animated API suffices or deadlines disallow learning curve. Revisit after major RN releases—defaults and best practices shift.

Shipping and reliability habits (1)

ScrollView versus FlatList is a data-volume question. Small static content belongs in ScrollView; long feeds belong in virtualized lists. Nested scrollables need explicit height contracts—redesign beats fighting physics. Document intentional choices so future refactors do not ‘optimize’ blindly.

Metro cache issues masquerade as logic bugs. Establish a documented reset ladder: dev server restart, cache flags, Watchman, derived data, then dependency reinstalls. Compare platforms when only one breaks—native steps diverge. Keep CI caches deterministic with lockfiles and pinned toolchains.

Platform differences worth rehearsing (2)

Accessibility is compatibility. Labels, focus order, and dynamic type are not polish—they determine whether users can complete tasks at all. Test with VoiceOver and TalkBack on hardware; simulators miss focus bugs. When designs prioritize minimalism, negotiate text alternatives for icon-only controls. Accessibility regressions often follow navigation redesigns—add checklist items to those PRs specifically.

Internationalization is a product feature, not a string swap. Plural rules, RTL layout, and locale-aware formatting change behavior—not just copy length. Pseudolocale helps find clipping early, but real Arabic and German QA catches nuance. Avoid concatenating translated fragments; context matters. Document glossary terms so translators do not invent inconsistent product names.

Security, privacy, and data handling (3)

Storage is not a database. AsyncStorage and MMKV excel at key-value preferences; SQLite or remote APIs belong elsewhere for relational data. Migrations should be incremental, logged, and non-blocking for UI. Secure tokens need secure storage when your model demands it—speed is not a substitute for correctness on auth material.

WebViews are untrusted browsers inside your app. Validate `postMessage` payloads, lock navigation to expected hosts, and prefer system-browser auth flows when OAuth security demands it. Third-party JavaScript can change without your deploy—treat XSS in web as bridge compromise risk. Clear storage on logout and rate-limit message handlers.

Performance and measurement discipline (4)

JWT and session refresh flows need single-flight refresh, clear logout semantics, and secure storage for refresh tokens when appropriate. Parallel 401s should not stampede refresh endpoints. Clock skew and biometrics policies belong in explicit product decisions, not accidental implementation details.

In-app purchases require server validation, restore flows, and support tooling that respects privacy. Sandbox quirks are normal—budget QA time. Subscriptions interact with family sharing, regional pricing, and refunds; engineering must stay aligned with finance and legal narratives users see in receipts.

Team process and long-term maintenance (5)

Background execution policies change with OS updates—revalidate after major iOS and Android releases. Misused background modes invite rejection. Persist user work frequently; the OS can kill you anytime after backgrounding. Uploads and timers should tolerate pause and resume without corrupting state.

Design tokens and semantic colors make dark mode and rebrands feasible. Mixing three styling systems doubles migration cost—pick a primary approach and draw boundaries. Runtime CSS-in-JS can cost frame time on hot screens—profile before adopting wholesale.

Shipping and reliability habits (6)

Performance work should start with measurement, not instinct. Watch JS thread versus UI thread separately; they bottleneck differently. Lists, images, and animations dominate most regressions—optimize those before micro-optimizing pure functions. Hermes, JSC, and bridge internals evolve; re-profile after every major upgrade instead of trusting last year’s numbers. Battery and thermal throttling on mid devices reveal issues flagship phones hide.

Security and privacy expectations move faster than roadmaps. Treat analytics, crash, and attribution SDKs as part of your threat model: initialize them deliberately, document data flows, and verify ‘off’ truly stops network calls. Client-side secrets are public secrets—anything shipped in an APK or IPA should be assumed extractable. Pair mobile changes with backend policies so authorization remains consistent across platforms.

Platform differences worth rehearsing (7)

Images and maps look simple in mocks and expensive in production. Decode sizes should match display sizes; static map thumbnails are not interchangeable with interactive MapView gestures. Quotas, API keys, and offline behavior need explicit fallbacks—addresses as text, retry buttons, and calm error copy. Monitor vendor dashboards for spikes that indicate bugs or abuse.

Error boundaries catch render failures, not native crashes or async mistakes. Pair them with platform crash reporting and structured client logs. Fallback UI should include build identifiers and humane copy—never raw stack traces for end users. Test fallbacks with screen readers; a broken error screen is still broken UX.

Security, privacy, and data handling (8)

FlatList performance is configuration as much as code. Stable keys, reasonable `windowSize`, and memoized rows beat switching to a different list primitive blindly. Nested virtualized lists are a last resort—redesign first. Profile with production-like data volumes; dev placeholders lie.

Splash screens and launch gates should reflect honest readiness: fonts, theme, session, critical remote config—not every SDK under the sun. Infinite splash is worse than a slightly longer branded hold. Match native and JS background colors to avoid flashes; respect reduced motion for animations.

Performance and measurement discipline (9)

Analytics schema governance prevents warehouse disasters: version events, avoid high-cardinality strings, and align names across iOS, Android, and web. Consent gating must stop network calls, not just UI. Separate dev and prod projects to avoid polluting dashboards.

Testing onboarding changes with funnel metrics beats debating opinions. Segment by acquisition channel and platform; back behavior differs. Skip paths must be genuine—dark patterns may win short metrics and destroy brand trust. Localization length tests prevent clipped CTAs in verbose languages.

Team process and long-term maintenance (10)

Helper modules concentrate glue code—storage, navigation, permissions—so screens stay readable. Split helpers by topic before files become merge-conflict magnets, and document each module’s contract. Good helpers answer ‘where do we save tokens?’ in one glance—not ‘ask Sarah.’

Shipping React Native features is less about any single API and more about the system around it: typed boundaries, predictable navigation, and telemetry that tells you what broke in production. Prefer boring, explicit modules over clever metaprogramming that the next hire cannot grep. When platform vendors change behavior in point releases, your defense is automated smoke tests on real devices and a short internal changelog of native assumptions you rely on.

Shipping and reliability habits (11)

Reanimated and gesture libraries earn their place when profiling proves UI-thread work and your team can maintain native upgrades. Worklets have constraints—read errors carefully. Respect reduced motion and test Android timing differences—identical JS does not guarantee identical feel.

Platform differences worth rehearsing (12)

Environment variables should be classified: public-by-design, sensitive-with-mitigations, or never-on-device. `EXPO_PUBLIC_` values are extractable—treat them that way. Align env handling across EAS profiles and local dev; fail fast when keys are missing instead of shipping undefined behavior.

Security, privacy, and data handling (13)

Performance and measurement discipline (14)

Push notifications walk a line between helpful and intrusive. Prime users with context, respect notification channels on Android, and measure opt-outs after campaigns—spikes mean copy or frequency problems. Payload design affects background behavior; test killed and locked-device states. Tokens belong server-side with rotation strategies; never treat the client as authoritative for subscription state.

Team process and long-term maintenance (15)

OTA updates are powerful and risky: runtime compatibility, rollback plans, and user-visible behavior changes need governance. Channels should map to release maturity—staging versus production—with access controls on publish credentials. Large assets over cellular need care; silent failures erode trust more than a frank ‘update failed, retry’ message.

Keyboard and form UX separate polished apps from ‘works on desktop simulators.’ Platform differences in soft input modes matter; test smallest phones and Android gesture navigation. Primary actions must remain reachable when the keyboard is visible—scroll containers and keyboard controllers exist because this problem is universal.

Shipping and reliability habits (16)

Privacy nutrition labels and Play Data Safety forms should reflect actual SDK behavior—inventory dependencies each release and remove dead code. Drift between claims and telemetry is legal and store risk, not just embarrassment. Involve legal early when adding analytics or ads.

Poursuivre la lecture

Plus récentToken refresh on mobile without random logouts Plus ancienImages: caching and placeholders that feel intentional

Structure du projet → · Utilitaires d’app →