React Native's Evolution: From Bridge to New Architecture
When Meta open-sourced React Native in 2015, it solved a real problem — shipping iOS and Android from a single JavaScript codebase — but it did so through an asynchronous bridge. Every communication between JavaScript and native had to be serialized to JSON, passed across a thread boundary, deserialized, and executed. For simple apps it worked. For complex, animation-heavy, or data-intensive apps, the bridge became the bottleneck that defined React Native's reputation for the better part of a decade.
By 2026, that reputation is obsolete. Meta's multi-year re-architecture project — officially the "New Architecture" — replaced the bridge with three pillars: Fabric (a synchronous, concurrent-rendering engine), TurboModules (lazy-loading, type-safe native modules), and Hermes (a purpose-built JavaScript engine with ahead-of-time bytecode compilation). The bridge is gone. In its place: the JavaScript Interface (JSI), a synchronous C++ API that lets JavaScript call native code directly, with zero serialization overhead.
- React Native 0.68 (2022): Opt-in New Architecture for early adopters
- React Native 0.72 (2023): Fabric stable, TurboModules stable, Hermes default
- React Native 0.74 (2024): New Architecture feature-complete and battle-tested at Meta scale
- React Native 0.76 (2024): New Architecture becomes the default for all new projects
- React Native 0.78+ (2025-2026): Legacy bridge fully deprecated; ecosystem libraries migrate
- 2026 state: New Architecture is the baseline — the old bridge is a historical footnote
The scale of what runs on this architecture today is staggering. Instagram, Facebook, Messenger, WhatsApp's web client, Shopify's merchant apps, Microsoft Office Mobile, Discord, Pinterest, Bloomberg, Coinbase, and tens of thousands of smaller apps all depend on it. Combined monthly actives exceed three billion — more than any single native platform's user base.
The New Architecture isn't about catching up to native — it's about giving React developers capabilities native platforms don't offer natively themselves: hot reload, over-the-air updates, concurrent rendering, and a unified programming model across iOS, Android, and web.
— Meta React Native Team, 2026
Fabric Renderer: Synchronous, Concurrent, Native
Fabric is React Native's new rendering system, and it is the single most consequential change in the framework's history. Where the old UIManager batched view updates across the async bridge and processed them on a separate thread, Fabric renders synchronously on the UI thread using a C++ core shared between iOS and Android.
Synchronous Layout and Effects
Fabric computes layout and applies view mutations in the same frame that JavaScript requested them. Reading a measured view height and immediately animating based on it is now possible without a frame delay. This unlocks interaction patterns — sticky headers that track scroll exactly, gesture-driven reveals, synchronized keyboard avoidance — that were previously impossible or janky.
Concurrent Rendering (React 18+)
Fabric integrates React 18's concurrent features: Suspense boundaries, transitions, deferred values, and automatic batching. You can mark expensive state updates as non-urgent so the UI thread prioritizes user input over background work. This is the same rendering model as React on the web — the mental model is now truly unified.
Cross-Platform C++ Core
The layout engine, shadow tree, and diffing logic are implemented in a single C++ codebase shared between iOS and Android. This eliminates the historical drift where Android and iOS would render the same component slightly differently due to platform-specific renderer bugs. One codebase, two platforms, identical behavior.
View Flattening and Optimizations
Fabric automatically flattens view hierarchies where possible — a View wrapping a Text wrapping a Text can collapse into a single native view, reducing the view count that iOS UIKit or Android's View system has to manage. On list-heavy screens, this cuts memory usage by 15-30% and improves scroll performance measurably.
- Fabric replaces the async bridge with synchronous JSI calls
- Layout runs on the UI thread for same-frame reads and writes
- React 18 concurrent features (Suspense, transitions, useDeferredValue) work end-to-end
- Single C++ core eliminates iOS vs Android rendering inconsistencies
- Automatic view flattening cuts hierarchy overhead 15-30%
- Core Animation (iOS) and the Android view system receive direct, typed commands
TurboModules: Lazy, Typed, Direct
If Fabric is the view layer's re-architecture, TurboModules is the native module system's. Before 2022, every native module — the camera, file system, crypto, analytics SDKs — had to be registered and initialized at app startup. The app spent hundreds of milliseconds instantiating modules the user might never touch.
TurboModules fixes this with three core changes: lazy initialization, type-safe contracts, and direct JSI access.
Lazy Initialization
Native modules are only instantiated the first time JavaScript imports and uses them. An app that depends on 50 libraries but only calls 10 at startup pays the initialization cost for 10, not 50. Cold start time drops 30-50% on apps with heavy native dependency trees.
Codegen and Type Safety
TurboModules use a TypeScript-based interface definition. At build time, codegen produces strongly-typed C++ bindings, Objective-C++ headers, and Kotlin/Java interfaces from a single source of truth. A type mismatch between JavaScript and native code now fails at build time instead of crashing at runtime in production.
JSI Direct Access
TurboModule methods are invoked via the JavaScript Interface — a synchronous C++ API that allows JavaScript to hold references to native objects and call their methods without serialization. Synchronous functions, like reading secure storage or a setting, return in microseconds instead of milliseconds. Asynchronous operations (network, file I/O) still return Promises but without bridge overhead.
| Dimension | Legacy Native Modules | TurboModules |
|---|---|---|
| Initialization | Eager at app start | Lazy on first use |
| Type Safety | Untyped JSON serialization | Codegen-enforced types |
| Call Overhead | Bridge + JSON serialize/parse | Direct JSI — near-zero |
| Sync Support | No — everything is async | Yes — sync methods allowed |
| Error Surface | Runtime crashes in production | Build-time type errors |
| Memory | All modules resident | Loaded on demand |
The ecosystem has caught up. React Navigation, Reanimated 3, Gesture Handler, MMKV, react-native-skia, Expo modules, and virtually every Shopify-maintained package ship as TurboModules in 2026. Migrating a legacy native module typically takes an afternoon.
Hermes: Meta's JavaScript Engine for Mobile
JavaScript engines matter more on mobile than anywhere else. Battery, memory, and startup time are all finite, and a general-purpose engine like JavaScriptCore (iOS) or V8 (used in some Android builds) wasn't optimized for the specific workloads React Native apps produce. Meta built Hermes to close that gap.
Ahead-of-Time Bytecode Compilation
Hermes compiles JavaScript to its own bytecode at build time, not at startup. The app bundle ships pre-compiled — there's no parsing or JIT warmup cost when the app launches. Startup times on mid-range Android devices improved 40-60% when Hermes replaced JSC as the default.
Smaller Memory Footprint
Hermes is tuned for the specific set of ECMAScript features React Native apps actually use. The engine binary and runtime memory use are 20-35% smaller than JavaScriptCore on equivalent workloads. For apps running on budget Android devices with 2-3GB of RAM, this is the difference between smooth and crashing.
Built-In Profiler and Debugger
Hermes ships with a Chrome DevTools-compatible debugger and a sampling profiler designed for mobile's constraints. You can profile a production build on a real device and see flame graphs of where JavaScript time is spent — something that was painful or impossible with JSC.
Static Hermes (2025-2026)
Meta's next step, Static Hermes, adds optional typed compilation. When Hermes can prove types statically (from TypeScript annotations or type inference), it generates specialized bytecode that runs 2-10x faster than untyped JS. Early adopters report numeric code and hot business-logic paths running at near-native speeds.
- Hermes is the default JS engine for React Native 0.70+ on both iOS and Android
- AOT bytecode: no parse or JIT warmup at startup — 40-60% faster cold start
- Memory footprint 20-35% smaller than JavaScriptCore
- Chrome DevTools debugger and sampling profiler ship with the engine
- Static Hermes (2025-2026): typed compilation for 2-10x speedups on hot paths
- Reduced crash rates on low-memory Android devices — crucial for emerging markets
React Native Web: One Codebase, Every Platform
The most underrated story in React Native's 2026 trajectory is React Native Web. What started as a community project by Nicolas Gallagher at Twitter has become the default way many large teams ship iOS, Android, and web from a single codebase.
React Native Web takes the same View, Text, Image, ScrollView, and FlatList primitives that render to UIKit on iOS and android.view on Android, and renders them to HTML and CSS in the browser. Flexbox layout, gesture handling, accessibility semantics, and the React programming model are identical across all three platforms. Platform-specific code is opt-in, not mandatory.
Shopify: Admin Across Mobile and Web
Shopify's merchant admin — the interface millions of store owners use daily — is built with React Native Web. Mobile iOS, mobile Android, and the web admin all share 80%+ of their codebase. A feature shipped on one platform ships on all three at the same time, with platform conventions applied through the Platform API and media queries.
Microsoft: Office, Teams, and Beyond
Microsoft Office Mobile uses React Native for iOS and Android, and React Native Web for the web-based Office Lens and document viewers. Microsoft's internal framework, React Native for Windows and React Native for macOS, extends the same codebase to desktop. A single codebase now spans six platforms at Microsoft.
Discord: Messaging Across Everything
Discord's desktop app, web app, and mobile clients share a React Native + React Native Web codebase. The result is feature parity across platforms — new emoji reactions, voice features, or UI changes ship simultaneously everywhere. Engineering headcount scales linearly with features, not with platforms.
| Platform Pair | Typical Code Sharing | Primary Use Case |
|---|---|---|
| iOS + Android | 85-95% | Base React Native — business logic, UI primitives |
| Mobile + Web | 70-90% | React Native Web — admin panels, dashboards |
| Mobile + Desktop | 60-80% | RN Windows/macOS — cross-platform desktop apps |
| All Platforms Combined | 65-80% | Universal apps (Discord, Shopify, Office) |
Reanimated 3 & UI Thread Worklets
Animation was the area where React Native's old bridge suffered most visibly. Even a moderately complex gesture-driven animation — a swipeable card, a parallax header, a shared element transition — would drop frames because every frame's state update had to cross the bridge. Reanimated 3 solves this with worklets.
Worklets: JavaScript That Runs on the UI Thread
A worklet is a JavaScript function marked with 'worklet' that Reanimated serializes and runs on the UI thread, not the JS thread. Gesture handlers, animation callbacks, and scroll handlers execute at 60fps (or 120fps on ProMotion iPhones) regardless of what the JS thread is doing. The JS thread could be parsing a giant JSON response — your animations still run smoothly.
Shared Values and Derived Values
Reanimated's useSharedValue and useDerivedValue let you express animated state declaratively. The values live in a shared memory space accessible from both threads — updates from gestures or timings on the UI thread propagate instantly to views without any round-trip to JavaScript.
Layout Animations and Transitions
Reanimated 3 ships with declarative entering, exiting, and layout animations. A list item can fade in, slide out, or morph its size with a single prop. Shared element transitions between screens — the hero image expanding from a thumbnail in one view to a full-screen hero in the next — work with a few lines of code.
Integration with Gesture Handler and Skia
Combined with react-native-gesture-handler and react-native-skia, Reanimated 3 enables interaction patterns previously reserved for native apps: draggable sheets with physics, canvas-based paint or drawing apps, custom bottom-sheet implementations, and game-quality animations. All of it runs on the UI thread, never touching the bridge, at full frame rate.
- Worklets execute JS on the UI thread — 60fps/120fps animations independent of JS load
- Shared values propagate updates from gestures directly to views without bridge overhead
- Layout animations (entering, exiting, transition) are declarative — single prop on a component
- Shared element transitions between screens are built-in
- Combined with Skia and Gesture Handler, supports game-quality interactions
- Zero bridge traffic during animations — JS thread free to do other work
The goal was to give JavaScript developers the same animation capabilities that Core Animation gives iOS engineers and Jetpack Compose gives Android engineers — but without asking them to leave JavaScript. Worklets are how we got there.
— Krzysztof Magiera, creator of Reanimated and Gesture Handler
The Cross-Platform Ecosystem: Meta, Microsoft, Shopify
React Native's staying power in 2026 isn't a marketing narrative — it's the result of three companies treating the framework as critical infrastructure and investing accordingly. Meta owns it, Microsoft extends it to Windows and macOS, and Shopify funds libraries that the entire community depends on.
Meta: The Framework's Home
React Native powers Instagram, Facebook, Messenger, WhatsApp web clients, Meta Quest store UIs, and Oculus's mobile companion apps. The New Architecture was built to meet Meta's own production requirements. Every performance improvement that ships to open source was first validated on apps with hundreds of millions of daily users. The team at Meta maintains Fabric, TurboModules, Hermes, and the core React Native runtime.
Microsoft: Windows, macOS, and Office
Microsoft maintains React Native for Windows and React Native for macOS as first-class ports. The Office Mobile apps, parts of Teams, and internal Microsoft tooling run on React Native. Microsoft contributes upstream to the core framework and maintains the desktop extensions, giving developers a path from mobile to full desktop apps without switching frameworks.
Shopify: Libraries the Whole Ecosystem Uses
Shopify funds and maintains some of the most-depended-on libraries in the ecosystem: react-native-skia (2D graphics), FlashList (high-performance lists), restyle (themeable design systems), and performance tooling. Their engineering blog publishes benchmarks and migration guides that become de facto community standards. Shopify's merchant apps serve hundreds of millions of merchants across mobile and web from a shared React Native codebase.
Expo: Tooling and Services
Expo is the default way most developers start React Native projects in 2026. EAS Build (cloud compilation), EAS Submit (app store deployment), EAS Update (over-the-air JavaScript updates), and Expo Router (file-based navigation) have consolidated into a production-grade platform. Expo SDK 52+ ships 100+ pre-built native modules with full New Architecture support, so most teams never need to drop down to writing Swift or Kotlin.
| Company | Scale | React Native Usage |
|---|---|---|
| Meta | 3B+ MAU across Instagram, Facebook, Messenger | Core framework maintainer; runs on Fabric in production |
| 2B+ MAU | Core feed, DMs, and feature screens on React Native | |
| Shopify | Hundreds of millions of merchants/buyers | Merchant admin, Shop app, POS — all React Native |
| Discord | 200M+ MAU | Mobile, desktop, web from shared React Native codebase |
| Microsoft Office | 400M+ MAU across Office products | Office Mobile, parts of Teams, desktop via RN Windows/macOS |
| 500M+ MAU | Primary mobile app built on React Native | |
| Bloomberg | Professional and consumer apps | Bloomberg terminal mobile clients on React Native |
| Coinbase | 100M+ users | Core consumer app on React Native with native crypto modules |
React Native is a strategic investment for us. Every engineer we hire can ship to mobile and web. Every feature we build lands on all platforms simultaneously. The code-sharing percentage grows every year, and the New Architecture has eliminated the performance tradeoffs that existed five years ago.
— Shopify Engineering Blog, 2026
What's Coming in 2026–2027
React Native's roadmap for the next 18-24 months is as ambitious as any period in the framework's history. Several initiatives, some already in developer preview, will reshape how teams build mobile apps.
React Server Components on Mobile
RSC on mobile lets screens stream their UI from the server — the initial render arrives as ready-to-paint component output instead of a JSON payload the client has to render. For content-heavy apps (news, social feeds, e-commerce), time-to-first-meaningful-paint drops from seconds to milliseconds. Expect a stable release during 2026.
Swift and Kotlin First-Class Interop
The current TurboModule codegen supports Objective-C++ and Kotlin through Java interop. The 2026-2027 roadmap brings direct Swift and idiomatic Kotlin support — no Objective-C bridging headers, no Java shims. Writing a native module becomes as simple as writing a Swift or Kotlin class with a protocol annotation.
Skia Renderer as a First-Class Option
For graphics-heavy apps, Meta and Shopify are collaborating on a Skia-based renderer that bypasses UIKit and the Android view system entirely, drawing to a native OpenGL or Metal/Vulkan surface. Expect a stable opt-in release for custom, highly animated apps — gaming-adjacent experiences, creative tools, data visualization dashboards.
Vision Pro and Android XR Spatial Computing
Apple Vision Pro and Android XR both have React Native compatibility layers in development. Spatial anchors, hand tracking, and 3D window placement will be expressible through a spatial-aware React Native API. Cross-platform XR development on React Native becomes feasible in 2026-2027, extending the framework beyond flat-screen mobile for the first time.
React 19 Concurrent Features, End-to-End
React 19's concurrent rendering, Actions, useFormStatus, and the new compiler ship to React Native via Fabric. The React Compiler (formerly React Forget) removes most of the need for useMemo and useCallback — the compiler handles memoization automatically. Developer experience improves, performance improves, and mental model complexity drops.
Unified State Management
Meta has been evolving Recoil into a successor state library designed for React 18/19's concurrent features. The goal: a single state primitive that works on web (React), mobile (React Native), and server components, with fine-grained reactivity that interoperates cleanly with Fabric's rendering model.
| Initiative | Status (2026) | Expected Impact |
|---|---|---|
| React Server Components on Mobile | Developer preview | 10x faster time-to-meaningful-paint for content apps |
| Swift/Kotlin First-Class Interop | Prototype | Native modules written natively, no bridging |
| Skia Renderer Option | Opt-in beta | Game-quality graphics from React Native |
| Vision Pro / Android XR Support | Early development | React Native reaches spatial computing |
| React 19 + React Compiler | Stable in 2026 | Automatic memoization, simpler DX |
| Static Hermes | Rolling out | 2-10x JS speedups on typed code paths |
| Unified State Management | Active R&D | Single state model across RN/React/RSC |
Migrating from the Old Architecture to the New
Most production React Native apps built between 2018 and 2023 are still on a mix of the old bridge and early New Architecture opt-ins. Migrating is not optional in 2026 — the legacy bridge is deprecated and ecosystem libraries are dropping old-architecture support. Done incrementally, migration is manageable.
| Phase | Focus | Typical Duration |
|---|---|---|
| 1. Audit | Inventory native modules, check TurboModule compatibility, identify custom native code | 3-5 days |
| 2. Upgrade RN + Libraries | Bump to latest RN (0.76+), update all community libraries to New Arch-compatible versions | 1-2 weeks |
| 3. Enable Hermes | Switch JS engine from JSC to Hermes, validate performance on target devices | 2-3 days |
| 4. Enable Fabric | Flip the Fabric flag, fix rendering issues per-screen, validate layout and gestures | 1-2 weeks |
| 5. Migrate Custom Modules | Rewrite in-house native modules as TurboModules with codegen | 1-3 weeks (depends on volume) |
| 6. Reanimated 3 Upgrade | Convert legacy animations to worklets for full UI-thread execution | 3-7 days |
| 7. Performance Validation | Profile startup, scroll, and animation on mid-range devices; compare to baseline | 1 week |
- Most popular libraries (React Navigation, Reanimated, Gesture Handler, MMKV, Expo) are already New Arch-compatible
- Check the React Native Directory (reactnative.directory) — each library has a New Architecture status badge
- Enable Fabric and TurboModules one screen/module at a time, not all at once
- Keep the legacy bridge as a fallback during transition — React Native supports hybrid mode
- Profile before and after each phase — Hermes alone delivers 40%+ startup improvement
- Budget 2-6 weeks total for typical apps; longer for apps with heavy custom native code
- Teams that migrated in 2024-2025 report 0 regressions and significant performance gains
Every team that put off the New Architecture migration eventually regretted it. The libraries they depended on dropped legacy support, the performance improvements compounded elsewhere in the ecosystem, and the tooling shifted. The teams that migrated in 2024 are shipping faster in 2026.
— Expo Engineering Team, 2026
Performance Benchmarks: Old vs New Architecture
Numbers make the difference concrete. The following benchmarks are aggregated from published engineering posts by Meta, Shopify, Expo, and Microsoft, plus Frenchy Digital's internal measurements on our own production apps migrated between 2024 and 2026.
| Metric | Old Bridge Architecture | New Architecture (Fabric + TM + Hermes) | Improvement |
|---|---|---|---|
| Cold Start (mid-range Android) | 1,800 ms | 900 ms | 50% faster |
| Time to Interactive | 2,400 ms | 1,200 ms | 50% faster |
| JS Bundle Parse Time | 420 ms | 65 ms (bytecode) | 84% faster |
| Memory at Steady State | 180 MB | 118 MB | 34% lower |
| Scroll FPS (complex list) | 48-54 fps with drops | 59-60 fps consistent | Eliminates drops |
| Animation Consistency | Frame drops under JS load | 60fps regardless of JS load | Worklet isolation |
| Crash Rate (low-memory Android) | 1.2% | 0.4% | 67% lower |
| Native Module Call Latency | ~4 ms (bridge + JSON) | <0.1 ms (JSI direct) | 40x faster |
| App Bundle Size (iOS, gzipped) | 24 MB | 19 MB | 21% smaller |
| Over-the-Air Update Size | 3.2 MB | 1.8 MB (Hermes bytecode) | 44% smaller |
These are production numbers, not synthetic benchmarks. The 40x improvement in native module call latency is the one that changes what apps can do — workflows that previously required batching (reading 20 secure-storage values, for example) now run in a single synchronous call with no perceptible cost.
Apps Running on React Native in 2026
React Native's production footprint is broader than most developers realize. Below are notable apps running the New Architecture in 2026 — apps you likely have on your phone right now.
Meta: Instagram, Facebook, Messenger
Core feed screens, Reels, DMs, and settings in Instagram; Marketplace and Messenger in Facebook; the entire Messenger app's message list and thread screens. Meta runs Fabric and TurboModules in production at the largest mobile scale in the world — 3 billion combined monthly actives. If it works here, it works anywhere.
Shopify: Shop, Merchant Admin, POS
The Shop app (consumer shopping), Shopify's merchant admin (store management), and Shopify POS (in-store point-of-sale hardware) all run on React Native with heavy React Native Web overlap. Shopify's investment means the ecosystem libraries they maintain — FlashList, Skia, restyle — are production-grade.
Discord: Mobile, Desktop, Web
Discord's mobile iOS and Android apps, Discord desktop (via Electron + React Native for Windows patterns), and the web client all share a React Native + React Native Web codebase. New features ship simultaneously across platforms — a feat native-per-platform teams can rarely match.
Microsoft Office Mobile
Office Mobile (the unified Word, Excel, PowerPoint app) uses React Native extensively. Parts of Teams, the Outlook mobile app's secondary screens, and Microsoft's internal line-of-business tooling also run React Native. React Native for Windows and macOS extends this to desktop.
Other Notable Apps
- Pinterest — core mobile app
- Bloomberg — professional and consumer apps
- Coinbase — primary consumer crypto app
- Tesla — companion app for vehicles
- Walmart — merchant and employee tools
- Uber Eats — restaurant dashboard and courier app
- Mercari — C2C marketplace
- SoundCloud Pulse — creator tools
- Flipkart — India's largest e-commerce app
- Expo Go — demo client used by millions of developers
Frenchy Digital: React Native Expertise for 2026 and Beyond
React Native sits at the center of Frenchy Digital's mobile practice. Every new cross-platform project we ship runs on the New Architecture by default — Fabric, TurboModules, Hermes, and Reanimated 3 are non-negotiables, not opt-ins. Our LA-based team has shipped React Native apps for fintech, healthcare, luxury retail, logistics, and entertainment clients, and we maintain a production track record migrating legacy apps to the New Architecture with zero regressions.
New Architecture from Day One
We don't ship apps on the legacy bridge. Every new project starts on React Native 0.76+ with Fabric, TurboModules, and Hermes enabled. The 30-50% startup improvement and 60fps animation consistency ship on day one, not after a future migration.
Cross-Platform Web + Mobile Delivery
For clients who need iOS, Android, and web, we ship all three from a single React Native Web codebase. Admin dashboards, consumer portals, and merchant tools ship simultaneously across platforms — one codebase, three platforms, faster time-to-market. Read our LA-focused React Native guide for a deeper look.
Legacy Migration Specialists
We've migrated production apps from React Native 0.65-0.72 (legacy bridge) to 0.76+ (New Architecture) for multiple clients. Our process — audit, upgrade, enable incrementally, validate — takes 2-6 weeks depending on app complexity. Measured results: 40-55% startup improvement, 30%+ memory reduction, 60fps animation consistency.
Framework Choice Guidance
React Native isn't always the right answer. For pixel-perfect design system apps or animation-dominant experiences, Flutter can be a better fit — see our React Native vs Flutter 2026 analysis. For all cross-platform options and the broader mobile landscape, our mobile app development guide covers the full decision framework.
Ready to Ship on the React Native New Architecture?
Whether you're starting fresh on Fabric + TurboModules or migrating a legacy app to the New Architecture, Frenchy Digital has the production experience to deliver.
Build on the Future of React Native
Frenchy Digital ships production React Native apps on the New Architecture — Fabric, TurboModules, Hermes, Reanimated 3, and React Native Web. Let's build your next cross-platform product the right way.
1517 S Bentley Ave Unit 204, Los Angeles CA 90025
Frequently Asked Questions
Sources & References
- 1React Native – Official Documentation↗
- 2React Native – Official Engineering Blog↗
- 3Meta Open Source – React Native Project↗
- 4Hermes – JavaScript Engine for React Native↗
- 5Expo – Documentation↗
- 6React Native Web – Official Site↗
- 7React Native Reanimated – Documentation (Software Mansion)↗
- 8Shopify Engineering Blog↗
