variations.md

Alternate Approaches and Variations

• redux-controller
  https://github.com/lexich/redux-controller
  redux-controller helps to generate controllers (functions) with access to (dispatch and getState) redux functionality without binding to React components.

• react-redux-controller
  https://github.com/artsy/react-redux-controller
  https://www.reddit.com/r/reactjs/comments/3z13qs/new_library_reactreduxcontroller/
  Library for creating a controller layer to link React and Redux, on top of react-redux.

• Redacs
  https://github.com/daniel-lundin/redacs
  Experimental redux-like state management with actions and reducers combined into reducer actions

• redux-store
  https://github.com/bingomanatee/redux-store
  A store/action subsystem for redux.

• react-redux-connect-context
  https://github.com/qwtel/react-redux-connect-context
  Enhanced version of redux' connect that puts action creators in the child context

• redux-viewmodel
  https://github.com/tdzl2003/redux-viewmodel
  React-ViewModel make it possible to write 'ViewModel' classes to reorganize code for reducer implement in Redux.

• Replux
  https://github.com/gregthebusker/replux
  Self contained components and enhancements for Redux

• Reductor
  https://github.com/mbensch/reductor
  Opinionated JS framework for React/Redux based applications.

• Redux Model Utilities
  https://github.com/jbellsey/redux-model-utils
  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.

• Vada
  https://github.com/xogeny/vada
  https://medium.com/@mtiller/encapsulating-application-logic-with-reactors-392635763e7
  Code to support a viewless, action driven architecture

• redux-apis
  https://github.com/Download/redux-apis
  Create class-based APIs that hide the fact that Redux is being used.

• react-redux-provide
  https://github.com/loggur/react-redux-provide
  https://medium.com/@timbur/react-automatic-redux-providers-and-replicators-c4e35a39f1
  Wrap components with a smart component and later assign providers (i.e., stores and action creators) to it.

• redux-tree
  https://github.com/dashed/redux-tree
  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).

• modular-redux
  https://github.com/ariporad/modular-redux
  Build completely modular applications with redux

• redux-2way-binding
  https://github.com/roderickwang/redux-2way-binding
  Build two way binding with Redux and Immutable.

• redux-interactions
  https://github.com/convoyinc/redux-interactions
  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.

• redux-simple
  https://github.com/barbuza/redux-simple
  Batching react-redux alternative with reverse subscription order. Exposes Provider and connect with api similar to react-redux

• Gambit
  https://github.com/Ghirro/gambit
  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.

• remerge
  https://github.com/siawyoung/remerge
  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.

• two-way-rest
  https://github.com/l2silver/two-way-rest
  A react-redux plugin that facilitates changes to the state and backend data sources.

• Radical
  https://github.com/nathan-rice/radical
  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.

• redux-nimble
  https://github.com/bodyflex/redux-nimble
  A library that removes a lot of the boilerplate necessary to use redux.

• redux-direct
  https://github.com/LiquidLabsGmbH/redux-direct
  With redux-direct you can use your action creators directly inside the reducers instead of having to define string constants for each action.

• Tango
  https://github.com/Graf009/tango
  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
  https://github.com/mariusandra/kea-logic
  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.

• redux-signals
  https://github.com/cerebral/redux-signals
  The Cerebral signals running on Redux

• redux-remake
  https://github.com/umidbekkarimov/redux-remake
  Make redux reducers more easier to define by using Flux-like features.

• redux-observe-store-path
  https://github.com/d6u/redux-observe-store-path
  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.

• redux-conductor
  https://github.com/alexyuly/redux-conductor
  Automatically conduct event traffic through Redux by reacting to actions

• Redux Action Thunk
  https://github.com/ShMcK/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
  https://github.com/latam-autos/redux-realtime-cqrs
  Redux Realtime CQRS is a library that lets you convert a traditional request/response rest api into a Real-time api with CQRS

• redux-action-class-middleware
  https://github.com/diosmosis/redux-action-class-middleware
  Redux middleware that lets you define async/sync actions as ES6 classes.

• redux-semantic-action-middleware
  https://github.com/diosmosis/redux-semantic-action-middleware
  Redux middleware that lets you define actions as meaningful units, without OOP.

• tinier
  https://github.com/zakandrewking/tinier
  Simple views and bindings to redux, with d3.js in mind

• socrates
  https://github.com/matthewmueller/socrates
  Small (12kb), batteries-included redux stack to reduce boilerplate and promote good habits.

• Strux
  https://github.com/jgnewman/strux
  A layer on top of redux for describing data flow throughout your application in a revolutionary way.

• react-relax
  https://github.com/musicglue/react-relax
  A minimal way of providing redux state to react components that doesn't use context

• redux-plus
  https://github.com/ashtonwar/redux-plus
  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.

• Conventional Redux
  https://github.com/mjaneczek/conventional-redux
  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

• react-redux-oop
  https://github.com/newtoncodes/react-redux-oop
  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.

• redux-store-element
  https://github.com/lastmjs/redux-store-element
  A simple Polymer web component that allows a more declarative use of Redux.

• redux-schema
  https://github.com/ddsol/redux-schema
  https://github.com/ddsol/react-redux-schema
  Automatic actions, reducers and validation for Redux. Designed to make using the immutable state easy to use while keeping the state serializable.

• react-redux-classconnect
  https://github.com/jondot/react-redux-classconnect
  Remove cognitive load by moving prop mapping into the component, by using static method references.

• easy-react-redux
  https://github.com/dai-shi/easy-react-redux
  Yet another react redux integration only with stateless function components.

• redux-action-object
  https://github.com/vasyas/redux-action-object
  Defining your Redux reducers and actions using ES6 class syntax.

• redux-entity-store
  https://github.com/vasyas/redux-entity-store
  ORM-like API to access Redux store state

• redux-virtual-dom
  https://github.com/subuta/redux-virtual-dom
  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!

• redux-smooth-bind-actioncreators
  https://github.com/dsacramone/redux-smooth-bind-actioncreators
  Simple utility to faciliate mapping and binding action creators / states to classes. Reduce the boilerplate of "mapStateToProps" and "mapDispatchToProps" !

• react-redux-with-path
  https://github.com/ZhengHe-MD/react-redux-with-path
  A customization of react-redux designed for cases that want to access sub-tree of the state

• Jumpsuit
  https://github.com/jumpsuit/jumpsuit
  https://medium.com/@tannerlinsley/jumpsuit-react-redux-made-simple-e3186ba1b077
  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
  https://github.com/jumpsuit/jumpstate
  Jumpstate is a dead-simple state machine for Redux and Vanilla JS that packs some serious power. Extracted from the Jumpsuit library.

• vidom
  https://github.com/dfilatov/vidom-redux
  Redux bindings for Vidom

• reduceless-connect
  https://github.com/anorudes/reduceless-connect
  Easy change redux state for ui without creating constants and actions

• redux-saga-models
  https://github.com/vshushkov/redux-saga-models
  Library to build models layer backed with redux-saga

• redux-easy-models
  https://github.com/machadogj/redux-easy-models
  Easily define your models using standard redux libraries (redux, redux-actions, redux-thunk).

• redux-entity
  https://github.com/lelandrichardson/redux-entity
  An abstraction layer around handling normalized entity storage and data fetching with redux

• redux-fp
  https://github.com/rvikmanis/redux-fp
  Functional programming helpers for Redux. Uses curried "action-first" reducers, known as "updaters", similar to Elm.

• redux-unitary-reducer
  https://github.com/rotaryden/redux-unitary-reducer
  Implements a reducers aggregator for Redux, where we have only one root reducer with additional management sugar, and simpler sub-handlers for action types. May not conform to Redux philosophy.

• Relax https://github.com/jayflaherty75/relax
  Relax provides simple and familiar yet scalable organization of your React/Redux applications.

• Feeble
  https://github.com/feeblejs/feeble
  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

• react-redux-stream
  https://github.com/noderaider/react-redux-stream
  Streams a singleton selector result to one or more contexts (components or objects) within a react-redux application.

• dva https://github.com/dvajs/dva
  https://medium.com/@chenchengpro/dva-1-0-a-lightweight-framework-based-on-react-redux-and-redux-saga-eeeecb7a481d
  React and redux based, lightweight and elm-style framework. (Inspired by choo).

• redux-config
  https://github.com/qftgtr/redux-config
  Rapidly configure Redux or React Redux.

• Realt
  https://github.com/Vnkitaev/realt
  A new way to work with Redux inspired by Alt

• redux-app-controller
  https://github.com/antonpkazakov/redux-app-controller
  A JavaScript library based on React+Redux combination that allows you to make React-powered SPA based on controllers rather than separate action-creators, reducers and action handlers.

• react-redux-connector
  https://github.com/akuzko/react-redux-connector
  Object-oriented React binding for Redux

• redux-branch
  https://github.com/stephenbunch/redux-branch
  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.

• redux-with-selectors
  https://github.com/guillaumearm/redux-with-selectors
  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
  https://github.com/ilkkahanninen/petiole
  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.

• react-redux-subscribe-while-mounted
  https://github.com/arnemahl/react-redux-subscribe-while-mounted
  A utility method to make it easier to subscribe to a Redux store from a React component.

• redux-retro
  https://github.com/bencompton/redux-retro
  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-quick-actions
  https://github.com/cashsun/redux-quick-action
  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.

• redux-model-s
  https://github.com/ophite/redux-model-s
  Working with redux through models. Involve OOP in redux. Do it more power and add DRY.

• feathersjs-redux-model
  https://github.com/Codaisseur/feathersjs-redux-model
  FeathersJS client that hooks into your Redux store. Create models that emit actions whenever the socket connection to the service receives any CRUD events.

• redux-actionize
  https://github.com/anonmily/redux-actionize
  Easier Redux Action/Reducer creation. Create actions and reducers all at once, in one place, for less duplication and cleaner, more readable code.

• react-redux-custom-store
  https://github.com/emmenko/react-redux-custom-store
  Simple wrapper around react-redux. It allows to use different nested Providers by specifying a custom store name.

• redux-modules
  https://github.com/procore/redux-modules
  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.

• react-redux-model
  https://github.com/jhudson8/react-redux-model
  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.

• Classy-Redux
  https://github.com/machineghost/Classy-Redux/
  An class-based system for creating Redux reducers

• redstate
  https://github.com/eisisig/redstate
  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
  https://github.com/xareelee/redux-jian
  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().

• redux-scene
  https://github.com/ryanwade/redux-scene
  React UI generated from redux state

• duxtape
  https://github.com/brianneisler/duxtape
  Module and util framework for redux. Introduces an abstract module construct for redux. Allows modularization of functionality and easy plug and play workflow

• redux-kv
  https://github.com/watert/redux-kv
  Key-value util component for redux and redux-react usage

• react-redux-wire
  https://github.com/jide/react-redux-wire
  Wire components directly to redux state without using containers.

• Arco
  https://github.com/planttheidea/arco
  A React+Redux framework with standards, conventions, and far less boilerplate

• simple-react-redux
  https://github.com/nstraub/simple-react-redux
  Connect state and actions to props declaratively

• redaction
  https://github.com/pavelivanov/redaction
  Redux action creator without string constants and less magic

• Redux-Reduced-Actions
  https://github.com/PlumTreeSystems/Redux-Reduced-Actions
  A middleware for dispatching actions which contain string lookup paths of data to update.

• redux-global-selectors
  https://github.com/guillaumearm/redux-global-selectors
  A redux store enhancer adding selectors inside the store.

• react-redux-connect-helpers
  https://github.com/rongierlach/react-redux-connect-helpers
  A helpful set of functions for connecting redux state to react components.

• react-redux-connect
  https://github.com/afitiskin/react-redux-connect
  Connect react components to redux store using component static props

• redux-object-connect
  https://github.com/alsiola/redux-object-connect
  Wraps the connect function from react-redux to enable passing an object in place of a mapStateToProps function.

• Redux-store-emitter
  https://github.com/morulus/redux-store-emitter
  Decoration for redux, that gives him the ability to distribute events.

• redux-synapse
  https://github.com/glitch100/redux-synapse
  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.