On-Device Intelligence with React Native: Building TurboModules Using TensorFlow Lite

Editor’s Note:
This blog is based on a React Native meetup hosted by GeekyAnts. The session was led by Sarthak Bakre, Software Development Engineer II at GeekyAnts, who delivered a highly practical walkthrough of integrating AI models directly within mobile devices using TensorFlow Lite and TurboModules. His talk explored how React Native developers can harness native performance, offline capability, and privacy by moving AI computation closer to the edge, right where users interact.

When I think about AI in mobile apps, many people default to cloud-based models like OpenAI or Gemini. These tools are powerful and easy to integrate, especially when you need something fast or flexible. But they come with trade-offs—subscription costs, latency, and loss of control over data.

That’s why I started exploring on-device intelligence. Instead of relying on the cloud, I wanted to run lightweight AI models directly within the app. This approach removes network dependency, improves responsiveness, enhances privacy, and provides better control over performance.

Most people do not realize that they are already using on-device AI every day. Take your phone’s camera, for example. The moment it detects a face or blurs the background—that’s AI. When you open the gallery and find your images grouped by events or people, that’s an image classification model running locally. Even features like Magic Editor in Android work without ever sending your photos to a server.

This got me thinking: if such models are already enhancing user experience, why not bring that same intelligence into the apps we build with React Native?

React Native’s modern architecture makes this possible. TurboModules, introduced alongside the JSI (JavaScript Interface), let you communicate with native code directly—no serialization, no JSON bridge overhead. This allows native modules to operate faster, execute asynchronously, and even lazy-load, which reduces memory consumption.

TensorFlow Lite, on the other hand, is designed for mobile AI. It offers pre-trained models optimized for speed, size, and hardware integration. Combined with TurboModules, it becomes a powerful way to run native ML pipelines within a cross-platform app, without sacrificing performance or UX.

To make this real, I built a TurboModule that connected a TensorFlow Lite object detection model with React Native. I started by generating the gluestack.io using TypeScript interfaces. This defined the methods that would be implemented natively and exposed to JavaScript.

On Android, I used Kotlin to build the native module. It loaded the model, parsed the input image, ran inference, and returned results—like classification and confidence scores. On iOS, I wrote the same logic in Objective-C++ and integrated it into Xcode. Both sides were tied together by the TurboModule interface, which ensured performance remained consistent and responsive.

By running inference on a background thread, I ensured the UI thread remained unaffected. This gave the app a native feel, with zero lag and full control over the model’s behavior.

I used TensorFlow’s model zoo to source the TF Lite model. These models are designed for common use cases like object detection, text classification, and image segmentation. Before implementing, I analyzed the model using Netron—an open-source visualization tool. It helped me understand the expected input and output tensors, so I could prepare the data accordingly.

This step matters. If you misinterpret the input format—like channel size or image dimensions—the model fails silently. Debugging becomes painful. Netron helped me avoid that.

There were moments when things broke without clear errors. Tensor formatting, memory allocation, and mismatch between expected and returned tensors caused issues. These problems do not show up in cloud APIs—they are unique to native ML workflows.

The other challenge was balancing cross-platform logic. I had to write native code for both Android and iOS, but ensure the interface stayed consistent. It required patience, good tooling, and a strong understanding of platform-specific differences.

But the payoff was worth it. The final app could run object detection on-device, without internet access, with excellent speed and full privacy.

On-device AI is not a buzzword—it is a technical shift. I see a future where apps will run compact language models, offer contextual predictions, and personalize content in real-time—all without calling a server. This is where React Native, when combined with TurboModules and TensorFlow Lite, shines.

The barrier is not capability—it is awareness. Once developers see what is possible, I believe more teams will invest in this architecture.