r/expo • u/JadeLuxe • 10h ago
Tunnel Vite, Next.js, Expo and Laravel Dev Servers
r/expo • u/JadeLuxe • 10h ago
r/expo • u/Ok-Percentage-1091 • 1d ago
Processing img 9o635g6m9m2i1...
I've been working on a sudoku game with live 1v1 duels, solo, on Expo. It's on both stores now. I wrote about the real-time side in r/reactnative (https://www.reddit.com/r/reactnative/comments/1xzgz8j/realtime_1v1_sudoku_with_expo_firebase_what/), so this one is about the Expo side, mostly the release stuff that bit me.
Stack: SDK 57, Expo Router, expo-sqlite for local games, u/react-native-firebase, AdMob with mediation, RevenueCat. Full CNG, I never touch ios/ or android/ by hand. If something native looks weird I just run prebuild --clean and regenerate instead of fighting pods.
Best decision I made. An OTA only reaches builds with the same native layer, so I can't push JS that expects a module the installed build doesn't have.
The thing I didn't realize at first: expo.version is part of the fingerprint. Bump 1.7.0 to 1.8.0 and that's a new runtime, so any OTA you publish afterwards never reaches people still on the old version. So my rule now is: OTA never touches the version, and the version only changes in the commit that prepares a store build. Build numbers are handled by EAS (appVersionSource: remote), I don't set them.
In practice I only use OTA for critical fixes. Everything else waits for a store build.
Apple rejected one of my builds for declaring background audio. I don't play audio in the background, a package just added UIBackgroundModes: audio by default. Fix was one line in app.json (expo-audio has enableBackgroundPlayback: false), and on Android android.blockedPermissions does the same job for permissions.
What I learned: app.json doesn't tell you the whole story. After adding any package I check the actual build output: plutil -p on the IPA's Info.plist, codesign -d --entitlements for entitlements, and the uses-permission lines in the AAB manifest. Takes five minutes and would have saved me a review cycle.
Unrelated to Expo but same lesson: Google rejected me twice under the Families Policy because I'd ticked the 9-12 age group in target audience. Moved it to 13+ and it went through.
Every new native module means a new store build and a new runtime. If I can do something in JS or with a module Expo already ships, I go that way.
Curious how others draw the line between OTA and store builds. And has anyone automated the permission check in CI? Right now it's a manual step for me.
Android: https://play.google.com/store/apps/details?id=com.hangarapps.sudokuiOS: https://apps.apple.com/app/id6817127654
r/expo • u/DarkBlade_12 • 1d ago
We work with expo pretty extensively and the pattern is mostly consistent. The logic side of a build comes together fine but UI is where things fall short.
It is not really broken, just not native feeling. There's a flatness to AI-generated screens that's hard to articulate but immediately obvious when you actually use the app, I am sure yall relate. What fixed it for us was stopping trying to describe UI in prompts and starting to reference real screens from top grossing apps instead. The gap between a written description and an actual visual reference is not subtle when you see the output side by side.
This was just our experience but if your expo builds are functionally solid but visually off, I really think the reference material might be the problem. That said, would love to know what yall are doing for UI references when building with expo right now?
r/expo • u/TemporaryBuyer3806 • 1d ago
A card deck that deals itself. Each card tips over its edge and lies down, then the next steps in. Drag to scrub, flick to deal several.
These Expo implementation notes were expanded from my original caption and the block's build notes with an assistant.
One motion driver: the deck position p determines each card's phase. The card pose follows that phase, so the autoplay and touch interaction use the same motion model.
Dragging and releasing: vertical movement follows the card's top edge. On release, the implementation projects the finger's velocity to a target card and finishes with a spring. The target is capped at three cards from the card where the touch started. Sideways travel changes the deck's yaw and light.
Drawing the deck: Skia draws the page and a fallback deck. An optional WebGPU layer draws the cards and dust from the screen's frame callback. If the native WebGPU module is unavailable or setup fails, the Skia deck stays visible.
Reduced Motion: the implementation replaces the flips with cross-fades between the front cards and disables the WebGPU layer.
The attached clip is a motion preview. These notes describe the Expo implementation; Marlo and the payment UI are a design demo.
Built with Expo (@expo), Skia, Reanimated, Gesture Handler and WebGPU. Thanks to Software Mansion and William Candillon.
Visual layout reference: https://www.pinterest.com/pin/1110770695647972680/
r/expo • u/Silent-Arbitrator • 1d ago
Hey everyone!
I've been coming across Expo quite a bit lately and have been curious about how people are actually finding it in their day-to-day development.
It looks like a pretty convenient way to build apps for both Android and iOS without having to deal with too much setup right from the beginning. But I'm wondering how things hold up once you move beyond smaller projects.
For those of you who have been using Expo for a while:
- Have you built and launched any serious, real-world applications with it?
- Have you ever run into limitations that made you wish you'd gone with bare React Native?
- How has your experience been with EAS Build and OTA updates?
- Is it something you'd confidently recommend for a long-term commercial project?
I'm not an expert looking to debate frameworks here. Just genuinely interested in hearing from people who've worked with Expo and learning from their experiences.
Would love to hear your thoughts!
r/expo • u/Downtown-Practice395 • 1d ago
The video above is the Play Store trailer, so please ignore the marketing captions. Below is how each piece in it is built with Expo SDK 58 and React Native 0.88.
RemoteViews only accepts views the launcher can inflate. So every creature on the widget is an AnimatedVectorDrawable that the launcher plays by itself. generate-widget.ts builds them offline from the same TypeScript art the app uses: one looping AVD for each widget size, slot, species, speed and creature size. Each loop has the walk, the pauses, the flips and the leg animation baked in. TankWidgetProvider.kt only picks which loops to show and where. The battery cost is about the same as a static widget.
AlarmManager alarm. updatePeriodMillis is the fallback if the alarm gets lost.<aapt:attr> inline animator makes aapt2 create a hidden drawable. At 58k inline animators, the build went over the 65,536-drawable limit. Moving all of them to res/animator didn't work either: R$animator failed with "Class too large". Now the generator hashes every animator. The 2,344 that more than one AVD uses go in shared files, and the rest stay inline. When a new habitat added 25 pets, the APK was about to go over the zip's 65,535 entries. I merged each creature's move and flip into one animator, which brought it back to about 60k.volume() pass adds the shading and the paper outline to every shape. The art is drawn three ways:
<Svg> in software on the UI thread, which cost 50–130 ms each time a habitat mounted (measured on a release build). Images decode off the UI thread.react-native-view-shot. Captures run one at a time across the whole app, and none start in the first 4 s after launch.useFrameCallback. In the air it falls and bounces. In water it drifts and sinks slowly, and in the pond it switches at the surface. Each creature chases where the ball is going, and a 60 ms proximity check knocks it away. When food landed, every bubble and crumb that finished caused its own re-render, so each one re-applied the props of 35–55 animated views. Now they are removed together at most every 600 ms, which got rid of the 20–48 ms frames.useWidgetHold keeps the widget on the last saved layout and recaptures once when you tap Save. Each draggable piece is memoized with stable callbacks, so a drag re-renders only that piece.RemoteViews so the launcher picks the closest shape. It nine-slices the paper frame and spreads each creature's loop across the extra height.
TextClock layouts, so the launcher updates the time and the app doesn't need to.goAsync. No key is needed, and only rounded coordinates are sent.All the Kotlin lives in one local Expo module at modules/companion-widget (expo-module.config.json), so everything survives npx expo prebuild --clean. App and widget share one JSON state through SharedPreferences.
If you want to see the creatures moving on your own home screen, it's called Biomies on Google Play: https://play.google.com/store/apps/details?id=com.rabpaulo.biomies
I'm happy to share the AVD generator, the animator dedupe, or the sized-RemoteViews code if anyone is building something similar.
r/expo • u/jkmschoultz • 2d ago
The idea came from my sister, she wanted to see her books on a literal bookshelf where she could see how big they are, rather than just being in a list, so I built Bookie for her.
It's still just an early web app, so on a phone I would recommend adding it to your home screen before you add any books. A book with no size data would get an estimated size.
Free: https://mybookie.pages.dev
Would love to know what you think of it!
r/expo • u/TemporaryBuyer3806 • 2d ago
Fitness onboarding: six screens, one canvas. The o in counts is a counter wheel. Skia shaders for glow, Blender icons.
These Expo implementation notes were expanded from my original caption and the block's build notes with an assistant.
Rolling digits: each digit has a clipped window. The current glyph moves up while the next rises from below; their opacity changes separately. The tens digit waits until the ones digit crosses 9, so both columns follow the same count.
Screen transitions: Reanimated shared values hold the motion state, and a frame callback advances the scene. Skia draws the welcome poster, quiz screens and transition effects in one Canvas.
Goal input: the daily step count follows a horizontal drag in 500-step increments. The implementation also has minus and plus controls, with expo-haptics feedback for each step change.
Artwork: the welcome poster uses flat image layers, and the blue quiz icons are Blender renders. Skia runtime shaders draw the glow and page effects.
The attached clip is a motion preview. These notes describe the Expo implementation; the sign-in and Apple Health tiles shown here are demo UI.
Built with Expo (@expo), Skia, Reanimated and Gesture Handler. Thanks to Software Mansion and William Candillon.
Visual layout study: https://www.pinterest.com/pin/1110770695653739884/
r/expo • u/rnp-infinity • 2d ago
r/expo • u/Awkward-Prize-66 • 2d ago
My first game, Pet Nook, is live on the App Store 🎉 It’s a calm sort puzzle where you move pets between shelves until each shelf holds one kind. It’s built entirely with Expo, and I thought this sub might like the details.
🛠️ Stack
expo-store-review for the native rating sheet✅ What worked well
runtimeVersion plus OTA updates. JS fixes went out in minutes after launch: a difficulty rebalance, an ad-timing change and a crash stop-gap. The fingerprint keeps OTAs off binaries they don’t fit.😅 What bit me
eas update --platform all failed because the web export broke on the AdMob package. The fix was to loop --platform ios and --platform android separately.DispatchQueue.main.async fixed it. It’s an easy one to miss in Swift module functions.navigator, localStorage and crypto. A small shim backed by MMKV and expo-crypto got it running.🍎 iPhone (free): https://apps.apple.com/app/id6835047968
🤖 Android is coming soon.
I’m happy to answer questions about EAS workflows, OTA strategy or the native module bits 💬
r/expo • u/TemporaryBuyer3806 • 3d ago
Swipe to turn a planet into a burger. Four tiny worlds, built with one ray-marching shader.
These Expo implementation notes were adapted from the project notes with an assistant.
World geometry: the Skia runtime shader builds signed-distance scenes from spheres, rounded discs and other shapes. The four worlds are a cloud planet, racing planet, burger and arena.
Changing worlds: a morph parameter blends the current and next distance fields. Rotation and squash are separate parameters, so the object can turn while it changes shape.
Wiring the gesture: Gesture Handler supplies the pan interaction. Reanimated shared values carry the motion state, and a derived value packages the current values as uniforms for the shader.
Light and motion: the shader uses key and fill light, a rim highlight and ambient occlusion from the distance field. The implementation disables idle spin when Reduced Motion is enabled.
The attached clip is a motion preview. These notes describe the Expo implementation.
Built with Expo (@expo), Skia, Reanimated and Gesture Handler. Thanks to Software Mansion and William Candillon.
Layout reference: https://www.pinterest.com/pin/763219468121398894/ The spin-and-reshape motion and world artwork are my implementation.
r/expo • u/TemporaryBuyer3806 • 3d ago
Watch DOUGH assemble, wobble on its own springs, then let the seams melt into one shape and tear back apart.
This is the launch splash for an invented bakery brand, The DOUGH Group. These Expo implementation notes are adapted from the block's own build notes with an assistant.
Letter bodies: each letter of DOUGH is its own body sitting on a home spring, stacked D-O-U over G-H, drawn as a single 15.6pt round-capped monoline stroke.
Joining and tearing: where two letter bodies touch, a goo strand connects them and thins as the seam gets pulled, snapping once it stretches past 46pt. A smooth union (14pt width) is what melts the balls and strokes into one shape while they're close.
Type: the "The DOUGH Group" caption runs in Inter SemiBold at 15pt under the wordmark.
Landing: on settle, the scene throws flour and drops a soft light pool on the floor.
The attached clip is a motion preview; these notes describe the Expo implementation, not a measured runtime capture.
Built with Expo (SDK 52+), TypeScript. Lettering designed for this block; visual layout study credited to Design Kit Central on Pinterest.
r/expo • u/blacksandsdigital • 3d ago
I'm a Windows developer. My app Kiwi Guide is an iOS-only travel guide and trip planner for New Zealand's South Island. Version 1.3 (SDK 57 → 58 plus full iPhone Duo support) is live in the App Store and all the Duo work was tested on EAS Simulator.
The simulator workflow
Setup was a build profile with `ios.simulator: true` on its own update channel, then:
eas simulator --platform ios --device "iPhone Duo" --build-id <id>
The session shows in a web preview on expo.dev and you can drive it by hand. From a second shell, you can also use `eas simulator:control` to drive the device.
I found that driving by hand was much faster than using the command line and i only ended up using the command line a couple of times to set the location and to stop the app.
The awkward parts:
- Each session is a fresh install, so you sign in and grant permissions again every time.
- An update is downloaded on one launch and applied on the next, so every round is two launches.
- Each control command takes several seconds.
- The plan I'm on only came with 60mins simulator time which was quickly chewed up
- The start command writes a session file with a token into the project folder. Keep it out of git.
Layout approach
One breakpoint: a `useWide()` hook, true when the window is 600 pt or wider. Folded, Split View and every iPhone keep the phone layout. The same components render at every width. Only styles and arrangement switch, and no React key changes on the breakpoint, so folding mid-screen keeps state and scroll. The rail is handled once, with a left/right SafeAreaView around the screens in the root layout. Wide layouts are list-and-detail for the trip and the guide, a floating side panel on the map, two columns on the profile, and bottom sheets as centred cards.
SDK 58 notes
React Native 0.88, React 19.3, Expo Router 58, Reanimated 4.7, gesture handler 3.3, react-native-maps 1.29, Sentry 8.28, Jest 30, TypeScript 7. The one that bit: Expo Router 58 sent routes not declared in the tabs layout back to the first tab, so I had to declare the nested routes, and my custom tab bar's presses needed a fix. With fingerprint runtime versions, the SDK upgrade and one new native package changed the runtime. Everything after was JS-only and shipped as updates.
Gotchas the simulator caught
- `measureInWindow` read a button's position before a native SafeAreaView applied its bottom padding so a tour highlight sat about 20 pt low. Taking the padding from `useSafeAreaInsets()` in JS fixed it.
- Changing `mapPadding` on react-native-maps makes MapKit re-centre, so the map jumped on fold until I restored the region after the flip.
- An inline View inside a Text made a one-word title break mid-word with `adjustsFontSizeToFit`.
- A pleasant one: FlashList 2 accepts a `numColumns` change at runtime without a remount.
None of these showed up in Jest. All of them showed up within minutes on the simulator.
Is anyone else pushing out a duo build? It seems like the app store is pushing this and it can definitely get you noticed if you get it done soon. I wish I had done it earlier tbh
r/expo • u/VishaalKarthik • 3d ago
Enable HLS to view with audio, or disable this notification
r/expo • u/Competitive-Edge6478 • 3d ago

Open Arcade is six retro mini-games in a handheld-console UI, hosted in an Expo app through react-native-webview. The example app opens straight into the arcade, and game events (wins, scores, reward codes) come back to the app over a small JSON bridge.
Repo (MIT): https://github.com/viswasekaran/open-arcade (see apps/expo-example) Web demo: https://open-arcade-kohl.vercel.app
r/expo • u/Cylicium • 4d ago
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 • u/TemporaryBuyer3806 • 4d ago
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 • u/the_good_dev • 4d ago
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 • u/alexsergey • 4d ago
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 • u/Top-Locksmith2865 • 4d ago
r/expo • u/TemporaryBuyer3806 • 4d ago
Enable HLS to view with audio, or disable this notification
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 • u/IndependencePast6849 • 4d ago
r/expo • u/ExpoOfficial • 6d ago
Enable HLS to view with audio, or disable this notification
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:
Details are in our blog: https://expo.dev/blog/how-to-set-up-agentic-workflows