Alternate Approaches and Variations
redux-controller helps to generate controllers (functions) with access to (dispatch and getState) redux functionality without binding to React components.
Library for creating a controller layer to link React and Redux, on top of react-redux.
Experimental redux-like state management with actions and reducers combined into reducer actions
A store/action subsystem for redux.
Enhanced version of redux' connect that puts action creators in the child context
React-ViewModel make it possible to write 'ViewModel' classes to reorganize code for reducer implement in Redux.
Self contained components and enhancements for Redux
Opinionated JS framework for React/Redux based applications.
Redux Model Utilities
A set of model-building utilities for Redux apps. Atomic actions and reducers, easy connection to React components, direct read-only access to the model state, subscription change notifications.
Code to support a viewless, action driven architecture
Create class-based APIs that hide the fact that Redux is being used.
Wrap components with a smart component and later assign providers (i.e., stores and action creators) to it.
Organize your redux stores in a tree-like structure. redux-trees are tree-like structured schemas where the leaves are either another redux-tree or a redux compatible reducer (not both).
Build completely modular applications with redux
Build two way binding with Redux and Immutable.
A streamlined approach to managing your Redux action creators and reducers. These observations have landed us on a pattern where you group related action creators and reducers into a single file, which we call an interaction.
Batching react-redux alternative with reverse subscription order. Exposes Provider and connect with api similar to react-redux
Gambit is a hyper-thin library designed to make building API driven apps with Redux/React easier. It is not a Redux replacement, it is a library built on top of Redux.
The sole purpose of Remerge is to provide a consistent interface for defining and manipulating state. It's extremely easy and intuitive to use once you get the hang of it. While there is a slight learning curve, hopefully our examples will ease the learning process. Although Remerge was built for use with Redux, it can also be used standalone.
A react-redux plugin that facilitates changes to the state and backend data sources.
Radical is a client API framework, designed to simplify the creation and maintenance of React/Redux applications. Radical allows you to model your client API and state via the composition of Actions and Namespaces.
A library that removes a lot of the boilerplate necessary to use redux.
With redux-direct you can use your action creators directly inside the reducers instead of having to define string constants for each action.
Toolkit for building redux/react applications. Easy to understand objects instead of crazy functional composition. Bundle groups of middleware, enhancers, and reducers together as "plugins". Dead simple Component API - use ES6 classes, bring back sane behavior, bind component functions scope to class (like old react), never write mapDispatchToProps or mapStateToProps.
kea-logic lets you create logic stores, and access their contents from React components as props. Logic stores consist of 1) actions, 2) reducers, 3) selectors and 4) optionally sagas. Logic stores augment your components, are stored in redux, and are connected via ES6 imports.
The Cerebral signals running on Redux
Make redux reducers more easier to define by using Flux-like features.
Efficient and descriptive Redux React binding. Unlike connect in react-redux, redux-observe-store-path will update tree leaf component directly, rather than passing down props at each level. This way we can skip middle level components and directly update deeply nested components.
Automatically conduct event traffic through Redux by reacting to actions
Redux Action Thunk
Move your actions & types into Redux middleware. No more importing actions & types. Instead, register your actions on startup and call them by dispatching strings. Redux Action Thunk (RAT) allows you to write more modular Redux code.
Redux Realtime CQRS is a library that lets you convert a traditional request/response rest api into a Real-time api with CQRS
Redux middleware that lets you define async/sync actions as ES6 classes.
Redux middleware that lets you define actions as meaningful units, without OOP.
Simple views and bindings to redux, with d3.js in mind
Small (12kb), batteries-included redux stack to reduce boilerplate and promote good habits.
A layer on top of redux for describing data flow throughout your application in a revolutionary way.
A minimal way of providing redux state to react components that doesn't use context
The core of Redux is simple. But it comes with a big ecosystem, middleware, action creators, selectors and other things attached that slow down development - a single change in specs shouldn't require changes in 5+ locations to implement. redux-plus makes developers more productive by finding one place for all state-related code: the reducer.
Make your redux more friendly by adding conventions and writing less code! Combine actions and reducers into a interactor class; Dispatch action in a interactorName:method format (eg. this.dispatch('counter:double')); Handle an action by defining methods in the interactor
OOP implementation of redux and react. It uses plain react, redux and react-redux. No functionality is changed or added to these libraries. It's only a way to organize your app with a bunch of helpful classes. Also it solves the problem with multiple stores and binded action creators.
A simple Polymer web component that allows a more declarative use of Redux.
Automatic actions, reducers and validation for Redux. Designed to make using the immutable state easy to use while keeping the state serializable.
Remove cognitive load by moving prop mapping into the component, by using static method references.
Yet another react redux integration only with stateless function components.
Defining your Redux reducers and actions using ES6 class syntax.
ORM-like API to access Redux store state
react-redux for your vdom library. Make your vdom-based development flow easy, with virtual-dom or snabbdom. Convenient utility(only ~100 line) for Redux. Automatically memoize your render function for better performance!
Simple utility to faciliate mapping and binding action creators / states to classes. Reduce the boilerplate of "mapStateToProps" and "mapDispatchToProps" !
A customization of react-redux designed for cases that want to access sub-tree of the state
Jumpsuit is a powerful and extremely efficient Front-end framework & CLI. It is the fastest way to write scalable react/redux apps with the least overhead. No boilerplate; Dedicated build system; Scaffolding tools; Minimal API; Simple and scalable state management based on Redux.
Jumpstate is a dead-simple state machine for Redux and Vanilla JS that packs some serious power. Extracted from the Jumpsuit library.
Redux bindings for Vidom
Easy change redux state for ui without creating constants and actions
Library to build models layer backed with redux-saga
Easily define your models using standard redux libraries (redux, redux-actions, redux-thunk).
An abstraction layer around handling normalized entity storage and data fetching with redux
Functional programming helpers for Redux. Uses curried "action-first" reducers, known as "updaters", similar to Elm.
Relax provides simple and familiar yet scalable organization of your React/Redux applications.
Feeble is a framework built on top of React/Redux/redux-saga which aims to make building React/Redux applications easier and better. If you are familiar with React/Redux/redux-saga, you'll love Feeble
Streams a singleton selector result to one or more contexts (components or objects) within a react-redux application.
React and redux based, lightweight and elm-style framework. (Inspired by choo).
Rapidly configure Redux or React Redux.
A new way to work with Redux inspired by Alt
Object-oriented React binding for Redux
A library for defining "branches" - local stores whose state is merged on top of the parent. This allows each component to have its own Redux store while still being able to interact with the parent store.
A redux store enhancer for adding selectors inside the store. Provide a withSelectors function that take a schema of your selectors, a store and return a new enhanced store. This will allow you to centralize all your selectors in the redux store, and call them by using getState()
Petiole embraces the idea of Redux reducer bundles, better known as ducks, but takes them further with uniform construction function and throws support for selectors in. In Petiole these bundles are called leaves -- they are the leaf nodes (end-nodes) in our state tree.
A utility method to make it easier to subscribe to a Redux store from a React component.
A Redux add-on that brings back the clean, minimal-boilerplate syntax you enjoyed with classic Flux libraries like Alt, Reflux, and Flummox, along with better TypeScript support
Redux action/reducer wrapper that hides synchronous reducers implementation. redux-quick-action helps abstract type strings, switch statements in reducers and many other implementation details away from you.
Working with redux through models. Involve OOP in redux. Do it more power and add DRY.
FeathersJS client that hooks into your Redux store. Create models that emit actions whenever the socket connection to the service receives any CRUD events.
Easier Redux Action/Reducer creation. Create actions and reducers all at once, in one place, for less duplication and cleaner, more readable code.
Simple wrapper around react-redux. It allows to use different nested Providers by specifying a custom store name.
redux-modules is a refinement on the Redux module concept with developer experience in mind. It provides An intuitive way to define actions and state transformations, and a modified Redux Provider that dynamically registers new reducers as connected components are mounted.
Simple to use XHR fetching and model-oriented utility functions. Most applications have common and consistent needs. Load data using XHR and know the fetch status so it can be represented with a loading indicator. This lib provides action creators, reducers and React component wrappers that work with each other to simplify and DRY up your code.
An class-based system for creating Redux reducers
Alternative redux api/usage. Main purpose of playing around with this is to get rid of more of the "plumbings" needed when creating the "redux" part of our apps. Easily call auto bound actions without importing or needing the dispatch method and enhanced reducer creator that has helper methods that we are always using
Redux-Jian is a library aiming to simplify how to use Redux. Jian means 'simple' or 'simplify'. Declare mutators (action creators) in one singleton, and you can get a mutator by its name anywhere. It's highly decoupling and easy to use. Bind mutators to Redux store once, and you'll no longer need to use mapDispatchToProps in the connect().
React UI generated from redux state
Module and util framework for redux. Introduces an abstract module construct for redux. Allows modularization of functionality and easy plug and play workflow
Key-value util component for redux and redux-react usage
Wire components directly to redux state without using containers.
A React+Redux framework with standards, conventions, and far less boilerplate
Connect state and actions to props declaratively
Redux action creator without string constants and less magic
A middleware for dispatching actions which contain string lookup paths of data to update.
A redux store enhancer adding selectors inside the store.
A helpful set of functions for connecting redux state to react components.
Connect react components to redux store using component static props
Wraps the connect function from react-redux to enable passing an object in place of a mapStateToProps function.
Decoration for redux, that gives him the ability to distribute events.
redux-synapse is a library that is heavily inspired by react-redux and acts as an alternative for the binding of react components to the store in a more explicit manner. The primary difference is the nature in which each component must declare explicity what updates should affect the component via its higher order component; a synapse.
Introduces a PropMap class to make connecting state and actions to components cleaner
A component way to integrate Redux and React. Provides a easy way to make components depend on Redux store structure, by creating it on-the-fly.
Redux bindings inspired by Domain Driven Design principles. Along the lines of react-redux, redux-ddd provides Redux bindings for generic domain-specific components.
Define your collections layer over redux state, with mixins to fetch, submit changes to your server. Wraps Redux in a Mongo collection interface.
React Redux Connected
React Redux Connected is an opinionated layer on top of react-redux that provides a simple props driven way to connect components.
redux-updeep is a small reducer generator that uses updeep to immutably deep merge partial updates into the reducer's state. It's great for reducing boilerplate in your redux actions and reducers!
A self contained Redux state management library that allows modular construction.
Enhances a Redux store by adding a
store.on()function, similar to pubsub/event-based programming.
Abstractions for interacting with Redux state by using Ramda lenses.
More controllable management, less noise for redux actions and reducers
slim-redux is an alternative interface for redux which aims at making working with redux less decoupled and a lot faster while being 100% redux compatible.
React bindings for RxJS and Redux - a higher order component that serves as an alternative to react-redux connect.
Simple redux container for react component
A simple package that aims to relieve you from the pain of opening multiple different files and write a lot of boring code each time you want to add a small feature when you're using react and redux.
Toolkit for building redux/react applications. Spend time building applications rather than wiring modules together.
Static initialization for Redux. This allows you to define your actions and state in the same static way that you define
React/Redux are going reactive with RxJS by means of this small library
A simple take on Redux, which generates reducers that respond to "UPDATE" and "RESET" actions
This package exposes an api that extends the standard redux offering. redux-em provides a more opinionated and simplified style of writing redux logic.
A reducer helper, primarily intended for use with the DVA Redux-based framework, but can also be used with Redux
Redux without reducers. Includes a redux middleware and store enhancer that maps url's to state, using a single "invisible" reducer.
Redux Action Creator Binder - an application dispatcher service/helper for Redux infrastructure.
Helpful function for connecting redux state and actions to React components. This function implements the same core functionality as react-redux-connect-helper's connectStateValue, but by building up mapStateToProps and mapDispatchToProps arguments to be passed to a single connect call.
Allows dispatching state update functions.
Classes for wrapping up a Redux store and setting its state
Lightweight version of the react-redux library
React-redux's connect function with additional shorthand syntax
Uses RxJS to provide live queries of the Redux store to components
connect, and allows defining dynamic actions and components based on the context of the application
A thin layer wrapping react-redux tools to simplify creating more powerful React containers.
An opinionated layer on top of react-redux that provides a simple props driven way to connect components.
Apply a redux reducer and an action at the specified path of your application state tree
A simpler interface to redux's connect with common utilities built in
Create a redux store, which is context-free, for a single container component. Let's use actions and reducer instead of using this.setState! Also, lots of sugar is inside by default. Binding actions to dispatch, composing enhancers and applying middleware become much easier
A library that tries to abstract the low-level usage of Redux, without the need to write actions or action creators.
Abstractions around Redux for state management in React
An extension to Redux that facilitates a cause-and-effect programming paradigm, and significantly reduces redux and react-redux coding.
Automatically generate Redux stories and actions from your folder and file structure, using Webpack's context.
Provides a context-free alternative to the connect function and the Provider component from react-redux, based on a declarative dependency injection API for Redux application powered by decorators, and the power of TypeScript and InversifyJS.
Bringing class-style reducer factory to your redux stack.
Manage your redux store, reducers, sagas in domains
Redux abstraction for state management in React
Help to connect to native React Component State
Reducer logic and a higher-order component for managing model classes
Automatically maps your action creators to your Redux store, and provides them to the child components through this.context.actions. This saves you writing mapDispatchToProps boilerplate in every component.
Redux requires too much boilerplate - let's use it as a primitive! Builds lens-based reducers and action creators using Ramda.
Reactions simplifies actions and reducers: actions and reducers defined right next to each other, no need for action type strings, no need to worry about not mutating the state, no need to wire togethe a reducer hierarchy, and in fact you don't define reducers - you just define functions that return a state slice.
A simplistic alternate approach to https://github.com/procore/redux-modules.
Command/Event Proxy for Redux
High performance data engine maintaining complex immutable state for reactive applications. Fully integrated with Immutable.js, Redux, and Meteor. Define a schema for your entire app state, and Duxen compiles the schema to generate reducers and action creators and handles the state using Immutable.js.
Another library for dispatching class instances as actions
Reusable Redux without boilerplate, by defining "state classes" for reducers.
Taming Redux with modules. Remodule works the same as Redux but removes the tedious tasks of organizing, splitting and collating files. Also does away with the need for constants.
Shorthand for react-redux�s mapStateToProps. Need some props? Just select 'em!
Global store for partial Redux apps.
react-redux is a remarkable piece of battle-tested engineering with a work-of-art API. This... is not that. This is a so-simple-it's-almost-dumb connector for redux stores which uses MobX to hook stuff together.
A store setup wrapper that includes the ability to dynamically add middleware and reducers.
A thin wrapper around Redux that exposes an API inspired by Event Sourcing.
Microframework for structuring code of React/Redux applications, by adding a Controller class and Containers to connect them to the view.
Yet another store using redux. (Inspired by vuex and dva)
Redux, minus the boilerplate. Redux is amazing, but the verbosity (const definitions, switch statements in primary reducers, etc) and fragmentation of the redux definitions can be painful to implement. This module adds a heap of magic with just enough flexibility to be useful. It basically just removes the repetitive parts and simplifies the cutting and pasting.
Redux extension with O(1) speed and dynamic importing of reducers/actions.
A simple and powerful React framework with minimal API and zero boilerplate. (Inspired by dva and jumpstate). Mirror is a front-end framework based on React, Redux and react-router. It encapsulates state management, routing and other essential things to build web apps together in very few methods, and makes it much easier to use:
Fantasyland-redux is a fork of Redux. This library is based on the observation that it is possible to add state selectors to reducers while maintaining all the same operations we're used to from Redux. We add map and other operations from the fantasyland spec to reducers, while remaining backwards compatible with react-redux, redux-thunk and other middlewares, as well as with automatically adapting Redux style reducers.
Boilerplate eliminator for React projects using Redux. Skip action creators, and create reducers with classes.
Redux Controller Pattern. Reduces boilerplate by introducing a Controller to manage specific slices of the store, actions, reducers, and selectors.
Simple, minimalistic and flexible way to organize redux logic
Atomic state management inspired by redux, observables, and optics.
Simple, intuitive, composable state management for React apps. Inspired by dva, based on redux, redux-loop.
Bind actions to changes in your Redux state based on the needs of your active Redux components.
A lightweight redux middleware to decouple and serialise state dependencies.
A Redux store enhancer for computing derived state by binding selectors to a Redux store, so that getState() incorporates derived data.
Want to use redux without using react ? Redux Component is a native implementation of react component which permits to watch your state and trigger render() method of your child component whenever it changes. It also has the ability to render only when parts of the state change.
Functional library for separating state & behavior from react components. This library aims to help keep your React components clean by providing a consistent pattern for managing redux mapStateToProps/mapDispatchToProps boilerplate.
An addon library for Redux that enhances its integration with TypeScript. Redoodle includes a few major categories of addons that can be used individually and play well with each other: Typed Actions, or "finally my reducers will stop breaking when I refactor"; Compound Actions, or "my action creators are finally sane"; Immutable typesafe state manipulation functions; Some opinions on state management.
A class-based Redux reducer.
Class-based controller logic linked to a Redux store
Redux with less boilerplate, actions statuses and controlled side-effects in a single shot. No more action creators and action types, just actions and reducers; actions dispatch their result automatically; error status for every action with no extra code; busy status for every async action; cancellable actions.
Wraps up React components and Redux stores with a Vue/VueX inspired API.
Powerful redux wrapper to make handling redux actions and reducers a breeze!
Shortcuts for Redux. Provides classes to wrap reducers and stores.
Creates a wrapper for Redux stores to handle action types both when dispatching actions, and in the reducer functions instead of the user. The name of the channel would be the type passed along to the store on a dispatch, and the manager would select and call the matching channels subscribers to handle state change.
Lightweight front-end framework for creating React and Redux based app painlessly. Based on Redux, Redux-Saga, and React-Router, inspired by dva.
Uses propTypes declared in the Component to link state properties or actions (dispatch is automatically added) to Component. The library will bind properties by listing state and actions object keys.
A suite of opt-in, high-level abstractions on top of Redux, using annotations on classes to reduce boilerplate.
React Redux Props Helper
Simple module for mapping state and dispatch to React props by name
Class-based action creators and reducers to help with Redux wiring
Brings structure to a Redux application. Actions, reducers and middleware in one file, action consts defined only once, clear structure, payload validation.
A Redux wrapper that provides state path subscriptions, a reducer registry, and more.
reSolve is a framework for developing apps based on CQRS and Event Sourcing, with React + Redux on the client. It can help you easily overcome the differences between your domain and technical languages, and focus on your application code.
Higher Order Component to allow you to use Redux without the need of a single root provider
A tiny React-Redux
Embed selectors in a Redux state tree. This is a convenient way for components to share selectors that are used widely throughout an app.
A small library (~20 loc) for creating action/reducer combinations, also known as reactors, which are reducers inside of actions.
Rematch makes Redux both easier to work with and more scalable. Helpful for both small and large applications. View agnostic - works with React, Vue, etc.
A react/redux library which automates all redux flows.
A simple framework based on redux, redux-saga, redux-action.
Based on the redux, redux-saga, and react-redux packages, McCree provides an easy way to organize state, reducer and effect as Model .
A wrapper for react-redux's connect to allow execution of multiple actions in a single procedure
A set of utility functions to make it easier to use Redux. No string constants, no reducers with switch statements, no nested reducers.
A refinement on the Redux module concept with developer experience in mind. It provides: a concise, intuitive way to define actions and state transformations; action creator middleware for transforming actions before they're dispatched; a decorator that handles mapping state and actions to components; a modified Redux Provider that dynamically registers new reducers as connected components mount;
Allows dispatching a
setStateaction that either contains an object to merge in, or a reducer function that updates the state.
A more declarative approach to working with Redux without writing numerous HoC containers. Uses a component based approach and children functions similar to approaches in react-motion and react-router.
Clean state management for your Redux store based on "updaters", with Firebase integration
Redux enhancer to access selectors directly from state as getters.
Redux Knife Manager is the lightweight library for easily managing, encapsulating and generating the redux entities such as action, reducer, selector and so on.
A framework for creating React + Redux apps using the domain driven design (DDD) paradigm.
A library that aims to separate commands from events instead of have just actions. Using this libraries all redux actions becames events and events are generate just by commands.
A small, simple and immutable model to manage data in your Redux store.
Redux enhancer to access state props and selectors via a simple store.get() method.
A library for making development with redux more comfortable and efficient via decorators
Provides multistore functionality for a redux store using redux-observable
A proxy-based state memoization library, with small wrappers for
connectthat encapsulate using it for your
Inject redux into react context
Dualism to Redux. Two-way combining of redux modules.
A dead simple React store that can easily be updated and accessed from any React component. Built on top of Redux so the devTools extension can be used. Follows Redux's philosophy of never directly mutating state and always returning a fresh state on updates.
A tiny and unobtrusive state management library for React and Preact apps
Simple React functional setState
Redux without the actions and reducers
Relessjs = Redux - Actions. Call the reducer directly. Redux without the maintenance. No more need to update Actions, Names, Constants, and Reducers' switch-cases in multiple places.
Repatch is just a simplified Redux, that let you create actions more briefly by dispatching reducers directly.
Redux without reducers
A paper-thin, 100% typesafe Redux for babies
Stent is combining the ideas of redux with the concept of state machines
A very small, simple library for managing state in a Svelte app. Steals the most useful bits from redux and react-redux and presents them as a single library with no dependencies.
Another take on redux that combines elements of flux for clarity and convenience including a global dispatcher for actions. It also makes use of ES6 features including inheritence and class notation for reducers.
a redux-like library for managing state with simpler api (1kb)
An Elm-like redux alternative inspired by Hyperapp, Elmish, Elm, Redux, etc.
A tiny ~650b centralized state container with component bindings for Preact.
A high-level, declarative, composable form of Redux