Flutter with Rust Bridge vs React Native

Nostr Tools vs Welshman

The preexisting rust Nostr tools require far more manual implementation than utilizing Welshman. Nostr-sdk is a higher level library but my implementation of NIP01 signing was still more involved, you also have to handle relays on your own.

Nostr-sdk is one of the more high level management tools. AND IT DOES NOT COMPILE TO WASM.

Most of the Nostr based tools use Tokio, an async multi-threaded library that doesn't work for WASM. This means we have to rely on lower level Nostr libraries like nostr, with much less immediate tooling and possible unreliable updates etc. There are also many other common rust crates for native async networking, async-std etc. which would not compile to WASM. We can either reduce functionality to maintain a single non-diverging codebase or attempt our own fills or patches to these functions(time intensive).

Examples of WASM limitations:

An example is relay networking. The pre-built solutions don't compile to WASM so you'd need to implement relay networking in JavaScript and call Rust via wasm_bindgen or proxy via Dart.
There are also limited cryptography apis available to the web version. There are JS libraries like nostr-tools, but we may have to build custom web solutions or separate some of our signing/relay logic to Dart instead of all logic implemented in Rust.

MLS

I think this is the core advantage to the flutter with rust_bridge approach. This is very difficult and time intensive to reproduce with Typescript in a React Native project. My attempts at using the Whitenoise repo to test MLS have been blocked by a transitive SQLite dependency. It fails to reconcile buildingg for iOS while on a mac(may be caused by an intel mac). Provided that can be fixed, MLS would be a major advantage over much less secure messaging.

Option: Custom WASM Nostr Core

Build your own Rust → WASM crypto/signing module for Web, use FRB for mobile.

Platform	Implementation
Mobile	Rust + FRB
Web	WASM build of Rust Nostr core via wasm-bindgen
Shared logic	Define a portable Rust interface (e.g. sign_event, validate_event)
Dart ↔ WASM	JS interop (package:js) for Web only

Note: WASM doesn't support everything — avoid native threads, sockets, or file I/O

Performance

✅ Pros

Native performance for CPU-intensive tasks by offloading to Rust code
Flutter's rendering engine is highly optimized, leading to smooth UI and animations
Rust's zero-cost abstractions and memory safety can lead to very efficient background processing
Reduced JavaScript bridge overhead compared to React Native

❌ Cons

Integrating Rust adds complexity, especially debugging across Dart and Rust boundaries
Large build times when changing rust code, slow to see active changes. Hot reloading is only for the UI changes
FFI calls between Dart and Rust can introduce latency if overused or not carefully designed

Web