React Native 0.80: Key Updates and What They Mean for Developers

Welcome to the exciting world of React Native 0.80! This release packs significant improvements aimed at making your development experience smoother, more stable, and future-proof. From upgrading to React 19.1.0 to introducing a stricter TypeScript API and freezing the Legacy Architecture, there's a lot to unpack. Let's dive into the most pressing questions developers have about this update.

What major version changes does React Native 0.80 bring?

The headline change in React Native 0.80 is the upgrade of the bundled React library to version 19.1.0. This brings all the latest React features, performance optimizations, and stability fixes directly into your mobile apps. But that's not all—this release also formally freezes the Legacy Architecture, meaning it won't receive further improvements and will eventually be removed. Additionally, the JavaScript API is undergoing a cleanup: deep imports are now deprecated with warnings, and a new opt-in Strict TypeScript API provides more accurate and safer type definitions. These changes collectively pave the way for a more resilient and predictable framework.

Why are deep imports being deprecated and how should I update my code?

Deep imports—like import {Alert} from 'react-native/Libraries/Alert/Alert'—have long been an unofficial way to access internal React Native modules. The core team wants to stabilize the public API by enforcing that only exports from the root react-native package are considered stable. Starting in 0.80, you'll see ESLint and console warnings for any deep imports in your project's source code. The fix is straightforward:

// Before - import from subpath
import {Alert} from 'react-native/Libraries/Alert/Alert';

// After - import from `react-native`
import {Alert} from 'react-native';

Some APIs not exported at root will become unavailable—this is intentional to reduce the surface area. The team has set up a feedback thread and will work with the community over the next two releases to finalize which exports remain. For more details, see our dedicated post on Moving Towards a Stable JavaScript API.

What is the new Strict TypeScript API and how do I opt in?

React Native 0.80 introduces an opt-in Strict TypeScript API that gives you a preview of the future stable JavaScript API. These new types are generated directly from the source code, improving coverage and correctness while being restricted to the React Native index file. This means you'll get stronger compatibility guarantees and fewer surprises from internal file changes. To opt in, add the following to your tsconfig.json:

{
  "compilerOptions": {
    "paths": {
      "react-native": ["./node_modules/react-native/index"],
      "react-native/*": ["./node_modules/react-native/*"]
    }
  }
}

The Strict API ships alongside existing types, so you can migrate at your own pace. Most apps using standard React Native APIs should validate with no changes. Early adopters and new projects are strongly encouraged to opt in.

What does 'freezing the Legacy Architecture' mean for my app?

Freezing the Legacy Architecture means the old React Native rendering system will no longer receive new features or bug fixes. It's effectively in maintenance mode until it's fully removed in a future major release. Starting with 0.80, you'll begin to see warnings for any APIs that depend on the Legacy Architecture. These warnings are a heads-up to start migrating to the new architecture (Fabric renderer and TurboModules). If your app is still using the legacy bridge, you should plan a migration path. The new architecture offers better performance, especially for complex views, and will be the only supported way going forward.

Are iOS dependencies now prebuilt? What does that mean?

Yes, as an experimental change in 0.80, React Native iOS dependencies are now prebuilt. This means when you run pod install for iOS, CocoaPods will download precompiled binaries of React Native's native modules instead of building them from source every time. The result: significantly faster installation and build times, especially for CI/CD pipelines. This is opt-in for now and may become the default in a future release. To enable it, ensure you're using the latest CocoaPods and follow the setup instructions in the upgrade guide.

What steps should I take to prepare my project for these changes?

Here's a quick checklist for upgrading to React Native 0.80:

• Update React imports: Use the root import (from 'react-native') instead of deep imports. Run the recommended ESLint plugin to catch and fix violations.
• Consider the Strict TypeScript API: Update your tsconfig.json to opt in. Test your types—most standard code should work unchanged.
• Check Legacy Architecture warnings: If you see warnings about deprecated APIs, start planning your migration to the new architecture.
• Test prebuilt iOS dependencies: If you develop for iOS, experiment with the new prebuilt pods to speed up your builds.
• Read the full release notes on the React Native blog for any additional breaking changes or deprecations.

Remember, these changes are designed to make React Native leaner and more maintainable. Take advantage of the feedback channels to report any issues.

Will my existing app break after upgrading to 0.80?

For most apps, the upgrade to React Native 0.80 should be smooth if you follow the migration steps. The deprecation of deep imports is non-breaking—warnings appear in the console and ESLint, but your code will still run. However, if you rely on internal APIs not exported at root, you may see failures in the future when deep imports are removed. The Strict TypeScript API is opt-in and ships alongside the old types, so TypeScript projects can migrate gradually. The Legacy Architecture freezing introduces warnings but does not immediately disable functionality. In short, with careful attention to deprecation warnings and a planned migration from the legacy architecture, your app should work fine.