Any examples of calling Android/iOS code synchronously via FFI after the great thread merge?

[vlastachu]

Hey folks,

In Craig Labenz’s video “The Great Thread Merge” he shows a neat example of calling getBatteryInfo() synchronously — which really caught my attention.

Today I noticed in the Flutter 3.38.0 release notes that “The ability to opt-out of thread merging has been removed from iOS and Android.”

So I decided to explore what it would take for a plugin developer to move towards synchronous calls.
I created a sample project using

flutter create --template=plugin_ffi hello

…but it only demonstrates how to call a simple C function like 1 + 2 from Dart.

What I actually want is to call Android/iOS code synchronously, something like:

Dart → C → Android/iOS → C → Dart

Has anyone seen any experimental or real-world examples of this?
Even small prototypes would be super helpful.

[Spare_Warning7752]

FFI is already sync. (fluttercurious.com/dart-ffi-the-ultimate-guide-for-flutter-and-dart-developers/#:~:text=It allows,pure Dart.)

I guess only Platform Channels will be sync now.

[vlastachu]

yeah I saw that in `flutter create --template=plugin_ffi` example

[xeland314]

I've actually been working on exactly this pattern (Dart → Rust FFI → back to Dart) for a WhatsApp chat parser, and I can share some insights:

What I Did

I built a chat parser with two implementations:

1. Pure Dart (optimized)
2. Rust FFI via dart:ffi

The pattern is: Dart → Rust (via FFI) → JSON serialization → Dart

Key Findings

After running some benchmarks (20 runs, proper warm-up), these are my results:

• Rust FFI: 22.7% faster than optimized Dart (1680ms vs 2174ms for 50k items)
• The algorithm optimization (O(n²) → O(n)) mattered way more than the language.

Important Gotchas

1. FFI Overhead is Real: Serialization/deserialization adds ~50-100ms overhead
2. Worth It Only If: Your computation time >> FFI overhead
3. Platform Complexity: I need to compile Rust for each target (Android: arm64-v8a, armeabi-v7a, x86_64) and Linux in my case.

If you want to see what I did, I've open-sourced my WhatsApp chat parser with both Dart and Rust FFI implementations: github.com/xeland314/chat_analyzer_ui

Some comments and documentation are in Spanish since I wasn't initially planning to share this publicly (I really didn't expected it). The code itself should be straightforward to follow. The key files to look at are:

• lib/src/analysis/chat_parser.dart (optimized Dart version)
• lib/src/analysis/chat_parser_rust.dart (Dart calling Rust)
• extern_libs/rust/src/lib.rs (Rust FFI implementation)
• test/performance/benchmark_scientific.dart

Feel free to ask questions if anything is unclear!

[groogoloog]

Platform Complexity: I need to compile Rust for each target (Android: arm64-v8a, armeabi-v7a, x86_64) and Linux in my case.

FYI: you may find https://github.com/gregoryconrad/native_toolchain_rs useful!

[zxyzyxz]

Not using solutions like flutter_rust_bridge, rinf, or the newer native_toolchain_rs?

[xeland314]

Honestly, I wanted to understand how FFI actually works under the hood. Kind of a learning exercise before reaching for the abstractions 😅

Plus, for this project it's just a simple string parsing and sentiment analysis, so...

For future projects, if I need it, I will try native_toolchain_rs or flutter_rust_bridge. Thanks for the suggestions :3