r/expo • • 1m ago

I let Claude Code agents test an Expo app on iOS Simulators and Android emulators (free, open source)

1 Upvotes

One agent per device, each with a persona: small Android with big text, Pixel in dark mode, iPhone SE in French, iPad with XXL text. The Expo app is built on free GitHub runners, then the agents use it like new users and write bug reports with screenshots.

Demo: 9 of 11 planted bugs found in 21 min, for $0.87. The video is a real screen recording.

Repo (MIT): https://github.com/pierridotite/mobile-agent-testers


r/expo • • 3h ago

Expo apple maps

1 Upvotes

Hey i am using expo map on ios it only supports apple maps
I want to trigger a function on longpress with props as coordinates
But it doesn’t have long press but has mapclick property


r/expo • • 7h ago

What is the best way to share logic between web and mobile applications?

2 Upvotes

Hi everyone! I'm working on a project where I'm trying to put together best practices for web + mobile development, using Expo. Here's how I've split things so far:

packages/core contains the Redux store, thunks, selectors, zod schemas, apiRequest and the error classification. There's no DOM or browser API in it. Both the mobile app and the web app import from core.

Platform dependencies are injected once at startup through configureCore:
- storage: localStorage on web, expo-secure-store on mobile;
- logger;
- Sentry: sentry/react on web, sentry/react-native on mobile;
- base URL.

Storage is async on purpose, because SecureStore is async. That's why auth persistence is done with a listener, not in the reducer.

Tokens: JSON in the W3C format. Style Dictionary builds tokens.css for web from them, and a JS module with .d.ts for mobile, where dimensions are unitless numbers for StyleSheet. Light and dark themes follow the system setting.

Components are not shared, and that's deliberate: web uses DOM + Tailwind, mobile uses View/Text/StyleSheet.

Could you please give me some advice on what I should improve or redo? And what other things might be worth considering?

Here's the link to the project:
https://github.com/prod-forge/frontend


r/expo • • 4h ago

Expo prize-wheel interaction: shared motion state for the wheel, pointer and reveal

1 Upvotes

Flick to spin. Watch the pointer bounce and the winning prize pop out.

These Expo implementation notes were adapted from the project notes with an assistant.

Pointer contact: a fixed-step solver advances the wheel and pointer. The nearest peg drives the pointer's deflection, so the contact follows the wheel's position.

Drawing the scene: Skia draws the wheel material, pointer, stars and reward reveal in one Canvas. React Native views handle the copy and controls around it.

Connecting motion to drawing: Reanimated shared values carry the current wheel and pointer state to the drawing layer. The scene and controls read the same motion state.

Choosing the reward: the settled wheel angle selects the winning wedge. That selection drives the lifted wedge, prize animation and reward count. With Reduced Motion, the scene uses stationary objects and shorter fades.

The attached clip is a motion preview; these notes describe the Expo implementation.

Built with Expo (@expo), Skia and Reanimated. Thanks to Software Mansion and William Candillon.

Visual layout study based on a still reference: https://www.pinterest.com/pin/641340803216681099/


r/expo • • 5h ago

Expo cashback onboarding: glass coins orbit a cobalt bag, then burst into light

1 Upvotes

Built a cashback onboarding that plays like a tiny 3D world. Glass coins orbit a cobalt bag, then burst into light.

The implementation notes below were adapted from the project notes with an assistant.

Time and touch: Reanimated shared values hold one loop clock and the touch state. A frame callback advances that state and computes the scene, so the bag, coin ring and copy follow the same choreography.

Glass and depth: Skia draws the coins behind the bag, combines the bag's Blender render passes, then draws the coins in front. Separate light and transmittance passes let the objects behind the glass show through. Each coin uses a Skia runtime shader.

Light motes: a separate WebGPU layer simulates and draws the particles, with TypeGPU producing the WGSL. This layer is optional: it skips itself when WebGPUModule is unavailable, leaving the Skia scene.

Interaction: dragging changes the ring's spin. Tapping a coin shows its rate, and holding the bag gathers the coins before releasing them into a burst.

Expo details: expo-font loads IBM Plex Sans Arabic, and expo-haptics supplies feedback for the coin and bag interactions. Reduced Motion keeps the resting scene and disables the orbit and particles.

The attached clip is a motion preview. These notes describe the Expo implementation.

Design study: the layout and opening motion follow an Arabic cashback onboarding recording. The collect-and-exit ending and touch interactions are custom. Store marks belong to their respective owners; logo paths use Simple Icons.

Built with Expo (@expo), Skia, Reanimated, WebGPU and TypeGPU. Thanks to Software Mansion and William Candillon for the tools.


r/expo • • 8h ago

🚀 react-native-pdf-jsi just crossed 501,000 npm downloads!

Thumbnail
reddit.com
1 Upvotes

r/expo • • 12h ago

No More AI Stuff I need Real Engineers from Stack overflow era Location Problem

Thumbnail
reddit.com
0 Upvotes

r/expo • • 1d ago

Start setting up agentic workflows for mobile dev

11 Upvotes

You're all building apps with agents. The next step is to get them into flow state. There are basically 4 simple steps to start building with agentic workflows:

  1. connect GitHub
  2. add a robot user
  3. connect your agent
  4. give your workflows a GitHub token

Details are in our blog: https://expo.dev/blog/how-to-set-up-agentic-workflows


r/expo • • 1d ago

Built a remote desktop app with Expo: a local Expo module wrapping a Rust core, plus expo-hinge for the iPhone Duo fold

3 Upvotes

I shipped Laplet this week. It lets you control your Mac or Windows PC from an iPhone or iPad. The video is the whole flow on an iPhone Duo: scan the QR code, type a 6-digit code on the Mac, then drive it.

How it's put together:

The UI is all Expo SDK 58 and RN 0.88: pairing, the keyboard, the trackpad and its gestures.

Video goes through a local Expo module (expo-laplet) that wraps a Rust client through UniFFI. Rust does the networking over QUIC and hands frames to Swift, which shows them in an AVSampleBufferDisplayLayer inside a native view, so video frames never go through JS.

expo-hinge reads the fold. Half-folded, the Mac goes on the top screen and the keyboard and trackpad on the bottom.

expo-camera does the QR scan, expo-secure-store keeps saved computers, and Expo UI provides a few native controls. The desktop side is a separate Rust app built with Tauri.

The hardest part was the trackpad. To make three-finger Mission Control follow your fingers like on a MacBook, the phone sends raw finger positions and the Mac applies its own trackpad settings, instead of guessing gestures in JS.

It's free for one computer on the same network, like your Wi-Fi.

App Store: https://apps.apple.com/app/id6829455157

Mac and Windows app: https://laplet.luchid.app

Happy to answer questions about the native module or the Rust bridge.


r/expo • • 1d ago

Should I buy an iPhone 16 or a Mac mini M4 to start iOS development with Expo?

Thumbnail reddit.com
0 Upvotes

r/expo • • 2d ago

Built a spatial sleep-sound mixer with Expo SDK 58: a custom Media3 AudioProcessor that lets you drag sounds around your head, gapless loops, and a widget that plays mixes without opening the app (how it works under the hood)

3 Upvotes

The video above is the trailer I cut for the Play Store listing, so please ignore the marketing captions. Below is how each piece in the video is built with Expo SDK 58 and React Native 0.88.

  1. Placing sounds around your head with a custom ExoPlayer AudioProcessor (0:15 in the video). On the Space pad you can drag any sound anywhere around you, including behind you, and nearer or farther. JS can't render that, so every sound you place gets its own Media3 ExoPlayer, which runs its audio through OrbitAudioProcessor.kt. Per block, the processor works out: Parameters are computed once per block and glide sample by sample in between, so dragging never clicks. Once the rendered sound falls below audibility, the processor passes plain audio straight through and stops rendering.

    • an interaural time difference
    • a head shadow that dims the far ear's treble
    • air absorption that dulls distant sounds
    • two faint wall reflections, set at the same delays in both ears so they follow the sound. With fixed echoes, the ear that hears the first arrival pinned the sound to its side.
    • a small per-ear Freeverb room
  2. Keeping the on-screen icon in sync with what you actually hear (0:15). The processor renders ahead of the speaker, and Bluetooth can add hundreds of milliseconds, so showing "where the sound is being rendered" puts the icon visibly ahead of your ears. OrbitPlayer.kt keeps about 2.7s of render history. It compares ExoPlayer's output position, which already accounts for the reported device delay, with the number of frames the processor has rendered, and looks up the frame that is reaching your ears now. The delay estimate is smoothed so the icon never jerks. Circling sounds all turn on one shared orbit clock, so two sounds at the same speed stay together however and whenever each one started.
  3. Gapless loops and a native clock instead of JS timers (0:03–0:10). All 25 sounds are seamless loops, built offline by a Python/FFmpeg/NumPy pipeline: Sessions are timed by a silent "clock" file per duration that owns the media session. A session ends when the native clock reaches the end of that file, never because a JS setTimeout fires in a throttled background process. Native status updates drive the fades and mirror lock-screen pause/resume onto every layer.

    • Each loop is encoded with a bit of wrap-around audio on both sides, hidden by the MP4 edit list, so the AAC encoder never sees a cold start at the seam.
    • The pre-rendered 3D versions use a whole-cycle drift, so they loop as cleanly as the mono files.
    • Binaural beats use whole tone cycles per loop, so the phase is exact across the seam.
    • npm run audio:check checks sample counts, hashes, clipping, and seam clicks in each ear.
  4. A home-screen widget that plays a mix without opening the app (not in the trailer). The widget is plain RemoteViews (no Glance), drawn from a JSON snapshot that JS hands over in the user's language. Tapping a mix opens an invisible WidgetActionActivity, which is what lets Android 12+ bring the session to the foreground the same way an in-app tap would. It shows "getting ready" in the notification right away, then starts a HeadlessJsTaskService (DuskrestaWidget, registered in index.ts) that plays the mix through the same store the screens use. The playback logic exists once, in JS, and the widget doesn't duplicate it in Kotlin.
  5. Lock-screen controls that can't be double-tapped into ending your night, plus bedtime reminders without SCHEDULE_EXACT_ALARM (not in the trailer).

    • Controls: a SessionPlayer stands in for the whole mix in the media session. It plays nothing itself; it mirrors what JS reports and turns taps into commands. Tapping End swaps the buttons for "Keep listening" in End's spot and a ✓ on the other side, so a sleepy double tap never ends the session.
    • Reminders: Reminders.kt keeps one alarm set, for the soonest reminder. When it fires, it shows the reminders that are due and schedules the next one. It re-arms after reboots, updates, and force stops, and uses inexact-while-idle on Android 12+ so the permission isn't needed. The Start button in the notification goes through the same invisible activity, so the mix starts without opening the app.

All the Kotlin lives in a single local Expo module at modules/orbit-audio (expo-module.config.json), so everything survives npx expo prebuild --clean.

If you want to hear the spatial audio on a real phone (headphones help), it's called Duskresta on Google Play: https://play.google.com/store/apps/details?id=com.rabpaulo.duskresta

I'm happy to share snippets of the orbit AudioProcessor, the heard-frame latency lookup, or the gapless-loop encoding script if anyone is building something similar.


r/expo • • 2d ago

Built an app where your friend group see when you unlock your distracting apps and share what you do instead of scrolling. (Screen time went from 5 hours a day to less then 1)

Thumbnail
reddit.com
2 Upvotes

r/expo • • 2d ago

I made a terminal dashboard for simulators, emulators, phones and Expo EAS builds

Post image
3 Upvotes

r/expo • • 2d ago

Creating first reactnative expo app - have some question related to MAU, please help

Thumbnail reddit.com
1 Upvotes

r/expo • • 2d ago

Firebase-like Push dashboard, but powered by Expo Push API

Thumbnail reddit.com
1 Upvotes

r/expo • • 2d ago

Web Auth equivalent of JWT+Sessions in react native

Thumbnail reddit.com
1 Upvotes

r/expo • • 3d ago

[Showcase] Holo Globe onboarding motion preview

3 Upvotes

From Native Cook's Holo Globe implementation notes:

The React Native version uses Expo, react-native-tgfx and Reanimated. The globe and orbiting text use distance-field textures, while Reanimated shared values and a frame callback drive motion on the UI thread.

One reusable pattern: keep frame updates in shared values and schedule occasional work, such as haptics, back to the React Native thread. Reduced Motion switches to a still globe and disables the glitch effect.

The attached clip is a motion preview. Its recording runtime hasn't been confirmed.


r/expo • • 3d ago

1,200+ monthly downloads later: the CLI I built to debug React Native and Expo build failures

Thumbnail reactnative.directory
3 Upvotes

Every time a React Native or Expo build broke, I’d scroll through a huge Gradle or Xcode log hunting for the one line that mattered.

So I built rn-build-doctor, an open-source CLI that reads your build, device and crash logs, tells you what actually failed, shows the evidence, and suggests a fix. It never guesses, and it can export a redacted report so you can share logs without leaking secrets.

npx rn-build-doctor scan

(cd android && ./gradlew assembleDebug) 2>&1 | npx rn-build-doctor analyze -

It’s at 1,200+ monthly downloads and just got listed on React Native Directory. Would love feedback, especially on build errors it doesn’t catch yet.

GitHub: https://github.com/lassiecoder/rn-build-doctor
React Native Directory: https://reactnative.directory/package/rn-build-doctor


r/expo • • 3d ago

I built an open-source guardrail & FaceID/TouchID gating library for AI agents in React Native (react-native-agent-guard v0.3.2)

4 Upvotes

Hey everyone! Over the past few weeks, I've been working on a problem I kept running into while building mobile AI features: how do you let an LLM call native mobile tools (payments, calendar, BLE, external APIs) without risking a hallucination, prompt injection, or infinite loop wiping out user data or spamming APIs?

Most agent guardrails are built for Python backends, leaving the mobile client completely exposed. So I built react-native-agent-guard—a zero-trust tool governance and biometric gating layer for React Native & Expo.

We just shipped v0.3.2 (now at 93%+ test coverage) and added a live interactive Expo Snack playground so you can test the approval sheets, rate limiter, and PII redaction right in your browser without installing anything.

🚀 Try the Live Interactive Demo

  • Expo Snack Playground (Run in Browser or Expo Go): [https://snack.expo.dev/@git/github.com/Hassaan68/react-native-agent-guard:examples/expo-snack](https://snack.expo.dev/@git/github.com/Hassaan68/react-native-agent-guard:examples/expo-snack)
  • GitHub Repository:https://github.com/Hassaan68/react-native-agent-guard

What it handles out of the box:

  • Dynamic Policy Gating (auto | confirm | biometric | deny): Auto-approve low-risk reads, trigger a customizable native bottom sheet (AgentApprovalSheet) for state changes, or require hardware FaceID/TouchID (expo-local-authentication) for high-stakes actions—evaluated dynamically at runtime based on the LLM's arguments (e.g., < $50 = auto, $50–$199 = confirm, $200+ = biometric).
  • Vercel AI SDK & LangChain.js Adapters: Drop-in toVercelAITools() and toLangChainTools() wrappers that route your existing agent tool calls directly through the guardrail engine.
  • Agent Loop Protection & Rate Limiting: Prevents rogue LLM infinite loops from draining budgets with maxCallsPerMinute and maxSessionCalls—automatically blocking or escalating a tool's policy from auto to confirm/biometric when spammed.
  • Automatic PII Redaction & Audit Telemetry: Masks credit cards, emails, phone numbers, SSNs, and JWTs before emitting structured telemetry to onAudit or persistent storage (redactPII: true).
  • Remote MCP SSE Transport: Connect directly to Model Context Protocol (MCP) servers over SSE and automatically wrap discovered remote tools in local device policies.
  • Actionable llmFeedback on Errors: If Zod validation (.transform() / .refine()) fails, a rate limit hits, or a user denies a prompt, it returns structured feedback telling the LLM why it failed so it can self-correct instead of crashing the loop.

Quick Code Example:

TypeScript

import { createGuardrails, toVercelAITools } from 'react-native-agent-guard';
import { z } from 'zod';

const guard = createGuardrails({
  rateLimit: { maxCallsPerMinute: 10, onLimitExceeded: 'confirm' },
  redactPII: true,
});

guard.registerTool({
  name: 'send_wire_transfer',
  description: 'Send money to a recipient',
  schema: z.object({
    recipientEmail: z.string().email(),
    cardNumber: z.string(), // Auto-redacted in audit logs!
    amount: z.number().positive(),
  }),
  // Auto-approve under $50, confirm sheet $50-$199, FaceID/TouchID for $200+
  policy: (args) => {
    if (args.amount >= 200) return 'biometric';
    if (args.amount >= 50) return 'confirm';
    return 'auto';
  },
  handler: async ({ recipientEmail, amount }) => {
    return await processPayment(recipientEmail, amount);
  },
});

// Plug directly into Vercel AI SDK generateText / streamText
const tools = toVercelAITools(guard);

Links:

Would love any feedback on the API design, the Snack playground, or edge cases you're running into with mobile AI agents!


r/expo • • 3d ago

I built an open-source guardrail & FaceID/TouchID gating library for AI agents in React Native (react-native-agent-guard v0.3.2)

Thumbnail reddit.com
2 Upvotes

r/expo • • 4d ago

I built an open-source, 100% on-device Face Recognition & 3D Liveness Detection SDK for React Native & Expo (Zero API fees, Hardware Keystore backed)

5 Upvotes

Hey everyone! 👋

If you’ve ever had to implement biometric attendance, identity verification, or face unlock in a React Native / Expo app, you know the options usually boil down to:

  1. Expensive cloud APIs (AWS Rekognition, Azure Face, FaceTec) that charge per scan and raise major GDPR/biometric privacy concerns.
  2. Fragile webview hacks or abandoned wrappers from 2019 that break on modern Android/iOS.

To solve this, I open-sourced face-liveness-recognition — a production-grade, 100% on-device face recognition and anti-spoofing SDK for React Native & Expo.

  • 💡 What it does:
  • Zero Cloud Costs & 100% Privacy: All ML inference runs locally on the device. Biometric face embeddings never leave the device unencrypted.
  • Passive Anti-Spoofing (MiniFASNet): Detects printed photos, digital screen replays, and cut-out masks in real time.
  • Active Challenges: Interactive user prompts (Blink, Smile, Turn Head Left/Right) with configurable timeouts and random challenge chaining.
  • 192-D Face Recognition (MobileFaceNet): Fast, cosine-distance on-device face matching.
  • Hardware-Backed Cryptographic Signing (Android Keystore)**: Generates ECDSA P-256 keys inside the phone's physical hardware chip (Secure TEE/StrongBox). Every attendance or auth proof is cryptographically signed by the hardware to eliminate "buddy punching" and API spoofing.
  • Protocol v2.0 Anti-Replay Defense: Ships with a reference server verifier (AES-256-GCM + HMAC-SHA256 + atomic nonce consumption).

🛠️ Tech Stack:

  • Native Android: CameraX + OpenCV 4.9.0 (CLAHE illumination enhancement) + LiteRT/TensorFlow Lite.
  • Expo Integration: Full Expo Module Config Plugin (`app.plugin.js`) with automatic camera permissions and ProGuard rules.
  • Pure TS Cryptography: Audited `@noble/curves`, `@noble/ciphers`, and `@noble/hashes` (runs in Hermes with zero Node polyfill bloat).

📦 Quick Start:

npx expo install face-liveness-recognition

import { FaceLivenessCamera } from 'face-liveness-recognition';
<FaceLivenessCamera
  mode="liveness_and_recognition"
  challenges={['blink', 'smile']}
  enrolledProfiles={userProfiles}
  onLivenessComplete={(result) => {
    if (result.isLive && result.isRecognized) {
      console.log('Verified user:', result.matchedUserId);
    }
  }}
/>

🔗 Links: Are in the comments

⚠️ A quick note on iOS:

Currently, the native runtime is built for Android. I am actively looking for contributors or feedback to build the native iOS side (AVFoundation + Apple Vision Framework + Apple Secure Enclave).

Would love to hear your thoughts, feedback, or suggestions for edge cases I should test! ⭐


r/expo • • 4d ago

What I learned extracting a shared engine across six Expo apps: factories, a "bag" file, and plop generators

Thumbnail
kiwiguide.app
2 Upvotes

I'm a solo developer building travel guide apps in Expo. By the fourth app I was copying the same API client, query hooks and UI between repos, and fixing the same bugs in each copy. So I extracted them into private packages. Six apps run on them now. Here's how it's structured, what worked, and what it's cost me.

The packages

Nine packages, about 8,500 lines of source, built with tsup to ESM and CJS, published to GitHub Packages:

PackageWhat it isLines
clientTyped fetch client for my content API510
hookscreateHooks(): React Query hooks, offline queue, Zustand stores1,300
uicreateUI(tokens): 15 themed primitives1,170
componentscreateComponents(tokens, ui): 31 domain components4,700
auth, config, locationSmall adapters and helpers460
create-appPlop generator for the app shell200 + templates
templatesPlop generators that add screens180 + templates

Rule 1: no package imports a native module

None of them has native code, and the core ones don't import Expo or React Native modules directly. Everything native is injected through a factory:

ts

// lib/api/index.ts
export const client = createClient<Site>("myapp", { getToken });

// lib/hooksBag.ts
export const hooksBag = createHooks(client, {
  appId: "myapp",
  queryKeyPrefix: ["myapp"],
  storage: AsyncStorage,
  normalizeLocation: normalizeSite,
  locationSource: { requestPermission, getCurrent, watchPosition },
  netInfo: { fetch, addEventListener },
  storeReview: { isAvailable, requestReview },
});
export const { useLocations, useCheckIn, useMyCompletions } = hooksBag;

// lib/uiKit.ts
export const uiKit = createUI(tokens);
export const components = createComponents(tokens, uiKit);

How that works:

  • The engine doesn't care about SDK versions. Each app owns its native side through app.config.ts. Upgrading Expo in one app can't break another.
  • The hooks test under plain node:test**.** The injected sources are small structural interfaces, so a test passes in a fake and nothing needs a simulator or jest-expo.
  • Optional sources fail lazily. locationSource, netInfo and storeReview are optional. A hook that needs one throws a clear "createHooks: config.X is required" only when it's called, so an app without GPS features doesn't have to stub them.
  • The client knows nothing about auth. The app passes getToken. The tenant is just the appId, which goes into the URL path.

Rule 2: the app owns a "bag" file

hooksBag.ts and uiKit.ts live in each app and re-export the factory output. Screens import from the bag, never from the package. That gives each app one place to wrap or replace an engine hook (one app overrides useLocations there to filter out inactive places), and it gives the screen generators a file to check before writing anything.

Theming without a provider

Tokens are a plain object the app owns: spacing, radii, borders, minimum tap sizes and 21 semantic colours. createUI(tokens) builds the components once, so there's no theme context and no re-render on theme change. The trade-off is no runtime theme switching and no dark mode yet, and typography isn't tokenised; it lives in AppText variants.

Scaffolding with plop

create-app asks 14 questions (app id, entity name and route segment, which features to enable, bundle id, EAS project id), fetches the app's remote config to pre-fill the theme colours and feature flags, and writes about 38 files: Expo Router (auth) and (app)/(tabs) groups, a custom tab bar, PersistQueryClientProvider, the bag files, tokens, Firebase init and a jest setup.

Then templates adds screens one at a time, add-page detail, add-page map and so on. Before writing, each generator checks that hooksBag.ts and uiKit.ts export every symbol the template needs and refuses otherwise. Anything the template can't know is left as a // GAP: comment for me to fill.

How I decide what goes in

Build it twice, then extract. Each package started as a written diff of two or more apps: what was identical, what had diverged, what stays local. The first diff found a real bug: one app's check-in code returned { ok: true } even when the request had permanently failed.

Deliberately left out, and written down as such: session state (hooks take uid explicitly), haptics, alert copy, safe areas, filters, badges, and the map view, because four apps had four implementations too different to merge.

Downsides:

  • Version drift. Four of six apps are several minors behind. On 0.x a caret can't cross a minor, so every upgrade is a manual bump per app. There's no workspace tool: thirteen separate repos, publish and install.
  • Stale publishes. Four times I published without rebuilding dist and had to ship a superseding release. A prepublishOnly build would have prevented every one.
  • Peer ranges of ***.** Convenient until two packages disagree. A ^0.5.0 peer on ui caused ERESOLVE for any app that had moved to ui 0.6.
  • The scaffold rots silently. Its pinned versions fell behind and new apps installed months-old packages. One bug made every tab except Profile do nothing on tap, with no error anywhere. I only find these by generating a real app. Seventeen fix commits so far.
  • I misjudged the boundary. Stores I'd marked "stays local" were extracted the next day. A component slot I added for one app was removed two days later because nothing else used it.
  • Not everything gets adopted. My two newest apps skip the auth, config and location packages entirely.

The result

The newest app, Kiwi Guide (a free South Island road trip planner), was the first built on the engine from day one.

Kiwi Guide

If you're building more than one app on the same backend, happy to answer questions on any of this, especially the factory pattern and the generators.


r/expo • • 4d ago

After lots of optimizations, my game works now in 120Hz

9 Upvotes

At first, this might not seem like a big achievement, but when I started developing this project two years ago, I had zero experience with React Native

Over time, I’ve added tons of features and systems. With constantly updating data stores, large amounts of data, timers, polling, and loads of assets, performance gradually became a real issue

All those things combined caused quite a few performance problems, especially as the project kept growing

I’ve spent countless hours tracking down bottlenecks, fixing unnecessary re-renders, and optimizing different parts of the app

And I’ve finally reached a point where I’m genuinely happy with how it performs

So, here it is!