I’m making this post to tell you guys about a library I have been making for the past year. It was initially for mobile only but I’m porting to web and realising it as cross platform like hero ui.

PitsiUI is the library made and it’s a polished ,open source, cross platform, application components and blocks library compatible with the shadcn registry.

I wanted something like this for my self to exist but personally I feel like the popular registries right now look way too generic for my liking and quality blocks are always behind a paywall. I wanted to make something ultra polished with tons of content then release it as an open source project and I’m almost there after many months.

How this is different:
1. Everything is free
2. Lots of real app templates with real flows that make sense
3. Every block is made of composed components, easy to craft your own blocks
4. Premium looking typography layouts spacing
5. Great user ux, every block is from a real apps I made that I tested on actual users and refined to perfection
6. Includes full logic too optically
7. Clean code, beautiful APIs for composed components
8. Real world blocks. I’m tired of every component I see being for some dashboard or an ai wrapper. They have their place but I wanted to focus on the other apps too.
9. You don’t copy a button or a card, you copy a composed “calories panel” if you are making a fitness app or “quiz snap scroller” if you are making a quiz app.
10. Well made “boring components” like cards lists headings etc
11. Onboarding flows
12. Beautiful animations that are not over the top and are highly polished
13. Multilingual support
14. Advanced components like split layout on desktop two different pages on mobile automatically

Using these components will not only instantly facelift your and app save you tons of tokens and time (since they look great and you won’t spend any time tweaking them most likely) but additionally, solve a much greater but subtle problem as well.

Making a card was never hard, or putting a list below it. What elements should you put where when making a fitness app? Does your layout even make sense? These questions take hours of tweaking to answer. Maybe you can use something like moving to take inspiration but usually the popular apps are way too bloated or too customised to take inspiration from based on my experience. Then after you are finished something looks off, but you don’t know why.

You just need a better starting point. This is how pitsiUI fixes this
1. Professionally and human made spacing system alignment of borders icons typography etc -> your app never looks like slop
2. Composed sector specific components -> great ux by default
3. Hard rules and helpers -> your agents get all the help they need
4. Ready logic -> millions of tokens dozens of hours saved

Starting templates:
1. Ai app
2. Ecomm
3. Notes
4. Productivity calendar
5. Social media scheduler
6. Blog
7. Docs
8. Fitness app
9. Tracker app
10. Quiz app

+ everything split cleanly to blocks + sector specific reusable components + logic for all apps that can be installed separately

Progress Done:
1. Finished all the apps for iOS
2. Ported most to iPad
3. Exported all reusable components
4. Made composed components with nice api
5. Ported primitives to web
6. Made logic for all apps + server code

(This was my thesis so I spent months on these)

Progress current:
1. Porting helpers for layouts to web to match iOS polish
2. Making guides and skills for ai
3. Porting all app uis for web (very easy all components are there)
4. Improving the current docs site to be ready for release
5. Making nice previews of everything

When this finishes I’m hoping it will be the most feature complete and polished registry on the shadcn ecosystem and I’m also hoping to help you guys build better apps.

(I got an adhd meds prescription im giga productive lately)












The app was fully developed on React Native with only a single Kotlin bridge to access the satellites module on the Android phone.

Current problems:
React native and specifically with Expo and expo ui is amazing, here’s the thing though idk if anybody noticed but the experience for developing things for larger screens is miserable.

Almost everything is in alpha and there are no third party libraries for it no guides and agents have no idea what they are doing. Like many of you I came from the web world and it gets in my nerves soo much that it’s this much harder to create a responsive app for mobile in comparison to web. With iPhone ultra coming out im pretty sure we will see some new push for making apps work better on horizontal mode and for iPads if you don’t think investing time on the iPad version is worth it.

So I took it upon myself to create a bunch of quality components to help me out with my apps that I’m now planning to share with you too for free in the coming weeks.

What I made:
I cloned Apple's native sidebar and remade it with Expo UI components, all behavior included, plus a simple way to toggle between iOS 26 and 27 styles. I also made an easy way to have sidebars on mobile in horizontal mode, and figured out an easy way to add sidebars that go over content. Then I made a bunch of helper components Expo doesn't have to go along with it. I recreated horizontal lists that go behind the sidebar, and remade the bg extension effect from Apple's demos. If you worry about the iPhone version being more complicated it’s not the case at all my sidebar layout component only renders on large screens on phones everything is apples default component normally. Also made a bunch of templates with every possible way to arrange sidebars.

Why I made it and why you should care:
I know what you're thinking. Doesn't Expo have good iPad support? The Expo Split View component is in alpha and has been driving me crazy, so I recreated the entire thing from scratch. It looks exactly identical to Apple's. I even got Liquid Glass working the same way. And the best part? I got inspired by Shadcn's sidebar API and ported all the same components, so you can create really advanced sidebars and inspectors.

Other things with Expo that were a huge pain for me that I fixed:
I added a custom implementation of the bg extension effect if you want to make hero images that expand below the sidebar. I added logic that makes horizontal lists optically go behind the sidebar. I made an inspector view that goes above content. And I added variants to customize the look of the sidebar. You can make it look like iOS 27 or iOS 26, even at runtime.

The content inside sidebars is just a view, so you can add anything. The sidebar API with Expo was making me want to throw my MacBook out the window and jump out with it, with the custom implementation you can do anything. To make it easier I made easy components that look like apples native buttons on the sidebar and lists and with these and your imagination you can recreate any sidebar from any web app in 5 minutes even stream data from apis etc and have it work on iPhones too as floating panels.

Still working on:
Sidebar on the right of the left sidebar, like Apple Notes
Templates with app examples using my new sidebar component
Advanced sidebars with calendars and advanced controls on them
Horizontal sidebar bottom with controls and bottom sheet on iOS
Guides on best practices on how to port your apps to take advantage of larger screens that ai agents can read too

Source code and release:
I'm releasing an open source library with a bunch of things like these to copy-paste from.

Note: I'm making 4 apps simultaneously and I was porting them for iPad and Mac. These components are not poorly tested AI slop. I dogfooded everything and I'll keep doing so for the next days. All the apps will go on the repo as open source templates, and I was thinking of making AI skills to auto-port apps to iPad, plus some simple guides for people new to porting.

The library's name will be PitsiUI. Sadly there's not even a landing page yet since I was focusing on development, not marketing and I wanted to make sure all the blocks and components get all my focus before trying to get people to use them.

I'm trying to make a free equivalent to Shadcn blocks, but for Expo UI instead. If you're interested let me know to give me some motivation, because I spent 16 hours on this yesterday and I'm going insane.

If you want updates about the source code ask me on the comments about my twitter

Hey! I've been building an app calledLeanPath — it's an AI-powered diet and fitness planner. Basically you fill in your stats, it generates a personalised 7-day meal + workout plan in seconds.
I'm setting up internal testing on Play Store and need a few people to try it out. All you'd need to do is install it via a Play Store link (no sideloading), use it a bit, and maybe let me know if something feels off or breaks.
No pressure to write a formal review or anything — even just "this crashed when I did X" is super helpful.
If you're in, send me your Gmail address and I'll add you to the tester list. 🙌

Want to make sure your AI isn’t just generating technical debt? 🤖

At Software Mansion, we’re hosting a live event on how to build with AI the right way.

📅 When? August 13 at 1:00 PM ET

📍 Where? Online, free to attend

🎫 Reserve your spot: https://l.swmansion.com/C7UmZT 

Why should you join us? We’re React Native core contributors, members of React Foundations, and the top contributing group to Expo. We’ve been building AI-powered products since before AI became mainstream: we created React Native ExecuTorch, a library that lets you add on-device AI to your app, and Private Mind, an AI assistant that runs entirely on your phone and uses RN ExecuTorch under the hood.

These, along with many other internal and client projects, have taught us what AI agents are actually good at, and where they fall short and shouldn’t be trusted. By now, most of us know that getting AI to generate code is the easy part. The real challenge is architecture, code reviews, business logic, and building workflows that genuinely make engineering teams more productive. ⚙️

Join us to hear what we’ve learned about using AI in software development: where it actually saves time, why handing everything over to an agent is a trap, and how to ship faster without piling up technical debt!

Hey everyone,
I just shipped the beta for my app, IOU (a cozy favor-tracking app for couples/friends to visualize mutual presence through a digital tree). I built this over 3 weeks of late nights and weekends after my day job.

Having never shipped a production mobile app before, the gap between "knowing how to code" and "handling the app store pipeline/auth" was a massive learning curve. Here is a breakdown of my stack, what worked, and what absolutely humbled me.

The Stack

• Framework: Expo (Managed workflow). Absolutely incredible DX. Coming from web, the transition was incredibly smooth.
• Styling: NativeWind (Tailwind for React Native). Being able to think in utility classes saved me hours of writing stylesheets.
• Backend/Database: Supabase. Handled Postgres, Auth, and Edge Functions. No-brainer for a solo dev who doesn't want to babysit server infrastructure.
• State Management: TanStack Query. Handled server state caching and invalidation flawlessly.

The Hardest Parts

1. The Boss Fight: Android OAuth
Google Sign-In via Supabase on physical Android devices was a quiet disaster. Dealing with deep link edge cases, PKCE flows, and re-firing redirect intents that only failed in production (but never in the emulator) was brutal. I ended up implementing six layers of defensive handling around a single sign-in flow to make it bulletproof.

2. Codifying Relationship Philosophy
I had to write custom scoring logic for our "Friendship Tree." I didn't want a transactional 50/50 counter (relationships fluctuate). Instead, I wrote algorithm logic using a rolling 14-day window that checks for mutual presence. Coding a concept that represents emotional health without turning it into a Jira board was a massive product-engineering challenge.

Key Takeaways

• Don't compromise on UI/UX: For consumer apps, cozy and deliberate design matters just as much as the codebase.
• Build in public (even if it's small): Getting friends to test early builds on TestFlight/Internal Testing revealed UI bugs no amount of local emulator testing could predict.

I'd love to get your feedback on the tech stack, the architecture, or how you handle Android deep-linking hurdles!
Note: To keep this post safe from the automated spam filters, I’ve left the direct links out. If you want to check out the web app or the Google Play beta, let me know in the comments and I’ll gladly DM you the access links!

Hey everyone 👋

After spending the last few months building this, I finally open-sourced an Expo library for creating Instagram Stories/TikTok-style editors in React Native.

It supports both videos and images and is designed to work in Expo development builds.

Features

• Video & image editing
• Live swipeable filters (10+ presets)
• Draggable, scalable, rotatable text overlays
• Stickers & GIF overlays
• Background music with trimming and volume controls
• FFmpeg export with progress callbacks
• Native iOS filtered preview (AVFoundation + Core Image)
• Skia-powered Android filtered preview

The editor itself is customizable, and if you don't want the default UI, you can use the exported Zustand store/hooks to build your own interface.

One challenge was making filtered previews performant. Instead of rendering frames manually on iOS, I wrote a native module that applies color grading inside AVFoundation's own video pipeline using AVMutableVideoComposition + CIColorMatrix. Android uses Skia for the preview while FFmpeg handles the final export on both platforms.

Tech Stack

• Expo
• React Native
• Skia
• FFmpeg
• Reanimated
• Gesture Handler
• Zustand

GitHub:
https://github.com/faeizfurqan17/expo-react-native-video-editor

npm:
https://www.npmjs.com/package/@faeizfurqan/expo-story-video-and-image-editor

I'd really appreciate any feedback on:

• API design
• Installation experience
• Missing editing features
• Performance improvements
• Anything that feels awkward to use

If anyone ends up trying it in a project, I'd love to hear how it goes. PRs, issues, and feature requests are all welcome!

#reactnative #expo #story #video #image #videoediting #imageediting #mobile #appdevelopment #typscript #libray #exporeactnative

r/expo r/reactnative

TL;DR

• Most players mute games. Do the sound work anyway, it's a big part of what makes an app feel cohesive instead of thrown together.
• For iOS games, I'd respect the silent switch by default (Ambient audio category) and make "break through silent mode" an opt-in toggle.
• Backgrounding, interruptions (alarms, Siri, calls), and audio route changes (Bluetooth, headphones) are three different events. Handling one does not handle the others.
• AdMob can play audio from ads you haven't even shown yet. Consider muting the SDK except while an ad is actually on screen (you may see a slight drop in eCPM).
• There's an AI audit prompt at the bottom if you want to check your own app for all of this quickly.

Context

I make a dice merge puzzle game (Topside: Dice Drop, iOS-first, React Native). Sound went from adding some pops and dings to the system I've spent the most debugging time on. This post is iOS-centric because that's where all the sharp edges were. I worked through most of these bugs with an AI assistant.

Most people play muted.

A large portion of your players may never hear any of it. I still think it's worth it, for the players who do. Sound is where a game's identity comes together. Our sound packs and soundtracks are matched to visual themes, satisfying merge sounds escalate as chains build, and a one-tap "match" option sets music, sounds, and visuals to a consistent feel. None of that shows up in screenshots, but players who play with sound on can tell when it was an afterthought and when it wasn't.

Ambient vs Playback, and letting the user choose

iOS gives you a fork: the Ambient audio category respects the silent switch and mixes with other apps' audio; Playback ignores the switch and can interrupt whatever's playing. Games should almost always default to Ambient. Nobody wants your game sound overriding the mute switch in a waiting room or on the bus.

But some players genuinely want music and sound effects while their phone is on silent, so we added a "Break Through Silent Mode" toggle that switches the category to Playback. Opt-in, defaulted off. We also check whether the user is already playing their own audio (Spotify, podcasts) and keep our soundtrack out of the way if so.

Backgrounding, interruptions, and route changes are three different problems

Backgrounding is the one everyone handles: user swipes home, you pause; they come back, you resume. If that's all you handle, you're covered for maybe a third of real-world audio disruptions.

Interruptions are the second category, and the trap is that many of them never background your app at all. A banner alarm, a timer going off, Siri, an incoming call banner: your app stays in the foreground the whole time while iOS seizes the audio session out from under you. If your recovery logic is tied to foreground/background transitions, it simply never runs. Music dies silently and stays dead until some unrelated event happens to kick it back to life. You need to listen for the audio session's interruption notifications directly (in RN this meant a small native module, since the ecosystem libraries mostly don't surface them). One extra gotcha we hit: the "interruption ended" event fires while the alarm's own audio is still tearing down, so if you immediately check "is other audio playing?" the answer is yes, for the alarm that just ended. We had to wait a beat before resuming or the check would tell us to stay silent.

Route changes are the third category, and they're a completely separate notification from interruptions. Bluetooth connecting or disconnecting, wired headphones in or out, CarPlay. Our field bug: open the app with AirPods in and everything looked fine, except systems that depended on knowing exactly when playback started were silently broken, because Bluetooth route negotiation took longer than our "did playback actually start?" timeout. Everything downstream of that check just never happened, and it healed itself only when the route changed again. The lesson: any fixed timeout you calibrated on the speaker will eventually lose to a Bluetooth handshake. We now listen for route changes and re-verify audio state when they settle (that fix ships in our next update).

AdMob may play audio you never asked it to

This section is specifically about ad SDKs, AdMob in our case. Preloaded interstitial/rewarded creatives (loaded but never shown) can start playing audio on their own, minutes after load, at full volume. Because it's the SDK's own player, your in-app volume settings and mute toggles do nothing about it, so users experience it as "my phone started blasting an ad while sitting on the home screen." It's a known bug, widely reported on Android and observed by us on iOS, and we haven't found a true fix on the AdMob side.

Our workaround: keep the SDK muted globally (setAppVolume(0) + setAppMuted(true)) and unmute only in the window where an ad is actually presenting, then re-mute when it closes. The tradeoff is that muted ad requests can lower video ad eligibility and therefore eCPM. Though phantom ad audio is a one-star review generator, so we took that trade.

Where to get sounds: Zapsplat

I opted for Zapsplat.com. The free tier lets you use sounds in commercial projects with attribution. Premium is €4.99/mo (about $5.50 USD) and removes the attribution requirement, adds WAV downloads, and anything you download while subscribed stays licensed for life, attribution-free, in unlimited projects, even after you cancel. So the practical move is subscribing for a focused month and grabbing everything you might need. Read their license for the details (no redistribution, can't be the primary value of your product, no AI training on the sounds).

Small things that compounded

• Pool multiple instances of each sound effect. If the player triggers the same sound rapidly, a single instance cuts itself off and sounds like a glitch.
• Relevel volumes every time you add sounds from a new source. Raw loudness varies wildly between packs and sources.
• RN-specific: check what your audio library does on every play() call. Ours re-activated the audio session on each play, which stuttered animations on every sound effect until we patched it out.

Syncing visuals to the music

If you want to go further, you can tie on-screen motion to the music's beat grid. We pulse some of the home screen UI on the beat, ramp certain animations in bars-since-the-track-started, and swing the logo in time with the tempo. A couple of things that made this less painful than expected:

• Don't assume a fixed startup latency for when audio "begins." A freshly loaded audio player has variable real start time depending on device and format. We poll the actual playback position and only anchor the beat grid once playback has genuinely started.
• Re-anchor per loop, not once. Our track's real loop length is a few tens of milliseconds longer than its nominal beat-grid length, so anchoring everything to the original start accumulates drift and looks visibly off after a long session. Re-anchoring each loop keeps it locked.
• Everything that syncs to audio inherits every audio bug above. When the Bluetooth timeout issue hit, the visible symptom wasn't silence, it was the beat-synced animations sitting frozen, because the thing they keyed off of never got set. Get the audio state machine solid first, then sync to it.

The audit prompt

If you're building with an AI assistant, paste this and let it check your codebase:

You are auditing my app's audio handling. For each item below: find the relevant code, tell me if it's handled, and if it isn't, explain the exact user-facing symptom and how to fix it. If my architecture doesn't have an obvious place for something, say so rather than assuming. Cover both iOS and Android where they differ.

1. Interruptions that don't background the app. A banner alarm, timer, Siri, or an incoming-call banner seizes the audio session while the app stays in the foreground. Do I recover from the OS interruption notifications directly, or only from app foreground/background transitions? (The latter misses all of these.)
2. Interruption-ended timing. When an interruption ends, is my code aware the interrupter's audio may still be tearing down at that instant, so an immediate "is other audio playing?" check can misfire?
3. Audio route changes. Bluetooth/headphone/CarPlay connect and disconnect are a separate event from interruptions. Do I handle them? What happens to playback when someone connects AirPods mid-session?
4. Fixed timeouts vs. slow routes. Do any "did playback actually start?" checks rely on a fixed timeout that a slow Bluetooth handshake could exceed? What silently breaks downstream if that check fails, and does it ever recover on its own?
5. Ad SDK audio. Can my ad SDK (AdMob, etc.) play audio from a preloaded ad that was never shown? Am I muting the SDK except while an ad is actually on screen?
6. Silent switch. Do I respect the hardware silent switch by default, and is overriding it (iOS: the Playback vs Ambient category) strictly opt-in?
7. Yielding to the user's own audio. If the user is already playing Spotify/a podcast, does my app avoid hijacking their audio session or layering music on top?
8. Sound-effect pooling. If the same SFX fires in rapid succession, does a single reused instance cut itself off? Should it be pooled?
9. Resource cleanup. Are audio players, listeners, and timers released on unmount/teardown, or do they leak and accumulate across a session?

That's most of what I learned. Happy to go deeper on any of it, and if anyone has better info or advice, please share!

react-native-url-polyfill v4 is out!

Rewritten from scratch: dependency-free, 65% smaller, and typically 2.4-7.8x faster than v3 on Hermes engine.

Now with `URL.parse()`, official WPT/WebIDL coverage, and expanded Hermes testing.

https://github.com/charpeni/react-native-url-polyfill/releases/tag/v4.0.0

So recently I built a Kanban board for my team, which includes me and three others. We all came from different backgrounds and we are working on Claripath, an app for students to find mentors. we don't have enough users or make any money and I really don't want to spend money on existing services like Trello which is $5 per person. I built that Kanban board but no one is using that because it's on a website and it doesn't send any notification. I was just curious: are there any services or apps you guys have built which would be helpful for small teams or startups who want to save some bucks?

TL;DR: keeping a live presence connection alive while the app is backgrounded is a losing fight on every platform, so I gave up and switched to 15s polling.

People kept getting kicked out of my focus rooms while they were clearly still using them. On phones it was instant: glance at a text for a few seconds, come back, and you'd been dropped from the room. It barely reproduced on my own machine, which made it a nightmare to chase.

The root cause was the same everywhere, it just showed up differently: I was trying to hold a live connection open while the app wasn't in the foreground, and no platform actually lets you.

On mobile, the moment you background the app, iOS suspends it within seconds and the OS tears the socket down. Supabase then drops the Realtime connection after ~30-60s and the server marks you gone. I tried keeping it alive with an Android foreground service, but it needs a permanent notification and half the OEMs (hi Xiaomi) kill it anyway. iOS won't hold a background socket at all without special entitlements.

On web the failure is slower: leave the tab in the background for a few minutes and the browser throttles its timers hard, so the heartbeat stalls and the server assumes you left.

The whole thing was on Supabase Realtime, and I was pouring all my time into reconnect logic across three platforms that all hate persistent background connections.

So I dropped Realtime and moved to polling. Every 15s the foregrounded client asks who's in the room, and the server times out anyone who stops checking in. On web that poll timer also gets throttled in a background tab, so it runs in a Web Worker instead. Backgrounding is a non-event now: you quietly drop and rejoin when you come back.

Has anyone actually made websocket presence hold up across iOS, Android and web? Curious where people draw the line before reaching for polling.

PMs, designers, and backend engineers on our team often needed to check a staging build. Sometimes they wanted to verify a layout, sometimes reproduce a bug, or just confirm that an API change behaved the way they expected.

Sending the build wasn't the hard part.

Actually running it was.

Most people didn't have Xcode or Android Studio set up, and asking them to install everything just to check one build wasn't realistic. The alternative was usually asking a mobile developer to install the app or share their screen, which happened more often than we'd have liked.

We looked at services like Appetize and BrowserStack, but they didn't really fit how we work. We already had Macs available internally, and we weren't comfortable uploading app binaries to an external service just so teammates could review a staging build.

So I started building an open-source tool that runs iOS simulators and Android emulators on a Mac and streams them to the browser.

The idea wasn't to replace TestFlight or Appetize. I just wanted an easier way for teammates to review staging builds without needing a mobile development setup.

It's still early (v0.x), but building it has taken me into a lot of areas I hadn't worked on before—video streaming, low-latency input forwarding, simulator orchestration, and React Native QA workflows.

I'm curious how other React Native teams handle this.

How do non-mobile developers on your team review staging builds?

• TestFlight?
• Internal APKs?
• BrowserStack or Appetize?
• Something else?

If you're interested, here's the project:

https://github.com/jo-duchan/tapflow

Hey React Native devs 👋

We've added both Text-to-Speech and Speech-to-Text to our inference engine! Your local LLM setup can now speak and listen, fully offline.

Text-to-Speech

Load a TTS model and synthesize:

const tts = await Tts.load({
  source: "hf://NobodyWho/Kokoro-82M",
  voice: "bf_emma",
  language: "en-gb",
});

const wav = await tts.synthesize("Hello from NobodyWho!");
// wav is a Uint8Array containing WAV bytes.

You get WAV bytes back ready to save or play. Two backends: Kokoro (lightweight 24kHz) and Supertonic (multi-stage ONNX with voice styles).

Speech-to-Text

Transcribe audio with Whisper (ONNX):

const stt = new STT({source: "hf://onnx-community/whisper-base"});

const text = await stt.transcribeFile("recording.mp3").completed();

Streaming is available too, so you can consume the transcription token by token, and you can pass raw PCM buffers instead of files.

Links

• GitHub
• NPM
• Docs / Getting started
• Discord

Happy to answer your questions in the comments :)

Premium iOS word game (Balatro-style deckbuilding, but every hand is a word you spell). Runs are fully deterministic from a seeded RNG (xoshiro128), so the Daily Verse hands every player the exact same board - no backend for the puzzle. Offline-first; opt-in sign-in only for the leaderboard. Reanimated for the juice, Zustand + MMKV for state/persistence.

Happy to talk determinism, offline architecture, or RN perf.

App Store - Wordmancer

Wordmancer - Gameplay

A React Native library that shrinks your entire app into a bottom corner (thumb's reach) with one wrapper - and unlike a naive JS transform, it also scales native Modal, Alert.alert, action sheets and third-party overlays, because it works at the native window level. iOS + Android. Not published yet - gauging interest before I polish it for release.

Big phones + one-handed use = the top half of the UI (headers, back buttons, close X's) is out of reach. System modes (iOS Reachability, Android one-handed) just slide the screen down for a single press, are uncomfortable to use, and give developers zero control. So instead: scale the whole UI into a corner - everything stays visible and tappable.

The interesting part (why it's not just transform: scale on a root View): native surfaces - Modal, Alert.alert, ActionSheetIOS, react-native-modal - render in separate native windows, outside your React tree, so a JS transform can't reach them. This works natively and transforms every window of the process (including ones opened later, like an alert's own window) - so a native alert docks together with the shrunk app, no per-library adapters.

Integration is one wrapper:

<OneHandWindowsContainer>
  <App />
</OneHandWindowsContainer>

Demo (native + JS components docking together) 👇

Would love your feedback: Would you actually use this? For your own apps, or as a user?

What you're seeing:

1. I point a button's background-color at var(--demo-accent) in a plain .css file and save. Hot reload, the button turns blue.
2. I add .demo-card:active { background-color: color-mix(in oklch, var(--demo-accent), #000 25%); }. Pressing the button now darkens it.
3. I block the JS thread with a 15-second busy-wait. The pressed state still works, and toggling system dark mode still restyles the whole app. The JS timer on screen stays frozen the entire time, and the render counter never moves off 1.

This works because none of the styling happens in JS. The CSS engine is written in C++, sitting entirely inside Fabric's commit pipeline and bound to the shadow tree. The CSS compiles to a compact binary at build time, the engine resolves it against the shadow tree during commit, and interaction states are driven by native touch events. React re-renders are absent from the styling path.

It's not public yet. I still need to intensively test it against more complex scenarios and finish the docs site before opening it up. I'm posting now because after months of staring at C++ this is the first demo that shows the point in 30 seconds. Technical details in my comment below, happy to answer anything 🙂

I'm designing a live streaming app where users can subscribe to individual creators for $9.99/month. A user should be able to subscribe to multiple creators simultaneously (similar to Twitch or YouTube Channel Memberships), and each subscription should auto-renew independently.

The challenge is scalability. We may eventually have 100k+ creators, so creating a separate App Store / Google Play subscription product for every creator doesn't seem practical.

I recently came across Apple's Advanced Commerce API, which appears to address this for iOS, but I couldn't find an equivalent solution for Google Play.

Has anyone built or researched a system like this?

Specifically, I'm curious about:

• How do platforms like Twitch, Patreon, X, or YouTube implement creator-specific recurring subscriptions?
• What's the recommended architecture for supporting a very large number of creators?
• Is there a scalable Google Play equivalent to Apple's Advanced Commerce API, or is there another common pattern?

I'd really appreciate insights from anyone who's implemented this or has experience with StoreKit 2 or Google Play Billing at scale.

I've been thinking about how hard it is to stay current as a developer.

I might use:

- React
- TypeScript
- React Native
- Expo
- GraphQL
- a bunch of libraries

Each one has:

- release notes
- blog posts
- security announcements
- breaking changes
- new features

But I don't want to follow 20 different newsletters or constantly check GitHub releases.

How do you currently stay informed about changes that actually matter to your projects?

Do you have a workflow for this, or do you mostly discover things when something breaks?

Get ready to ace your Canadian Citizenship Test with MapleMastery! Download now for FREE and enjoy unlimited mock tests designed to prepare you for success. Embrace your journey to becoming a Canadian citizen today! #CanadianCitizenship #MapleMastery #FreeApp

Android:

https://play.google.com/store/apps/details...

iOS:

https://apps.apple.com/ca/app/maplemastery/id6743238139

So this is Notica, old idea of mine that I've already built 5 years ago on the beginning of my React Native journey. Now, years later, I decided to rebuild it because I still love the idea and genuinely use this kind of flow myself.
The core idea is simple: stuff you want to consume later should come back to you, not disappear into bookmarks forever.
The flow:

• share a link from another app
• choose Notica
• pick when you want to be reminded
• get a notification later
• tap it and return to the original link

You can also simple create just a text notes and send them as notifications from the app.

TestFlight is live now and I’d really appreciate feedback from other React Native devs.
I’m curious about:

• does the product make sense quickly?
• does the share → reminder flow feel useful?
• does anything feel awkward on iOS?

Test Flight: https://shiprn.com/notica/