A reactive caching and data-binding framework. Riverpod makes working with asynchronous code a breeze.

A reactive caching and data-binding framework. Riverpod makes working with asynchronous code a breeze.

ValueNotifier, but outside Flutter and with some extra perks

A predictable state management library that helps implement the BLoC (Business Logic Component) design pattern.

Simple direct Service Locator that allows to decouple the interface from a concrete implementation and to access the concrete implementation from everywhere in your App"

Flutter widgets that make it easy to implement the BLoC (Business Logic Component) design pattern. Built to be used with the bloc state management package.

A wrapper around InheritedWidget to make them easier to use and more reusable.

A project for analyzing Riverpod code. This is internally used by riverpod_lint and riverpod_generator

A package exposing annotations for riverpod_generator

A testing library which makes it easy to test blocs. Built to be used with the bloc state management package.

A code generator for Riverpod. This both simplifies the syntax empowers it, such as allowing stateful hot-reload.

Open screens/snackbars/dialogs without context, manage states and inject dependencies easily with GetX.

Custom event transformers inspired by ember concurrency. Built to be used with the bloc state management package.

Riverpod_lint is a developer tool for users of Riverpod, designed to help stop common issues and simplify repetitive tasks.

injector is a simple to use and lightweight dependency injection library for dart

A reactive caching and data-binding framework. Riverpod makes working with asynchronous code a breeze.

A Widget that passes a Reactive Model to all of it's children

A flutter implementation of React hooks. It adds a new kind of widget with enhanced code reuse.

A simple Event Bus using Dart Streams for decoupling applications

Observe value changes using a Future, Stream, and/or a callback.

A Dependency injection (Inversion of Control) library. Supports nested Scopes and multiple values of the same type.

An extension to the bloc state management library which automatically persists and restores bloc states.

Calculate the difference between two lists as list of edit operations. Used for example for implicitly animating Flutter lists without having to maintain a StatefulWidget.

Official lint rules for development when using the bloc state management library.

Free and open-source chat SDK. Build fast, real-time apps and generative AI agents with a high-performance, customizable, cross-platform UI.

MobX is a library for reactively managing the state of your applications. Use the power of observables, actions, and reactions to supercharge your Dart and Flutter apps.

Smart project structure with dependency injection and route management

Flutter integration for MobX. It provides a set of Observer widgets that automatically rebuild when the tracked observables change.

A normalized, strongly typed, optimistic cache for GraphQL Operations and Fragments

Code generator for MobX that adds support for annotating your code with @observable, @computed, @action and also creating Store classes.

Redux is a predictable state container for Dart and Flutter apps

Lightweight and customizable BLoC state management library logger on talker base.

Smart project structure with dependency injection and route management

A simple package to simplify screen management. When loading any async task, this package prevent the user from interacting with the screen until the async task finishes.

Easily restart your application from scratch, losing any previous state

The framework to build testable, scalable and maintainable flutter apps

Stream Chat official Flutter SDK Core. Build your own chat experience using Dart and Flutter.

A set of utility Widgets that Provide and Connect to a Redux Store

A Flutter-like framework for building rich terminal user interfaces with components, state management, animations, and more.

Tools for building applications using the bloc state management library.

Lightweight and customizable Riverpod state management library logger on talker base.

The Amplify Flutter API category plugin, supporting GraphQL and REST operations.

The signals library exposes four core functions which are the building blocks to model any business logic you can think of.

Dart port of Preact.js Signals

The signals library exposes four core functions which are the building blocks to model any business logic you can think of.

Flutter bindings for state_notifier, such as StateNotifierProvider and StateNotifierBuilder

An extension to the bloc state management library which adds support for undo and redo.

Transform method calls to a stream of events.

Smart project structure with dependency injection and route management

Some extension methods and classes built on top of RxDart - RxDart extension.

Finite state machine library. Easily define legal state transitions. Listen to state entrances, departures, and transitions.

Time Travel Dev Tools for Dart Redux

Reactivity made simple. Do more by doing less. Supports Flutter and any Dart project including HTML/JS, CLI, Shelf Server, VM and more.

Flux library for uni-directional dataflow inspired by reflux and Facebook's flux architecture.

Flutter+Riverpod support library.

A library that enables DeepEquals support for Riverpod's Ref.watch().

StateStream with Riverpod support.

Library for UI=f(State) architecture.

A library that supports asynchronous disposal of Riverpod's ProviderContainer.

riverpod_container_async test support library.

Riverpod Provider for path_provider

FBroadcast Help developers build an efficient broadcast system in the application.

A Redux.dart Middleware that allows you to dispatch functions that perform async work as actions.

Alien Signals is a reactive state management library that brings the power of signals to Dart and Flutter applications.

Create lightweight custom Events, that allow interested subscribers to be notified that something has happened.

A simple State Management solution for Dart applications inspired by SolidJS

A simple State Management solution for Flutter applications inspired by SolidJS

a simple yet powerful state management technique for Flutter

An annotation package simplifying Bloc event and state classes, enhancing code readability and reducing naming conflicts.

A package that contains some default implementations of services required for a cleaner implementation of the Stacked Architecture.

A code generator for simplifying Bloc event and state classes, enhancing code readability and reducing naming conflicts.

Convert Listenable (e.g. ChangeNotifier), ValueListenable(e.g. ValueNotifier) to Stream / ValueStream.

A simple yet efficient dependency injection container for Dart and Flutter (can be coupled with the kiwi_generator package).

Stacked Generator is a package dedicated to reduce the boilerplate required to setup a stacked application

A simple, yet powerful state machine framework for Dart supporting Flutter and web apps.

A widget that rebuilds itself on scheduled, periodic, or dynamically generated time events.

Smart project structure with dependency injection and route management

redirect user to authentication page if the application doesn't recieve any user interaction, or been running in the background for "x" duration.

Helpful lightweight tools for working with ValueNotifiers

A simple library for dealing with server state in dart and flutter.

The simple state management powered by get_it. It allows to observe changes of objects inside the get_it service locator and rebuild the UI accordingly.

The modern version of Redux. State management that's simple to learn and easy to use; Powerful enough to handle complex applications with millions of users; Testable.

A common dependency for all context_watch-related packages

A hassle-free way to watch for observable value changes within the `build` method.

A state management library written in dart that enforces immutability

A simple yet highly configurable Mediator implementation that allows sending requests and publishing events.

Reactive primitives for Flutter - observable collections and powerful operators. Work with ValueNotifiers like Streams. Includes ListNotifier, MapNotifier, SetNotifier. Previously published as functional_listener.

A minimal Service Locator with compile-time safe provider references, enabling clean dependency injection patterns.

Flutter generic provider using InheritedWidget. An helper to easily exposes a value using InheritedWidget without having to write one.

Bloc provider. Provides bloc to descendant widget (O(1)), and the bloc is disposed appropriately by state which the bloc_provider holds internally.

A redux.dart Middleware that helps you perform side effects using Streams

Efficiently derive data from your Redux Store

A hassle-free way to provide and retrieve values for a BuildContext

Convenient value propagation and observing for Flutter. Utilize existing reactive value types more easily and with less boilerplate.

redux_saga is a library that aims to make application side effects easier to manage, more efficient to execute, easy to test, and better at handling failures.

Dart-only core package for the Async Redux state management, the easy and powerful version of Redux.

Assortment of builders and addons for use with Cached Query in flutter.

Reactive storage for Dart/Flutter. RxDart Storage for Dart/Flutter.

A flutter package that let you easily add hooks for widget lifecycle.

Easy to use and customizable Theme Provider. This Widget can be used to easily provide a theme controller across the widget tree.

A package for managing form state based on BLoC.

Integration for the Bloc state management library to Flame games.

A collection of cubits and widgets that facilitate the creation of repetitive pages, eliminating boilerplate.

A simple notification center. A notification dispatch mechanism that enables the broadcast of information to registered observers.

Essential Flutter hooks collection with 36 production-ready hooks for async operations, form management, UI interactions, and state management.

A Brick domain that routes data fetching through local providers before remote providers.

A dart package to bootstrap using bloc state management for network requests.

A Brick domain that routes data fetching through local providers before a REST providers.

A state management library for Dart and Flutter. Inspired by Riverpod and async_redux.

DisposableProvider is thin wrapper of Provider and it calls dispose automatically.

A lightweight dependency injection package with support for overriding for testing.

Flutter package that simplifies injection and usage of Bloc/Cubit.

Package supporting bloc types for dispose_scope.

A lightweight dependency injection package for dart and flutter with support for overriding for testing.

Extends Riverpod ref types with additional helpers, to easily add common functionalities to your providers.

The Amplify Flutter DataStore category plugin, providing a queryable, on-device data store.

VsyncProvider provides vsync for AnimationController. This works with provider package.

Provides bloc to descendant widget (O(1)), and the bloc is disposed appropriately by state which the bloc_provider holds internally.

Event Bus for Dart.

Flutter package for the Model-Widget-BLoC pattern

BLoC state management integration for ISpect toolkit

Init widget to execute initialization methods declaratively

Classes that help you make use of hooks when using the stacked package

A state management library for Dart and Flutter. Inspired by Riverpod and async_redux.

mixin on Stateless- and StatefulWidgts that makes binding the Widget to Objects stored in GetIt easier.

Configurable transformers for your bloc (bloclibrary.dev) events. Throttle, debounce, skip, and delay with ease.

The client for the inspector of the Refena state management library.

The inspector developer utility app for the Refena state management library.

This is architecture library with the main goal to split code between different responsibility layers, make code clear, simple, readable and easy testable.

command_it is a way to manage your state based on `ValueListenable` and the `Command` design pattern. It is a rebranding of flutter_command.

Widgets for bootstraping Meshagent Flutter apps: secure room sync, live documents, and messaging in a ready-to-use SDK.

flutter_hooks bindings for signals

A reactive primitive and simple state managerment solution for dart.

A reactive primitive and simple state managerment solution for dart and flutter

Allows you to specify a number of color themes for the user to choose from. Persits the selected theme across app restarts.

Support library for the Nylo framework. This library supports routing, widgets, localization, cli, storage and more.

Cubit and Bloc abstractions and Flutter Widget that make it easy to add UI Effects to the BLoC state management.

Implementation of the Segmented State Pattern (SSP) nicknamed Triple.

A reactive primitive and simple state managerment solution for dart and flutter

Riverpod for Jaspr

A library with a bunch of helpers for elementary library, such as publisher-subscriber implementations, wrappers, etc.

Extended bloc with second stream of side effect value.

A Flutter package which allows to listening to multiple ValueListenables using a single widget.

A beautiful, customizable country picker for Flutter with 250 countries, 5,300+ states, 150,000+ cities, 5 display modes, theming, and 132 translations.

BlocProvider implementation with riverpod as alternative to provider, similar to StateNotifierProvider

Abstraction for the Segmented State Pattern. Use to create Triple Store.

DevTools extension for Riverpod - inspect and monitor your providers in real-time.

"An extension to the bloc state management library which serve an additional stream for events that should be consumed only once"

A simple pkg that toggles between light , dark mode and persists it.

Persist Redux State with custom storage engines and serializers

A Flutter package that helps implementing the BLoC (Business Logic Component) Design Pattern using the power of reactive streams.

Flutter extension for inject.dart that simplifies ViewModel injection and lifecycle management to promote cleaner architecture in Flutter apps.

ASP (Atomic State Pattern) offers a simplified, Predictable and Powerful State Management for Flutter.

Flutter widgets to replace multiple nested StreamBuilder widgets

Extension to ValueNotifier by transparently applying functional reactive programming (TFRP)

Redux Persist Flutter Integration with custom storage engines

A minimalistic and easy-to-use dependency injection library for managing singletons and factories in Dart.

A testing library which makes it easy to test elementary used apps. Built to be used with the elementary architecture package.

A high-performance Flutter state management tool, Oref is one of the fastest Flutter signals and state management solutions.

Redux.dart Middleware that prints the latest action & state

Dart package that provides feature flags support for Flutter applications allowing you to enable and disable features easily. Can be used with or without Toggly.io.

A library to simplify data binding and to allow rebuild just some part of your UI instead of separate your in multiple StatefulWidget.

Easy to use session wrapper that adds support to session storage and management in flutter.

Simple yet powerful async state management solution with in-built caching

A safe drop-in replacement for Flutter's ChangeNotifier, that makes notifyListeners() a no-op, rather than an error, after its disposal.

An encapsulation of a Stream<T>, a single variable of type T, and a bool indicating whether value is loaded

async_value_group is a a Dart library for grouping some riverpod AsyncValues into single AsyncValue.

Helpers for using Riverpod - a reactive caching and data-binding framework, in conjunction with Flame.

A core package of the compile-safe DI framework with advanced scoping capabilities

A straightforward way to manage global state in flutter apps.

Write elegant reactive cross-platform client side application using observable states and event emitters.

A drop-in replacement for ChangeNotifier for observing only certain properties of a model.

An adapter package that provides yx_scope widgets for Flutter UI integration

A Brick domain that routes data fetching through local providers before a Supabase provider.

A performant state machine framework inspired by UML. Hierarchical parent/child states enable shared event handling for cleaner, more efficient logic.

Set of Flutter Widgets that help implementing the BLoC design pattern. Built to be used with the rx_bloc package.

Hooks we often use, all gathered in one place.

A widget can prevent Child Widget unnecessary rebuild.You can customize the rebuild conditions。

A re-imagined declarative approach to application design and architecture

A set of utilities for provider package.

An atomic dependency and state management toolkit - fast, simple and composable.

A flutter package that let you easily add hooks for application lifecycle state

A state management package to allow for retention and management while specifying the scope of the state.

A Flutter library bringing a new concept of scoped providers for dependency injection, which are independent of any specific state management solution.

Eppo is a composable next-generation feature flagging and experimentation platform focused on tightly integrating with your existing tech stack.

Abstraction for fetching local or remote data via flutter_bloc

multi_state_bloc allows you to easily use different states in one bloc.

A lightweight, flexible, and high-performance dependency injection and service location library for Dart and Flutter

Flutter package the helps manage streams and subscriptions. Built in order to reduce the complexity of having to manually subscribe to streams and cancel subscriptions.

This package brings back context.read and context.watch for riverpod

A convenience package that re-exports the entire flutter_it ecosystem - get_it, watch_it, command_it, and listen_it. Import once, use all the reactive state management tools.

Automatically get your OS defined Theme (Dynamic), force your prefered one (Light / Dark) and persist your choice in the device.

A Flutter package to manage feature flagging.

All-in-one Flutter timer widget with countdown, cooldown, debounce, and async loader. Perfect for OTP resend buttons, rate limiting, form submission, API loading with retry. Zero dependencies - internal state management. Fully customizable with controller support.

A state management library for Dart/Flutter applications.

It's an easy-to-use and elegant event bus-based library.

A Flutter autocomplete search widget with custom dropdowns and Cubit/BLoC support.

Agnostic Reusable Component Architecture for New Ecosystems: a modern framework for bootstrapping new applications

A set of classes to help you better manage Themes in flutter

A MassTransit-style state machine framework for Dart. Declarative, event-driven saga pattern with fluent builder API.

A lightweight architecture helper for your Flutter projects.

A flutter package to manage application configurations via singleton pattern.

Fish Redux is an assembled flutter application framework based on Redux state management.

A package that make it easy to implement the Senior X authentication for Flutter. Built to be used with the bloc state management package.

Making OverlayPortalController listenable.

A Undo/Redo Library for Flutter

Universal model to represent basic UI states.

A high-performance reactive state management library for Flutter featuring automatic dependency tracking and granular field-level updates.

A flutter_bloc reimplementation based on flutter_hooks with the same API.

Multi-platform Convex backend integration for Flutter. Real-time WebSocket, subscriptions, auth, lifecycle management. Supports web (pure Dart) and native.

A state management solution on top of Router API for larger apps.

The package offers a structured way to implemet clean architecture with redux pattern

Official IntelliToggle provider for the OpenFeature Dart Server SDK.

Simplified state management focused on animations

FlowR: state management package for the MVVM pattern based on reactive programming.

solidart_lint is a developer tool for users of solidart, designed to help stop common issues and simplify repetitive tasks

A top-down, recent-first Flutter event framework supporting multiple event types, routes, TabControllers, and context-based UI.

Flutter SDK for rendering server-driven UIs using JSON from Digia Studio. Supports dynamic layouts, state, actions, and custom widgets.

A state for StatefulWidgets that is aware of its visibility.

An extension to the MobX state management library which automatically persists and restores MobX states.

A comprehensive custom lint package that automatically enforces Clean Architecture principles in Flutter projects with Riverpod state management.

Everything is ViewModel. Enjoy automatic lifecycle management, prevent memory leaks, and share state effortlessly. Simple, lightweight, and powerful.

Scoped Service Locator with Constructor Injections for Dart and Flutter.

Easy Form State Management using BLoC pattern. Separate the Form State and Business Logic from the User Interface. Async Validation, Progress, Dynamic fields, and more.

State management solution for Flutter applications, providing a streamlined and efficient way to manage ViewModel-based architectures.

This class extends the capabilities of Flutter's State class and includes a controller.

Automatically generates an observable interface for any class. Observer Pattern implementation for Dart, generalized using mixins and multiple alternative interfaces.

Angular Components that make it easy to implement the BLoC (Business Logic Component) design pattern. Built to be used with the bloc state management package.

Stark - a pragmatic lightweight dependency injection framework for Dart

The core library for the Vyuh framework which contains the base types and runtime.

similar android BroadcastReceiver andd ios NSNotification,Used to notify the page to refresh.This is a pure dart language development package

An asynchronous variant of ValueNotifier that coalesces multiple value assignments within the same event‑loop turn into a single notification dispatched in a later microtask.

A group of pre-built providers the wrap the basic dart collections - list, set, map

Remote DevTools for Redux.dart. This package connects a Dart Redux store to the Remote Devtools Server, allowing the developer to inspect changes to the Redux Store during runtime.

An Elm-inspired state management for leveraging benefits from the Elm architecture while still being Dart friendly.

Dart mediatr package. Central mediator that allows sending requests, and publishing events.

Riverpod implementation of infinite_scroll_pagination, this package allows to use infinite_scroll_pagination with Riverpod abstracting away the complexity

A state management library that enables concise, fluid, readable and testable business logic code.

A special BlocBuilder for displaying the lifecycle of a state with a LoadingStatus.

A set of abstractions, utilities inspired from android Jetpack to help manage state in flutter applications.

A workaround for Flutter Issue 108697 that prevents state recovery on page refresh. Gets the state directly from the browser History API.

Independent Flutter state management, routing, and DI solution inspired by GetX with high performance.

A state management library that enables concise, fluid, readable and testable business logic code.

Reduce the massive amount of boilerplate for Flutter redux application

BodyBuilder is a widget that manage the loading of your data

Refactored architecture with enhanced global configuration for state management and data handling in Flutter applications. This package provides a robust solution for managing API states, including loading, error handling, and data retrieval, while ensuring a clean and maintainable codebase.

Build on top of the wonderful flutter_bloc package. Contains some useful blocs/cubits.

Easily scope providers to routes with GoProviderRoute and ShellProviderRoute.

A simple, lightweight package for adding undo/redo functionality to your Flutter apps, suitable for both primitives and complex objects

A pragmatic dependency injection (DI) system, coupled with service classes for seamless state management in Dart.

An improved version of FutureBuilder

A package offering tools to manage app state using ValueListenable objects called Pods.

RapidFire Flutter Library is a comprehensive ORM system for mobile application development, used various popular Dart packages in one place. Validation, CRUD and API operations are automatic requires no code.

A Flutter state management library that bridges the gap between traditional state holders and a modern, reactive consumption model.

Entity State Management Package

Smart project structure with dependency injection and route management

Dart package that provides a set of basic streams with easy access to the latest emitted value

A helper class for maintaining a TextEditingController and/or a FocusNode for a State and its Widgets.

A powerful State Management, Dependency Injection, Reactive programming and Navigation for Flutter apps.

Flutter widgets for value_stream.

An easy to use value notifier wrapper with some sugar syntax

A Flutter package to display the data loaded with list_bloc.

A locator that manages models in a global registry (like GetIt) and in the widget tree (like Provider, InheritedWidget).

Package to speed up GetX.

Fetch, cache, and sync server data with automatic state management and background updates, inspired by TanStack Query.

Signal/Slot reactive state management for Flutter. Clean syntax, powerful features including middleware, persistence, time-travel debugging, and code generation support.

Advanced tools for development using the BLoC pattern

A Flutter package that implements the Clean Architecture by Uncle Bob in Flutter. It provides Views, Controllers, Presenters, Observers, and UseCases.

The [bloc_scope] package helps you to easily cancel the futures and streams in case of BLOC or Cubit disposing.

A straightforward way to manage global state in flutter apps.

BLoC for DuskMoon theme persistence (theme name + mode)

BodyBuilder is a widget that manage the loading of your data

A super module using bloc and clean architecture that is common in every app such as authentication, utils, extension and common widgets.

A Time Traveling Redux Debugger for Flutter

RxDart Subscriptions management. Provide Apis to store and manage RxDart subscriptions and provide methods to unsubscribe them all.

A utility similar to Compose’s remember, which leverages anlifecycle to let Flutter’s BuildContext remember an instance and provide corresponding management functions.

A high-performance, tactical grid engine for Flutter. Featuring an immutable state-driven drag-and-resize system with built-in collision detection.

DoSo is a lightweight Dart library for simple and elegant error and state handling, designed to reduce boilerplate and avoid code generation in Flutter apps.

A Flutter package for managing scopes and dependency injection within the widget tree

GetX Scaffold is a comprehensive rapid development template built on the GetX framework and several commonly used plugins

rx_bloc_cli that enables quick project setup including: flavors, localization [intl], state management [rx_bloc], routing [go_router], design system, analytics [firebase], tests

Syringe is a dependency injection (DI) library for Dart applications.

A dart library that helps you to implement the BLoC pattern.

syncx is a lightweight, flexible Flutter state management library with notifiers and reactive UI updates, inspired by provider, bloc, and riverpod.

A comprehensive but flexible state management solution inspired by React Hooks.

AnLifecycle draws on lifecycle in androidx to implement lifecycle on Flutter, Developers can sense the LifecycleState under the current context wherever you need it.

A package with stream based Flutter Widgets that facilitate an reactive programming style.

Conflict-free replicated data type (CRDT) - Local-first implementation provided in dart

depend simplifies dependency management in Flutter apps, providing easy initialization and access to services across the widget tree.

A high-performance dependency injection library for Dart and Flutter. Features multi-profile support and serves as a drop-in replacement for get_it with enhanced capabilities.

A minimalistic Dependency Injection and Service Locator implementation in Dart.

A simple State Managment, Dependency Injection, Reactive programming for dart Projects.

This Dart package simplifies the implementation of common data-fetching states (loading, success, error).

Modern implementation of the Original BLoC that uses asynchronous generators to describe relationships between events and states.

Bloc wrapper over 'flutter_esp_ble_prov' which provisions WiFi on Espressif ESP32 devices over Bluetooth using Espressif-provided provisioning libraries.

OptiCore is a lightweight micro-framework for Flutter that simplifies and optimizes your app development

Reactive event handler wrapper class inspired by ReactiveUI.

A Flutter library to easily display a list with animated changes from a Stream<List<E>>. It's like StreamBuilder + ListView.Builder with animations.

Flutter/Riverpod pagination utilities. Easily build screens with loading/error states. Supports page, offset, and cursor-based pagination.

A light, powerful and quick Reactive State Management, Dependency Injection and Event Handler.

MVVM+ is a lightweight Flutter implementation of MVVM, plus a locator for sharing states via a global registry (like GetIt) or inherited widgets (like Provider).

A Flutter package with the goal to enable testing rxBlocs from the FlutterRxBloc package with ease.

Simplify Flutter Bloc with code generation. Define events as methods, get automatic concurrency control, actions for side effects, and async state management.

A simple reactive navigation middleware for Flutter's redux library.

Combines flutter_hooks and async_redux packages to add Redux to flutter_hooks

A flutter package for the cart management. This package helps you to perform basic cart operation like (Add to cart, Remove from cart, Get total count) etc.

A mixin to avoid "setState while widget is building or locked" issue and improve performance.

Flutter library for fetching, caching and invalidating asynchronous data.

A BLoC library for loading data from an api end-point with filtering and pagination.

A fork of vxstate with added features and improvements.

ValueListenable/ValueNotifier for async operations

Code generator for mono_bloc. Generates event classes, action handlers, and base bloc classes from annotated methods.

This package will help you to call a loading in your async methods very easily, and you don't need to worried when it's is starting or finishing.

Flutter widgets and utilities for mono_bloc. Provides MonoBlocActionListener for handling side effects in Flutter apps.

Flutter state management with MVVM-inspired ViewModels & Notifiers. Offers fine-grained control.

Shared architecture for Impaktfull Flutter projects.

The core component for DashKit that provides basic architecture components

A light, powerful and quick Reactive State Management, Dependency Injection and Event Handler.

An automatically persisted BehaviorSubject with simple hydration for Flutter. Intended to be used with the BLoC pattern.

A re-imagined declarative approach to application design and architecture

A simple yet powerful state management library for Flutter. Keeps your widget build methods clean, with ZERO dependencies on other packages.

Core engine of the Fluxy framework including UI, state management, HTTP, and motion.

Unified network BLoC for Flutter - request coalescing, caching, retry, and interceptors built on the Juice framework.

Dart package for Async Data Loading and Caching. Combine local (DB, cache) and network data simply and safely.

State management using stream to avoid use of flutter's State/setState/StatefulWidget, boosting the performance and code separation.

June is a lightweight and modern state management library that focuses on providing a pattern very similar to Flutter's native state management.

Flutter hooks for MonoBloc - easily handle actions and state in HookWidget components

A wrapper around sharedpreferences which provides a valuenotifier for each preference.

A lightweight, SwiftUI-inspired Prop management library for Flutter. Powered by Prop, ViewModel, and Declare.

Wrapper that improves readability and solves the common refiring FutureBuilder problem

A state management framework for Flutter using RxDart and MVVM.

consumer is like react-consumer state manage, use Stream at dart, consumer have memo and shoudWidgetUpdate function to intercept update.

A package to generate clean architecture files with various state management options.

A simple state management machine for Flutter.

A package for managing ViewModel that depends on an_lifecycle. Similar to Androidx ViewModel.

LiveData is a data holder class that can be observed. This is a Flutter implementation inspired by Android LiveData

Idiomatic State Lifecycles for Flutter. Part of the State, part of the Tree.

This package isolates business logic so that it can be reused.

Lightweight Firestore repositories for Flutter: single-doc, collection, and collection-group repos that react to auth, stream updates, and support live-window pagination.

Isolator is a package, which offer to you a simple way for creating two-component states with isolated part and frontend part of any kind - BLoC, MobX, ChangeNotifier and others

A dart form implementation using riverpod package.

基于provider封装的脚手架.

split your business logic easily / handle your page state / handle animation state within your business logic

Utopia libs - complete architecture (including hooks, widgets, utils, reporter, collections, validation)

Typed Event Bus to share events on a bus and be sure of payload

A flutter implementation of riverform using flutter_riverpod package.

Simple state management for Flutter with concurrency support.

A reusable Flutter infrastructure package — cache, storage, auth, network, database, permissions, formatters, and more.

Result-first caching and data orchestration layer for Dart and Flutter apps. Memory-first cache with policies, single-flight dedup, and reactive watch streams.

An extension of Bloc that adds a one-shot UI side-effect stream alongside state, for navigation, dialogs, snackbars, and other fire-and-forget actions.

Safely store access and refresh tokens, efficiently refreshing access tokens upon expiration.

Simple State Manager (Focusing on simplicity and rebuilding only the necessary)

A cross-platform declarative router for Flutter with a focus on state and nested navigation. Made with ❤️ by PlugFox.

A dart-native turnkey solution for painless network synchronization

A flutter package that manages dispose callbacks and subscriptions cancellations.

Functional error handling with Result pattern. Safely manage operations that can fail, with clean, type-safe error control.

Easily save and load values locally. Effortless local persistence with type safety and zero boilerplate. Just get, set, and go. Drop-in replacement for raw SharedPreferences.

Supply Chain (SC) is a data flow and state management architecture.

Mosaic is a modular architecture for Flutter that enables clean separation of features using dynamic modules, internal events, UI injection, and centralized builds

High-level data layer for Clean Architecture with standardized Drivers, typed DataSources, and Repository mixins for caching, deduplication, and safe error handling.

A lightweight reactive system for Flutter, inspired by simple state binding.

A Flutter plugin for seamless multi-display Android apps with shared state across multiple Flutter engines.

Core functionalities of a flutter application including translations, lifecycle events, navigation, dialogs

Powerful asynchronous state management, automatic caching, hierarchical DI, and zero-boilerplate reactivity. A holistic architecture for modern Flutter apps.

A state management library that helps add reactivity to widgets

Translate your project 100% using signals

Starter archetype for Flutter apps with Jocaagura Clean Architecture, cross-cutting BLoCs, theming, and navigation setup.

Generates STATE, EVENT AND BLOC from a SINGLE LINE OF STATE VARIABLE and can generate custom event classes from factory constructors

A reactive state management library for Flutter applications. Provides simple and efficient way to manage application state using signals and reactive patterns.

A replacement for ChangeNotifier and ValueNotifier that is easier to use and more flexible

A lightweight router designed for ease of use and efficient state management.

Minimalist state managment

A package that simplifies adding localization to your Flutter app.

A Clean Architecture code generator for Flutter with support for BLoC, Cubit, Riverpod, and GetX state management.

Base interface for `ValueListenable`-implementing classes which need to be `dispose`d after usage.

An advanced Flutter package for state management and business logic components, extending flutter_bloc.

A client-side Flutter library to interact with user-facing Knock features, such as feeds.

Lightweight and reactive state management solution for Flutter.

An extension to the bloc state management library which adds support for broadcasting state changes to stream channels.

MVVM Modify for Dart but you can also port to another language

A package intended for implementing pagination in various ways in the application in the simplest way with many customizations.

Lightweight props provider for Flutter with fine-grained rebuilds powered by InheritedModel.

A state management library for Flutter that combines aspects of Redux and BLoC. Rebloc uses streams and BLoCs to compose middleware and reducers.

A high-level, state-agnostic, drop-in module for the Telnyx Flutter SDK that simplifies WebRTC integration.

Smart project structure with dependency injection and route management

A mutation implementation for the riverpod community - made by Theodo

A framework to build Flutter applications. It provides state management, persistence, caching and opinionated project structure.

A Dart package for generation of typed BloC widgets like BlocBuilder and BlocListener for concrete implementations

This package allows you to easily undo and redo saved data in your applications.

A lightweight, high-performance reactive signals library for Dart/Flutter with fine-grained updates and intelligent resource management.

Time-travel dev tools for flutter_bloc, inspired by Redux DevTools. Provides an in-app debugging panel and a Flutter DevTools browser extension with state history, BLoC connection graph, performance metrics, state diff, event timeline, and state replay.

Server driver UI framework for Flutter. Allows you to update your cool UI without updating the app!

Anchor data in your widget tree & obtain them more reliably than provider.

The Flutter productivity library that replaces scattered Supabase boilerplate with a unified, typed, and retry-capable API across auth, database, storage, and realtime.

A highly performant and reactive tree structure widget for Flutter, built with rxflare for efficient state management and rendering.

Cubit Form

A generic BloC Provider for your Flutter apps. This package will help you avoid the boilerplate of writing BloC Providers.

A minimal and scalable light-weight event bus library for get.dart

Cherrypick is a small dependency injection (DI) library for dart/flutter projects.

Flutter Control is complex library to maintain App and State management, Dependency Injection, Navigation with Routing, Localization and more..

Adds a didInitState() lifecycle method to stateful widgets where you can safely access inherited widgets.

Provide an extension development toolkit for the flutter_hooks library for anlifecycle and an_viewmodel.

Most simple and stable ui update instrument

Provides a convenient single-state management solution for loading, data, and error, along with corresponding state-conversion mechanisms.

A Flutter plugin for Mapxus indoor positioning services. Provides real-time location tracking and positioning state management for indoor navigation applications.

A mixin on Bloc that allows to perform UI actions and get results back.

Flutter SDK for rendering server-driven UIs using JSON from Digia Studio. Supports dynamic layouts, state, actions, and custom widgets.

A Riverpod provider for Flutter State Restoration

Provides the core of live cells: A replacement for ChangeNotifier and ValueNotifier that is easier to use and more flexible

A declarative cross-platform Flutter engine with focus on state to display presentations, such as campaigns, banners, notifications, etc., anywhere, anytime.

Production-ready reactive state management with robust logging, undo/redo, computed values, debounce/throttle, and more. Lightweight, powerful, and easy to use.

A robust code generator for the Air Framework that automates state management through Pulses and StateFlows.

Flutter package to implement forms in an easy, fast and effective way using the lyform and flutter_bloc packages.

Flutter Widgets that make it easy to implement state management patterns. Built to be used with the ValueNotifier.

A plugin for simplifying the use of GetX

A high-performance event bus for Dart/Flutter

Smart project structure with dependency injection and route management

A simple and reusable Flutter widget for handling loading, error, empty and success API states.

This library contains components for Flutter architecture, and also utility classes for HTTP, navigation and DI

A Flutter plugin project to manage events (time, place and attendees) using the atPlatform.

A powerful, lightweight state management solution for Flutter with built-in persistence, debounce, throttle, and seamless widget integration.

Messaging service to connect your components and services through publisher/subscriber pattern.

A state management library using the Observer pattern, optimized for notifying changes in collections.

Flutter widget to change `themeMode` during runtime and persist it across restarts

An easy to understand implementation of reactive values and objects

A thin application framework for flutter making use of async_redux

This package is a dev dependency for Mustang framework. Complex code needed to manage application state, cache and other APIs is automatically generated by this package.

Wrapper around Riverpod for powerful asynchronous state management, server-state utilities and data fetching. Inspired by TanStack Query

easy to use flutter async state with hook

Flutter widgets that simplify the BLoC pattern implementation for REST APIs within an MVC architecture, significantly reducing boilerplate code.

Simple single value cubit. Works as a simple state manager for inputs, scrolls, flags etc. Works best as injected and observed by other blocs/cubits.

A lightweight form library for Flutter that handles form validation and state management gracefully, with unified form representation.

Easily manage role, permission, and condition-based access control in Flutter UIs — entirely in Dart.

A message notification listener for riverpod architecture

EventTaxi could be used to send events through different layers of the application decoupled from the architecture.

Local-first sync engine for Flutter with offline support, delta sync, encryption, custom conflict resolvers, and real-time synchronization.

Simple but powerfull Flutter navigation with riverpod and Navigator 2.0

Simple communication pattern abstraction on streams, created for communication between logic classes and or widgets.

Package adds a stream to which you can send actions from your Bloc or Cubit and process these actions on the UI similar to a BlocListener

Official Flutter SDK for SignaKit Feature Flags. Fetches flag configurations from CloudFront/S3 and evaluates flags locally with deterministic bucketing.

A comprehensive Flutter package for managing Rive animations with data binding, image replacement, and global state management capabilities.

An Android similar state management package (StateFlow and SharedFlow with ViewModel) which helps to implement MVVM pattern easily.

Dart package to implement forms in an easy, fast and effective way using the bloc package

Pure Dart client for Convex with WebSocket sync, type-safe values, and reactive subscriptions. Works on iOS, Android, web, and desktop.

Lifecycle-aware Flutter application framework built around use-case driven blocs, scoped ownership, and targeted rebuilds.

Event Bloc is an event-based implementation of the BLoC pattern, the recommended State Management Pattern for Flutter by Google!

A simple widget that listen streams without rebuilding its child (ex. to show a dialog)

A small package that helps easily to work with UI changes base on the state of fetching remote data

Adds support for managing theme modes (light, dark, system) and switching theme colors.

StreamDisposer

Flutter library for jolt reactive signals library that builds reactive widgets from signals, automatically updating UI when signals change.

ValueNotifier and ValueListenableBuilder but for asynchronous value.

Asynchronous data caching, refetching & invalidation library for Flutter

context_watch adapter for mobx package

A Swift-inspired persistent data management solution for Flutter. Provides simple, powerful, and type-safe way to persist your app's models with automatic UI updates.

A Dependency Injection library, that provides a simple way to manage your dependencies.

A view-controller pattern implementation to separate UI from logic

A Flutter widget that updates (rebuilds) when an Event occurs.

Allows you to use Provider with Redux. Uses AsyncRedux, the non-boilerplate version of Redux (https://pub.dev/packages/async_redux).

A generic implementation of resource states and UI builders for paginated and standard resources.

A set of cubits that can be used to handle async operations in a simple, consistent way.

Easy State Framework is a lightweight, high-performance, strongly-typed state management micro-framework for Flutter.

Simple but powerfull Flutter navigation with riverpod and Navigator 2.0.

A lightweight, fast, and type-safe reactive state management library for Dart.

Powerful Event-Component-System state management for Flutter. Promotes clean architecture, testability, and includes visual debugging with Inspector

A modular, reactive, and scalable framework for Flutter. Build industrial-grade apps with a decoupled architecture.

ObserverFuture, ObserverStream and ObserverText Widget - A simple way to consume MobX Observables through widgets. You can find a sort of widgets.

Dart package to implement forms in an easy, fast and effective way using the bloc package

You can monitor page lifecycle by this lib.

Easily wrap async functions into blocs to manage their execution states

Provides the state view pattern for Flutter, creating a strong separation between UI and domain logic.

Simple listenable support multi listeners.

Lightweight and improved versions of FutureBuilder and StreamBuilder as state machines. Useful for handling Futures and Streams.

Simple interface for creating a streamable data source that caches it latest value.

A enhanced version of ChangeNotifier introduces new features `target`, `once`, and `immediate`.

A ValueNotifier for all async states. Listen, notify, and manage loading, error and data in one place.

Based on the provider encapsulation plugin (recommended to be used in conjunction with the provider_temp_gen template generator to greatly improve development efficiency)

rxdart_flutter is a Flutter package that provides a set of widgets for working with rxdart. This package is officially maintained in the ReactiveX/rxdart repository. These widgets are specifically designed to work with ValueStreams, making it easier to build reactive UIs in Flutter.

A robust, reactive asynchronous state management and data-fetching library for Flutter leveraging the minimal, hooks-free power of Signals.

A reactive state management library for Flutter with a simple and intuitive API which allows you to build Flutter applications with ease.

A companion package for handling models and databases using the event bloc.

A lightweight publisher/observer open-source library used for messaging to run through the entire Flutter applications. Inspired by NotificationCenter in iOS and EventBus on in Android.

Dash library is responsible to offer a service locator pattern that cares about provide and dispose blocs.

Provides wrappers over Flutter widgets which allow the properties of the widgets to be controlled by ValueCell's

An implementation of `StreamBuilderBase` that folds new stream events into a summary and builds with the summary of stream events seen so far.

Reactive Forms architecture in Flutter inspired by Angular's FormGroup/FormControl pattern and integration with TextEditingController.

Keep application instances in sync with a simple pub/sub API.

Quickly develop Flutter App's MVI framework, encapsulate Dio network requests, and convenient tools.

Setup Widget API and Flutter hooks for building reactive widgets with Jolt signals, featuring automatic resource cleanup and lifecycle management.

dartz Either adapter for flutter_stasis. Bridges Future<Either<F, R>> use cases to StasisViewModel with zero boilerplate.

A Flutter package for Convex backend integration, enabling developers to interact with Convex services, manage data, and build applications with real-time synchronization.

A light and simple State Manager for Flutter Apps.

A Flutter package that simplifies implementing infinite scrolling lists with automatic pagination handling.

Bootstrap a production-ready Flutter monorepo in one command. Choose state management (GetX/Riverpod/Bloc/Cubit), HTTP client, locales, and platforms.

A declarative dependency injection library which use dart syntax and flutter style

Pure Dart command queue primitives for retryable API work, terminal failures, and offline-first orchestration.

A lightweight reactive state container for Flutter, built on Jolt Signals and inspired by BLoC's Cubit architecture.

Bloc and hydrated_bloc adapters for the api_command_queue core package.

Extended BLoC with second stream of Side Effects and widgets.

Dart SDK for SpacetimeDB. v2 wire protocol, real-time typed tables, reactive primitives, optimistic updates, and opt-in offline storage for Flutter apps.

A flexible cursor-based pagination library for Flutter with full generic type support. Works with ChangeNotifier, BLoC/Cubit, and supports any cursor type.

Declarative, state-driven navigation for Juice applications with Navigator 2.0 integration, route guards, and deep linking support.

Flutter hooks integration for the Jolt reactive state management system, providing declarative hooks for signals, computed values, effects, and more.

Layer communication package. It helps to develop data layer with models and API connectors, which will be used by BLoC to build UI.

A package to help handle Cubit instances across the app.

Pure Dart core of the Stasis ecosystem. StateObject, ViewModelState, Command, CommandPolicy and CommandResult — no Flutter, no third-party dependencies.

'A Flutter package that helps implement the [BLoC pattern] It is best used as an extension with the flutter_bloc package which already provides MultiBlocProvider , MultiBlocListenerX and MultiBlocConsumer.'

Flutter integration for armature: ArmatureApp bootstrap, slot widgets, reactive providers, and a debug overlay.

A clean & simple MVVM solution for state management using Provider package.

A lightweight dependency injection package for Flutter that enables context-free dependency management and modular architecture.

A Dependency Injection package, with Qualifier, Decorators, Interceptors and more. Inspired by Java CDI.

Loon is a reactive collection data store for Dart & Flutter.

A variant of ValueNotifier that helps you better manage phases of asynchronous operations.

An extension of leancode_cubit_utils that provides cqrs support.

Test helpers for flutter_stasis. captureStates, captureEvents, assertStateSequence and assertEventSequence.

An extension to bloc state management library that manages unexpected exceptions.

Offline-capable extension for Dartvex. SQLite query cache and mutation queue with optimistic updates.

A state-management and data providing library. this lib gives (AmDataProvider<T>) as data provider and (AmRefreshWidget<T>) as wrapper to widgets.

Fluxivity is a package that allows you to build a reactive graph of your application's state.

theme_change package by Sumit Gohil theme_change: Seamless Theme Management with Persistent Preferences and (GetX OR Provider) Transform your Flutter app's theme management with theme_change—a robust package designed to effortlessly handle theme changes and persist them across sessions. Leveraging the power of SharedPreferences for permanent storage and GetX OR Provider for state management, theme_change provides an elegant solution for dynamic and persistent theming in your applications.

Sane Provider-Provider dependencies with flutter_sub. A smart alternative to ProxyProvider.

Used for pumping data through different contexts

A Flutter-inspired TUI framework for Dart. Build terminal UIs with declarative widgets, state management, diff-based rendering, and a rich widget library.

A package that handles the creation and state of a dynamic questionnaire/data collection survey with conditional questions.

Feature-based app framework with dependency-graph resolution, reactive stores, typed ports (pipes / behaviors / slots), and tasks.

CLI to scaffold Flutter projects with clean architecture, state management (Bloc, Provider, Riverpod, GetX), and RelaxORM integration.

Package that merge between microsoft cqrs and mediator patterns

Reactive collection wrappers (List, Map, Set, Queue) with ChangeNotifier and ValueListenable support for efficient Flutter UI rebuilds.

An offline-first, conflict-free, shared editing library for Dart.

Brings zustand's bear necessities for state management to Dart

Use the atomic state management package nucleus with Flutter.

A library that provides composable, reactive primitives for Dart inspired by Signals and Runes.

Flutter State Manager + UI Library

Lifecycle callbacks to be aware of different events in the route navigation and state lifecycle in a flutter project

A collection of Dart collections that behave like ValueNotifier if their data changes.

Easy to use Dynamic Theme for Flutter with automatic persistence support.

flutter_offline_queue is a Flutter/Dart package to queue API requests offline and retry when online.

Reactive composition primitives for Flutter inspired by the Vue 3 Composition API.

A light, modern and powerful Flutter framework combining state management, dependency injection, and route management - inspired by GetX but with a cleaner API.

A powerful Flutter widget for managing UI states with built-in retry functionality. This widget handles loading, error, empty, and normal states elegantly while providing a customizable retry mechanism with cooldown support.

Brings zustand's bear necessities for state management to Flutter

Core package of LikeMinds Feed Flutter SDK, provides access to screens, BLoCs, and other utilities.

A lightweight, reactive state management solution for Flutter applications with async state support and domain-specific atoms.

Provider-like state binding, management, and injection using only context extensions.

A List where filters can be applied to the List and elements can be accessed or modified in that state.

Pacote para construção de projetos flutter com padrão reativo.

Dispatch and listen events everywhere and whenever. Also know as `Event Bus`.

A state management library based on the ViewModel design pattern for Flutter.

Based on the provider and combined with GetX, a state management tool is developed, which enables the widget to have an Android-like life cycle.

SINT (State, Injection, Navigation, Translation) - The Four Pillars of High-Fidelity Flutter Infrastructure.

A set of state & navigation manager for flutter. It allows you to update wisely your states and to navigate easily.

The most powerful dependency injection library for Dart.

A customizable multi-select dropdown widget with search functionality for Flutter applications using MobX state management.

A minimal, elegant, and powerful reactive state management solution for Flutter. Built to be simple, intuitive, and fully compatible with Flutter's widget system.

A zero-config BLoC state inspector with a built-in web dashboard. Visualize state changes, events, and errors in real time in your browser.

Handle async tasks with ease through automatic loading, error handling, and native widget integration.

A Flutter package for efficient UI state management, handling loading, empty views, content display, caching, and pull-to-refresh with customizable widgets.

Displays a scrollable list of items lazily fetched from an asynchronous data source.

A minimal state management solution for Flutter apps using the Model-View-Notifier (MVN) pattern

Lightweight MobX-style reactive primitives — Atom, Reaction, and automatic dependency tracking for pure Dart.

Code generator for @AutoProvid annotation, enabling automatic Bloc state management With lazy singletons GetIt and auto routing integration.

A neat set of tools aimed at making the state management easier.

A high-performance Server-Driven UI (SDUI) engine for Flutter. Render dynamic, state-aware layouts from JSON payloads at runtime — no App Store review needed for UI changes.

Reactive state management framework for scalable flutter applications.

A very lightweight state management library.

Human-friendly hierarchical state machines - ported to Dart from Chickensoft's C# LogicBlocks library.

Typed event bus with Stream subscriptions, sticky events, event history, and scoped lifecycle

A fully declarative data-lifecycle approach to BLoC-style state management in Flutter.

A Flutter package inspired by React hooks and the `flutter_hooks` package. It offers a similar hooks experience but without the need for additional widgets, allowing you to use just `StatefulWidget` to manage complex states declaratively and reactively.

This is a dart-json-mapper complementary package provides support for MobX Stores to persist as JSON.

An Event Bus based on Publish/Subscribe pattern to decouple your code dependencies using dart's Stream.

Inspired by Apple's NotificationCenter. Passes information around to registered observers.

A suite of abstract cubits to reduce boilerplate code and construct app use cases.

Smart project structure with dependency injection and route management

Async Data, Loading notifier, Error all in one variable, reducing boilerplate code and making your code more concise

A Flutter Http lib for easy cache and update UI bind with Getx.

Build Flutter Apps with PostgreSQL, MySQL, or any database, stream data changes through websockets effortlessly, handle websocket authentication like a pro and elevate your Flutter Chat App with video and audio calls!

Deterministic reactive computation core with explicit dependency graphs, boxes, and flows. Designed for testable business logic and state pipelines.

A set of most common BLoC use cases build on top of flutter_bloc library.

Automatically disposes StreamSubscription and closes Sink when disposing State<T>.

App service based on GetX library.

Superpowers for your Cubits: Loading and error states, retry, check-internet, debounce, throttle, non-reentrant, fresh, sequential, effects, optimistic functions.

A library that makes accessing shared preferences or secured storage a lot easier. It handles the common use case that reads or write preferences. It also supports read and write serializable complex types in a type-safe way. It also supports listening to the value changes. It exposes its values as mobx observable values, but it can actually works with any state management library.

A performant and flexible reactive programming framework for Dart

Helper functions for creating RiverPod providers for OffsetIterator's.

A library that make flutter to have a lifecycle like android or iOS. It can sense the lifecycle wherever you need them.

A Flutter MVVM. It uses property-based data binding to establish a connection between the ViewModel and the View, and drives the View changes through the ViewModel.

A modular, type-safe form management library. Features input aggregation, sanitization pipelines, declarative validation, smart UI error handling, and State-management agnostic.

Lightweight infinite query utilities for Riverpod and Flutter. Compose paged FutureProviders while keeping Riverpod cache, refresh, and invalidation behavior.

A lightweight, reactive state management library for Flutter with fine-grained reactivity and minimal boilerplate.

ABUS (A-synchronous Business Unified System) is a unified approach to handling asynchronous operations and API interactions with built-in optimistic updates, rollback capabilities, and error handling.

Extension to flutter_bloc that handles the underlying logic to filter and search list view data dynamically.

Type-safe async operation state management for Flutter using sealed classes and exhaustive pattern matching.

A collection of common blocs and cubits that maybe will be used very often (powered by the bloc library).

Core implementation of Modularity framework providing dependency injection container and module lifecycle management.

This package provides a stream-based way to represent stateful services in Dart, agnostic to any state management solution (BLoC, Riverpod, etc.).

Uses the NetworkBoundResources to control the offline-first or only to centralize the errors from fetching from the network or any other function.

A simple package that copies improves the behaviour of Flutter's ValueNotifier.

An implementation of the flutter_ioc package based on get_it.

A lightweight, modular state management library for the Air Framework.

State management library which let developer full access to widget state

Communication and data container layers library aimed to decouple UI from business logic

Elite flutter_hooks compatible library for fl_query, the Asynchronous data caching, refetching & invalidation library for Flutter

A Flutter useRequest-style async request management library based on dio, flutter_hooks, and Riverpod.

Simple and clean state management backed by InheritedWidget and DI backed by the service locator pattern.

Widgets that help state management of asynchronous operations such as sending HTTP requests, getting the response, and caching the result.

A collection of helper classes to make the use of ChangeNotifier easier for state management

Reactive Flutter widgets and convenience components for fast_rx

A lightweight, yet powerful way to bind your application state with your business logic.

The simplest and the easist state manager for Flutter.

A powerful a comprehensive and efficient reactivity system for Flutter, inspired by Vue 3's @vue/reactivity.

A widget that listens to a ChangeNotifier and rebuilds when it changes.

Crystal clear state management

A practical solution for building and managing the state of selectable lists.

Real-time Flutter debugging SDK. Inspect Riverpod state, network requests, and events from an in-app overlay — without leaving your app.

A package to implement onResume, onPause, onReady functionality on a Stateful widget (this is for every screen).

Re-reselect is a lightweight wrapper around Reselect meant to enhance selectors with deeper memoization and cache management.

A cache abstraction designed for Clean Architecture.

Support for marking objects as observable

A Flutter package providing AcceptableStatefulWidget which glues Provider and StatefulWidget

A pure reducer pattern for Riverpod notifiers. Separates state initialization from reactive bindings with a single reduce(State, Event) → State function.

Flutter widget to replace multiple nester StreamBuilder/ValueListenableBuilder, allowing to combine both

Ribbon-based multi-day event calendar for Flutter. Month view with swipeable navigation. State-management agnostic — works with BLoC, Riverpod, Provider.

A minimalist study project for state management, lifecycle, and observables in Flutter, but not recommended for production due to alpha status.

A Flutter library that enables seamless integration between flutter_alice, and get_connect from GetX.

Pocketsync is a Flutter plugin that provides a simple way to sync your data between devices.

Editors for complex models and lists inspired by simplicity of TextEditingController, without manual state management.

Flutter Hooks bindings for Solidart, suitable for ephemeral state and for writing less boilerplate.

A Flutter plugin for loading content asynchronously with Dart stream and RxDart. RxDart loader bloc. Reactive loader bloc. Simple reactive state management container.

Flutter mediator is a reactive state management package base on the InheritedModel with automatic aspect management.

A dart library to solve boilerplate issues with flutter_bloc by just using typedefs instead of defining state classes.

A flutter state management solution with dependency injection. You can easily manage your state

Reliable UI-oriented service locator with great performance, Widget lifecycle bindings, queued auto disposal and useful UI integrations.

An event without data, using StreamController to be used in flutter projects.

A Flutter package for responsive UIs and state management. Adapts to screen sizes and orientations.

State management for Flutter built around explicit lifecycle, standardised async execution, and ephemeral UI events.

A flexible solution for managing the cleanup of resources in Flutter.

A bold and balanced state management library that pairs MVVM structures with the simplicity of InheritedWidget.

Reactive state management framework for scalable dart applications.

A reactive, agent-based architecture framework for Flutter applications.