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

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

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.

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

A simple way to access state from anywhere in your application while robust and testable.

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

RxDart is an implementation of the popular reactiveX api for asynchronous programming, leveraging the native Dart Streams api.

A simple way to access state from anywhere in your application while robust and testable.

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.

Injectable is a convenient code generator for get_it. Inspired by Angular DI, Guice DI and inject.dart.

A simple way to access state from anywhere in your application while robust and testable.

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

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

A simple Event Bus using Dart Streams for decoupling applications

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

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

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

a simple yet powerful state management technique for Flutter

Redux is a predictable state container for Dart and Flutter apps

The seamless way to work with persistent data models in Flutter. Inspired by Ember Data and ActiveRecord.

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

ValueNotifier, but outside Flutter and with some extra perks

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

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

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

Redux without the boilerplate, tailored for Flutter. Easy to learn, to use and test. Allows for both sync and async reducers.

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

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

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.

MVC pattern for flutter. Works as state management, dependency injection and service locator.

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

Just a package with bases to deploy the BloC your code. Modules, Consumers And BLoC!

Automatic Dependency Injection System, but without build_runner

ASP (Atomic State Pattern) is a extension to ValueNotifier by transparently applying functional reactive programming (TFRP)

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

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

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

flutter_bloc state management extension that integrates sealed_unions.

Project that allows you to use get_it as a dependency injection but controlled by Flutter's lifecycle, registering and unregistering in page navigation.

A super simple dependency injection implementation for flutter that behaves like any normal IOC container and does not rely on mirrors

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

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

flutter_command is a way to manage your state based on 'ValueListenable' and the 'Command' design pattern.

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

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

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

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

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

Persist state across app launches. By default this library store state as a local JSON file called 'data.json' in the applications data directory.

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

An rx like extension methods on ValueListenable type, that lets you work with ValueNotifiers almost like with Streams

A pragmatic lightweight dependency injection framework for Dart projects.

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

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

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

Flutter bindings for state_notifier, such as StateNotifierProvider and StateNotifierBuilder

A simple State Management solution for Dart applications inspired by SolidJS

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

Extends blocs with an additional stream which can serve as a way of indicating single-time events (so-called "presentation events").

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

A state management library that provides a simple solution for updating state and navigation.

A simple State Management solution for Flutter applications inspired by SolidJS

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

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

A dart package that helps implement the BLoC pattern. BLoC works in Isolate and don't slow down UI.

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

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

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

Unified facade for the basic features of state management frameworks.

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

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

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

FQuery is a powerful async state management solution for flutter. It caches, updates and fully manages asynchronous data in your flutter apps.

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.

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

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

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

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

introducing a new type in getx called RxFuture to listen to future state.

A stateless stateful state management package that is not stateless.

VxState is an another state management solution for flutter. It is highly inspired from Redux & VueX.

A flutter_bloc reimplementation based on flutter_hooks with the same API.

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

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.

Service locator for IoC pattern. Export annotations and abstract classes used by injecteo_generator.

A wrapper for the observer pattern for Dart in the style of the iOS Notification Center.

LiveStream is a simple class which makes communication easy among different modules of your application.

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

Redux.dart Middleware that prints the latest action & state

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

Asynchronous data caching, refetching & invalidation library for Flutter

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

Event Bus for Dart.

Remote DevTools for flutter_bloc. This package connects all Bloc to the Remote Devtools Server, allowing the developer to inspect changes to the Blocs during runtime.

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

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

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

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

Provides a simple way to re-use behaviors across StatefulWidgets. Improves readability and robustness of your components.

Support for marking objects as observable

Redux Persist Flutter Integration with custom storage engines

Redux implementation based on Dart Stream, with the power of RxDart. Reactive redux store for Dart & Flutter.

The goal behind is to move as much of the state and logic from the ViewState into a separate entity called the ViewModel.

state management package built on top of InheritedWidget, that aims to simplify the state managementm work for flutter developers and perofrm the task using the minimal resources .

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

Efficiently derive data from your Redux Store

Segmented State Pattern for MobX

A set of tools for MobX that helps you with common processes making everything easier.

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

A convenient, stream-based Flutter architecture

Minimalist and Easy State Management for Bloc Inspired from Dart Generics.

Lets you use Provider with Redux. Uses AsyncRedux, the non-boilerplate version of Redux.

Tools for building applications using the bloc state management library.

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

package for binding the UI with your stores (viewmodels) easily , the package is inspired by filled stacks archticture pattern

A set of mixins and extension methods as an alternative to ListenableBuilder / ValueListenableBuilder, good for state management.

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

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

A library that provides components for more easier and boilerplate implementation of the BLoC architecture pattern.

A command line tool for Riverpod

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

The modular state management solution for flutter.

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

Compile-time safe and easy to manage service locators.

A state management library written in dart that enforces immutability

Powerful, yet simple, asynchronous state management for Flutter

Flux library for Flutter, featuring unidirectional dataflow inspired by reflux and Facebook's flux architecture.

A pragmatic lightweight dependency injection framework for Flutter developers.

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

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

Another way to build Flutter applications for mobile, web and desktop using Karee Architecture.

Simple Architecture for Flutter apps with Dependency Injection, Mediator Pattern and Observable Streams

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

Flutter Dependency Injection library based on dotnet ServiceProvider

An easy and safe DI (Dependency Injection) solution for Dart with support for scoping.

A simple, fast state management & service container solution for Flutter, without acrobatics.

A simple state management machine for Flutter.

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

Pulse X is the mini state management. It has four features - state management, context-less routing, dependency injection & reaction (side effects)

A set of helpers for pragmatic state handling as mentioned in my Medium article.

Making blocs easy again. A simplified library for the original bloc approach.

A BLoC implementation for sequentially executed async state updates.

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

Utilities for implementing beyond architecture patterns

Karee core files, Karee core represents a set of amazing libraries, that work together to offer very powerful MVC experience in Flutter App Development

Implemented using the MVVM architecture, quickly build projects to help consumers focus only on the business implementation

A mixin which automatically persists and restores store state.

A widget to create and manage BLoCs implemented on top of ValueNotifier, such as StateQueue.