The main idea behind Redux is that the state of whole application is stored in a single global "store", and modification to the state are made by using "actions" that are dispatched to the store. The store then updates its state based on these actions and provides the updated state to the React components that need it. This architecture makes it easier to manage the state of a complex application, and ensures that the application's behavior is predictable and easy to debug.
React-Redux is designed to work with the Redux state management library and provides bindings and utilitis for using Redux with React.
For example, it provides a higher-order component called "connect" that you can use to connect your React components to the Redux store, and a set of hooks that you can use to access the state and dispatch actions directly from your components.
By using React-Redux, you can take advantage of the benefits of both React and Redux, and build scalable, maintainable applications with a clean and organized codebase.
In Redux, an envet handler dispatches an action, then prcossed by reducer.
Xstate is Finite State Machines and Statecharts for the Modern Web.
It's often used for creating, interpreting, and executing finite state machines. It provides a powerful and flexible way to model the behavior of applications, from simple client-side control UI to complex state machines. XState can be used to create state machines for anything from interactive interfaces, to async processes and event driven systems
Xstate Visualizer makes state management so easy. Each arrow is an action that tracks the state modification.
Zustand is a small, fast and scalable bearbones state-management solution using simplified flux principles. It is designed to be performant and easy to use, and has gained popularity among React developers as a lightweight and effective solution for managing state in their applications.
Zustand provides a simple and lightweight API for managing state in a React application. It allows developers to create stores that hold data and can be accessed and updated by components within the application.
Zustand is built on top of React's built-in Context API. It makes hooks the primary means of consuming state and you don't need to wrap your app in context providers.
Zustand use hooks to manage React's Context API.
MobX is a battle-tested library that makes state management simple and scalable by transparently applying functional reactive programming.
MobX is a library for reactively managing the state of applications based on functional reactive programming. It provides tools to make the development of complex, data-driven user interfaces more manageable and efficient, as well as allowing developers to detect changes in their applications more effectively.
Additionally, MobX provides observables, computed values, and other state-management tools that track any changes to the state of the application in real time and can be used to create reliable and predictable applications
In mobx, event fires an action that updates observable state. Changes in the state are propagated to side effects.
Recoil - A state management library for React
👻 Next gen state management that will spook you
💊 Valtio makes proxy-state simple for React and Vanilla
Opinionated, transactional, MobX powered state container
Yet another React state management library that lets you work with local state and scale up to global state with ease
Compose render prop components
200 bytes to never think about React state management libraries ever again
A Reactive State Management Tailored-Made for JS Applications
State so simple, it goes without saying
Easy Peasy is an abstraction of Redux, providing a reimagined API that focuses on developer experience. It allows you to quickly and easily manage your state, whilst leveraging the strong architectural guarantees and extensive eco-system that Redux has to offer.
Business logic with ease
The flexible, fast and extendable state management for React that is based on hooks and state usage tracking.
A flux implementation. Flux is an application architecture for building complex user interfaces.
Frictionless state management. Overmind aims for a developer experience where that is all you focus on, reducing the orchestration of state management to a minimum.
A tiny state manager for React, React Native, Preact, Vue, Svelte, and vanilla JS. It uses many atomic stores and direct manipulation.
Elf is a reactive immutable state management solution built on top of RxJS. It uses custom RxJS operators to query the state and pure functions to update it.
A tiny event-based Redux-like state manager for React, Preact, Angular, Vue and Svelte.
Share React hooks state between components.
Composable state management for React
A MobX powered state management solution based on data trees with first class support for TypeScript, snapshots, patches and much more