React Native 0.87 release marks a significant milestone in framework modernization and toolchain stability

The React Native ecosystem has officially reached a new operational threshold with the release of version 0.87. This update serves as a cornerstone for the framework’s ongoing evolution, prioritizing type safety, build system efficiency, and a reduction in dependency complexity. By transitioning the Strict TypeScript API to the default standard and introducing experimental support for the Swift Package Manager (SwiftPM), the React Native team is signaling a decisive move toward modern development paradigms that favor native integration and long-term maintainability.

The Evolution of Type Safety and Developer Experience

The primary shift in this release is the promotion of the Strict TypeScript API to the default JavaScript API for all React Native projects. This transition is not merely a syntactic preference but a structural overhaul of how developers interact with the framework’s surface area. Originally introduced as an opt-in preview in version 0.80—concurrent with the deprecation of deep imports—the Strict TypeScript API provides a more robust, predictable, and self-documenting development environment.

For developers, the implications are immediate. The integration of comprehensive doc comments directly into type definitions means that IDEs can now surface rich metadata, such as property descriptions and usage guidelines, upon hovering over components like TextInput. This improvement significantly lowers the cognitive load for developers working within large codebases. By mandating these strict types, the framework aims to minimize runtime errors caused by type mismatches, a common pain point in large-scale JavaScript applications.

While this change introduces intentional breaking changes, the core team has provided a structured migration path. Developers are encouraged to utilize the migrate-to-strict-api skill through the community-led migration tools to streamline the transition. For teams unable to immediately refactor their projects, a temporary opt-out bridge remains available through the remainder of the 0.88 release cycle, allowing for a phased adoption of these new standards.

Modernizing the iOS Build Pipeline: Swift Package Manager

In a move that addresses long-standing developer feedback regarding build complexity, React Native 0.87 introduces experimental support for the Swift Package Manager (SwiftPM) on iOS. For nearly a decade, CocoaPods has been the de facto standard for managing native dependencies in React Native projects. However, the reliance on Ruby-based tooling and the often-opaque nature of the Podfile have historically been sources of friction for developers.

The new SwiftPM implementation offers an alternative that leverages the native Apple build ecosystem. By consuming prebuilt XCFrameworks, this approach allows for a "pure" Xcode experience, effectively removing the requirement for Ruby and Bundler in the iOS build process. The transition is additive rather than subtractive; projects can continue to use CocoaPods if desired, but those opting for SwiftPM will find a more integrated workflow where dependency changes are automatically detected by the project structure without the need for manual pod install commands.

This shift required a fundamental rethink of how React Native distributes its own binaries. The introduction of headers-only frameworks ensures that namespace resolution is more precise and adheres to the strict standards required by SwiftPM. While the feature is currently experimental, it represents a long-term strategic pivot toward reducing the "black box" nature of build tools in favor of standardized, native-first solutions.

Infrastructure Requirements and Build System Updates

The release of 0.87 also mandates significant upgrades to the underlying toolchain. As the industry moves forward, React Native has raised its minimum requirements to Node.js 22, the Android Gradle Plugin (AGP) 9, and Kotlin 2.0+. These requirements ensure that projects benefit from the latest performance improvements, security patches, and language features provided by these upstream vendors.

The inclusion of support for AGP 9 is particularly noteworthy. As a major release from the Android team, AGP 9 introduces significant changes to the build DSL (Domain Specific Language). React Native 0.87 provides a temporary configuration path for developers to opt out of the new built-in Kotlin and DSL behaviors, providing a grace period before these features become mandatory in future AGP versions. This cautious approach reflects the framework’s commitment to stability, ensuring that developers are not forced into breaking changes before they are ready to address them.

Additionally, Metro—the JavaScript bundler that powers React Native—has been updated to version 0.87. This update brings a suite of performance optimizations, particularly in the areas of module resolution and cache management. By making Metro faster and leaner, the framework continues to chip away at the latency that can impact the development cycle of large, cross-platform applications.

Chronology of the 0.87 Development Cycle

The path to 0.87 was marked by a series of iterative releases and community-driven discussions. The journey began in mid-2025 with the 0.80 release, which first signaled the intent to deprecate legacy deep imports and introduced the experimental Strict TypeScript API. This period of approximately six months allowed the React Native community to pressure-test the new type definitions and provide feedback on potential incompatibilities.

During this time, the React Native community engaged in several Requests for Comments (RFCs), including the pivotal RFC #0994, which outlined the design for SwiftPM integration, and RFC #1006, which mapped out the ecosystem-wide transition to AGP 9. This transparent, collaborative process has been a hallmark of the framework’s governance, allowing developers to anticipate breaking changes well in advance of the final release.

Impact Analysis and Broader Implications

The release of 0.87 suggests that React Native is entering a period of "maturation by simplification." By forcing a shift toward strict typing and native-first build systems, the core team is effectively narrowing the scope of supported configurations. While this may increase the short-term burden on maintainers of legacy applications, the long-term benefit is a more cohesive and predictable ecosystem.

The move toward SwiftPM, for example, is likely to improve the onboarding experience for developers coming from native Swift/iOS backgrounds, as the tooling will feel more familiar and integrated. Similarly, the enforcement of Strict TypeScript will likely reduce the frequency of "undefined is not a function" errors, which have historically plagued JavaScript development.

However, the rapid escalation of minimum toolchain requirements—specifically the shift to Node.js 22 and Kotlin 2.0—underscores the need for organizations to maintain a disciplined approach to dependency management. The "Upgrade Helper" provided by the community is no longer just a recommendation; it is an essential tool for navigating the frequent and necessary updates that define the modern React Native experience.

Looking Ahead: The End of Legacy Support

The release of 0.87 is a clear signal that the window for legacy support is closing. With 0.84.x now classified as unsupported, the framework is pushing the community toward a unified standard. The explicit intent to remove legacy TypeScript types in the 0.88 release confirms that the current "opt-out" mechanism is a temporary bridge, not a permanent solution.

As the ecosystem continues to evolve, the focus will likely remain on reducing the reliance on external build-tooling wrappers and improving the speed of the development feedback loop. With 265 commits from 74 contributors, the 0.87 release demonstrates that the community is not only keeping pace with these changes but is actively driving the innovation required to keep React Native competitive in an increasingly demanding mobile development landscape.

For teams currently evaluating their upgrade strategy, the priority should be the audit of existing TypeScript configurations and an assessment of their iOS project structure. By addressing these items in alignment with the 0.87 standards, organizations can ensure that they are well-positioned to leverage the performance and reliability improvements that this release offers, while avoiding the technical debt that comes with delaying essential infrastructure updates.