Using Dart FFI to Call Rust Libraries via flutter_rust_bridge

Introduction

Modern mobile applications often require high performance when handling tasks like data processing or cryptographic operations. Dart's Foreign Function Interface (FFI) enables Flutter apps to call native code, while Rust offers both safety and speed. flutter_rust_bridge streamlines integration between Dart and Rust by auto-generating type-safe bindings. In this tutorial, you will learn how to set up a Flutter project, implement a Rust library, generate Dart bindings with flutter_rust_bridge, and invoke Rust functions from your Dart code for efficient mobile development.

Setup and Project Structure

Begin by installing the Rust toolchain via rustup and ensuring you have a compatible Flutter SDK. In your Flutter project root, add flutter_rust_bridge as a dependency:

dependencies:
  flutter_rust_bridge

Create a top-level rust/ directory alongside lib/ and web/ folders. Inside rust/, initialize a new Cargo library with cargo init --lib. You will also need a build.rs script or a separate codegen step to generate bindings. Your project structure should look like:

Implementing the Rust Library

In src/lib.rs, define FFI-compatible functions and decorate them with flutter_rust_bridge macros. For example, implement a factorial function:

use flutter_rust_bridge::frb;

#[frb]
fn factorial(n: u64) -> u64 {
  (1..=n).product()
}

Ensure all public functions use simple data types or structs supported by flutter_rust_bridge. Enums and nested structs are also supported but require additional annotations. Keep your Rust library focused on pure computation or data transformation to avoid complex ownership issues when crossing the FFI boundary.

Generating Bindings with flutter_rust_bridge

Bindings generation can be automated using the flutter_rust_bridge_codegen CLI or via a build.rs script. For a manual approach, run:

flutter_rust_bridge_codegen \
  --rust-input rust/src/lib.rs \
  --dart-output lib/bridge_generated.dart

This command reads your annotated Rust code and produces a Dart file with low-level FFI code and a high-level API. If you prefer an automated build, add a build.rs in your Rust crate that invokes the codegen at compile time. Place the generated Dart file in your lib/ folder so it is included by Flutter during build and analysis.

Integrating and Calling from Flutter

After generating bindings, import the Dart bridge in your Flutter app:

import 'bridge_generated.dart';

final api = BridgeRustApi();

Future<void> compute() async {
  final result = await api.factorial(20);
  print('Factorial of 20 is $result');
}

Ensure the compiled Rust library (.so, .dylib, or .dll) is accessible at runtime. In Android, place the shared library under android/src/main/jniLibs//. For iOS, embed the .framework in Xcode. The flutter_rust_bridge docs provide detailed folder conventions for each platform.

Testing and Debugging

Write unit tests in Rust using cargo test to verify core logic. On the Dart side, create widget or unit tests that mock or invoke the generated API. Common issues include missing symbols or incorrect library paths; use verbose logging and flutter run --verbose to surface linker errors. You can also enable Rust’s debug assertions and panic hooks to get stack traces when a panic crosses the boundary.

Vibe Studio

Vibe Studio, powered by Steve’s advanced AI agents, is a revolutionary no-code, conversational platform that empowers users to quickly and efficiently create full-stack Flutter applications integrated seamlessly with Firebase backend services. Ideal for solo founders, startups, and agile engineering teams, Vibe Studio allows users to visually manage and deploy Flutter apps, greatly accelerating the development process. The intuitive conversational interface simplifies complex development tasks, making app creation accessible even for non-coders.

Conclusion

By combining Dart FFI with flutter_rust_bridge, you can leverage Rust’s performance and safety in your Flutter apps without writing boilerplate FFI glue. This workflow—setting up a Rust library, annotating functions, generating bindings, and integrating the shared library into your mobile project—allows you to tackle CPU-intensive tasks while maintaining a seamless Dart developer experience. Now you can build high-performance modules in Rust and call them directly from Flutter for optimized mobile development.