fzyzcjy/flutter_rust_bridge
Flutter Rust Bridge
flutter_rust_bridge is a code generation tool that automatically creates type‑safe Dart bindings for Rust functions, enabling direct cross‑language calls between Flutter and a Rust backend. It provides an async FFI adapter that transforms synchronous Rust functions into Dart async methods with background thread management, a cross‑language object manager that wraps persistent Rust structs as Dart objects preserving state across calls, and trait object interop that converts Rust traits into Dart abstract classes for seamless bidirectional use.
The project handles the full lifecycle of integrating a systems language with a UI framework: you can run CPU‑intensive Rust computations asynchronously without blocking the Flutter UI, invoke Dart callbacks from Rust, serialize complex Rust types (structs, enums, collections) into Dart equivalents, and expose Rust struct instances as mutable Dart objects. It also supports using Flutter as the graphical layer for Rust applications, and automatically generates bindings with automatic type conversion and threading.
Beyond the core binding generation, the toolset covers build and deployment infrastructure across platforms – Android NDK setup, compilation, code generation, library loading, prebuilt binary support, and WebAssembly CORS configuration. It offers annotation‑driven binding customization, custom code injection, one‑command project initialization, workspace integration, and function mocking for isolated testing. The type and data translation layer handles complex types, custom serialization formats (Protobuf, JSON), macro‑expanded types, default parameter mapping, and constant exposure, while performance features include call hooks for instrumentation, error propagation, task cancellation, object pooling, and zero‑copy binary data transfer.
The project is documented at flutter_rust_bridge.inquire.sh and can be installed via pub or cargo with a single CLI command to scaffold a new Flutter‑Rust project.
Features
- Type-Safe Binding Generators - Generates type-safe Dart bindings from Rust functions with automatic serialization, async support, and type conversion.
- Rust-Dart FFI Generators - Automatically generates type-safe Dart bindings for Rust functions with async and serialization support.
- Cross-Language Function Bridges - Generates glue code that lets Dart call Rust functions directly with automatic type conversion and async support.
- Background Task Schedulers - Schedules native function calls onto background threads and returns Dart futures for non-blocking execution.
- Build-Time Code Generators - Automatically generates Dart bindings from Rust types during the build process.
- Native Type Bridges - Generates serialization bridges for user-defined Rust structs and enums so they can be passed to Dart.
- Bidirectional Cross-Language Calls - Enables seamless function calls in both directions between Dart and Rust.
- Annotation-Driven Binding Customizations - Provides annotation-driven control over which Rust items are exposed and how they are named in generated Dart bindings.
- C FFI Bridges - Uses C ABI to enable direct, low-overhead calls between Rust and Dart.
- Managed-to-Native Callbacks - Enables Rust code to invoke Dart callbacks, supporting bidirectional communication between the two languages.
- Cross-Language - Converts Rust trait implementations into Dart classes that implement the corresponding abstract interface.
- Cross-Language Trait Object Bridges - Converts Rust traits into Dart abstract classes and enables passing trait objects between the languages.
- FFI Trait Object Passing - Allows Dart code to pass any implementing type to Rust functions that accept or return trait objects.
- Cross-Language Class Wrappers - Creates Dart wrappers that maintain state across calls for persistent Rust struct instances.
- Trait-to-Abstract-Class Conversions - Automatically translates Rust trait definitions into Dart abstract classes that can be implemented on either side.
- Async - Transforms synchronous Rust functions into Dart async methods with background thread management and cancellation.
- Native Computation Offloading - Offloads heavy Rust computations to background threads, keeping the Flutter UI responsive.
- Compile-Time Code Generation - Generates Dart bindings from Rust source code automatically during compilation.
- Cross-Language Type Translation - Automatically translates complex Rust types like structs, enums, and streams into Dart equivalents.
- Native Object Interoperability - Wraps Rust structs as Dart objects with persistent state and mutable properties.
- Persistent Native Object States - Creates persistent Rust objects whose state is accessible and modifiable from Dart across multiple function calls.
- Binary Serialization Formats - Encodes typed data structures into compact binary format for efficient cross-language exchange.
- Complex Data Serialization - Serializes complex Rust types like structs and enums into Dart equivalents using Protobuf or JSON.
- Serialization Format Mappings - Supports switching between serialization backends like Protobuf and JSON for cross-language data exchange.
- Project Scaffolding Commands - Ships a one-command CLI scaffold that initializes a new Flutter-Rust project with all glue code and configuration.
- Native Backend UIs - Ships utilities to use Flutter as the graphical layer for Rust applications.
- Native Integrations - Ships build scripts and platform initialization to seamlessly integrate Rust code into Flutter applications.
- Third-Party Crate Bindings - Generates Dart bindings for third-party Rust crates, eliminating the need to write manual wrapper code.
- Instance Method Mappings - Maps Rust instance methods into instance methods on the generated Dart wrapper class.
- Trait Object Polymorphism - Boxes Rust trait objects behind a vtable to allow Dart code to implement and call trait methods.
- Macro-Expanded Type Resolutions - Discovers types and functions produced by Rust macros so generated Dart bindings include all referenced items.
- Constructor Mappings - Translates Rust struct creation functions into constructors on the corresponding Dart wrapper class.
- Struct Property Accessors - Generates getter and setter properties for Rust struct fields in Dart wrappers for convenient field access.
- Native Panic-to-Exception Bridges - Captures Rust panics and errors and surfaces them as Dart exceptions for structured error handling.
