React Native 0.80 has arrived, bringing a major update to React (19.1), important JavaScript API stability improvements, and a clear signal that the Legacy Architecture is being phased out. This release introduces warnings for deep imports, a new opt-in Strict TypeScript API, and experimental prebuilt iOS dependencies. In this Q&A, we break down each significant change, what it means for your projects, and how to prepare for the future of React Native.

1. What is the most important update in React Native 0.80?

The headline update is that React Native now ships with React 19.1.0, the latest stable version of React. This brings all the performance improvements, bug fixes, and new features from the React 19.x line directly to React Native apps. Developers can immediately benefit from better concurrent rendering, automatic batching improvements, and updated hooks behavior. Additionally, the release freezes the Legacy Architecture, marking it as deprecated and warning developers to migrate to the New Architecture. These two changes together signal a major shift: React Native is modernizing its core to align more closely with the React ecosystem while streamlining its internal APIs.

2. Why are deep imports being deprecated and how should I migrate?

Deep imports—like import { Alert } from 'react-native/Libraries/Alert/Alert'—are being formally deprecated to stabilize React Native's public JavaScript API. The goal is to reduce the API surface area and enforce a clear boundary between internal and public modules. Starting in 0.80, you'll see ESLint and console warnings for deep imports found in your source code. You can opt out temporarily, but the team intends to remove deep imports entirely in a future release. Migration is straightforward: replace deep imports with root imports from 'react-native', e.g., import { Alert } from 'react-native'. Some APIs were never exported at the root and will become unavailable—this is intentional. Check the open feedback thread if you rely on a specific API that isn't exposed at root. The deprecation applies to your project's source code; third-party libraries may still use deep imports for now, but they will need to update eventually.

3. What is the new Strict TypeScript API and how can I opt in?

The Strict TypeScript API is a new, optional set of TypeScript types introduced in React Native 0.80. These types are generated directly from React Native's source code, giving them higher coverage and correctness. They also restrict exports to only what is in the package's index file, meaning internal file changes won't break your type checking. To opt in, add the following to your tsconfig.json:

{
  "compilerOptions": {
    "paths": {
      "react-native": ["./node_modules/react-native/types/strict"]
    }
  }
}

Once enabled, you'll experience more accurate types, better autocomplete, and stronger compatibility guarantees. The Strict TypeScript API is a preview of the future stable JavaScript API. For most standard React Native APIs, your code should validate with no changes. The React Native team encourages new projects and early adopters to opt in now. Note that the existing types remain available, so you can migrate at your own pace.

4. What does “freezing the Legacy Architecture” mean for my existing app?

Freezing the Legacy Architecture means that the React Native team has stopped adding new features or making non-critical fixes to the legacy rendering and threading systems. Starting in 0.80, you'll see warnings for APIs that are part of the Legacy Architecture. These warnings alert you to functions that will stop working once the Legacy Architecture is fully removed. For example, direct usage of UIManager methods or legacy bridge APIs will trigger console warnings. If your app currently runs on the Legacy Architecture, you are strongly advised to plan migration to the New Architecture (Fabric + TurboModules). The freeze signals that the sunset of the Legacy Architecture is imminent—likely within the next one or two major releases. Migrating early ensures your app remains compatible and can take advantage of better performance and modern debugging tools.

5. Are there any experimental changes in this release?

Yes, React Native 0.80 includes an experimental change: prebuilt iOS dependencies are now available. Previously, building a React Native app for iOS required compiling all native dependencies from source, which could be slow. The experimental prebuilt binaries allow you to skip many build steps, significantly reducing the initial build time and CI pipeline duration. To enable this, you'll need to opt in via a configuration flag. This feature is still experimental and may not work with all custom native modules. If you rely heavily on custom native code, test the prebuilt option carefully. The team is collecting feedback to stabilize this feature for a future release.

6. How does the deprecation of deep imports affect third-party libraries?

The deprecation warnings are currently scoped to your project's source code only. Third-party libraries installed via npm or yarn will not trigger these warnings in 0.80. However, this is likely temporary. The React Native team has indicated that they will work with the community over the next two releases to finalize which APIs are exported at the root. Once that process is complete, libraries that rely on deep imports will need to update their code. Library maintainers should start auditing their imports now and prepare to switch to root imports. If a library uses an API that is not available at root, it may break in future releases. The team has opened a feedback thread for users to report missing exports, so maintainers can advocate for necessary API exposure.

7. What is the timeline for removing deep imports and fully sunsetting the Legacy Architecture?

The React Native team has not announced a specific version for removal, but they have committed to at least two more releases with the deprecation warnings in place. This means React Native 0.81 and 0.82 will likely continue to support deep imports (with warnings) while the team refines the public API. A final removal could happen in React Native 0.83 or later. Similarly, the Legacy Architecture freezing marks the start of its sunset, with full removal expected within the same timeframe. The team encourages developers to start migrating now: use root imports, enable the Strict TypeScript API, and begin testing your app on the New Architecture. Early migration reduces the risk of last-minute surprises and ensures you benefit from the performance and stability improvements sooner.