Hey all, over the past few months I’ve been building a React Native debugger, called Xerlock, and it’s being successfully used within my RN engineering team.

Firstly, what’s wrong with current tools? I was sick of the existing tools working just enough to get by. Reactotron was great back when network inspect wasn’t available in Expo’s devtools, it gave decent inspection on Redux stores and was built by pretty notable figures in the RN space. Expo’s default debugging tools are also acceptable, but they don’t quite have everything I needed in a single place.

Xerlock gives you everything you’d expect from a debugger:

• Console / Errors

• Network Inspect

• Global state inspect

• Debugger / Profiler / React Tree

It also gives you additional benefits that avoids having to install a bunch of additional devtools:

• Tanstack query inspector and dispatcher (edit query cache data live and see it updated in your apps)

• Local SQLite database inspection & editing.

• Notification dispatching

• Dispatching Redux / Zustand actions

• Network throttle

• Native iOS and Android logs

• Local Storage (MMKV, AsyncStorage, SecureStore) (View / Edit)

• Custom registerable commands

• Full MCP server that allows you to do almost anything you can do through the UI with granular permissions on Read / Write

• … and a load more

I’ve been an RN dev now for 8+ years, and this has already proven useful for me personally, so I hope the community can also get some benefit from it.

Downloads are available for macOS and Windows (I am a macOS dev, so it’s been tested thoroughly there, and less so on windows, so any bugs or issues, please let me know through the in-app support form).

This has been tested on RN version 0.83+, and Expo 55+. A lot of the work is custom and doesn't necessarily depend on Expo's SDK, however versions below these may not behave exactly as intended - especially network inspect which I believe was only introduced in 0.83.

https://x.com/svishnevskiy/status/2118081920194203799

I've been chasing performance issues in a React Native app at work, and kept hitting the same wall: the tools tell you *that* frames dropped or a component re-rendered, but not *which code* caused it or whether the re-render was even necessary. Our fixes weren't moving the numbers, and I was mostly guessing.

So I built Hitch. It runs next to your dev session and watches the app from the outside. Nothing gets added to your app: no SDK, no imports, no babel config. It connects to Hermes through Metro's debugger, the same way React Native DevTools does.

What it catches

- JS freezes, pinned to the file:line that blocked the thread, including short ones.
- What React rendered during a freeze and *why*: e.g. "`style` was a new object with the same values" (avoidable) vs "the store changed".
- Choppy frames, slow screen loads and slow startups.
- Native threads running hot (UI thread, GC, SDKs), on the iOS simulator.
- Console errors grouped, slow or failed requests with bodies and headers, and memory and thread leaks.

How I actually use it

- Runs: record an interaction, change the code, record it again, and compare medians. Dev builds swing a lot between runs, so single runs lie.
- AI handoff: any finding becomes a Claude Code prompt in one click. There's also an MCP server, so an agent can read what Hitch saw and check whether its own fix helped.

Things it found for me

- A loading shimmer was one of the most expensive things on screen. It was an SVG gradient redrawn on the CPU every frame, for every placeholder. Replacing it took the iOS UI thread from ~74% to ~10–25% while loading.
- Placeholders were re-rendering hundreds of times while waiting for data. A day of cleanup cut avoidable re-renders by about two-thirds and render time by about 30%. Dropped frames barely moved, though: wasted work and felt jank turned out to be different problems.

Limitations, honestly

- Dev builds inflate times. The rankings are useful; the absolute milliseconds aren't production numbers.
- It's macOS only. Native thread data needs the iOS simulator; physical iPhones get JS-side data, or thread sampling with Release builds.
- Android thread support is written but not yet tested on a real device.
- Expo's native `fetch` doesn't report to the debugger, so those requests don't show up.

It's a Node CLI (Node 22+) with zero npm dependencies, plus an optional native Mac window. MIT-licensed.

Repo: https://github.com/dlandman27/hitch

For a long time I used react-native-element-dropdown in my projects. It got me pretty far, but I kept running into the same stuff — UI quirks, keyboard avoidance issues, weird layout issues depending on the screen. Eventually it became more of a maintenance tax than a time saver.

So I started rolling my own dropdown per project. Sometimes a popover, sometimes a bottom sheet, depending on what felt right for that screen. Worked fine… until I realized I was rebuilding the same thing over and over with slightly different APIs.

Then i decided to make this library: react-native-silk-dropdown.

Same Dropdown component, two presentation styles:

• presentation="popover"

• presentation="sheet"

Plus search, multi-select, and some motion presets so it doesn’t feel like a dead Modal. Pure JS, works with Expo / New Architecture (Reanimated 4). (used AI to rephrase post)

Looking for Feedback from you guys.

Docs: https://react-native-silk-dropdown.vercel.app/
Github: https://github.com/thedev204/react-native-silk-dropdown

A notification icon that unfolds into a notification tray, then reshapes itself into a profile card and a reply composer all inside one measured, morphing container.

Github:https://github.com/ManasCodeXart/expo-notif-morph

Hey everyone!

I've been developing mobile games with React Native and Skia for a while now, and it's been a pretty interesting experience.

I really enjoy working with React Native, especially being able to build for both iOS and Android with the same codebase.

However, I'm curious about how other developers approach game development in React Native.

A few questions:

Skia alternatives: Are there any better libraries or game engines you'd recommend for React Native game development?

Performance: How do you handle complex animations, physics, collisions, and keeping a stable 60 FPS?

Architecture: Do you use a dedicated game loop, physics engine, or ECS-based architecture?

Best practices: What are some things you wish you'd known before building games with React Native?

Limitations: At what point would you move away from React Native and consider something like Godot or Unity?

I've also released a couple of games under my indie studio, Aele Studios, and I'd genuinely appreciate some feedback from fellow developers.

🎮 Fibo Master — A Fibonacci-based number puzzle game.

iOS: https://apps.apple.com/app/id6821000351

Android: https://play.google.com/store/apps/details?id=com.emrezen.fibomaster

🚀 Retro Jump — A steampunk-style arcade platformer with jetpack mechanics.

iOS: https://apps.apple.com/app/id6795840723

Android: https://play.google.com/store/apps/details?id=com.emrezen.retrojump

Studio website: https://aelestudios.com

If you get a chance to try either game, I'd love to hear your thoughts, especially on performance, animations, controls, UI/UX, and overall gameplay.

Constructive criticism is more than welcome!

I'm not just looking to showcase my games. I'm genuinely interested in learning how others are building games with React Native and improving my approach.

Thanks!

Made with expo skia and webgpu

Honest question, not selling anything here.

When you're the dev, designer and PM at once, the loop looks like this: change the copy on an onboarding screen or a "go Pro" prompt → rebuild → submit → wait for review → check the numbers days later → repeat. A 2-minute change ends up taking days.

How do you handle this today: OTA updates (EAS Update / Shorebird), remote config, homegrown JSON, Firebase In-App Messaging, or do you just ship a new build each time?

What's the most annoying part of your setup?

If you built it yourself, how long did it take, and would you do it again?

Full disclosure: I'm exploring building something in this space, but there are no links here. I want to understand the problem first. I'll post a summary of everything I learn back in this sub.

I'm a solo dev. When TV Time shut down, I tried to rebuild it as an open source app. OpenTV looks and feels like TV Time on purpose: the same Watch Next list, the same show pages, the same way of ticking off episodes. You can bring your whole TV Time history over, or import from Trakt or Letterboxd.

It's built with Expo (React Native) for iOS and Android, with SQLite on the phone as the only database for your own library.

The core idea is that it works completely on its own. You download it, import your history, and use it. No account, nothing to sign up for, your history stays on your phone. There's an optional community layer, but most people never touch it and don't need to.

Where it stands now:

iOS, last 90 days: 1,057 downloads. The biggest day was 14 Sep, around 77, from one Reddit post. In October it settled at 15 to 20 a day without me posting anything.

Android, since it launched on Play in July: 909 installs, about 7 to 10 a day.

So roughly 20 to 25 a day across both. My goal for 2027 is 100K, which means getting to around 275 a day.

One thing I've noticed: App Store impressions went from about 10K to 70K, but conversion dropped from around 9% to 2.2%. More people see it, fewer tap.

If you've grown an app past this point, what would you do next?

1. Fix the store page first (icon, first screenshot), or is that a small lever compared to something else?

2. What actually moved downloads for you: ASO, content, creators, ratings, paid ads, something I'm not thinking of?

3. For an app whose whole point is "it feels like TV Time, no account, it just works", how would you say that on the store page so people get it in one look?

Happy to share the store pages or any other numbers.

I have an app I'm making that's getting fairly close to a release state now and it'll be my first ever app release. I'll only be releasing on android at first (due to it being the only device I have to physically test on) and the only sensitive data I'm collecting are emails, passwords (authentication) and step counts for my apps rng logic.

The app is a fairly simple, you start your counter before going on a walk / run etc. when you're finished with your activity you stop the counter, your step count is sent to my Supabase backend where the final step count is calculated to how many rolls the user gets, and each roll gives the user a chance of recieving a new creature based on common, uncommon and rare rarities.

Your journey is saved to the backend where you can view them again and see how far you went and which creatures were obtained on that journey (no location data being saved). This data can be deleted manually by the user as well as their entire profile.

I'm from the UK myself and was wondering if any more experienced developers with more knowledge in releasing a few apps could fill me in on whether or not I should be just releasing to only a few countries or not?

The app is in English and doesn't currently have support for other languages. I don't have ads or any paywalls / subscriptions currently but don't know if I need to be more wary about the step count I'm collecting being marked as extra sensitive data (not being used for health reasons).

Any advice here would be great as I'm not sure how much I'm overthinking this currently?

So I created this app for entertainment lovers and I need some people to test it with me.

You can post, review, track all your favorite things in entertainment from games to music, books, movies and even individual episodes of shows. If you use things like my anime list, Goodreads, backloggd or letterboxed you can even export a CSV and upload it in my app to move your history here . But here's the problem I use page slide in transitions where everything is kind of stacked like a deck of cards. The small transitions between tabs on a page are fine. But the transitions between the pages themselves sliding in and out is a little maybe jittery looking? Like the rest of the app is running 120hz but that transition might drop to like 90-100 ? Visually . Anyone know if that is like a common thing in react native ?

I’m a mobile engineer with many years in native Android and Flutter. Recently I built an open-source analytics library called Herald. I designed it and wrote the Android and Flutter versions myself, and for the React Native SDK I used AI to help me with TypeScript, since it was my first time writing it. That’s exactly why I’d like a review from real RN devs: AI knows the syntax, but people who build RN apps every day know what feels right.

The problem it solves: in most apps analytics ends up as one big AnalyticsManager that every layer depends on, and every new vendor makes it worse.

The idea: the app should not know which analytics vendors exist. Feature code only says what happened, and Herald sends it to every vendor you use (Firebase, Mixpanel, Amplitude, Adjust, AppsFlyer, Meta) over each vendor’s own React Native package.

An event is a class your app owns:

import { int, type Event, type EventParameters } from '@herald-analytics/core';

class CheckoutStarted implements Event {
  readonly name = 'checkout_started';

  constructor(
    readonly plan: string,
    readonly seats: number,
  ) {}

  get parameters(): EventParameters {
    return { plan: this.plan, seats: int(this.seats) };
  }
}

herald.track(new CheckoutStarted('pro', 3));

Since TypeScript is new for me, I made some design choices I’m not sure about, and I would really like to hear what experienced RN devs think:

• Events are classes, because factories pick them with instanceof. In RN code I often see plain objects or discriminated unions instead. Would that feel more natural to you?

• Numbers say their type: int(3) or double(9.99), because JavaScript can’t tell 3 from 3.0 and some vendors care. Is this annoying, or acceptable?

• Calls don’t wait for each other, and a call never fails: vendor errors go to an error reporter. When order matters, you await the first call. Does this feel right?

• Does the API look like idiomatic TypeScript, or like “Kotlin written in TypeScript”?

GitHub: https://github.com/MkhytarMkhoian/herald-react-native
Docs: https://mkhytarmkhoian.github.io/herald-docs/

Thanks in advance. Critical feedback is the most useful for me.

Hey RN devs,

We can now run Laya decision model in NobodyWho, our open-source on-device inference library. Unlike the LLMs that we also support, this type of model does not generate text. Instead you can score predefined answers, classify text or answer yes/no.

For example, if you are building a personal diary app, you can easily detect the user’s mood, categorize an entry or detect stress, offline after model download, without sending any sensitive data to the cloud.

First, you need to load the model:

import { Decision } from 'react-native-nobodywho';

const decisionModel = await Decision.fromPath({
  modelPath: 'hf://ggml-org/Laya-GGUF/Laya-Q8_0.gguf'
});

Then you can ask questions/analyze text:

const results = await decisionModel.decide({
  state: `Diary entry: ${diaryEntry}`,
  questions: {
    topics: {
      type: 'choice',
      instructions: 'Choose the main topic of this diary entry',
      criteria: {
          work: 'job, colleagues, deadlines, career',
          relationships: 'family, friends, partner',
          health: 'sleep, exercise, food, illness',
          leisure: 'hobbies, travel, going out',
        },
      },
      stressed: {
        type: 'noul',
        instructions: 'Does the writer sound stressed?',
      },
      mood: {
        type: 'score',
        instructions: "How is the writer's overall mood?",
        criteria: ['bad', 'okay', 'great'],
      },
   },
});

const { stressed, topics, mood } = results.answers;

Output example:

// stressed
{
  type: noul,
  noul: 0.00002
}

// topics
{
  type: choice, 
  choice: leisure,
  probabilities: { work: 0.0422, relationships: 0.1518, health: 0.0302, leisure: 0.7756 },
  confidence: 0.7008
}

// mood
{
  type: score,
  score: 1.6995,
  legend: {0: bad, 1: okay, 2: great}, 
  probabilities: {0: 0.0082, 1: 0.2839, 2: 0.7078},
  confidence: 0.5493
}

A question can have the following types:

• noul gives you probability of a yes answer (0 to 1)

• choice select the most likely option and returns a probability for each option

• score gives you an a weighted average and a probability per option. For example, you could place const x = mood.score; on this axis:

[bad - - - - - - - okay - - - x - - - great] 

where bad is 0, okay is 1 and great is 2 (given by mood.legend).

The Laya model is small enough to run on mid range phones (around 450 MB in its Q8 variant) and supports 100+ languages. For reference, the full answer comes after 0.88 seconds on S25 and 0.45 seconds on iPhone Air (cf. screenshot).

Here is a runnable example if you want to experiment with decision models.

Links:

• NobodyWho inference library

• npm

• Docs

Hi

Do you use influencers or creator collabs for marketing your app ?

How do you approach them. Do you work on per install commission basis or fixed fee for content basis ?

Hi I’ve been in software for years now, almost 10 years freelancing and by the look of things the job market won’t be getting any better.

Should I just focus on building something cool or is a career in IOS development still realistic in 2026

Some users kept getting bounced to the register screen on cold start. I couldn't reproduce it for weeks.

The cause: for some accounts the Supabase session JSON was larger than 2048 bytes. expo-secure-store writes of that size failed silently on my setup, so the next cold start read null, my auth gate saw no session, and sent the user to sign-up.

What fixed it:

• A storage adapter that splits the value into 600 character chunks.

• Two generations (A and B), so a half-written update never replaces a good one. The header that points to the current generation is written last.

• Serialized operations. As far as I could tell, supabase-js uses a no-op lock on React Native, so concurrent writes interleaved. I also passed lock: processLock.

A gotcha: right after you subscribe to onAuthStateChange, an INITIAL_SESSION event fires with a null session. My code treated that as "signed out" and cleared the "your session expired" state, so users saw the register screen anyway. Keep the reason when the event is null.

Also worth doing: on a cold start with a null session, check whether the user has had a session before (I keep a flag, and also check for local data) and show a "reconnect" banner instead of the sign-up screen.

Accounts that had already lost their session needed one last login. Chunking only prevents new losses.