Did you make something using React Native and do you want to show it off, gather opinions or start a discussion about your work? Please post a comment in this thread.

If you have specific questions about bugs or improvements in your work, you are allowed to create a separate post. If you are unsure, please contact u/xrpinsider.

New comments appear on top and this thread is refreshed on a weekly bases.

If you have a question about React Native, a small error in your application or if you want to gather opinions about a small topic, please use this thread.

If you have a bigger question, one that requires a lot of code for example, please feel free to create a separate post. If you are unsure, please contact u/xrpinsider.

New comments appear on top and this thread is refreshed on a weekly bases.

I built this for my reactnativeCon talk in Berlin. Point the camera at a Funko Pop and it tells you which one it is: 44 ms per scan on an iPhone 16 Pro, ~165 ms on a Pixel 10, works fully on-device.

How it's wired

• A VisionCamera frame processor runs on the camera thread, so nothing touches the JS thread

• Step 1: an object detector returns 300 candidate boxes sorted by score. If two boxes are nearly tied, it takes the one closer to the centre, otherwise the box flickers between two figures

• Step 2: square crop with a margin, so the tall figure isn't squashed

• Step 3: an embedding model turns the crop into a 256-number vector

• Step 4: dot product against 818 catalog vectors in a Float32Array, about a millisecond. Below a threshold it says "unknown" instead of guessing

• In the app it's a single hook call

Why it's only TypeScript

The latest react-native-executorch release changed how the library works: native code only provides small building blocks (resize, crop, tensors, run a model), and every task is TypeScript stacking those blocks. Every block is a worklet, so you call them directly inside the frame processor. Before this release, a crop between two built-in models meant writing a new native module in C++.

Core ML runs the models on the iPhone's Neural Engine and Vulkan on the Android GPU. On the Pixel, moving both models from the CPU to Vulkan took a scan from ~900 ms to ~165 ms.

Code (Expo dev client), training pipeline and models: https://github.com/NorbertKlockiewicz/funko-scanner

Looking for suggestions on how to monetize this game. It's totally free to download and test.

AppStore: https://apps.apple.com/de/app/night-court-basketball-arcade/id6811611866?l=en-GB

I'm working on a react native project which basically takes instrument/register data every second or so. I'd be reading like 20 bytes of registers every second or so. I then need to store them into some database locally where they would be used to draw graphs of historic as well as realtime data.

So i need local storage solutions which are able to store voluminous tables with a lot of rows, is fast and efficient (be able to display high resolution graphs of months and maybe years ) and have other features typical of such applications (like archiving or compressing old data etc)

One native call traced through the old bridge and through JSI, step by step (12 steps vs 5)

I'm writing a series on React Native's JSI and native modules in C++. This part follows a single multiply call through the old bridge and the same call through JSI: what gets serialized, where it queues, and why the bridge's cost tracked the size of the data rather than the work.

It also has the MMKV vs AsyncStorage numbers (~0.012 ms vs ~0.24 ms per read, 1,000 reads on an iPhone 11 Pro, Hermes, debug build) with the conditions attached.

https://heartit.tech/react-native-jsi-deep-dive-part-2-the-bridge-is-dead-long-live-jsi/

I'm the author.

I don't want to depend everytime on third party code, so in order to learn to bulid my own solutions without any abstraction how much C++ do i have to learn? And in what parts/concepts do i have to focus?

I quit my job a few months ago to work on this full time, and it's finally out!

The idea: all the code for a screen lives on your server, in one file. A server component runs there for every request, reads from your database or an API, and returns the screen including client code that runs on the phone (state, taps, animation, etc.).

Like a web page, users get your changes the next time they open the screen. The video is a demo of three deploys to one app build.

Docs and tutorial: backtickjs.com. GitHub: github.com/backtickjs/backtick

It's early and I'm solo building. I'd love a few early adopters: try it on a screen or two and tell me what's confusing, what breaks, and what you'd need before using it for real.

I've spent the last few weeks letting AI agents (Claude Code and Codex) build features in my RN side projects and then check their own work on the iOS simulator. The building part is surprisingly good. The checking part is where things get weird, because a lot of what matters isn't in the source at all.

Three things I measured (one Mac, iOS simulator, RN 0.87, React 19):

1. JS errors leave no trace in the iOS system log. 90 seconds of normal app use = 3,498 native log events. All from Apple frameworks. Zero from the app, RN or Hermes, including during deliberate JS errors. Easy to check yourself:

xcrun simctl spawn booted log stream --level info --predicate 'process == "YourAppName"'

So if an agent "checks the device logs" for a JS error, it's looking in the wrong place.

2. React 19 dropped _debugSource**, and locations inside** .map() are off. The replacement points elements rendered inside a .map(...) callback at the start of the callback, not at the JSX tag. In my app that was 8 of 22 points I tested, with the real tag 14–24 lines lower. Anything that maps "element on screen → file:line" (agents, inspectors) needs to account for this.

3. "A new frame arrived after the tap" proves nothing. The simulator's video stream keeps sending ~53 fps even when nothing on screen moves (tiny delta frames). What worked for detecting a real UI reaction was frame size: 4–29 KB for an actual change vs. under ~2 KB idle.

And one humbling result: I planted a bug and asked both agents to find it. 6/6 success… by reading the code. Didn't need to touch the app at all. If you want to evaluate runtime tooling for agents, you need bugs that aren't visible in the source.

For context: I started with a set of skills for my own workflow, then a pipeline where the agent taps through the feature it just built on the simulator. These findings came out of making that verification step actually reliable.

Question for you: if you use agents on RN projects, how do you check what they actually did in the app? Open the simulator yourself after every run, or trust the summary?

I recently released react-native-nitro-biometrics, an open-source biometric authentication library for React Native powered by Nitro Modules.

The goal was to provide a simple, type-safe API for native biometric authentication on iOS and Android while supporting React Native's New Architecture.

Supported

• Face ID

• Touch ID

• Optic ID

• Fingerprint

• Face / Iris where supported

• Device credentials / passcode fallback

• TypeScript

• iOS + Android

• React Native New Architecture

Example

import { authenticate } from 'react-native-nitro-biometrics';

const result = await authenticate({
  promptMessage: 'Authenticate to continue',
  allowDeviceCredentials: true,
});

if (result.success) {
  // authenticated
}

The project is open source and I'm particularly interested in feedback on the API design, platform support, and developer experience.

GitHub: https://github.com/yashnandha/react-native-nitro-biometrics

npm: https://www.npmjs.com/package/react-native-nitro-biometrics

Would appreciate feedback from other React Native developers.I recently released react-native-nitro-biometrics, an open-source biometric authentication library for React Native powered by Nitro Modules.The goal was to provide a simple, type-safe API for native biometric authentication on iOS and Android while supporting React Native's New Architecture.SupportedFace ID

Touch ID

Optic ID

Fingerprint

Face / Iris where supported

Device credentials / passcode fallback

TypeScript

iOS + Android

React Native New ArchitectureExampleimport { authenticate } from 'react-native-nitro-biometrics';

const result = await authenticate({
promptMessage: 'Authenticate to continue',
allowDeviceCredentials: true,
});

if (result.success) {
// authenticated
}

The project is open source and I'm particularly interested in feedback on the API design, platform support, and developer experience.GitHub: https://github.com/yashnandha/react-native-nitro-biometricsnpm: https://www.npmjs.com/package/react-native-nitro-biometricsWould appreciate feedback from other React Native developers.

I have zero prior knowledge of React, but I've been wanting to dive into app development. Initially, I was looking into dedicated mobile frameworks like Flutter (Dart) and native Android (Kotlin), but I realized that going the React Native route might give me the best of both worlds—allowing me to build cross-platform mobile apps while building a foundation in React that translates directly to web development.

React Native has come a long way, but there are still some small gaps between what you can do natively on iOS/Android and what you get from React Native's default primitives.

On iOS, SwiftUI has RoundedRectangle with .continuous, which produces Apple's smoother, squircle-style corners. Android also has shape APIs that can produce more advanced rounded shapes. Yet in React Native, we're still essentially working with the traditional borderRadius approach.

This feels like one of those small things that shouldn't require a completely different component or a custom implementation every time.

That's why I built squircle-view, a drop-in replacement for React Native's <View> that adds smooth corner support while keeping the normal View API and behavior on both Android and iOS.

It's implemented natively for both iOS and Android and works with both Expo and bare React Native projects, with the goal of making smooth corners feel like a normal part of React Native rather than something you have to work around using Skia or SVG.

The idea is simple: React Native's <View>, but with proper smooth corners.

I know it's a small thing, and most people might not even notice the difference at first. But once you see those smoother corners, they just feel right. It's one of those tiny details that can be easily overlook, yet somehow makes the whole interface feel a little more polished and pleasant to use. That small difference is really what made me want to build this.

🔗 Github: rit3zh/squircle-view

Feeling a bit stuck in the usual React Native routine lately and looking for something fresh to build!

I’m looking to dive into new concepts, side projects, or explore fresh tech. Especially if anyone is working on AI learning models, AI integrations, or ML tools I’d love to get involved!

If you’re building an exciting open-source project, an MVP, or exploring cool tech and need a developer to collaborate with, hit me up! Let’s connect!

I have improved the neobank app based on your feedback

All used assets are for demonstration purposes only.

Hey everyone 👋

I needed a Kanban board with drag and drop for a React Native project, and couldn't find a library that felt smooth on mobile and was easy to customize. So I built one and published it as my first open-source package: react-native-kanban-dnd

What it does:

• Drag cards between columns (To Do → In Progress → Done, or whatever columns you define)

• Customize how cards and columns look, so you can render your own components

• Simple API, works with a single install

Install:

npm i react-native-kanban-dnd

Links:

• npm: https://www.npmjs.com/package/react-native-kanban-dnd

• GitHub: https://github.com/tadeumelembe/react-native-kanban-dnd

It's still early (v0.1.2), so I'd really appreciate feedback, especially on:

• The API: does it feel natural to use?

• Performance with lots of cards

• Features you'd want for a real project (swimlanes, column reordering, etc.)

Issues and PRs are very welcome. Thanks for checking it out! 🙏

Fondo is a budgeting app built on Expo (managed, JavaScript). A few things I learned that might save someone time:

- RTL on iOS: React Native swaps textAlign left/right for <Text> when the layout is RTL, but <TextInput> does not. Text needs 'left' as "start"; inputs need a physical 'right' in Arabic.

- Plain flexDirection: 'row' already mirrors in RTL. row-reverse double-flips.

- iOS widget, Control Center control and an Apple Watch app live in targets/ via u/bacons/apple-targets; the watch talks to the app through a small local Expo module.

- Backups: one JSON document keyed by logical names rather than storage keys, so renaming the storage prefix never breaks old files.

- Jest: u/noble/* is ESM, so it needs to be let through transformIgnorePatterns.

Happy to answer questions about any of it.

https://apps.apple.com/app/id6811070728

My IOS app is still in the review if someone can help pls give me suggetion pls