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 testing library which makes it easy to test blocs. 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 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.

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 for Flutter.

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

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

Redux is a predictable state container for Dart and Flutter apps

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

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.

The framework to build testable, scalable and maintainable flutter apps

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

Easily restart your application from scratch, losing any previous state

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

Tools for building applications using the bloc state management library.

Dart port of Preact.js Signals

Transform method calls to a stream of events.

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

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

Flutter+Riverpod support library.

Library for UI=f(State) architecture.

StateStream with Riverpod support.

Riverpod Provider for path_provider

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

riverpod_container_async test support library.

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.

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.

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

Time Travel Dev Tools for Dart Redux

Flutter bindings for state_notifier, such as StateNotifierProvider and StateNotifierBuilder

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

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.

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

Smart project structure with dependency injection and route management

A common dependency for all context_watch-related packages

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

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 simple yet powerful state management technique for Flutter

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

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

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

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

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

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.

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

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

Helpful lightweight tools for working with ValueNotifiers

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.

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

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

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

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

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

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

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

A state management library written in dart that enforces immutability

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

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

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.

Efficiently derive data from your Redux Store

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

Integration for the Bloc state management library to Flame games.

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

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

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

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

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

Flutter package for the Model-Widget-BLoC pattern

A set of utilities for provider package.

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.

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

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

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

Riverpod for Jaspr

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

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

flutter_hooks bindings for signals

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

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

A straightforward way to manage global state in flutter apps.

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

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

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

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

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 package for managing form state based on BLoC.

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

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

A simple State Management solution for Dart applications inspired by SolidJS

An adapter package that provides yx_scope widgets for Flutter UI integration

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

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

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

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

Event Bus for Dart.

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

Persist Redux State with custom storage engines and serializers

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 collection of cubits and widgets that facilitate the creation of repetitive pages, eliminating boilerplate.

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

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

A state management library for Dart/Flutter applications.

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

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

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

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

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

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.

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

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

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

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

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

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

Package supporting bloc types for dispose_scope.

Redux Persist Flutter Integration with custom storage engines

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

A lightweight architecture helper for your Flutter projects.

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

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

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

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

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

Init widget to execute initialization methods declaratively

Extended bloc with second stream of side effect value.

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

Flutter widgets to replace multiple nested StreamBuilder widgets

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

Hooks we often use, all gathered in one place.

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

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

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

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.

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.

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

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

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

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

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

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

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

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

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

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

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

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

A Flutter package to manage feature flagging.

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.

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

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

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 autocomplete search widget with custom dropdowns and Cubit/BLoC support.

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

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

Flutter extensions and bindings for BlocSignal state management library.

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

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

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.

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

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

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

A Undo/Redo Library for Flutter

Simplified state management focused on animations

基于provider封装的脚手架.

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

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

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

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.

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

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

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

Making OverlayPortalController listenable.

A flutter package to manage application configurations via singleton pattern.

Official IntelliToggle provider for the OpenFeature Dart Server SDK.

Flutter widgets for yx_state.

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

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

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

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.

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

A minimalistic Dependency Injection and Service Locator implementation in Dart.

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

State persistence and hydration adapters for BlocSignal state containers.

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

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

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

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

Custom task transformers for yx_state

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

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 flutter_bloc reimplementation based on flutter_hooks with the same API.

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

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

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

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

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

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

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

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

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.

An easy to use value notifier wrapper with some sugar syntax

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

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

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

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

Universal model to represent basic UI states.

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

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

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

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

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.

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

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.

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

Simple state management for Flutter with concurrency support.

Scoped Service Locator with Constructor Injections for Dart and Flutter.

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

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

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

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

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

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

Abstraction for fetching local or remote data via flutter_bloc

ValueListenable/ValueNotifier for async operations

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

A package that simplifies adding localization to your Flutter app.

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

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

Riverpod interoperability adapters for BlocSignal state containers.

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

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

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

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

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

Easily scope providers to routes with GoProviderRoute and ShellProviderRoute.

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

BLoC for DuskMoon theme persistence (theme name + mode)

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

Wrapper that improves readability and solves the common refiring FutureBuilder problem

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

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

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

A fork of vxstate with added features and improvements.

A Flutter package to display the data loaded with list_bloc.

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

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

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

The core component for DashKit that provides basic architecture components

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

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

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

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

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

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.

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

Reduce the massive amount of boilerplate for Flutter redux application

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

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

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

A straightforward way to manage global state in flutter apps.

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

Stark - a pragmatic lightweight dependency injection framework for Dart

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

linter and developer tool for signals

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

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

Entity State Management Package

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

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

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.

A re-imagined declarative approach to application design and architecture

A state for StatefulWidgets that is aware of its visibility.

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

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

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

An improved version of FutureBuilder

OpenTelemetry tracing instrumentation for BlocSignal.

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.

Flutter library for fetching, caching and invalidating asynchronous data.

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

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

Cubit Form

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

A flutter implementation of riverform using flutter_riverpod package.

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.

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

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

Flutter package to Fetch and display asynchronous data easily

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

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>>.

Reactive event handler wrapper class inspired by ReactiveUI.

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

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.

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

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

Dedicated Flutter DevTools extension UI for inspecting BlocSignal containers.

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

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

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

A re-imagined declarative approach to application design and architecture

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

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

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

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

A dart form implementation using riverpod package.

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

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

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.

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

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).

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

A Time Traveling Redux Debugger for Flutter

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

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

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

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

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

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

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 hooks for MonoBloc - easily handle actions and state in HookWidget components

Smart project structure with dependency injection and route management

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.

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

Type-safe event bus with Riverpod integration for Flutter.

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

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

A fastest, lightweight, high-performance, and boilerplate-free state management and dependency injection solution for Flutter.

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

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

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.

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

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.

Provider state management integration for the Kache Flutter library.

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

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

Immutable context for carrying data through an application.

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

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

A tool kit for provider package with predefined builders, listeners, caches, observers and much more with reduced boilerplate.

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

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.

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

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

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

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

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

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

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

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

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.

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

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

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.

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

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

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

A helpful tool for riverpod developer.

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

Combines flutter_hooks and async_redux packages to add Redux to flutter_hooks

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

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

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

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

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

Hierarchical dependency scopes with deterministic ownership and teardown.

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

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

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

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

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

Most simple and stable ui update instrument

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

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.

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

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

A flutter package that manages dispose callbacks and subscriptions cancellations.

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

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

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

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

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

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

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

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

easy to use flutter async state with hook

Advanced tools for development using the BLoC pattern

Action Hooks, a Flutter Hook for building asynchronous commands

An easy-to-use Flutter package offering a streamlined BLoC pattern implementation for intuitive and efficient state management in Flutter apps.

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

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

Deterministic ownership and fine-grained reactivity for Flutter applications.

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

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

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

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.

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

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

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

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

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

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

An extension of leancode_cubit_utils that provides cqrs support.

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

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

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

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

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

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

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

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

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

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

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

Flutter bindings for Levit scopes, rebuild boundaries, and widget-tree ownership.

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

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 lightweight Flutter SDK for connecting apps with HosteDay APIs, including authentication, user requests, custom endpoints, and realtime support.

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

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

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

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

A dart-native turnkey solution for painless network synchronization

Flutter widgets for Piper State with lifecycle-aware ViewModel scopes, automatic dependency tracking, builders, listeners, and effects.

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.

A mutation implementation for the riverpod community - made by Theodo

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

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

Deterministic ownership and fine-grained reactivity for pure Dart applications.

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

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

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

Reactive state management framework for scalable flutter applications.

Simple but powerfull Flutter navigation with riverpod and Navigator 2.0

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

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

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

Flutter Hooks lifecycle integration for the Kache caching library.

A thin application framework for flutter making use of async_redux

Shared package for the Serverpod Offline Sync project.

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

Asynchronous data caching, refetching & invalidation library for Flutter

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

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

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

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

hooks_riverpod bindings for the Kache caching library.

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

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

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

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

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

fbroadcast 飞猪 空安全版本

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

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.

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

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

Minimalist state management and dependency injection.

Lightweight and reactive state management solution for Flutter.

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

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.

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

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

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

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

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

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

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

Flutter state management that cleans up after itself. Plain Dart ViewModels, computed state, explicit dependencies, and cooperative task cancellation.

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

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

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

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.

A lightweight, type-safe pub/sub library for Dart, inspired by Apple's `NotificationCenter` and Android's `EventBus`.

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

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

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.

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

An easy to understand implementation of reactive values and objects

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.

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

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

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

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

A flutter plugin for loading content asynchronously.

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

Flutter widgets for value_stream.

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

Bloc and hydrated_bloc adapters for the api_command_queue core package.

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

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

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

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

Riverpod 3 AsyncValue adapters for steady_async widgets and states.

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

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

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

A simple state management machine for Flutter.

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

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

A cache abstraction designed for Clean Architecture.

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

BLoC and Cubit selector adapters for steady_async widgets and states.

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

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.

A lightweight MVVM framework for Flutter. Built-in dependencies between members, bunch of built-in members for common use cases, and minimum boilerplate approach.

Minimalist state managment

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.

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

Package supporting flutter types for dispose_scope.

Brings zustand's bear necessities for state management to Flutter

BodyBuilder is a widget that manage the loading of your 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.

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

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

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

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

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

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 view-controller pattern implementation to separate UI from logic

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

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

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

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

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

A state management framework for Flutter using RxDart and MVVM.

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

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

A code generator that scaffolds a feature-first Clean Architecture project structure with Riverpod (Notifier/AsyncNotifier) into a Flutter project.

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

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

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

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

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

A Flutter package for managing complex Dialog user flows

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 performant and flexible reactive programming framework for Dart

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

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

A very lightweight state management library.

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

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

A Flutter presentation layer framework, which will clean up your widget code and make your widgets testable without a need for thousands of mock objects. Let's go driving!

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

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

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

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

An integration of signals into the impulse_flutter package.

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

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

A trick to notify errors in ChangeNotifier/ValueNotifier/StateNotifier.

ValueNotifier and ValueListenableBuilder but for asynchronous value.

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

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

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

Smart project structure with dependency injection and route management

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

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

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.

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

Minimalist state management and dependency injection.

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

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

context_watch adapter for mobx package

Easily wrap async functions into blocs to manage their execution states

Flutter State Manager + UI Library

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

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.