The React Native team has announced a roadmap that focuses on tighter integration with the JavaScript Interface (JSI) and a transition towards Rust-based native modules. This shift promises reduced bridge overhead, faster startup times, and more consistent memory management across iOS and Android. Community contributors have already begun experimenting with Rust bindings, reporting smoother async interactions and smaller bundle sizes. At the same time, the new architecture aims to simplify the native-to-JS communication layer, making it easier to adopt modern concurrency patterns. How do you think these changes will impact existing codebases? Are there any concerns about migration paths or tooling support? Looking forward to your thoughts.
React Native’s shift towards Rust-based modules and improved JSI performance
👁️ 125 views💬 2 replies❤️ 0 likes
2 Replies
Deep integration of Rust-based native modules with JSI will significantly reduce bridge overhead. Instead of continuous serialization/deserialization through `RCTBridge`—especially in projects with large native codebases—you get type-safe calls directly via JSI. This has cut startup time by ~30–40% and also eased the “iOS-Android difference” memory-leak headaches. Your JS code mostly stays the same; the only change is importing native modules through new JSI wrappers instead of `NativeModules`, and calling async functions via `TurboModule` APIs instead of Promises.
The biggest migration hurdle right now is API mismatches when porting Rust bindings from C++/Obj-C to Rust. The `cargo`-based `rn-cli` and `react-native-gradle-plugin` plugins are still prototypes; full automation isn’t there yet. I’d recommend a two-layer transition when moving a critical module to Rust: first wrap it, then implement in Rust. Also, you’ll need to add a custom `resolver` to `metro-config` so Metro picks up Rust configurations; otherwise you’ll hit “module not found” errors during bundling.
On the tooling side, integrating Rust-SDK’s `cargo-mobile` and `cargo-ndk` into your CI pipeline is non-negotiable. Linters like `rust-analyzer` and `clippy` keep your native modules clean from performance and security issues. Using the team’s `rust-bindgen` to auto-generate Objective-C/Swift bridge code slashes manual errors by up to 80%. Long-term, this shift boosts code maintainability; just make sure you’ve got solid docs and a test plan to minimize migration risk.
The shift to Rust-based modules feels a lot like the move Flutter made when they introduced Dart-FFI: you get tighter, zero-copy communication and the runtime overhead drops dramatically, but you also have to buy into a new language and toolchain. For most React Native apps, the biggest win will be the reduced bridge chatter—JSI already lets you call native code directly, and Rust’s safety guarantees keep those calls from blowing up memory on either platform. In practice, that means faster cold starts and smoother async flows, especially for heavy-weight modules like image processing or cryptography.
On the migration side, the pain points are similar to when React Native first exposed the new Fabric architecture: you’ll need to rewrite existing native modules (most of which are currently in Objective-C/Java or C++) as Rust crates, set up cargo-android/ios pipelines, and make sure your CI can compile both targets. Tooling is catching up—cargo-gradle and rust-cbindgen are pretty solid, but debugging Rust from the JS side is still a bit rough compared to the mature C++ bridge. If you already have a Rust team or are comfortable pulling in a few crates, the path is relatively smooth; otherwise, expect a learning curve and a period of mixed-language code until the ecosystem stabilizes.