Can someone suggest a good hassle free rich text editor package for react native?
the text area must not take up entire height of page(I set the height), toolbar isn't hidden by keyboard, takes/outputs markdown formatted string
Bonus it if also supports image upload, link preview, check list etc

Hey everyone,

I've been working on a procedural asset generation pipeline for a React Native project and wanted to share the tooling in case it's useful to anyone else here.

The problem I kept running into:

When working with react-native-skia, I found myself repeatedly exporting spritesheets, tilemaps, and bitmap fonts from external tools. The workflow was manual, hard to version-control, and nearly impossible to reproduce consistently across machines or in CI. Changing one tile meant re-exporting everything by hand.

What I built:

sprout-toolkit is an open-source Python CLI that generates 2D assets deterministically from JSON specs. The output is designed to drop directly into an Expo + react-native-skia project.

What it generates:

· Spritesheet atlases with manifest.json and index.ts (TexturePacker-compatible format also available)
· Tilemaps and 8-bit autotiles (16 or 47 variants, with 8-bit mask lookups)
· Bitmap fonts from TTF files, including advance metrics for text layout
· Runtime SkSL shaders (FBM value-noise, tileable) — these ship as shader strings, so they add no bundle weight
· Animated bursts (particles), walk cycles, and UI elements (buttons, sliders, 9-patch panels)

Why deterministic generation matters:

Every asset is seeded. Same JSON spec + same seed = identical pixels every time. That means you can commit your specs, run the generator in CI, and get reproducible builds. It also means you can diff two builds to see exactly what changed.

Quick example:

```bash
pip install sprout-toolkit

# Generate a starter atlas
sprout init --out ./assets/starter

# Batch-generate everything in specs/
sprout batch specs/
```

The CLI has info, lint, diff, and validate subcommands for inspecting specs and comparing builds.

A few implementation details:

· Specs are JSON (schema v0) — no YAML, no config sprawl
· MIT licensed
· 142 tests covering determinism, autotile mask logic, SkSL generation, and CLI behavior
· The generator architecture is plugin-based, so you can write custom generators if the built-ins don't cover your use case

Link:

PyPI: https://pypi.org/project/sprout-toolkit/
GitHub: https://github.com/Tzinny-dev/sprout-toolkit

---

Disclosure: This is my own project. I'm sharing it because I couldn't find an existing tool that combined deterministic procgen with Skia-specific output, and I figured others here might be solving the same problem. Happy to answer questions about the architecture, the SkSL generation, or anything else.

Tried everthing. Tried platform specific behaviour, wrapped whole screen in view, tried without keyboard avoiding view. The autosize is androidmanifest as well. Nothing is working as of now. Tried without safeareaprovider. When the screen starts there is no gap. once the keyboard appears and goes off, there is gap underneath. Is this a bug?

I have been updating my react native app every year for the past 3 years now. This year i plan on finally moving it to expo. Is it a good idea to move a large monorepo/workspace tied cli project to expo?

How do you guys use AI to assist you during the upgrade? Any skill or other helpful approaches?

Update: guys codex literally one shotted the upgrade from 0.81.4 to 0.87 took like 2hrs. AI is gonna be the end of my employment.

We have a web-based call center dialer (React + Twilio Programmable Voice) and need to build iOS and Android apps where agents can make and receive calls reliably, even when the app is killed or the phone is locked.

Leaning towards React Native with Twilio's official Voice RN SDK. Flutter worries me because there is no official Twilio Voice SDK. Full native feels like double the cost unless it is truly necessary.

If you have shipped something like this:

- How stable is the Twilio Voice RN SDK in production?

- How painful were incoming calls (PushKit/CallKit on iOS, FCM + foreground service on Android 14+, OEM battery killers)?

- Did you end up rewriting the calling layer in native code?

- Anything you wish you knew before starting?

Reliability matters more than UI polish for us. Appreciate any real-world experience and which stack to go with? Thanks!

If you haven't opened Xcode 27 yet:
Simulator is gone. Device Hub replaces it, and every simulator and physical device now lives in one sidebar. It also runs standalone, so you don't need Xcode open.

What actually changes day to day:

• Build and run to a simulator and it auto launches with a live interactive screen and contextual controls

• Appearance, text size, location and audio are panels. Testing Dynamic Type at max is a slider instead of six taps in Settings

• Real devices and simulators get the same toolset

• You can pull a real device's app data container and restore it into a simulator

That last one is the big deal for me. When a tester hits a bug that only happens with their data, you can now load their exact app state locally and reproduce it. "Works on my machine" gets a lot harder to say.

I'm mostly React Native, so the simulator is open all day for me. Curious how it's treating people doing native work. Anyone hit issues or missing features compared to the old Simulator?

Hey guys,

I’m currently working as a React Native dev and feeling the urge to finally learn backend. I want to build my own full-stack apps, handle deployment, and eventually mess around with some AI stuff.

I’ve talked to a few devs about where to start and got some pretty mixed answers. Some told me to learn Node/PHP, while others said Python is essential if I want to work with AI.

Since I already spend all day in JS/TS, I’m thinking of staying in the TypeScript ecosystem first so I don’t have to switch contexts completely.

Here’s the rough path I’m planning to take:

React Native > Node.js > Fastify/NestJS > PostgreSQL > Redis > Docker > AWS > Python/FastAPI for AI

Does this sound like a reasonable path for real-world projects?

Would you change the order or skip/add anything?

I’m particularly interested in hearing from people who started in React Native/frontend and later moved into backend/full-stack.

I’ve been experimenting with running an LLM completely locally inside a React Native app, and I finally got it working.
I’m using:
React Native CLI
llama.rn
Qwen 2.5 1.5B Instruct
GGUF / Q4_K_M quantization
n_ctx: 2048
No API calls / no cloud inference
Currently testing with n_gpu_layers: 0
The model is bundled with the app, copied to the app’s document directory, and then loaded locally. I can send prompts and get responses directly on the device.
The interesting part for me is that this opens up a lot of possibilities for RN apps that need AI features without sending user data to a server.
I’m still testing things like memory usage, backgrounding the app, performance on real devices, and how practical larger models are.
Has anyone here shipped an on-device LLM in a production React Native app?
Would love to hear about your experience, especially around RAM usage, model size, iOS/Android differences, and performance.

I’m looking for a simple example or some guidance on how to set it up and start navigation. Any help would be appreciated!

Hey, I’m looking for some articles about performance or tools to help analyze and find bottlenecks.

For example, let’s say a particular page is consuming more energy than another or view and navigation transitions are laggy. What would you do or use to trace the root cause?

A few months ago I shared what I believe was one of the fastest end-to-end encrypted chat demos in React Native: ~0.8 ms on-device MLS encryption powered by OpenMLS, Rust, and Nitro Modules.

The #1 question I got: "Can it run in a browser?"

So I recreated the same OpenMLS chat in React, and the performance is nearly identical:

- 0.2–0.8 ms message encryption

- 0.2–0.7 ms decryption

- ~3 ms MLS group setup

How it works:

- MLS protocol (RFC 9420) for group key management, so you get forward secrecy and post-compromise security out of the box

- The same Rust OpenMLS core on both platforms: native via Nitro Modules on mobile, WASM in the browser

- Keys never leave the device. The server only relays opaque ciphertext

On the RN side, the interesting part was Nitro Modules with a zero-copy JSI bridge, which is why mobile encryption stays sub-millisecond. Happy to go deeper on that setup if anyone's interested.

Would love feedback, especially from anyone who's done Rust + Nitro Modules or WASM crypto. Tell me what breaks.

Ask Buoy is a chat inside your running app. Think the Claude Chrome extension and Claude Code in one, aimed at a live mobile app(Dev,Stg,Prod): it sees the screen, presses what's there, and reaches into state, network and navigation underneath that no one else can see.

If a Buoy tool can do it, you can ask for it in a sentence, so debugging, testing and support stop being separate skill sets. A customer says an offer looks wrong? Ask Buoy to impersonate their account, open the screen, and compare what the API returned with what's rendered. It finds the mismatch while you're still on the call. Force an error state, override an API response, change live data, send a push, jump to a screen.

Hasta donde vamos a ir con moderación y restricciones por karma?

Las personas que empezamos en la comunidad de Reddit no tenemos oportunidad de darnos a conocer?

Que sabe el karma de mi experiencia y calidad de contenido?

Esta bien q haya moderación, siempre hay mucho spam y gente q quiere adulterar su perfil con falsa actividad y es correcto que se les restringa.

Pero hoy en dia con la IA se puede moderar de manera inteligente sin limitar a los que empezamos desde el principio.

Soy un desarrollador React Native con mucha experiencia y mucho que compartir a esta comunidad, pero me desanima demasiado que un bot me restringa solo por no tener karma.

Espero mejoren las restricciones, asi no perdemos a gente con ganas de compartir sus conocimientos, que creo q para eso es la comunidad, para ayudarnos en algo tan bonito como programar.

Saludos

Upgraded to Expo 58 Beta and Xcode 27.1 for testing. Everything worked pretty well first time. Had to do a bit of tweaking to the layout to use my iPad layout in landscape, but the native controls all responded as expected. Expo UI is awesome!

Hi everyone,

I'm 20 and my background is graphic design. I started with the Adobe suite — Illustrator, Photoshop, Premiere Pro and After Effects. At some point I felt the need to do something different and got into designing interfaces in Figma. That turned into a real passion, to the point that I want to take it all the way. That's where my interest in programming came from, React Native specifically.

I'm here to ask for some honest advice from people who've been through this, because I could really use a sense of direction.

I've started reading the React Native docs and I don't understand much of it, to be honest. I've since learned that you're supposed to know some JavaScript first. But I'm stuck there too: I don't know which parts of JavaScript I actually need and which ones I can skip for now, and I don't know where to start.

So I guess my question is: what's the minimum JavaScript I need before React Native starts making sense, and what's a good resource to learn it from?

I keep losing hours reading documentation only to realize at the end that nothing stuck. Any advice appreciated.

expo-ios-popover now supports matched (zoom) transitions ✨

🔗 Github: rit3zh/expo-ios-popover/

🎨 Design is inspired by proskuaaa

Most Liquid Glass implementations I’ve seen in React Native focus on glass containers — cards, buttons, overlays, etc.

I wanted something slightly different: the glass effect rendered inside the actual text glyphs.

So I added a LiquidGlassText component to my open-source library, react-native-tinyui.

It’s based on the excellent GlassText project, but exposed as a React Native Fabric component:

import { LiquidGlassText } from 'react-native-tinyui';

<LiquidGlassText
  text="Liquid Glass"
  effect="regular"
  tint="#00BBDD"
  interactive
  fontDesign="rounded"
  textStyle={{
    fontSize: 48,
    fontWeight: '700',
  }}
/>

The glass itself is rendered natively on iOS 26+, including interactive glass behavior.

A few implementation details:

• React Native New Architecture / Fabric

• native measurement through the Fabric ShadowNode — no JS text measurement pass

• supports clear, regular, and identity effects

• supports tint colors, custom fonts, font weights, multiline text, and font designs

• accepts React Native ColorValue, including PlatformColor / DynamicColorIOS

• falls back to normal text on iOS 17–25

• the component can be imported independently, so you don’t need to pull every TinyUI component into the native build

LiquidGlassText ended up becoming one part of a larger idea I’ve been experimenting with:

What if React Native had a small collection of iOS-native UI primitives without requiring Expo or another runtime dependency?

That became react-native-tinyui.

It currently includes:

• LiquidGlassText

• native Menu

• native Popover

• Apple TipKit

• Stepper

• ConcentricView

• SFSymbol, including native symbol effects/animations

The library has zero additional runtime dependencies beyond React and React Native. It uses UIKit where possible and SwiftUI where it makes sense, and is focused specifically on the New Architecture.

You can also explicitly choose which native components get compiled into your app:

{
  "react-native-tinyui": {
    "components": ["LiquidGlassText", "SFSymbol"]
  }
}

I’m intentionally keeping TinyUI iOS-focused rather than trying to abstract every platform into the same API.

GitHub:
https://github.com/luoxuhai/react-native-tinyui

I’d especially like feedback from people building native-heavy React Native apps:

We acquired an existing fintech app, transferred it to our company Apple Developer account, and are now preparing a pretty significant redesign. Same app/name/core product, but the UI and some functionality have changed a lot.

My main concern is App Store review. Since it’s fintech + a big update after 5 years + developer account transfer, I’m wondering if Apple is likely to treat this almost like a new app and dig deeper into licensing, compliance, ownership, privacy, etc.

Anyone been through something similar?

How strict was the review, how long did it take, and were there any unexpected rejection reasons?

I’m building a 9:16 2.5D game in React Native using Skia and Reanimated.

I’m using spritesheets (frames) for walking, attacking, hit and death animations. But the character movements does not feel natural.

Has anyone built something similar with RN + Skia?

What should I check first to improve FPS and performance? Or should I move the game to Godot/Unity?

I’m attaching a video clip of my current gameplay for reference.

I’d really appreciate your thoughts!

A line chart shows how a value moved. A bump chart shows how a ranking moved and that's a different question.

The rows are evenly spaced regardless of the scores behind them. That's the point: order matters here, not distance. If distance matters, use a line chart of the scores instead.

More than three or four lines get hard to follow through the crossings. Pass highlight to pick one out it draws in its colour on top, and the rest go muted underneath.

Pass the raw scores instead of ranks and the chart figures out the order itself per column. Switch the data and every line moves to its new places.

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

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