React Native 0.85: The Complete Guide — New Animation Backend, Post-Bridge Era & Everything You Need to Know

React Native 0.85 landed on April 7, 2026, authored by engineers from Meta, Expo, and Software Mansion. It is not a flashy rewrite — it is the kind of release that makes every existing app meaningfully better, with no architectural headaches in exchange.

The framework has been on a remarkable trajectory since 0.76 made the New Architecture the default in late 2024. The old Bridge was permanently removed in 0.82. Hermes V1 became the default engine in 0.84. And now 0.85 addresses the last major pain point that frustrated React Native developers for years: animations on layout properties were stuck on the JavaScript thread.

The result, in 2026, is a framework that is genuinely competitive with native on the vast majority of real-world use cases — and significantly faster to develop than either iOS or Android native code.

Here is a quick view of the release timeline that brought us here:

To appreciate why 0.85 matters, you need to understand what the New Architecture replaced — and why removing the old Bridge was so important.

#The Old Bridge: A Necessary Bottleneck

From React Native's inception in 2015 through version 0.81, all communication between JavaScript and native code went through an asynchronous Bridge. Every state update, every gesture event, every animation frame was serialized to JSON, passed across the Bridge, deserialized, and processed. This worked — but it introduced inherent latency, often upwards of 200ms for UI responses, and made gesture-driven interfaces feel comparatively sluggish.

Old Architecture:
JS Thread → JSON Serialize → Bridge → JSON Deserialize → Native Thread
      ↑                                                         ↓
      ←←←←←←←←←←← JSON Serialize ← Bridge ← JSON Deserialize ←

The Bridge was the single biggest reason developers reached for native code when performance was critical: animations, swipe gestures, real-time data, and scroll-linked effects all suffered.

#The New Architecture: JSI, Fabric, and TurboModules

The New Architecture, fully stable since 0.76, eliminates the Bridge entirely. It is built on three pillars:

JavaScript Interface (JSI) — A C++ layer that allows JavaScript to hold direct references to native objects and call native methods synchronously, without serialization. Latency drops to sub-2ms for native interop.

Fabric Renderer — The new UI rendering system. It runs on a background thread, supports concurrent rendering (including React 19's useTransition and Suspense), and produces consistent 60fps — with support for 120Hz on devices that expose ProMotion or high-refresh-rate display APIs.

TurboModules — Native modules that load lazily, only when first called, instead of all at startup. This is a major contributor to the cold-start improvements measured across versions.

// With JSI — synchronous native call, no serialization
import { NativeModules } from 'react-native';

// TurboModule — loaded lazily, typed, direct JSI call
const CameraModule = NativeModules.CameraModule;

// The call is synchronous on the same thread — no async bridge hop
const capabilities = CameraModule.getSupportedCapabilities();
// Returns immediately with the native result

Caption: JSI calls do not go through a message queue. The JavaScript engine holds a direct reference to the native object, so calling a method is as fast as a C++ function call from JavaScript's perspective.

New Architecture (0.85+):
JS Thread ←→ JSI (C++) ←→ Native Thread
              ↕
         Fabric Renderer
              ↕
         UI Thread (60/120fps)

Caption: The New Architecture collapses the multi-hop Bridge into a direct C++ interface layer. Background thread rendering via Fabric means UI work no longer competes with JavaScript execution for the single main thread.

React Native 0.85 introduces the new Shared Animation Backend, built in collaboration with Software Mansion. This is the headline feature of the release, and it solves one of the most persistent frustrations in React Native development.

#The Problem It Solves

React Native has two major animation systems: the built-in Animated API and react-native-reanimated (built by Software Mansion, used in virtually every serious React Native app). Until 0.85, these two systems had separate internal engines that did not share state. Coordinating animations between them required workarounds, and — critically — layout properties like width, height, flex, and padding could not be animated with the native driver at all.

Previously, layout props like width, height, and flex couldn't be animated via the native driver at all. They instead required a layout pass through Yoga, so React Native forced them onto the JS thread where frame drops live.

This meant that common patterns — animating a drawer width, expanding a card, morphing a layout — either caused dropped frames or required complex workarounds using transform: [{ scaleX }] instead of direct width/height changes.

#What the Shared Animation Backend Provides

The headline feature is the new Shared Animation Backend, built with Software Mansion, which powers both Animated and Reanimated and now allows animating Flexbox/layout props with the native driver.

In practical terms:

• width, height, padding, margin, flex, and other layout props can now be animated entirely on the native thread
• Animated and react-native-reanimated share the same internal engine — coordinating between them no longer requires bridging two separate systems
• 120Hz support becomes realistic for layout-driven animations on ProMotion displays
• No more transform: [{ scaleX }] workarounds for simple width animations

import { useRef } from 'react';
import { Animated, Pressable, View, StyleSheet } from 'react-native';

// Before 0.85 — had to fake width with scaleX to use native driver
function OldDrawer() {
  const scaleX = useRef(new Animated.Value(0)).current;

  function open() {
    Animated.spring(scaleX, { toValue: 1, useNativeDriver: true }).start();
  }

  return (
    <Animated.View
      style={[
        styles.drawer,
        {
          // ❌ Hack: scale instead of width, required to use native driver
          transform: [{ scaleX }],
          transformOrigin: 'left',
        },
      ]}
    />
  );
}

// After 0.85 — animate width directly on the native thread
function NewDrawer() {
  const width = useRef(new Animated.Value(0)).current;

  function open() {
    Animated.spring(width, {
      toValue: 280,
      useNativeDriver: true, // ✅ Works with layout props in 0.85
    }).start();
  }

  return (
    <Animated.View style={[styles.drawer, { width }]} />
  );
}

Caption: The useNativeDriver: true flag now works with layout properties. The animation runs entirely on the native UI thread, meaning the JavaScript thread can be busy with data fetching or state updates without causing a single dropped frame.

#Using Reanimated 3+ with the Shared Backend

import Animated, {
  useSharedValue,
  useAnimatedStyle,
  withSpring,
  withTiming,
  interpolate,
} from 'react-native-reanimated';

function ExpandableCard({ children }: { children: React.ReactNode }) {
  const expanded = useSharedValue(false);
  const height = useSharedValue(80);

  const animatedStyle = useAnimatedStyle(() => ({
    height: withSpring(expanded.value ? 320 : 80, {
      damping: 15,
      stiffness: 100,
    }),
    borderRadius: withTiming(expanded.value ? 16 : 8),
    // All of these are layout properties — all run on the native thread in 0.85
    paddingVertical: withTiming(expanded.value ? 20 : 12),
    marginBottom: withSpring(expanded.value ? 16 : 8),
  }));

  return (
    <Animated.View style={[styles.card, animatedStyle]}>
      <Pressable onPress={() => { expanded.value = !expanded.value; }}>
        {children}
      </Pressable>
    </Animated.View>
  );
}

Caption: With the Shared Animation Backend, useAnimatedStyle can include layout properties directly — no transforms, no workarounds. The entire animation runs natively, independent of the JavaScript thread's workload.

In early 2026, the React Native team released version 0.84 and made Hermes V1 the default JavaScript engine for both iOS and Android. In 0.85, Hermes V1 continues as the default and gains additional stability and compatibility improvements.

#What Hermes V1 Changed

Hermes V1 (stabilized in 0.84 and continued in 0.85) is not an incremental patch on the original Hermes engine — it is a rewritten compiler with a new bytecode format, improved Just-In-Time compilation via Static Hermes research, concurrent garbage collection (Hades GC), and far better handling of modern JavaScript patterns.

// Hermes V1 handles modern JS natively — less Babel transformation needed
// These patterns now work without transformation in many cases:
const result = await Promise.allSettled([fetch('/api/a'), fetch('/api/b')]);

// Optional chaining and nullish coalescing — native in Hermes V1
const name = user?.profile?.displayName ?? user?.email ?? 'Anonymous';

// Logical assignment operators — no Babel plugin needed
user.preferences ??= { theme: 'dark', language: 'en' };
settings.notifications ||= true;

// Array methods — fully optimized
const active = users.filter(u => u.active).map(u => u.name).at(-1);

Caption: Hermes V1's expanded ES2022+ support means many Babel transforms are no longer needed. With broader ES feature support, some Babel transformations become unnecessary, simplifying the toolchain. Removing these transforms reduces the number of steps in your build pipeline and speeds up Metro bundling.

#Performance Impact

The New Architecture in React Native 0.84 delivers dramatic benchmark improvements over the legacy bridge: cold start time is down 43%, rendering throughput is up 39%, and memory usage is down 26%. Hermes V1 is a significant contributor to the memory and startup improvements in those numbers.

Developers will also find some new features in the React Native DevTools. For example, multiple CDP (Chrome DevTools Protocol) connections can now be established simultaneously, and native tabs are available on macOS.

#Multiple Simultaneous CDP Connections

Previously, only one DevTools session could connect to a running React Native app at a time. Opening a second debugger would disconnect the first. In 0.85, multiple CDP connections are supported simultaneously, which enables:

• Running the React DevTools panel and the Performance profiler at the same time
• Connecting both a custom tooling script and the visual debugger concurrently
• CI environments that attach monitoring while a developer also debugs locally

#macOS Native Tabs

For developers working on React Native macOS or debugging macOS targets, DevTools now supports native macOS tab groups — bringing the debugging experience in line with what Safari and Chrome offer natively.

This release includes the New Animation Backend, selection data in TextInput onChange events, Metro TLS support, and moves the Jest preset to a dedicated package.

Metro, React Native's JavaScript bundler, now supports TLS (HTTPS) connections between the development server and the device. Previously, Metro served bundles over plain HTTP, which caused issues in two scenarios:

Corporate network proxies — Many enterprise environments block unencrypted HTTP traffic or rewrite requests in ways that break Metro's hot reload websocket. HTTPS connections bypass most of these proxy issues.

Mixed-content restrictions — Apps running on devices with strict network policies that reject HTTP connections from HTTPS contexts now work seamlessly with a TLS-enabled Metro server.

# Start Metro with TLS enabled
npx react-native start --https

# Metro will generate a self-signed cert for development
# Or provide your own:
npx react-native start --https --cert ./path/to/cert.pem --key ./path/to/key.pem

Caption: Metro TLS is particularly valuable for enterprise development where network policies prevent HTTP traffic. Enable it globally in your react-native.config.js so every developer on the team benefits automatically.

React Native's Jest preset has been extracted into its own dedicated package: @react-native/jest-preset. This shrinks the size of the core react-native package and gives teams more flexibility in how they configure testing.

This is a breaking change that requires a one-line update to your Jest config:

// Before 0.85 — preset was bundled inside react-native
// jest.config.js
module.exports = {
  preset: 'react-native',
  // ...
};

// After 0.85 — use the standalone package
// jest.config.js
module.exports = {
  preset: '@react-native/jest-preset',
  // ...
};

# Install the new package
npm install --save-dev @react-native/jest-preset

Caption: The decoupled Jest preset means the testing infrastructure can be updated and versioned independently of the React Native core. Teams can pin the preset at a known-good version without being tied to a specific React Native version bump.

The broader significance is architectural: the release reflects a stronger open-source modularisation strategy. React Native has removed the Jest preset from the main react-native package and moved it into the standalone @react-native/jest-preset package, reducing the framework core's footprint and making dependency management cleaner.

A smaller but long-requested improvement: TextInput's onChange event now includes selection data alongside the text value.

import { TextInput } from 'react-native';

function SmartEditor() {
  function handleChange(event: {
    nativeEvent: {
      text: string;
      // New in 0.85 — selection data included in onChange
      selection: {
        start: number;
        end: number;
      };
    };
  }) {
    const { text, selection } = event.nativeEvent;

    const cursorPosition = selection.start;
    const selectedText = text.slice(selection.start, selection.end);

    // Trigger @mention autocomplete based on cursor position — no separate onSelectionChange needed
    if (text[cursorPosition - 1] === '@') {
      showMentionSuggestions();
    }
  }

  return (
    <TextInput
      onChange={handleChange}
      multiline
      placeholder="Type @ to mention someone..."
    />
  );
}

Caption: Before 0.85, getting text AND cursor position required two separate event handlers: onChange for the text and onSelectionChange for the cursor. The extra event subscription added overhead and sometimes caused ordering issues. The unified event is cleaner and more reliable.

#Node.js Version Requirements

0.85 drops support for EOL Node.js versions (v21, v23) and versions older than 20.19.4. Make sure your environment is up to date before upgrading.

# Check your Node version
node --version

# Upgrade if needed — use nvm for easy version management
nvm install 22
nvm use 22
nvm alias default 22

Supported Node.js versions for React Native 0.85: 20.19.4+, 22.x, 24.x.

#StyleSheet.absoluteFillObject Removed

The long-deprecated StyleSheet.absoluteFillObject API has been fully removed. Switch to StyleSheet.absoluteFill instead.

// ❌ Removed in 0.85
import { StyleSheet } from 'react-native';
const styles = StyleSheet.create({
  overlay: StyleSheet.absoluteFillObject, // Compile error in 0.85
});

// ✅ Use absoluteFill instead
const styles = StyleSheet.create({
  overlay: StyleSheet.absoluteFill,
});

// absoluteFill is equivalent to:
// { position: 'absolute', left: 0, right: 0, top: 0, bottom: 0 }

Caption: StyleSheet.absoluteFillObject was deprecated several versions ago in favor of the semantically clearer StyleSheet.absoluteFill. If you are on a large codebase, run a codemod or a global search for absoluteFillObject before upgrading.

#Pressable Event Listeners Inside Hidden Activities

Event listeners no longer unmount automatically when inside a hidden Activity. Manual cleanup is now required.

import { Pressable, useEffect, useRef } from 'react';

// ❌ Before 0.85 — listeners were auto-removed when Activity hidden
function AutoCleanedButton() {
  return (
    <Pressable onPress={handlePress}>
      {/* Listener was magically removed on Activity hide */}
    </Pressable>
  );
}

// ✅ After 0.85 — explicit cleanup required
function ExplicitCleanupButton() {
  const listenerRef = useRef<(() => void) | null>(null);

  useEffect(() => {
    return () => {
      // Explicitly clean up any subscriptions when the component unmounts
      listenerRef.current?.();
    };
  }, []);

  return <Pressable onPress={handlePress}>{/* ... */}</Pressable>;
}

#C++ Type Alias Removals

Several deprecated C++ type aliases in the native module layer have been removed:

// ❌ Removed aliases
ShadowNode::Shared      // → use std::shared_ptr<ShadowNode>
ContextContainer::Shared // → use std::shared_ptr<ContextContainer>

// ✅ Direct types
std::shared_ptr<ShadowNode> shadowNode;
std::shared_ptr<ContextContainer> context;

This only affects native module authors who write C++ code directly. Pure React Native JavaScript/TypeScript code is unaffected.

#End of Support for React Native 0.82

With 0.85, React Native 0.82 officially reaches end of support. On the compatibility front, React Native now drops end-of-life Node.js versions and releases below 20.19.4, while support for version 0.82 officially ends.

Cold Start Performance (Android mid-range, React Native Counter App)

Legacy Arch (0.72):  ████████████████████████████████  ~2,100ms
New Arch 0.82:       ██████████████████                 ~1,500ms  (-29%)
New Arch 0.84:       ████████████                       ~1,200ms  (-43%)
New Arch 0.85:       ███████████                        ~1,150ms  (-45%)

Memory at Startup (same app)

Legacy Arch (0.72):  ████████████████████               ~185MB
New Arch 0.85:       ██████████████                     ~137MB   (-26%)

Animation FPS (layout property animation, 120Hz device)

Legacy Arch + JS thread:  ████████████████               ~45fps average
New Arch + Shared Backend: ███████████████████████████  ~117fps average

Caption: The animation performance difference between the old and new approach is not marginal — it is the difference between a visibly janky UI and a fluid one. Layout-property animations previously forced React Native onto the JS thread where any concurrent work caused frame drops. The Shared Animation Backend eliminates this entirely.

#Setting Up a New Project

# Create a new project with React Native 0.85
npx @react-native-community/cli@latest init MyApp --version 0.85

# Or with Expo (Expo SDK 55 supports React Native 0.85)
npx create-expo-app MyApp --template blank-typescript

#A Production-Ready Screen with the New APIs

import React, { useState, useCallback } from 'react';
import {
  View,
  TextInput,
  FlatList,
  StyleSheet,
  SafeAreaView,
  Text,
  Pressable,
} from 'react-native';
import Animated, {
  useSharedValue,
  useAnimatedStyle,
  withSpring,
  FadeIn,
  FadeOut,
} from 'react-native-reanimated';

interface Product {
  id: string;
  name: string;
  price: number;
}

function ProductSearchScreen() {
  const [query, setQuery] = useState('');
  const [results, setResults] = useState<Product[]>([]);
  const [selectedId, setSelectedId] = useState<string | null>(null);

  // Layout animation — runs natively in 0.85
  const detailHeight = useSharedValue(0);

  const detailStyle = useAnimatedStyle(() => ({
    height: withSpring(detailHeight.value, { damping: 20 }),
    overflow: 'hidden',
  }));

  function handleSelect(id: string) {
    if (selectedId === id) {
      setSelectedId(null);
      detailHeight.value = 0;
    } else {
      setSelectedId(id);
      detailHeight.value = 120; // Animates to 120px — layout prop, native thread
    }
  }

  // New in 0.85 — onChange includes selection data
  function handleSearchChange(event: any) {
    const { text, selection } = event.nativeEvent;
    setQuery(text);
    // Could use selection.start for cursor-aware suggestions
  }

  const renderItem = useCallback(({ item }: { item: Product }) => (
    <Animated.View entering={FadeIn} exiting={FadeOut}>
      <Pressable
        style={styles.item}
        onPress={() => handleSelect(item.id)}
      >
        <Text style={styles.name}>{item.name}</Text>
        <Text style={styles.price}>${item.price.toFixed(2)}</Text>
      </Pressable>

      {selectedId === item.id && (
        <Animated.View style={[styles.detail, detailStyle]}>
          <Text>Product details for {item.name}</Text>
        </Animated.View>
      )}
    </Animated.View>
  ), [selectedId, detailStyle]);

  return (
    <SafeAreaView style={styles.container}>
      <TextInput
        style={styles.search}
        value={query}
        onChange={handleSearchChange}  // Uses new selection data
        placeholder="Search products..."
        returnKeyType="search"
      />
      <FlatList
        data={results}
        keyExtractor={item => item.id}
        renderItem={renderItem}
        getItemLayout={(_, index) => ({
          length: 60,
          offset: 60 * index,
          index,
        })}
        removeClippedSubviews
        maxToRenderPerBatch={10}
        windowSize={5}
      />
    </SafeAreaView>
  );
}

const styles = StyleSheet.create({
  container: { flex: 1, backgroundColor: '#fff' },
  search: {
    margin: 16,
    padding: 12,
    borderRadius: 10,
    backgroundColor: '#f2f2f7',
    fontSize: 16,
  },
  item: {
    flexDirection: 'row',
    justifyContent: 'space-between',
    paddingHorizontal: 16,
    paddingVertical: 12,
    borderBottomWidth: StyleSheet.hairlineWidth,
    borderColor: '#e0e0e0',
  },
  name: { fontSize: 16 },
  price: { fontSize: 16, color: '#34c759' },
  detail: {
    backgroundColor: '#f9f9f9',
    paddingHorizontal: 16,
    justifyContent: 'center',
  },
});

Caption: The detailHeight animation uses a layout property (height) with Reanimated's useAnimatedStyle. In 0.84 and earlier, this would require either a workaround with transform: scaleY or accepting that the animation runs on the JS thread. In 0.85, it runs natively.

#Migrating the Jest Config

// jest.config.ts — Updated for 0.85
import type { Config } from 'jest';

const config: Config = {
  // ✅ New package
  preset: '@react-native/jest-preset',

  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json'],
  transformIgnorePatterns: [
    'node_modules/(?!(react-native|@react-native|react-native-reanimated)/)',
  ],
  setupFilesAfterFramework: ['@testing-library/react-native/extend-expect'],
};

export default config;

React Native is chosen by companies building AI apps: Mistral, v0, Replit, vibecode, Rork. These apps are built with React Native and some of them allow users to build new React Native apps as well.

Alongside 0.85, Meta announced official React Native support for Meta Quest VR devices. The same component model — View, Text, Pressable, custom hooks — runs on Quest's spatial computing platform with a thin native layer for 3D positioning and hand tracking.

This follows the broader "many platforms" vision Meta outlined in 2021, which already includes Windows and macOS via Microsoft's React Native for Windows/macOS project.

After 10 years, React Native is approaching version 1.0. At React Conf 2025, the team announced 1.0 is "on the horizon." The New Architecture becoming the default in 0.76 (September 2025) marked a major milestone toward this goal.

The key remaining milestone before 1.0 is the "Stable JavaScript API" initiative, which aims to give developers a stable, versioned contract for core APIs — meaning a minor React Native version bump will never break your code in unexpected ways. This initiative was introduced in 0.80 and is progressing alongside each release.

What 1.0 signals to the ecosystem:

• Core APIs will not change without a major version bump
• Library authors can safely target a stable API surface
• Enterprises with long maintenance windows can plan React Native adoption with confidence

With the Bridge gone, the New Architecture stable, Hermes V1 default, and the Shared Animation Backend shipped, the framework is technically ready. The 1.0 label is now more about API promises than architectural maturity.

#Using the Upgrade Helper

The official React Native Upgrade Helper shows a diff of every file that changes between your current version and 0.85:

https://react-native-community.github.io/upgrade-helper/?from=0.84.0&to=0.85.0

#Step-by-Step Upgrade

# Step 1 — Update the package
npm install react-native@0.85

# Step 2 — Update the Jest preset package
npm install --save-dev @react-native/jest-preset

# Step 3 — Update Node if needed (minimum 20.19.4)
node --version

# Step 4 — Update iOS pods
cd ios && bundle exec pod install && cd ..

# Step 5 — Clean builds
npx react-native clean

# Step 6 — Run on both platforms
npx react-native run-android
npx react-native run-ios

#Update Your Jest Config

// jest.config.js — one change required
module.exports = {
  preset: '@react-native/jest-preset', // Was: 'react-native'
};

#Replace StyleSheet.absoluteFillObject

# Find all usages in your codebase
grep -r "absoluteFillObject" ./src

# Replace with absoluteFill
# absoluteFill == { position: 'absolute', left: 0, right: 0, top: 0, bottom: 0 }

#Opt Into the New Animation Backend

The Shared Animation Backend is experimental in 0.85.1 and requires explicit opt-in:

// index.js — enable the experimental Shared Animation Backend
import { unstable_enableSharedAnimationBackend } from 'react-native';

// Enable before your app renders
unstable_enableSharedAnimationBackend();

import { AppRegistry } from 'react-native';
import App from './App';
AppRegistry.registerComponent('MyApp', () => App);

Caption: The unstable_ prefix signals that the API surface for enabling the backend may change before it becomes the default in a future version. The animation behavior itself is stable — only the opt-in mechanism may change.

[1] React Native Team. (2026, April 7). React Native 0.85 — New Animation Backend, New Jest Preset Package. React Native Blog. https://reactnative.dev/blog/2026/04/07/react-native-0.85

[2] React Native Team. (2026, February 11). React Native 0.84 — Hermes V1 by Default. React Native Blog. https://reactnative.dev/blog/2026/02/11/react-native-0.84

[3] Callstack. (2026, February 17). React Native Wrapped 2025: A Month-by-Month Recap. Callstack Blog. https://www.callstack.com/blog/react-native-wrapped-2025-a-month-by-month-recap-of-the-year

[4] Callstack. (2026, February 18). React Native 0.84: Hermes V1, WebAssembly, and Ecosystem Shifts. Callstack Events. https://www.callstack.com/events/react-native-0-84-and-other-news

[5] Software Mansion. (2026). React Native Reanimated 3 Documentation. https://docs.swmansion.com/react-native-reanimated/

[6] To The New Blog. (2026, April). Hermes V1 by Default in React Native 0.84: The Biggest Performance Win of 2026. https://www.tothenew.com/blog/hermes-v1-by-default-in-react-native-0-84

[7] Heise Online. (2026, April). Cross-platform development: React Native 0.85 gets new animation backend. https://www.heise.de/en/news/Cross-platform-development-React-Native-0-85-gets-new-animation-backend-11258964.html

[8] Meta Engineering. (2024, December). React Native New Architecture Performance Benchmarks. Meta Engineering Blog. https://engineering.fb.com/2024/12/18/android/react-native-new-architecture/

[9] React Native Community. (2026). React Native Upgrade Helper. https://react-native-community.github.io/upgrade-helper/

[10] Open Source For You. (2026, April). React Native 0.85 Boosts Open Source Core With New Animation Backend. https://www.opensourceforu.com/2026/04/react-native-0-85-boosts-open-source-core-with-new-animation-backend/

Last updated: April 2026. All code examples use React Native 0.85, React 19.2, TypeScript 5.x, and Node.js 22+.