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

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"

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

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 project for analyzing Riverpod code. This is internally used by riverpod_lint and riverpod_generator

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

A package exposing annotations for riverpod_generator

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

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.

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

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.

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

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

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

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

A simple Event Bus using Dart Streams for decoupling applications

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

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.

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

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

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

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.

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

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

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

Smart project structure with dependency injection and route management for Flutter.

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

Redux is a predictable state container for Dart and Flutter apps

The framework to build testable, scalable and maintainable flutter apps

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.

Smart project structure with dependency injection and route management

Easily restart your application from scratch, losing any previous state

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

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

Transform method calls to a stream of events.

Tools for building applications using the bloc state management library.

Dart port of Preact.js Signals

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

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

Transform method calls to a stream of events.

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

Library for UI=f(State) architecture.

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

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

Flutter+Riverpod support library.

StateStream with Riverpod support.

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

Riverpod Provider for path_provider

riverpod_container_async test support library.

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

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

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

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

Time Travel Dev Tools for Dart Redux

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

Flutter bindings for state_notifier, such as StateNotifierProvider and StateNotifierBuilder

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

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

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

Smart project structure with dependency injection and route management

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

A common dependency for all context_watch-related packages

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

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

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

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

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

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

a simple yet powerful state management technique for Flutter

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

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

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

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

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

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

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

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

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

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

Smart project structure with dependency injection and route management

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.

Helpful lightweight tools for working with ValueNotifiers

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

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

Integration for the Bloc state management library to Flame games.

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

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

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

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

A state management library written in dart that enforces immutability

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

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

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

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

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.

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

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

Efficiently derive data from your Redux Store

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

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

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

flutter_hooks bindings for signals

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

An adapter package that provides yx_scope widgets for Flutter UI integration

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.

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

A set of utilities for provider package.

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

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

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

Riverpod for Jaspr

Replicated state for dashwire. Property schema, snapshots, relevancy, spawning, RPCs, and rooms.

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

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

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

Flutter package for the Model-Widget-BLoC pattern

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

A simple State Management solution for Flutter applications inspired by SolidJS

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

A straightforward way to manage global state in flutter apps.

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

A state management library for Dart/Flutter applications.

A measurement domain built on the genesis_tree spine: read-only perception trees with Node/Field leaves and a harvest pipeline.

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

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

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

A package for managing form state based on BLoC.

A simple State Management solution for Dart applications inspired by SolidJS

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

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

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

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

BLoC and Cubit observer for ISpect with event, transition, change, error, completion, and redacted metadata logging.

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

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

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

A reactive primitive and simple state managerment solution for dart.

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

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

Event Bus for Dart.

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

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

Persist Redux State with custom storage engines and serializers

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

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

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

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

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

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

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

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

Flutter integration for inject_annotation. Provides ViewModelFactory and ViewModelBuilder to inject ViewModels into widgets with automatic lifecycle management.

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

DevTools extension for Riverpod - inspect providers in real-time, now with MCP support for AI coding tools.

Package supporting bloc types for dispose_scope.

(自家用) Common encapsulation of Flutter includes the implementation of BLoC pattern and other widget combination.

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

Redux.dart Middleware that prints the latest action & state

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

Flutter widgets to replace multiple nested StreamBuilder widgets

Init widget to execute initialization methods declaratively

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

Redux Persist Flutter Integration with custom storage engines

A small wrapper class around Riverpod Mutations to bind a function to a mutation.

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

Extended bloc with second stream of side effect value.

A simple Dart library for managing scoped dependencies built on top of Zones from dart:async.

Hooks we often use, all gathered in one place.

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

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

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

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

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

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

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

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.

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

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

A Flutter package to manage feature flagging.

Generate production-ready Flutter apps from the fluFrame boilerplate — Riverpod 3, go_router, localization, theming, dio, and tests wired out of the box.

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

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

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

Riverpod ProviderObserver for ISpect with add, update, dispose, fail, and redacted metadata logging.

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

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

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

AI first Clean Architecture Framework and CLI with Result types, UseCase patterns, Dependency Injection and MCP server for building type-safe, scalable apps with AI agents.

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 drop-in replacement for ChangeNotifier for observing only certain properties of a model.

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

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

Core pure Dart reactive state container bridging BLoC semantics with signals v7 primitives.

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

A Undo/Redo Library for Flutter

Simplified state management focused on animations

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

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 lightweight architecture helper for your Flutter projects.

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

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

A library that makes FutureContext easier to use from hooks.

Riverpod Provider for package_info_plus

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

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

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

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.

Subscribable and observable pattern for the Solana Kit Dart SDK.

Official IntelliToggle provider for the OpenFeature Dart Server SDK.

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

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.

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

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

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

Making OverlayPortalController listenable.

Flutter extensions and bindings for BlocSignal state management library.

A minimalistic Dependency Injection and Service Locator implementation in Dart.

Complete state management for Flutter — hierarchical dependency injection, intelligent async caching, and offline-first resilience. Zero boilerplate, automatic cleanup.

Headless Flutter client for EasyLiveChat real-time customer support: sessions, messages, attachments, typing, presence and pre/post-chat forms over HTTP and Socket.IO. No UI.

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

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

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

BLoC/Cubit extension for hexsis_infinity_scroll with zero boilerplate and full scroll integration.

Token lifecycle management with storage, refresh, and token streams.

A clean, lightweight, type-safe form state management and validation library for Flutter & Dart.

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

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

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

A flutter package to manage application configurations via singleton pattern.

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.

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

Flutter widgets for yx_state.

A flutter_bloc reimplementation based on flutter_hooks with the same API.

A Flutter extension to the at_client library which adds support for mobile, desktop and IoT devices.

Simple state management for Flutter with concurrency support.

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

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

A lightweight state management framework using ValueNotifier and Listenable with built-in Dio HTTP resources, pagination, targeted rebuilds.

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

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

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

基于provider封装的脚手架.

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

Unified static analysis and runtime profiling for Flutter rebuild scopes and their triggers.

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

An easy to use value notifier wrapper with some sugar syntax

Universal model to represent basic UI states.

Easily scope providers to routes with GoProviderRoute and ShellProviderRoute.

This is a testing utility designed to simplify the process of testing Blocs that produce side effects. It builds upon the bloc_test package and introduces features that allow developers to expect side effects to be emitted

Custom task transformers for yx_state

An immutable state machine that supports transient states, integrates with various state and data management frameworks, and is ideal for UI applications.

A tiny, Pinia-style state management library for Flutter. Zero dependencies, built entirely on ChangeNotifier + AnimatedBuilder.

Changes the theme during runtime, also presists brightness settings across restarts

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

A flutter package that manages dispose callbacks and subscriptions cancellations.

Reusable stateful controllers for Plinth UI (equivalent to Mantine's @mantine/hooks).

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

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

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

ValueListenable/ValueNotifier for async operations

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

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

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

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.

Flutter integration for Modularity framework. Provides widgets and utilities for module-based Flutter apps.

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

Scoped Service Locator with Constructor Injections for Dart and Flutter.

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

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

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

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

Advanced tools for development using the BLoC pattern

Wrapper that improves readability and solves the common refiring FutureBuilder problem

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

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

Shared package for the Serverpod Offline Sync project.

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

Lightweight and reactive state management solution for Flutter.

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

BLoC for DuskMoon theme persistence (theme name + mode)

Policy-driven coordination for remote and local repository data.

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

A Flutter package to display the data loaded with list_bloc.

A Laravel-inspired Flutter framework with Eloquent ORM, routing, and MVC architecture.

Flutter bindings for canon — router delegate, screen/entity scopes, and reactive view-state widgets over the pure-Dart canon runtime.

State persistence and hydration adapters for BlocSignal state containers.

Reduce the massive amount of boilerplate for Flutter redux application

This is a basic library based on Getx. In order to build applications conveniently and quickly, you can quickly integrate the basic functions needed by general applications.

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

A state management package for Jaspr that implements the BLoC pattern, enabling Jaspr apps to handle state the same way as Flutter apps.

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

A state for StatefulWidgets that is aware of its visibility.

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

Jaspr web component integration and state binding for BlocSignal state containers.

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.

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

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

linter and developer tool for signals

Real-time collaborative editing for lexical_core: a transport-agnostic CRDT, an editor binding and presence awareness.

Entity State Management Package

Flutter plugin for the Adaptive SDK Core module. Provides SDK initialization, user session management, and a resilient HTTP client with offline queue for the Adaptive e-learning platform.

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

A Time Traveling Redux Debugger for Flutter

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

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

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

An improved version of FutureBuilder

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.

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

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

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

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

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

Analyzer plugin that enforces cohesive Flutter application architecture.

Notifier Plus is a Flutter plugin that improves reactive data handling, merges consecutive state updates, and prevents redundant rebuilds. It provides specialized notifiers (both synchronous and asynchronous), composable watchers, and useful utilities (like OneCallTask) to streamline state management and enhance performance.

Abstraction for fetching local or remote data via flutter_bloc

A pure Dart command-driven UseCase runtime with typed handlers, scheduling policies, cancellation, snapshots, and bounded history.

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

DevTools extension and protocol models for inspecting UseCase Forge applications.

OpenTelemetry tracing instrumentation for BlocSignal.

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

A Flutter package for easy language selection with beautiful UI and state management support.

Zero-magic reactive state management framework for CubePod with fine-grained reactivity.

A package that simplifies adding localization to your Flutter app.

Convergent Replicated Data Types for Dart — composable building blocks for offline-first apps. Registers, sets, counters, maps that merge deterministically across replicas without a central coordinator.

Flutter bindings for NoveraChat — lifecycle-managed providers and controllers over the headless noverachat_dart core.

Minimal reactive-store + scoped dependency injection for Flutter. Retain and release stores by reference count, wire them into widgets with one line, rebuild on value change. Five files, zero codegen.

A minimal MVVM ViewModel contract for Flutter using ChangeNotifier and ValueListenable<Result<T>>.

Flutter reactivity for crdt_lf — rebuild widgets when CRDT state changes, with selectors, a provider and a collaborative text field. Wraps provider, like flutter_bloc.

Full Orbital package that reexports core, injector, router and state.

Reactive event handler wrapper class inspired by ReactiveUI.

A straightforward way to manage global state in flutter apps.

A fork of vxstate with added features and improvements.

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.

Smart project structure with dependency injection and route management

The official bridge between network_cool_client (ncc) and data_shaft. Provides standardized drivers and datasources for a clean data layer.

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

Core building block for the GrowERP frontend: authentication, theming, navigation, and shared widgets used by every GrowERP Flutter package and app.

Riverpod interoperability adapters for BlocSignal state containers.

A re-imagined declarative approach to application design and architecture

Reactive state management extensions for navhost — .obs values, Obs auto-tracking widget, ViewModelBuilder, and Listen.

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

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

Reduce flutter_bloc boilerplate with compile-time-safe context access and typed selector, builder, listener, and consumer widgets.

A toolkit for the Provider package with reusable state management components, builders, listeners, mutations, caching, and observers to reduce boilerplate.

Provides a declarative hierarchical state machine implementation that loosely follows the UML State Machine specification.

Flutter annotations and runtime APIs for Dust-generated routing, state management, and i18n.

Runtime helpers, annotations, and mixins for Riverpod experimental mutations.

The Flutter skeleton of a DartWay app: bootstrap runner, guarded UI actions, the AsyncValue rendering contract, notifications and error reporting. Riverpod-native.

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

Realtime state synchronization across devices, powered by the Locality Social Cloud.

A lightweight reactive architecture framework and design system toolkit for Flutter multiplatform applications.

An extension of leancode_cubit_utils that provides cqrs support.

A reactive state management framework for Flutter based on chain of reactivity and lazy computation pipeline.

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 reactive state management library for Flutter with a simple and intuitive API which allows you to build Flutter applications with ease.

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

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

Dedicated Flutter DevTools extension UI for inspecting BlocSignal containers.

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

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

Riverpod provider observer adapter for DebugKit. Records provider state events into the State tab with sanitization and optional log mirroring.

React-style lifecycle and state hooks for native Jaspr components.

Flutter widgets for building and reacting to usecase_forge snapshots.

Flutter library for fetching, caching and invalidating asynchronous data.

Deterministic test helpers for the pure Dart usecase_forge runtime.

Optimistic, message-driven state engine: a journal of sealed facts folded into keyed stores and units, with guards, correlation, and merge edges. Pure Dart.

Flutter package to Fetch and display asynchronous data easily

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

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

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

The core component for DashKit that provides basic architecture components

Stark - a pragmatic lightweight dependency injection framework for Dart

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

A high-performance, ultra-lightweight, and fine-grained reactive state management solution for Flutter.

Server-state cache for Flutter — dedupe, cache by query key, stale-while-revalidate. A TanStack Query for Flutter.

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

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.

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

A modular Flutter utilities package useful utilities such as constants, extensions, helpers, mixins, and state management.

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

A high-performance, type-safe global event bus system for Flutter applications with priority support, batch processing, comprehensive logging, and visual debugging tools.

A code generation toolkit for Riverpod state management. Better syntax and side effect solution with commands.

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

A helpful tool for riverpod developer.

Visual devtools overlay for tanquery. Inspect query cache, mutation log, and query states in real-time with a floating panel overlay.

A customizable file upload progress indicator widget for Flutter, supporting multiple variants (linear, circular, overlay, and percentage text) and integration with flutter_bloc state management.

Pure-Dart Remote Flutter Widget (RFW) catalog format, schemas, validation, and shared value types used across the Restage packages.

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

Immutable context for carrying data through an application.

BLoC states that keep the last known good data through error and loading, plus a paginated list bloc, built on verdict's Result and Failure.

Flutter adapter for tanquery. Widget builders for automatic caching, stale-while-revalidate, and background refetching. QueryBuilder, MutationBuilder, InfiniteQueryBuilder.

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

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

Flutter Dio API client with automatic state management, error handling, request logging, file downloads, and reactive UI widgets.

A macro-powered simple state management solution for Flutter to eliminate boilerplate.

OpenTelemetry tracing instrumentation for BlocSignal.

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.

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

A flutter implementation of riverform using flutter_riverpod package.

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

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

Cascading Thai address picker widgets (province/district/subdistrict + postcode) for Flutter. No state-management lock-in, no code generation.

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

SQLite persistence backend for the Toggly Flutter SDK (feature_flags_toggly), enabling offline feature flag, variant, and JWKS caching via sqflite.

Riverpod-native Firebase bootstrap, telemetry, Crashlytics, Performance, Dio, and test fake helpers for Flutter apps.

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

Shared architecture for Impaktfull Flutter projects.

Secure-storage persistence backend for the Toggly Flutter SDK (feature_flags_toggly), enabling offline feature flag, variant, and JWKS caching via flutter_secure_storage.

On-disk (plain JSON file) persistence backend for the Toggly Flutter SDK (feature_flags_toggly), enabling offline feature flag, variant, and JWKS caching.

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

Flutter reactive render binding for DripState, enabling zero-rebuild UI updates through direct RenderObject synchronization.

A Dart code generation package for Role-Based UI Access Control in Flutter widgets.

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

Asynchronous data caching, refetching & invalidation library for Flutter

A re-imagined declarative approach to application design and architecture

An automated Flutter architecture generator (Clean, MVVM, MVC with Bloc, Cubit, Riverpod, Provider, GetX), feature module generator, and multi-flavor CLI configuration tool.

A lightweight, high-performance, molecular state management library for Flutter.

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.

Declarative hooks for Flutter Dva state management. Provides useDvaConnect, useDvaProps, and useDvaStore hooks on flutter_hooks for reactive store access in Flutter widgets.

DevConnect client SDK for Flutter - auto-intercepts HTTP, logs, state, storage. Works with Dio, http, Firebase, OAuth2, logger, talker, fimber, and more.

A Flutter CLI for generating GetX, Dio, ScreenUtil, routing, services, and feature architecture.

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

A Flutter state management library inspired by dva, built on Redux. Supports models, reducers, async effects, loading plugin, and state persistence.

A CLI tool for scaffolding and managing Flutter projects with GetX and Clean Architecture.

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 package that encapsulates Build Generators for the data_monitor package.

app essentials - common app infrastructure for localizations, ui messages, state management, useful extensions, rest api

A high-performance Dart reactive framework implementing Chain of Reactivity and Lazy-computation pipelines.

Official extension library for Coralline, bringing reactive pipeline operations to Dart collections and iterables.

Core state management primitives for the Current ecosystem

Structured Flutter state management with typed stores, scoped rebuilds, effects, persistence, and test helpers.

A powerful Flutter package for executing async operations with built-in error handling, loading dialogs, retry logic, and Result pattern support.

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

Action Hooks, a Flutter Hook for building asynchronous commands

Combines flutter_hooks and async_redux packages to add Redux to flutter_hooks

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

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

A React-inspired error boundary package for Flutter that catches subtree build errors, prevents UI crashes, logs exceptions, and displays localized fallback UI.

A flutter package template with sample code and usage of Bloc pattern for state management.

Agility Redux is a modular, pluggable Redux state management library.

Smart project structure with dependency injection and route management

Scaffold a Flutter app from a YAML config. Add features with one command, keep router and DI in sync, and migrate your stack safely.

Pure Dart reactive state management with microtask batching and single-propagation-pass updates, with zero Flutter dependency.

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

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

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

The official CLI for the Air Framework. Streamline your Flutter development with modular architecture, automated code generation, and scalable state management.

A serverless Flutter framework for building applications with an event-sourced architecture, shared site management, and built-in compliance.

A dart form implementation using riverpod package.

Flutter widget integration for Orchestra — scope, reactive widgets, and handler API connecting the Orchestra runtime to the Flutter widget tree.

A flutter_bloc-based architecture (Result, UseCase, Bloc/Event/State separation) and recommended folder structure, extending flutter_basic_kit_library.

A professional Flutter package for handling permissions automatically with Riverpod state management, retry logic, and beautiful UI dialogs.

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

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

Cubit Form

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

A mutation implementation for the riverpod community - made by Theodo

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

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

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

A reusable, MVC-style infinite-scroll pagination toolkit for Flutter — one controller, many providers (Future/Stream/sync), page or cursor based, eight builders, hasReachedEnd, item + batch ops, key-based dedup (DuplicateResolver are byUpdatedAt/byVersion/custom), SortManager, selection, focus, scroll-to-index, rxdart realtime merging, bloc bindings (PaginationBloc/PaginationCubit), and a multi-section Sliver engine for mixed list + grid feeds.

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

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

A reactive state management library. Manage your application's states, effects, and actions easy way. Make apps more scalable with a unidirectional data-flow.

Best dependency injection library for Flutter, Rethought and redesigned specifically for flutter

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

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

A cache abstraction designed for Clean Architecture.

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.

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

A distilled, high-performance micro-state management and scoped DI engine for Flutter.

Simple but powerfull Flutter navigation with riverpod and Navigator 2.0

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

Easy Form State Management using BLoC pattern. Separate the Form State and Business Logic from the User Interface.

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

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

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

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

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

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

fbroadcast 飞猪 空安全版本

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

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

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

WondTech Flutter MVC framework — controllers, models, views, routing, sessions, and enveloped token-auth API helpers for building structured Flutter apps.

Simple but powerfull Flutter navigation with riverpod and Navigator 2.0.

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

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

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.

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

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

Minimalist state management and dependency injection.

A lightweight Flutter package for countries, states, and cities.

A state manager for those who like BLoC but don't like BLoC verbosity.

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

Type-safe event bus with Riverpod integration for Flutter.

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 comprehensive but flexible state management solution inspired by React Hooks.

easy to use flutter async state with hook

A Code Generator Plugin to Generate Pages and Dependencies for GetX State Manager base on Annotation.

A lightweight HiveCubit that auto-persists Cubit state to a Hive box with zero boilerplate.

App state, routing and other shared patterns for Code Collective flutter projects

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

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

Code generator for the inlay add-to-app framework - produces type-safe route and store classes for Dart, Kotlin, and Swift from annotated schemas.

ValueNotifier and ValueListenableBuilder but for asynchronous value.

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

Brings zustand's bear necessities for state management to Flutter

A lightweight and simple tree menu component for Flutter Web admin panels.

A CLI tool to scaffold Flutter projects with your chosen architecture, state management, and production-ready extras.

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

Flutter SDK for offline-first Frappe/ERPNext mobile apps with auth, API access, dynamic forms, and sync-aware local data operations.

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

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

A lightweight, type-safe action dispatcher for Flutter applications. Works seamlessly across all layers - UI, domain, data, and services.

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

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

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

Bloc and Cubit state management integration for the Kache caching library.

Terminal-friendly Bloc & Cubit helpers for nocterm.dev and related CLI apps.

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

Provider state management integration for the Kache Flutter library.

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

A flutter_riverpod-based architecture (ref.watch, Result, UseCase, UiEventEmitter) and recommended folder structure, extending flutter_basic_kit_library.

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

Flutter Renderer widget for OpenUI Lang. Owns the streaming parser, reactive store, error boundary, and form-state cache.

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

Bloc and hydrated_bloc adapters for the api_command_queue core package.

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

Flutter bindings for casl: an ability in the widget tree, a Can widget, and context.can(...) — so a screen draws what a user may actually do.

Stream and data holder class, which helps to ensure reusability and reduce the number of lines of code.

A provider-based MVI architecture (MviViewModel, onAction, UiEventEmitter) and recommended folder structure, extending flutter_basic_kit_library.

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

BLoC Utilities to make your life easier when you want to perform API Calls

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

flutter_hooks integration for qora. useQuery, useMutation, useQueryClient and useInfiniteQuery.

A modular form and file editor package for Flutter with support for Form widgets. Includes Cubit-based state management, form field validation, and UI input widgets.

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

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

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

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

A flutter plugin for loading content asynchronously.

Flutter widgets for value_stream.

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

Smart project structure with dependency injection and route management

A maintained GetX fork for context-free navigation, state management, and dependency injection.

A Flutter package for managing complex Dialog user flows

A type-safe, async-first domain event library for Dart. Clean event bus implementation following clean architecture principles.

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

BodyBuilder is a widget that manage the loading of your data

Riverpod 3 AsyncValue adapters for steady_async widgets and states.

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.

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.

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

Package supporting flutter types for dispose_scope.

BLoC and Cubit selector adapters for steady_async widgets and states.

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

A CLI tool to scaffold Flutter projects with Clean Architecture and Riverpod dependency injection. Generates a fully named, ready-to-run project from a versioned GitHub template.

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

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

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

A view-controller pattern implementation to separate UI from logic

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

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

A lightweight Flutter library to simplify data fetching and pagination using Bloc/Cubit. It provides standardized states and a Fetcher utility to reduce boilerplate.

Pure Dart reactive state management primitives for FlowR, built on bloc with update, error handling, logging, and stream helpers.

A framework for building Flutter applications based on Riverpod and GoRouter.

Type-safe, universal form field wrapper for Flutter with zero dependencies, high performance, and validation optimizations.

Flutter Hooks lifecycle integration for the Kache caching library.

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

Minimalist Cubit-style state management for Flutter using Streams and InheritedWidget.

A new way to extract/group/reuse common logic of StatefulWidget. Think of them like React hooks but for and of flutter.

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

hooks_riverpod bindings for the Kache caching library.

A Riverpod debugging and state-inspection package that records every provider update, tracks dependencies, visualizes state changes, and supports time-travel debugging.

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

A Dart implementation of CASL.js for managing access control in Flutter apps with dynamic permission handling.

Reactive state management framework for scalable flutter applications.

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.

A Flutter package for displaying geomaps with Google Maps and Flutter Map, supporting both mobile and web platforms with GetX state management.

A performant and flexible reactive programming framework for Dart

Dispatcher for paginated list loading with offset/cursor support, debounced search and pluggable cancellation strategies.

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

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

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

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

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

Fine-grained reactive primitives for deterministic updates and derived state.

A package that allows you to control observables within scopes that are linked to the Widget Lifecycle.

Brings zustand's bear necessities for state management to Dart

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

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

Agility Redux is a modular, pluggable Redux state management library.

An integration of signals into the impulse_flutter package.

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

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

Composable BLoC mixins and use-cases for lists & forms (Dart-only core).

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

Easily wrap async functions into blocs to manage their execution states

Minimalist state management and dependency injection.

Manage and observe data states with ValueNotifier/ValueListenable. Handle loading, loaded, and error states with enhanced debugging.

context_watch adapter for mobx package

Fast, lightweight server-state engine for Dart & Flutter — caching, deduplication, retry, pagination, mutations, and offline sync. Works with any state manager.

Flutter widgets and bindings for the Reacton state management library. Provides ReactonScope, ReactonBuilder, context.watch(), and more.

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

Hierarchical dependency scopes with deterministic ownership and teardown.

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

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

Lightweight reactive state management for Flutter with zero external dependencies: observable values plus an auto-tracking Observer widget.

Deterministic ownership and fine-grained reactivity for Flutter applications.

An easy to understand implementation of reactive values and objects

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

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

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

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.

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

Flutter BLoC management package that eliminates boilerplate code with sealed BaseState, BlocManager, and caching/pagination/refresh mixins.

Optional Jetpack Compose integration for the inlay framework - embed inlay Flutter screens directly into Compose navigation graphs. Android-only.

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

Utilities for building Flutter UIs from streams.

A Data Monitor package that encapsulates Annotations, Example and Utilities.

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

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

FASQ (Flutter Async State Query) delivers caching-first async data management for Flutter with smart refetching, error recovery, and unified APIs.

A TanStack Query-inspired server state management library for Flutter. Handles caching, background refetching, pagination, mutations, and network-aware fetching out of the box.

Core Dart runtime for Levit scopes, controllers, stores, and reactive ownership.

A Pipeline-first reactive state toolkit for Dart.

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

Hide Flutter widgets behind feature flags, roles, permissions, and attribute-based access policies.

A lightweight, type-safe Event Bus for Dart with optional event replaying. Decouples asynchronous code with minimal overhead.

Embed Flutter in native iOS and Android apps with type-safe navigation and key-value storage synced in real time across engines and native code.

Flutter SDK for ART realtime communication with WebSocket channels, AI Agents, AI Orchestrators, presence tracking, end-to-end encrypted messaging, and CRDT-backed shared objects.