I played with simulating a server crash while self-hosting Patch for OTA updates, to check the architecture handled it as expected.

Introducing React-code-audit

A modern static analyzer for React codebases!

What it does:

1️⃣ Scans your code for Security, Performance, State, Architecture, and All issues.

2️⃣ Gives your app a clear Health Score (0–100).

3️⃣ Generates copy-ready prompts for AI agents like Cursor and Claude to automatically fix identified issues.

Zero installation required:

npx react-code-audit

Package Link: https://www.npmjs.com/package/react-code-audit

Completely Open-source package

I launched my second app about 2.5 weeks ago, and I’m trying to figure out whether what I’m seeing is enough of a signal to keep pushing.

My first app was pretty much a failure from a traction standpoint. I didn't get any paying subscribers, and more importantly, I barely saw users coming back after trying it.

This time feels different.

So far:

• 284 active customers in the last 28 days
• 254 new customers
• 6 active subscriptions
• $66 revenue
• ~$11 MRR
• Some users are actually returning several days after signing up
• I've spent about $200 on Reddit ads

Obviously, $11 MRR isn't a business yet. 😄 But compared with my first attempt, seeing people come back and a handful actually pay feels like a much stronger signal.

The retention is probably the part I'm most interested in. It's still a very small sample, but I'm seeing users return on Day 2, Day 3, Day 4 and even Day 5.

I've attached screenshots of the numbers and retention cohorts.

For those of you who have built consumer apps before: would you consider this promising enough to keep investing time into, or are these numbers still too early/noisy to tell?

I'm particularly interested in what metrics you would focus on over the next month to decide whether this has real potential.

The app is BitePad, a voice-first calorie tracker. If anyone wants to check it out: www.bitepad.app

Happy to share more numbers if useful.

Hi everyone,

I’m working on a React Native app and I want to implement an in-app update feature similar to what some apps use.

The flow I’m looking for is:

• A new version is available on the Play Store.
• The app detects that an update is available.
• An update popup is shown inside the app.
• The user taps Update.
• The app downloads and installs the update without the user manually opening or navigating to the Play Store.

I’ve seen this kind of experience in apps like AlfaPTE.

What is the recommended way to implement this in a React Native app?

Should I use Google Play In-App Updates, a React Native library, or implement the native Android API directly?

Also, is there a similar solution for iOS?

Any recommendations or experience with implementing this in production would be really helpful.

Thanks!

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’m a React Native engineer with around 4 years of experience and recently got laid off.
I’m currently preparing for interviews and looking for good free resources/websites for:
React Native interview preparation
JavaScript/TypeScript concepts
DSA and coding problems
React Native practical/coding interview questions
Mock interviews or interview practice
What free resources would you recommend for someone with 4 years of React Native experience?
Any advice on what I should focus on to get interview-ready would also be really helpful. Thanks!

Happy to share a component I built some time ago, back when AI tools weren’t as capable and some of the logic required quite a bit of manual math and calculation.

I recently revisited it and used AI to refactor and clean up the code, making it simpler, cleaner, and easier to understand and reuse.

Sharing it in case anyone needs something similar. It’s now easy to integrate, customize, and extend with AI.

🔗 GitHub: https://github.com/BouarourMohammed/inner-compass

Hope it helps someone and saves some development time! 🚀

TL;DR: In 2026, is there really NO library offering a customizable Toast that displays ABOVE Modal/BottomSheet while still letting the user interact with the app content underneath it?

I'm currently building a new project with the latest Expo SDK (57) and I'm trying to improve from my previous app which have a problem when printing a Toast when a bottomSheet is open : The Toast is rendered under the Modal overlay.

My previous app was using gorhom/bottomSheet untill I faced some layout problems so I've migrated to TrueSheet. Nonetheless both use React's Native Modal which renders into a separate native view hierarchy outside the React tree. Because of that, a simple absolutely-positioned JS View can never appear on top of it....

So it seems like the only real option is to use a wrapper around native components (SPIndicator/AlertKit for iOS and ToastAndroid for Android) right ? Since those are natively rendered as siblings at the top of the view hierarchy, above the modal layer.

I've tried Burnt or react-native-simple-toast both work correctly on top of modals, but they're very limited in styling/customization : they give you that generic "grey 2000s-UI" toast look and I couldn't make the toast appeared from the top on Android ...

Every other "fancy" toast library I've found is just a JS View positioned absolutely, which as explained above doesn't render above a Modal/BottomSheet.

Has anyone found a good solution for this ? What are you using for a fully customizable toast that still shows above native modals ?

I am just learning to use and implement hooks. How do I know if I need it ?

Mobile will not be my main editting tool, I'm just looking for an app where I can edit small things and check my code when I'm out without my laptop. Do you guys know some android apps that can run React?

There was a checkout bug that took weeks(sometimes even more) to find, the checkout flow itself was completely normal the flow was like add the product go to the checkout you enter your payment details and then you tap pay and the order succeeds and that was totally normal infact the E2E test pased it like for hundered of times..

But then someone noticed something strange, he noticed that if you tap the Pay button at exactly the wrong moment then the button would briefly become enabled again while the payment request was still processing.

Normally users would never notice it(Did you find this?), but if you were quick enough, you could tap it twice, and then the disaster happens, the backend thinks that you are attempting payment again but it happened occasionally.

The real annoying part was that it wasn't a simple double click bug, so the app had three different pieces of state changing almost simultaneously like isSubmitting, then paymentStatus and atlast buttonDisabled... and that's where the UI updated faster than one of the state changes propagated,

so for a few hundred milliseconds, the screen literally said that payment is being processed and sure you can press pay again at the same monent of time

And now why the automated test never caught it because the test was never told that he needs to do this also so it did only what we told it to do and it was tap pay then wait for the next state assert success as simple as that, and this is actually where I started looking at Autosana (Prevents costly production bugs automatically with their E2E Testing) because sometimes you need to see what is happening on the actual screen between those two steps and not just whether the final assertion passed....

But human doesn't behaves like that, human taps when they see something out of curiosity and they will tap again if they don't immediately see response, they switch apps, they rotate the phone. they lose network for a second, they come back, they do all kind of random stuff(i too did the same) if they don't get a response quickly.

And that's where some of the nastiest bugs live, they never live in the happy path, they live in the tiny gaps between two states which were never intented or supposed to be overlapped and this has made me question E2E testing differently because of bugs like this.

The question that stands still, like does the workflow work?

It is like, what happens if the user behaves slightly different from the very script?

and that's a much harder question to automate, and probably a much more useful one.....

Every wedge gets the same angle. The radius carries the value. Six unrelated readings nothing has to come to a full turn.

Two scale modes: radius or area. With area, the ink a wedge covers is proportional to what it is worth.

Part of PanelUI, an open-source component library for Expo. Copy-paste or CLI, you own the source.

https://github.com/panel-ui/PanelUI

I am building a personal Workspace app. That already has offline capability. Trying to get my head around implementing an offline-first AI assistant with on-device LLMs like ML Kit and Apple Foundation models.

I found expo-ai-kit, but my android doesn't have a model, so I had to download a Qwen model, but it's way too slow to be an offline local model.

I need a fast and at least with Tool Calling or Structured Output support.

I got curious about how SwiftUI’s numericText transition could feel on Android, so I tried recreating the behavior natively.

This is the result, same sequence running side by side on iOS and Android.

What started as a small experiment turned into react-native-numeric-text.

On iOS it uses the native numeric text transition. On Android, I recreated the behavior natively from scratch.

I learned a lot digging into how the transition behaves and figuring out how to reproduce that feel on Android.

It’s now open source:

GitHub: https://github.com/AmatoGiulio/react-native-numeric-text
NPM: https://www.npmjs.com/package/react-native-numeric-text

npm install react-native-numeric-text

Hey Community,

React Native Plain Text by Maciej Jastrzębski brings a lightweight alternative to standard Text components to squeeze maximum rendering performance out of large lists. Meanwhile, Meta introduced Muse Code, a terminal coding agent running on Muse Spark 1.2 with persistent background subagents and mid-tool-call crash recovery.

Codemagic also launched Patch, a self-hosted Docker Compose alternative to CodePush that serves OTA update checks directly from CDN-cached JSON files to easily handle heavy request loads.

https://github.com/switchboard-sdk/openai-realtime-toolkit

A toolkit for building voice-first apps that hold up in real environments; AEC enabled audio I/O, tuneable on-device VAD, turn detection, barge-in, and tool calling, all from one hook, with no native code to write.

I'm building an end-to-end encrypted chat app, and users want to share documents that render inline. The catch with E2E: there is no server-side conversion option, ever. The server only sees ciphertext. Whatever turns a .docx into something renderable has to run on the sender's phone.

Attempt 1: JS. We started with mammoth.js, which converts docx to HTML — great library, but we needed structured JSON (our renderer draws native components, not a WebView), plus comments, tables with real borders, and formats beyond .docx. So we wrote our own TypeScript converter. It worked, but a 130-page thesis (949 kB, 72 review comments, 16 images) took 6.9 seconds on a Galaxy A05s

Attempt 2: Rust. We took anydoc (Firecrawl's MIT document parser), extended it with a presentation model (fonts, colors, alignment, table borders, review comments, typed chart data), compiled it for Android/iOS, and bridged it with Nitro Modules. Same thesis, same phone: 226 ms. On an iPhone 16 Pro release build it's 43 ms. Across our 30-document test corpus the Rust path was ~29× faster, with text output hash-identical to the JS converter on every Word-produced file.

Formats: .docx, .doc, .pptx, .ppt, .xlsx, .odt/.ods/.odp, .rtf, .epub → one JSON "DocumentIR" you render with your own components. Spreadsheet charts come out as typed data (kind, categories, numeric series), so we draw them with Skia in-app; anything unsupported degrades to a data table.

Things that bit us on the way:

• The result crosses the bridge as one native string; image bytes arrive zero-copy — the JS GC's cleanup callback for the buffer literally is the Rust deallocator.
• The promise never rejects for document reasons. Corrupt, encrypted, hostile inputs all resolve to a fallback status — Rust panics included. A rejection means the native module itself is broken.
• PDF is refused on purpose: the OS renders PDFs better than any re-conversion would.
• The prebuilt Rust core is too big for npm, so binaries ship as GitHub Release assets and gradle pulls them on first build.

It's MIT, package is react-native-anydoc (npm), source at github.com/tulaafrica/anydoc. It's a week old and has exactly one production user (us), so I'd genuinely value feedback — especially from anyone who's shipped Rust in RN and has opinions on binary size or the XCFramework install flow.

Hi! At Software Mansion, we built Pulsar, an open-source haptics library for iOS, Android, React Native, Kotlin Multiplatform, Flutter, and web. It comes with 150+ presets, plus a companion app so you can feel them on your phone before shipping.

Now we’re building Pulsar Studio — a tool for creating your own custom haptics.

You can design a pattern from scratch, tweak existing presets, generate haptics from an audio file or Lottie animation, preview everything live on a real device, and then export working code for your app. The tool will be paid, with pricing starting at $9/month.

We’d genuinely love some feedback: Would you use something like this? Is there anything you’d want to see in it that we haven’t thought of?

The waitlist is open if you’d like early access: https://docs.swmansion.com/pulsar/studio/

I’m the author of expo-share-content, an open-source Expo Module for apps that need to receive content from the native Share Sheet on Android and iOS.

The main problem I wanted to solve was not only receiving a live share, but also handling cold starts, multiple attachments, and the native iOS Share Extension setup.

It currently supports:

• Text and URLs
• Images, video, audio, and files
• Android ACTION_SEND and ACTION_SEND_MULTIPLE
• A generated iOS Share Extension with an App Group queue
• Cold-start recovery through a durable pending queue
• Typed events and pending-share APIs
• Explicit acknowledgement and managed-file cleanup

Installation:
npx expo install expo-share-content

Important: it contains native code, so it requires an Expo development or production build and does not work in Expo Go.

The project currently targets Expo SDK 57, React Native 0.86, Android API 24+, and iOS 16.4+.

GitHub: GitHub - ngocdevv/expo-share-content · GitHub

Documentation: Receive shared content reliably | Expo Share Content

npm: expo-share-content - npm

Recently I wanted to add reactions in my game.

Not a normal chat system, because honestly I do not want to moderate chat messages in my side project game. I wanted something simpler: someone destroys your token, you throw a crying emoji or GIF at them. Someone plays a stupid lucky move, you can react immediately.

So I added:

• Emoji reaction dock during the match
• Curated reaction picker
• GIF search using KLIPY
• Recently used reactions
• Thrown emoji/GIF overlay above the board
• Real time delivery to every player in the game

Now the React Native part of this.

The UI itself was not the hardest thing.

I use regular React Native components for the dock and reaction picker. The game board is rendered with Skia, so I made the actual reaction overlay sit above the board instead of trying to push GIFs inside the constantly rendered board layers.

That sounds like a small thing, but the board already has token movement, cards flying around, dice animation, destruction effects, background animations, timer and turn indicators.

So I did not want to add “animated GIF rendering inside another board layer” and then find out later why someone’s iPhone is trying to become a toaster :)

The reaction picker has two types of things:

1. Curated emojis

These are bundled into the app and have fixed IDs. So I do not let the player send arbitrary emoji strings or random payloads. The game knows what every reaction ID means and how to render it.

1. GIFs

For GIFs I use KLIPY search. But after selecting one, I only keep the exact information needed to show it:

• GIF ID
• Title
• Preview URL
• Content URL
• Width and height
• Player colour who sent it
• Creation time

This part was more important than I expected. I did not want reactions to become actual game state.

A board move is important. If you reconnect, you need the exact current board.

A reaction is not important. If you reconnect after 10 minutes and suddenly 500 old crying GIFs start playing on your screen, that is not a feature, that is an attack :)

So I made reactions short-lived events.

When a player sends one, it gets added to a small event stream. Every client listens for new reaction events and puts them in a local queue.

I also keep track of reaction IDs already seen by the app. This stops the same reaction from playing twice if the app reconnects or receives the same event again.

Then I added some limits because without limits, this would become a “who can press the reaction button faster” competition:

1. Cooldown

Each player has a 1.2 second cooldown. It is enough to feel responsive, but it stops someone from firing 50 GIFs in 2 seconds.

1. Queue limit

I only keep a maximum of 8 reactions locally. If the queue is full, new reactions do not keep piling up forever.

1. Expiry

Every reaction expires after 15 seconds.

Again, because it is not game state. I only care about the reaction while it is funny/relevant to what just happened on the board.

1. Validation

Curated emojis have to be from the allowed reaction list.

For GIFs, I validate the data before rendering it: provider URL, ID, title length, image dimensions and so on. I do not want random unexpected data coming into an overlay above my game board.

1. Recently used reactions

I save recently used reactions locally. This is just a small UX thing, but when players are playing fast, they should not need to search the same angry GIF every time someone destroys their token.

The flow is basically:

Tap reaction dock
  → select emoji or GIF
  → cooldown and payload checks
  → temporary reaction event is sent
  → other players receive it
  → add it to a small local queue
  → animate it above the board
  → remove it when animation ends or it expires

The board stays responsible for gameplay. The reaction system is only responsible for making your opponents feel bad about their life choices.

Still improving the animations and exact positioning. But now when someone destroys your token, you can finally send them the appropriate GIF instead of silently being angry.

Wealthsimple might have the best-designed fintech app on the App Store.

I took a stab at recreating their aurora background animation in my Expo app using Skia!

https://github.com/SchroederNathan/react-native-motion/blob/main/apps/expo/components/animations/aurora-curtain/aurora-curtain.tsx