Welcome to a landmark release in the React Native ecosystem. Version 0.82 doesn't just bring the usual refinements; it marks a definitive break from the past. After years of coexistence, the legacy architecture has been completely removed, and the framework now stands solely on the New Architecture. This guide unpacks the ten most crucial changes, from the mandatory migration to the experimental Hermes milestone version, and explains what these mean for your development workflow, your app's performance, and your third-party dependencies.
1. The Legacy Architecture is Gone – New Architecture Only
React Native 0.82 is the first version that only supports the New Architecture. If you attempt to set newArchEnabled=false on Android or RCT_NEW_ARCH_ENABLED=0 on iOS, those flags will be ignored. Everything—from the bridge replacement to the improved Fabric renderer and TurboModules—is now native. This exclusivity unlocks streamlined performance, better memory management, and a codebase that's easier to maintain. For developers, it means there's no more juggling two sets of configs or worrying about legacy compatibility. The framework is now fully committed to the new foundation, and future releases will build exclusively on this architecture.
2. Your Migration Path: Start with 0.81
If you haven't migrated yet, don't jump directly to 0.82—start with React Native 0.81 (or Expo SDK 54). These are the last versions that allow you to use the Legacy Architecture. They include specific warnings and performance tweaks designed to ease the transition. First, enable the New Architecture in 0.81 and test thoroughly. Once your app runs smoothly, you can upgrade to 0.82. Skipping this step could break your app because the legacy fallback won't be available. The recommended path ensures you catch issues early, especially those related to third-party libraries that may still rely on legacy APIs.
3. What About Third-Party Libraries?
Compatibility with third-party (3P) libraries is a natural concern. The good news: libraries that already offer backward compatibility with both architectures will continue to work under 0.82. However, if a dependency only supports the legacy architecture, it will break. The React Native team has verified that most popular libraries with dual support are unaffected. For those that aren't, the best course is to reach out to the library maintainers directly. The team also plans to keep interop layers in the codebase for the foreseeable future, meaning class and function fallbacks remain available. Removal of those layers will be announced separately, giving library authors time to adapt.
4. Interop Layers Stay—For Now
Interop layers bridge the gap between legacy and new architecture components. In 0.82, these layers are not removed. All classes and functions required by them still exist, ensuring that libraries using legacy patterns don't immediately crash. This is a deliberate decision to give the ecosystem time to fully transition. The team has stated they will share future updates on when these interop layers will be phased out. For now, you can rely on them to maintain functionality while you work with library maintainers to upgrade to native modules or Fabric-compatible components.
5. Legacy Architecture APIs Stay (Temporarily)
To minimize breaking changes, the removal of legacy API classes (like RCTView, RCTEventDispatcher, etc.) has not happened yet. The React Native core still includes those APIs so that existing codebases can continue to compile. However, this is only a temporary reprieve. The removal is scheduled to begin with the next version. The goal is to reduce the overall bundle size significantly. RFC0929 outlines the plan. If your code references any legacy API directly, start refactoring now to avoid sudden breaks in the near future.
6. Experimental Hermes V1: A New JavaScript Engine Baseline
Version 0.82 introduces an opt-in experimental feature: Hermes V1. This is a newer version of the Hermes JavaScript engine that brings enhancements in startup time and memory footprint. While still experimental, it signals the direction for future Hermes updates. Developers can enable it to test performance gains, but should expect potential edge cases. The team encourages early feedback. This update is particularly interesting for apps that rely heavily on JIT compilation or use complex JavaScript bundles, as Hermes V1 refines optimizations introduced in earlier Hermes releases.
7. React 19.1.1: New Features and Bug Fixes
With 0.82, React Native bumps its React dependency to version 19.1.1. This brings all the latest React 19 features, including improvements to concurrency, better server components (for use with React Native Web or custom bridges), and various bug fixes. The updated version also enhances the behavior of hooks like useEffect and useMemo in native environments. Importantly, it ensures that the New Architecture's threading and rendering model takes full advantage of React's concurrent capabilities. This is a foundational upgrade that will influence how you write components going forward.
8. Support for DOM Node APIs
React Native 0.82 ships with support for DOM Node APIs. This means that in certain contexts (especially when using React Native Web or very new native implementations), you can now call standard DOM methods like getBoundingClientRect(), addEventListener with passive options, or manipulate element properties directly. While not a full browser DOM, this brings web developers closer to a unified API. It's particularly useful for cross-platform libraries that need to abstract layout measurements or event handling. This feature is experimental but documented, and it's expected to become more robust in later releases.
9. Performance Gains from Architecture Consolidation
By removing the legacy architecture, the team has simplified the rendering pipeline and reduced the overhead of maintaining two code paths. Early benchmarks show improvements in startup time (up to 10-15% on some devices) and smoother animations, thanks to Fabric's synchronous rendering. Additionally, the exclusive use of TurboModules eliminates the serialization overhead that existed with the old bridge. Memory usage also drops because the JSI integration avoids creating full copies of data. While not a complete rewrite of every internal, these cumulative optimizations make 0.82 noticeably faster for most apps.
10. Preparing for Future Versions: Roadmap Ahead
0.82 is just the beginning. The team has indicated that the next major versions will remove legacy API classes entirely, delete interop layers, and further shrink the JavaScript bundle. They are also working on improved Hermes profiling, better error handling, and deeper integration with React 19's concurrent features. For developers, the key takeaway is to ensure your codebase is fully compliant with the New Architecture. If you still rely on legacy or third-party libraries without dual support, start building migration plans now. The window for legacy compatibility is closing fast.
React Native 0.82 is more than a version bump—it's a resolution. By fully committing to the New Architecture, the framework has shed its transitional baggage. The road ahead is leaner, faster, and more predictable. Whether you're eagerly adopting the experimental Hermes V1 or carefully stepping through the migration guide, these ten points give you the map. The future of React Native is here, and it's architecturally unified.