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 package to notify state changes to interested listeners in pure Dart.

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

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.

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

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

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 simple Event Bus using Dart Streams for decoupling applications

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

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

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

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

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

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.

Tools for building applications using the bloc state management library.

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

Flutter integration for inject_annotation. Provides ViewModelFactory and ViewModelBuilder to inject ViewModels into widgets with automatic lifecycle management, plus SubcomponentBuilder to own a @subcomponent graph's lifecycle from a widget.

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

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.

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

Dart port of Preact.js Signals

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

Easily restart your application from scratch, losing any previous state

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

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

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

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.

Smart project structure with dependency injection and route management

Library for UI=f(State) architecture.

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

Flutter bindings for state_notifier, such as StateNotifierProvider and StateNotifierBuilder

Time Travel Dev Tools for Dart Redux

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

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

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

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

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

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

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

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

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

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

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

Smart project structure with dependency injection and route management

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

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

A common dependency for all context_watch-related packages

a simple yet powerful state management technique for Flutter

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 minimalistic and easy-to-use dependency injection library for managing singletons and factories in Dart.

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

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.

Transform method calls to a stream of events.

Transform method calls to a stream of events.

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

A state management library written in dart that enforces immutability

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

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

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

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

ValueListenable operators (map, where, select, debounce, combineLatest) and reactive collections (ListNotifier, MapNotifier, SetNotifier). Formerly known as functional_listener.

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.

Smart project structure with dependency injection and route management

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

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

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

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

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

flutter_hooks bindings for signals

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

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

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

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 for Dart/Flutter applications.

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.

An adapter package that provides yx_scope widgets for Flutter UI integration

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

Flutter form validation and state management — typed controllers for text, checkbox, dropdown and multi-select fields, async and cross-field validators, and subforms.

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

Helpful lightweight tools for working with ValueNotifiers

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

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

Integration for the Bloc state management library to Flame games.

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

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

Serverpod chat server module.

Efficiently derive data from your Redux Store

A set of utilities for provider package.

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

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

Command pattern for Flutter that wraps sync/async functions as callable Command objects with automatic isRunning, error and result state exposed as ValueListenables.

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

Riverpod for Jaspr

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

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

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

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

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 reactive primitive and simple state managerment solution for dart and flutter

Flutter+Riverpod support library.

StateStream with Riverpod support.

riverpod_container_async test support library.

Riverpod Provider for path_provider

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

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

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

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

A reactive primitive and simple state managerment solution for dart.

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

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

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

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

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

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

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

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

A package for managing form state based on BLoC.

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

Official IntelliToggle provider for the OpenFeature Dart Server SDK.

Composable app, route, page, and viewport lifecycle for Flutter widgets.

A simple State Management solution for Dart applications inspired by SolidJS

Event Bus for Dart.

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

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

Package supporting bloc types for dispose_scope.

Redux.dart Middleware that prints the latest action & state

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

A simple State Management solution for Flutter applications inspired by SolidJS

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

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

Flutter package for the Model-Widget-BLoC pattern

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

A straightforward way to manage global state in flutter apps.

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.

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

A lightweight architecture helper for your Flutter projects.

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

Persist Redux State with custom storage engines and serializers

Flutter extensions and bindings for BlocSignal state management library.

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

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

Flutter widgets to replace multiple nested StreamBuilder widgets

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

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

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

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

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

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

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

Subscribable and observable pattern for the Solana Kit Dart SDK.

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

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

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

Shared package for the Serverpod Offline Sync project.

Init widget to execute initialization methods declaratively

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

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

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

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.

Redux Persist Flutter Integration with custom storage engines

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

OpenTelemetry instrumentation for `package:riverpod`. A ProviderObserver emitting short-lived spans for provider add, update, fail and dispose, so you can see your state graph.

Extended bloc with second stream of side effect value.

Hooks we often use, all gathered in one place.

Simple state management for Flutter with concurrency support.

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

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

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

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

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

Server data caching for Dart: cache API responses, deduplicate requests, refetch in the background, paginate, and mutate with optimistic updates.

A EventBus using RxDart

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

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

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

A flutter package that manages dispose callbacks and subscriptions cancellations.

Server data caching for Flutter: cache API responses, refetch in the background, paginate, mutate with optimistic updates, and keep data across restarts.

Runtime core of Cobalt, a dependency injection framework with hierarchical scopes, deterministic disposal and async init graphs.

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

Flutter bindings for Cobalt — scope providers, widget-owned child scopes and BuildContext resolution helpers.

基于provider封装的脚手架.

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

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

Lets an Cobalt scope close the blocs it built — a mixin that bridges bloc's close() to Cobalt's AsyncDisposable, and the function to name where a mixin will not reach.

Flutter bindings for the Talaria SDK — error hooks, zone bootstrap, navigator observer, and lifecycle tags.

go_router bindings for Cobalt — dependency scopes whose lifetime is a navigation flow, created on entry and disposed on exit.

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

A flutter package to manage application configurations via singleton pattern.

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

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.

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

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

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

A way to use Blocs and Cubits registered in GetIt with flutter_bloc's BlocProvider

Package for managing form state, in Flutter using Cubits. Includes validation, binding and error handling.

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.

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

A minimalistic Dependency Injection and Service Locator implementation in Dart.

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

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.

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

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

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

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

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 state management package to allow for retention and management while specifying the scope of the state.

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

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

A Time Traveling Redux Debugger for Flutter

A Flutter package to manage feature flagging.

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

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

Riverpod request and user scopes for Cloud Frog applications.

A flutter_bloc reimplementation based on flutter_hooks with the same API.

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

Simplified state management focused on animations

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

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

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

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

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

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

A state for StatefulWidgets that is aware of its visibility.

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

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

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

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.

A Undo/Redo Library for Flutter

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

The SMF module of events with event_bus for the Flutter app that SMF generates. Parts of the app that do not know each other exchange events through it.

The SMF module of dependency injection with get_it for the Flutter app that SMF generates. It registers the services that the modules of the app declare.

The SMF module that manages the state of screens with BLoC. It adds flutter_bloc to the Flutter app that SMF generates.

The SMF module that manages the state of screens with Riverpod. It adds flutter_riverpod and its ProviderScope to the Flutter app that SMF generates.

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

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

Flutter SDK for the TinyBase backend: auth, JWT refresh, collection CRUD, file uploads, and realtime SSE.

Flutter package to Fetch and display asynchronous data easily

A Flutter-native MVVM service layer that creates, loads, watches, shares, and disposes services according to the widget lifecycle.

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

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.

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

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

An easy to use value notifier wrapper with some sugar syntax

A library that makes FutureContext easier to use from hooks.

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

Wrapper that improves readability and solves the common refiring FutureBuilder problem

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

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

Kletso client for Dart and Flutter: sessions, realtime chat with typed surfaces, actions, context, triggers, voice and avatar state. Bring your own model key.

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

Backend-agnostic auth state machine & session lifecycle for Dart/Flutter.

A flexible, reactive, and type-safe Flutter form management library powered by flutter_bloc. Handles minimal to complex forms with ease.

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

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

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.

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

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

Write social apps with Flutter. This code connects to the backend of Locality Social Cloud to provide realtime state synchronization across devices.

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.

Making OverlayPortalController listenable.

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

Persistence & Event Sourcing Extension for Dactor - Industrial-grade event sourcing platform with hybrid architecture

A chat based on Locality Social Cloud that supported End-to-End encrypted Chats and GroupChats and Chat Message state management.

State persistence and hydration adapters for BlocSignal state containers.

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

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.

Application foundation for Flutter apps: fragment navigation with optional go_router sync, view models, token handling and common widgets.

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

A reactive state management library for Flutter, built around Signals and Nodes to simplify app logic and keep your UI in sync.

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

Flutter client foundation for kashi APIs, a Dio client with typed failures, single-flight token refresh, secure storage, and a Riverpod auth controller.

Explicit, scoped dependency injection for Flutter applications using Provider.

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

OpenTelemetry tracing instrumentation for BlocSignal.

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

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

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

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

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

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

Undo and redo state history tracking utilities for CubitSignal and BlocSignal.

An extension of leancode_cubit_utils that provides cqrs support.

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

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

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

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

Searchable, sortable, infinitely scrolling lists for kashi keyset APIs, with a directory controller and a Cupertino KDataList widget with pull-to-refresh and a sort sheet.

Offline-first sync for Flutter apps on Drift, with a transactional outbox with batched push and retries, and a cursor-based pull that never overwrites unsent edits.

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

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.

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

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

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

Universal model to represent basic UI states.

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

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

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

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

Flutter UI widgets for paginated lists, infinite grids, slivers, reactive forms, and screen state management powered by blocx_core.

A reusable Flutter chatbot package with API integration, session management, interactive options, and customizable UI.

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

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.

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

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

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

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.

Abstraction for fetching local or remote data via flutter_bloc

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

Dedicated Flutter DevTools extension UI for inspecting BlocSignal containers.

Umbrella package for the Mitosis reactive framework — Cell (core), Flow (orchestration), and Tissue (application) layers for Dart.

Hooks for Fuery: useQuery, useInfiniteQuery, useMutation, useQueries, and useMutationState for flutter_hooks, with useOnQueryChange and useOnMutationChange for side effects.

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

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

linter and developer tool for signals

Production infrastructure for Flutter applications — networking, auth refresh, caching, offline sync, diagnostics, and a debug inspector.

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

Orchestration Layer (Flow) for the Cell Framework — 90+ forensic-grade operators (asyncMap, switchMap, debounce) for reactive signal processing.

Easily scope providers to routes with GoProviderRoute and ShellProviderRoute.

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

Foundation layer of the Cell Framework — Cells, Nucleus, Context, Deputy Pattern, and Conactive execution with Causal Integrity.

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

A re-imagined declarative approach to application design and architecture

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

A lightweight, lifecycle-safe framework to manage singleton subsystems and services in Dart applications.

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

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.

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

BLoC for DuskMoon theme persistence (theme name + mode)

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

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

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.

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

drift storage adapter for CRDT LF library objects, providing persistence for Change and Snapshot objects.

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

ValueListenable/ValueNotifier for async operations

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

A Flutter package to display the data loaded with list_bloc.

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

Provision WiFi on Espressif ESP32 devices over Bluetooth LE from Flutter, with a Bloc API and native Android and iOS provisioning implementations.

Hive adapters for CRDT LF library objects, providing persistence for Change and Snapshot objects.

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

Riverpod interoperability adapters for BlocSignal state containers.

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

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

A flutter implementation of riverform using flutter_riverpod package.

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

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.

Flutter overlay for `otel_riverpod`. Re-exports the OTel provider observer and adds an `OTelProviderScope` widget that installs it on the root container with one line.

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

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

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

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

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

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

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

The core component for DashKit that provides basic architecture components

Self-optimizing state management engine for Flutter: clean domain architecture of BLoC, micro-rebuild precision of Signals, and register-level diffing speed of a hardware bitmask.

MCP server that inspects and injects state in a running Flutter app over the Dart VM Service, supporting route navigation and Riverpod, Bloc and GetX.

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

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

Flutter SDK for RiviumChat — headless chat-as-a-service powered by Centrifugo. Use with any state management.

Enterprise MVI + Command Pattern architecture for Flutter with declarative concurrency, strict decoupling, one-shot side effects, and zero code-gen.

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

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.

Riverpod Provider for package_info_plus

Entity State Management Package

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

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.

An improved version of FutureBuilder

A service-locator-based dependency injection solution for Dart, with scopes, modules, computed dependencies, and reactivity support.

Event bus for your app with extended types feature

Remote config for Flutter backed by Cloudflare Workers KV: in-app defaults, fetch and activate, typed getters and an offline cache.

Offline-first data engine for Dart and Flutter: a durable outbox plus a stale-while-revalidate cache. Pending edits survive restarts, eviction and retries.

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

Role-based access control (RBAC) for Dart: role inheritance, wildcard permissions, pluggable persistence and change notifications.

Render retained asynchronous state without owning or restarting the work.

Observable data holders inspired by Android LiveData, with lazy activation, mediators, history, storage, observable collections and widget builders.

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

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

A reactive state management library for Flutter, providing seamless integration between ViewModels, Widgets, and reactive observables.

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

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 state management library using the Observer pattern, optimized for notifying changes in collections.

Cubit Form

Simple service locator package developed in Dart, tinier alternative to get_it

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

A Flutter theme management library for dynamic theme switching with BLoC and ThemeExtension.

Analyzer plugin that enforces cohesive Flutter application architecture.

Stark - a pragmatic lightweight dependency injection framework for Dart

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

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.

Bloc wrapper over 'multicast_dns' which performs service discovery over multicast DNS (mDNS), Bonjour and Avahi.

DevTools extension and protocol models for inspecting UseCase Forge applications.

Observability providers/middleware for Routed (tracing, metrics, health).

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

Reactive event handler wrapper class inspired by ReactiveUI.

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

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

Compact Flutter state management with scoped DI, reactive values, Stores, effects, undo/redo history, streams, and composable async state.

Policy-driven coordination for remote and local repository data.

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

Service-locator-based dependency injection for Flutter, with modules, reactivity, and scopes bound to the widget tree but accesible outside it.

A production-ready CLI tool to scaffold enterprise-grade Flutter projects with a scalable, clean architecture template featuring GetX state management, Dio networking, secure storage, and modular feature-based structure.

Package simplificado para gerenciamento de estado efêmoro para widgets.

A gamified focus and anti-doomscroll productivity engine for Flutter apps with sessions, rewards, streaks, persistence, and Riverpod integration.

Flutter bindings for keyed_form: a scope, field and list widgets with selective rebuilds, caret-safe text editing, and scroll-to-first-error anchors.

A form-state controller for immutable aggregates, built on keyed_form_core: holds the working draft, FieldKey-addressed validation errors and touched/dirty/submit state.

A production-ready Flutter CLI and architecture kit for Clean Architecture, BLoC, API, and project scaffolding.

Bloc and Cubit integration for Lean DI, with state observable through context.watch and context.select.

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.

A simple state management solution that uses streams.

kirak's Flutter integration - a working, zero-config session default for Flutter apps.

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 distilled, high-performance micro-state management and scoped DI engine for Flutter.

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

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

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

A Flutter package for managing API states, loading, error handling, and data retrieval with enhanced global configuration.

Smart project structure with dependency injection and route management

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

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

A Flutter package for managing chat with support for messages, replies, user blocking, and real-time updates.

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

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

A scaffolding CLI for Flutter projects with feature-first architecture and BLoC/Cubit state management.

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

Container-scoped state management and dependency injection engine for Flutter. Features surgical rendering, async lifecycle guards, and type-safe DI.

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

A Flutter package for reusable and customizable tab bars with state management support using ChangeNotifier and Bloc. Includes flexible options for app bar, tab styling, and more.

Minimalist state managment

Flutter library for fetching, caching and invalidating asynchronous data.

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

A Talker logger integration for CherryPick DI to observe and log DI events and errors.

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

Translate your project 100% using signals

A lightweight, zero-dependency Dart package for tracking unsaved form changes with deep equality and defensive snapshots.

A Dart/Flutter package providing base BLoC and form submission states with Equatable support, following SOLID principles.

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

A re-imagined declarative approach to application design and architecture

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

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

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

A mutation implementation for the riverpod community - made by Theodo

A lightweight reusable Bloc architecture with centralized state handling, loading, error handling, and UI building.

The annotations for a small code generator for simple dependency injection via riverpod.

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

GgValue allows managing a value in a dart application. It provides a stream, a flag preventing too many updates, and a custom transform and a comparison function.

An offline-first cache and sync engine for Dart with optimistic mutations, reactive streams, and pluggable storage.

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

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

Minimalist state management and dependency injection.

A reusable BLoC-powered paginated list and grid with debounced search, refresh, and item updates.

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

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

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

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

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

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

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

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

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

A fork of vxstate with added features and improvements.

Flutter integration for Syncache - lifecycle management, widgets, and connectivity detection.

Flutter widgets for building and reacting to usecase_forge snapshots.

Deterministic test helpers for the pure Dart usecase_forge runtime.

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

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

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

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

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

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

A high-performance synchronous reactive graph engine for Dart. Features lazy evaluation, async isolation via Zones, and absolute memory safety with Cancellable.

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

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

A straightforward way to manage global state in flutter apps.

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.

Asynchronous data caching, refetching & invalidation library for Flutter

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

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.

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

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

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

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

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

Lightweight BLoC foundations for stream-based events, explicit states, concurrency policies, subscriptions, and disposal.

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 for managing comments with support for replies, likes, reporting, and user blocking.

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

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.

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

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.

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

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

Shared architecture for Impaktfull Flutter projects.

State management with one law: output = compute(input, state). Boxes with private memory, an explicit dependency graph you can render as a map, built-in persistence and caching. No code generation.

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 Flutter useRequest-style async request management library based on dio, flutter_hooks, and Riverpod.

Advanced tools for development using the BLoC pattern

Enterprise local-first sync framework for Flutter with offline sync, conflict resolution, and pluggable backends.

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

A easy and simple Implementation of the BLoC (Business Logic Component) Pattern in Flutter / Dart

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

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.

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

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

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

Flutter widgets for yx_state.

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

The package provides various generic implementations of blocs.

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

A simple way to organize dependency injection using modules.

A dart form implementation using riverpod package.

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

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

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

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.

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

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

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

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 dart-native turnkey solution for painless network synchronization

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

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

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

Action Hooks, a Flutter Hook for building asynchronous commands

Form is a Bond package provides a convenient way to handle Form using riverpod.

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 Control is complex library to maintain App and State management, Dependency Injection, Navigation with Routing, Localization and more..

Manage and synchronize concurrent tasks, preventing duplicate executions and race conditions while optimizing resource usage in Flutter apps

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

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

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

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

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

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

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

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

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

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

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

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

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

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

An implementation of a database engine for dORM using bloc and in-memory storage.

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.

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.

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

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

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

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

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

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

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

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

A lightweight Flutter SDK for connecting apps with Hosteday APIs, including authentication, user requests, custom endpoints, and realtime support.

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.

Reduce the massive amount of boilerplate for Flutter redux application

A Flutter package that simplifies async UI state handling (loading, success, error, empty) with built-in retry and pull-to-refresh support.

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

Initialize a package's config and dependencies as one graph, and read them from a typed package context.

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 Dart implementation of CASL.js for managing access control in Flutter apps with dynamic permission handling.

Lightweight and reactive state management solution for Flutter.

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

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

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

Flutter widgets for mux, a request-keyed state channel.

An integration of signals into the impulse_flutter package.

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

A lightweight Riverpod CRUD helper for loading, error, refresh, pagination, create, update, and delete states.

A Flutter package that provides offline-first HTTP request handling with automatic synchronization when internet connectivity is restored.

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

Simple Event Notifier - Send notifications from anywhere to anywhere. No requirement that there is a listener nor a publisher

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

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

Minimalist state management and dependency injection.

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

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

fbroadcast 飞猪 空安全版本

Reactive state management framework for scalable flutter applications.

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

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

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

Ultra-simple offline-first Flutter package. Just get(), save(), and syncAll(). Automatic local storage with Hive, manual sync when you want.

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

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

A thin application framework for flutter making use of async_redux

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

Request-keyed state channel with a retained per-key cache. Pure Dart.

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

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 that simplifies adding localization to your Flutter app.

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

A lightweight reactive state management and dependency injection library for Dart and Flutter — pure and minimal.

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

A state management framework for Flutter using RxDart and MVVM.

Computables are composable, streamable values.

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

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

Annotations for rxget code generation. Use with rxget_generator to eliminate GetxState boilerplate.

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