Native Module Integration
React Native covers most app requirements through the JavaScript ecosystem – but some features require deep access to native platform APIs that no ready-made package provides.
Native Modules Beyond the JS Ecosystem
We write native modules in Swift, Kotlin, and Objective-C and integrate them seamlessly into your React Native app, giving you access to any device capability without giving up cross-platform advantages.
The essentials of Native Module Integration
- We write native modules in Swift, Kotlin and Objective-C and integrate them seamlessly into your React Native app, giving you access to any device capability.
- Before writing native code, we always check whether a maintained open-source package meets the requirement – custom modules are a last resort.
- Depending on the call, we choose between the classic bridge and the synchronous, type-safe turbo module of the new architecture for frequently called native functions.
- We implement iOS in Swift and Android in Kotlin, both speaking through an interface typed in TypeScript that hides the platform differences.
- We handle the error case cleanly – missing hardware, denied permission, SDK errors – because these paths decide the robustness of the module.
When Native Modules?
Native modules are needed when no maintained package exists, a specific hardware feature is required (special Bluetooth profiles, proprietary SDKs), or existing native libraries must be embedded in the React Native app. We always check whether a ready-made package suffices before writing native code.
Turbo Modules
The new React Native Architecture uses Turbo Modules for significantly more performant native bridge communication. We implement native modules directly as Turbo Modules when you are on the new architecture – for synchronous calls and type-safe interfaces between JavaScript and native code.
iOS and Android
We implement native modules for both platforms: Swift or Objective-C for iOS, Kotlin or Java for Android. The JavaScript API is identical on both platforms; the implementation underneath is platform-specific. This keeps your React Native code platform-agnostic.
Testing and Debugging
Native modules are particularly error-prone because they bridge the gap between JavaScript and native code. We write unit tests for the native implementations and integrate logging mechanisms that make problems at the bridge boundary visible.
Package-First Decision Process
Before a single line of native code is written, every requirement runs through this evaluation path. The effort of building a custom native module is only justified once all upstream options have truly been exhausted.
Ecosystem Check
Search for well-maintained open-source packages that already cover the requirement.
Package Assessment
Review active maintenance, OS compatibility and licence of any candidate.
Choose Module Type
Classic Bridge for infrequent calls, Turbo Module for frequent or latency-critical functions.
Platform Implementation
Swift on iOS, Kotlin on Android — both encapsulated behind a shared TypeScript API.
Error-Path Hardening
Handle missing hardware, denied permissions and SDK errors gracefully and explicitly.
Custom native modules are the last resort — not the first step.
Bridge vs. Turbo Module
The choice of communication architecture between JavaScript and native code directly affects latency, type safety and maintainability. Which model fits which use case?
| Classic Bridge | Turbo Module | |
|---|---|---|
| Call model | asynchronous | synchronous possible |
| Type safety | enforce manually | TypeScript-typed |
| Architecture | old architecture | new architecture (RN 0.68+) |
| Performance in critical path | ||
| Implementation effort | lower | higher |
| Recommended for | infrequent calls | frequent / latency-sensitive calls |
The wrong choice produces either unnecessary complexity or exactly the latency you were trying to avoid.
What matters for Native Module Integration
What matters first with native modules is the decision not to write them unless you must. A well-maintained open-source package is almost always the better choice than your own native code, because it is used by many and kept current with every OS update. We check the ecosystem first and reach for native code only when nothing there holds up.
If a custom module is needed, the choice between the classic bridge and a turbo module decides. For rarely called functions, a classic module is enough. If a native function is called often and on the critical path, the synchronous, type-safe turbo module of the new architecture pays off. The wrong choice creates either needless complexity or exactly the latency you wanted to avoid.
A good native module hides the platform differences behind a clean JavaScript API. iOS is implemented in Swift, Android in Kotlin, and both speak through an interface typed in TypeScript, so the app developer never needs to know what happens underneath. A leaky abstraction that lets native quirks show through into JavaScript is a future source of bugs.
And a native module is only finished once the error case is handled cleanly. What happens when the hardware is missing, the permission is denied, or the SDK throws an error? These paths decide robustness but are easily forgotten in a happy-path test.
Bridge vs. Turbo Module
Classic native modules communicate asynchronously over the JavaScript Bridge. Turbo Modules (new architecture) enable synchronous calls and type-safe interfaces – significantly more performant for frequently called native functions.
Swift, Kotlin, TypeScript
We write iOS implementations in Swift, Android implementations in Kotlin, and the JavaScript API in TypeScript. Each layer in the language optimised for it.
Package-First Approach
Before writing native code, we always check whether a maintained open-source package meets the requirement. Custom native modules are a last resort, not a first step.
Native power where it counts
With us you're always one step ahead technologically and tap directly into our extensive app development expertise. We take a close look at your app idea, identify key success factors and create tailor-made applications. Your visions and goals are at the heart of our joint project work.
Expert knowledge in app technologies
React Native, Flutter, native iOS and Android: we pick the stack to fit your project, not our preference.
Comprehensive user experience know-how
Intuitive operation and seamless interactions decide ratings and how long users stay in the app.
Proven track record
Published apps in the App Store and Play Store, from MVP to mature platform.
Versatile team
Concept, design, development and backend come together in one team that works without interface friction.
Long-term partnerships
We stay after launch and keep evolving your app with maintenance and updates.
READY FOR YOUR APP THAT SETS NEW STANDARDS?
Related articles from our blog
Frequently asked questions