React Native 0.87 release introduces strict TypeScript integration and experimental Swift Package Manager support

The release of React Native 0.87 marks a significant evolution in the framework’s development lifecycle, emphasizing stricter type safety, modern build toolchains, and a pivot toward more efficient iOS dependency management. This update, which serves as the latest stable iteration of the framework, mandates a transition to the Strict TypeScript API as the default JavaScript interface, effectively deprecating legacy patterns that have persisted for years. Alongside these architectural shifts, the release enforces updated minimum requirements for Node.js, the Android Gradle Plugin, and the Kotlin language, signaling a broader industry-wide migration toward modern development standards.

The Shift Toward Type-First Development

The adoption of the Strict TypeScript API as the default is the defining characteristic of the 0.87 release. First introduced as an opt-in feature in version 0.80, this initiative aimed to resolve the ambiguity inherent in legacy JavaScript imports. By forcing a standardized type-safe interface across the ecosystem, the core team intends to eliminate common runtime errors that arise from loosely typed components.

From a developer experience standpoint, this change manifests in enhanced IDE support. By hovering over standard components such as TextInput, developers now receive comprehensive type documentation and metadata, a feature that was previously inconsistent or entirely missing under the legacy system. While this transition represents a substantial breaking change for many existing codebases, the core team has provided a clear migration path through ESLint fixers and an automated "migrate-to-strict-api" skill set. For organizations unable to migrate immediately, a temporary opt-out mechanism is available; however, this is explicitly framed as a bridge that will be dismantled in version 0.88, leaving no room for long-term reliance on legacy types.

Architectural Modernization: iOS and Android Toolchains

React Native 0.87 introduces a noteworthy experiment for the iOS ecosystem: support for Swift Package Manager (SwiftPM). Historically, React Native has relied on CocoaPods to manage native dependencies, a process that often requires managing Ruby environments and complex build configurations. The experimental SwiftPM support offers a streamlined alternative, allowing developers to manage dependencies directly through Xcode. This shift is designed to eliminate the reliance on third-party tools like Bundler or RubyGems, potentially reducing the friction associated with setting up and maintaining iOS development environments.

The implementation of SwiftPM requires a fundamental change in how React Native distributes its precompiled binaries. By shifting to a structure that aligns with the strict requirements of XCFrameworks, the framework now ensures that headers are resolved through standard search path mechanics. While this provides a cleaner, more robust build process, it necessitates minor syntax adjustments, specifically requiring developers to use namespaced imports (e.g., changing imports from #import to #import <React/RCTAppDelegate.h>).

On the Android front, this release is the first to officially support the Android Gradle Plugin (AGP) 9.0. This update is significant as AGP 9.0 introduces substantial changes to the Gradle build lifecycle and the underlying Kotlin integration. To manage this transition, the React Native team has recommended that developers temporarily opt out of the new "built-in Kotlin" and "new DSL" behaviors within their gradle.properties files. This strategic decision provides a buffer for the broader ecosystem to adapt to the more aggressive changes mandated by the latest Android tooling, with the expectation that these flags will be phased out in subsequent versions.

Chronology of Recent React Native Evolution

The release of 0.87 is the culmination of a multi-year effort to refine the React Native architecture. The journey began in earnest with the introduction of the New Architecture, which aimed to replace the legacy "Bridge" with the JSI (JavaScript Interface) and TurboModules.

• Version 0.80 (June 2025): The framework introduced the Strict TypeScript API as an opt-in preview and deprecated deep imports, setting the stage for the current transition.
• Version 0.84 (Late 2025): This version served as the final release before the deprecation of several legacy toolchain dependencies, effectively preparing the ground for the current strict requirements.
• Version 0.87 (Current): With the formal move to a default Strict TypeScript API and the introduction of experimental SwiftPM, 0.87 effectively draws a line under legacy compatibility, requiring teams to align with modern standards to receive further security and feature updates.

Impact on Ecosystem Stability

The transition to version 0.87 is not merely a feature update; it is an enforcement of technical debt reduction. By raising the minimum requirements to Node.js 22, Android Gradle Plugin 9, and Kotlin 2.0+, the framework is ensuring that the entire React Native ecosystem remains compatible with the latest security patches and performance improvements offered by upstream providers.

The decision to deprecate older versions, such as 0.84.x, in tandem with this release follows a well-established support policy. Organizations that fail to upgrade may find themselves increasingly isolated from the community, as the latest libraries and native modules are expected to target the 0.87+ API surface. For the developer, this means a shift in maintenance strategy: the focus is no longer just on adding features, but on maintaining a baseline of modern compatibility to ensure the longevity of the application.

Industry Perspective and Developer Sentiment

The response from the developer community, as evidenced by initial discussions on project repositories and RFCs, is one of cautious support. While the burden of migrating to the Strict TypeScript API is non-trivial for large-scale enterprise applications, the long-term benefit of a more predictable and better-documented API is widely acknowledged.

The introduction of SwiftPM, in particular, has been received as a long-awaited improvement. For years, the complexity of the CocoaPods setup has been a recurring point of frustration for teams working on cross-platform mobile development. By enabling an Xcode-native dependency management flow, the React Native team is acknowledging the need to simplify the "inner loop" of mobile development—the cycle of adding a dependency, syncing the project, and building the binary.

Broader Implications for Mobile Development

The trajectory of React Native, as evidenced by version 0.87, reflects a broader trend in mobile development: the move toward native-first integration. By aligning more closely with native build systems—like SwiftPM and the latest AGP releases—React Native is shedding its reputation as a "black box" that sits atop native code. Instead, it is becoming a more transparent layer, one that respects the constraints and best practices of the underlying platforms.

This transition also has implications for the hiring and training of mobile engineers. As the framework adopts more standard native tooling and strict type-safety, the barrier to entry for developers with a background in traditional native development (Swift/Kotlin) is lowered, while simultaneously raising the standard for JavaScript/TypeScript developers working in the mobile space.

Ultimately, React Native 0.87 serves as a benchmark for the framework’s maturity. The transition to a strict, type-safe, and modern toolchain is indicative of a framework that has outgrown its experimental origins and is now firmly positioned as a production-grade enterprise tool. For organizations, the mandate is clear: the path to future-proofing mobile investments lies in embracing these structural changes, prioritizing code quality through strict typing, and staying in lock-step with the rapidly evolving native build ecosystems. As the industry moves forward, the ability to rapidly adapt to these shifts will likely differentiate successful long-term product teams from those burdened by outdated, high-maintenance technical debt.