Rinf

rinf is a cross-platform native bridge and integration layer used to connect business logic written in Rust to application frontends. It functions as a cross-language message broker and binary serialization framework that enables the exchange of structured data between a Rust backend and user interfaces across mobile, desktop, and web targets.

The project utilizes a schema-driven code generator to produce language-specific message classes from shared definitions. This ensures type-safe message passing and consistency across different programming environments, preventing data mismatches during serialization.

The framework covers asynchronous message passing and reactive data streaming for pushing real-time updates from the native layer to the UI. It also manages bidirectional data transmission, allowing for both upstream and downstream structured data exchange.

The system includes utilities for cross-platform build orchestration, project template generation, and resource lifecycle management.

Features

Native Backend UIs - Provides a native Rust backend integrated with a Flutter graphical front-end.

Native-to-UI Bridges - Connects a Rust backend to a frontend using generated types that prevent data mismatches during serialization.

Type-Safe Message Buses - Exchanges asynchronous data packets between a frontend and backend while enforcing type safety through generated classes.

Binary Serialization Formats - Provides a binary serialization format to encode structured data into compact byte streams for efficient transfer.

Rust - Implements a serialization framework specifically for the Rust ecosystem to exchange structured data with other languages.

Native-to-UI Type Mappings - Provides a typed interface for connecting business logic written in Rust to application frontends across multiple platforms.

Schema-Driven Code Generators - Produces language-specific message classes from shared definitions to ensure type consistency across different environments.

Rust-Dart FFI Generators - Provides type-safe Dart bindings and automatic serialization for transmitting data to Rust backend logic.

Asynchronous Message Passing - Implements non-blocking communication channels to transmit data packets between the Rust native layer and the user interface.

Message Brokers - Acts as a middleware component facilitating asynchronous, schema-defined communication between a native backend and a UI.

Structured Data Exchanges - Implements binary serialization for exchanging structured data between Rust and Dart application layers.

Native Logic Integrations - Connects a native Rust logic layer to a user interface with type-safe communication and automated build configurations.

Cross-Language Data Exchange - Enables bidirectional movement of structured data between Rust and frontend languages using a shared serialization format.

Cross-Language Message Classes - Generates type-safe language-specific classes from shared schemas to prevent data mismatches.

Reactive Data Streams - Pipes real-time structured updates from the native logic layer to the user interface via reactive streams.

Cross-Platform UI Bridges - Provides a bridge for streaming structured updates and handling binary data exchange between Rust and multi-platform targets.

Cross-Platform App Builders - Builds applications for mobile, desktop, and web targets from a single source with a shared native core.

Cross-Platform Build Systems - Automates build configurations to compile and package native code and UI layers across mobile, desktop, and web targets.

Cross-Platform Deployment Targets - Supports compiling and running integrated applications across diverse operating systems and hardware architectures.

cunaristrinf

Features

Star history