by luisvinicius167

luisvinicius167 / godux

State Management for Go Backend application inspired in Redux.

218 Stars 15 Forks Last release: Not found MIT License 36 Commits 0 Releases

Available items

No Items, yet!

The developer of this repository has not created any items for sale yet. Need a bug fixed? Help with integration? A different license? Create a request here:


Join the chat at https://gitter.im/luisvinicius167/godux Go Report Card

State Management for Go Backend applications inspired by Redux.


╔═════════╗       ╔══════════╗       ╔═══════════╗       ╔═════════════════╗
║ Action  ║──────>║ Reducer  ║ ────> ║   Store   ║ ────> ║   Application   ║
╚═════════╝       ╚══════════╝       ╚═══════════╝       ╚═════════════════╝
     ^                                                            │


  • Go:
    go get github.com/luisvinicius167/godux

Data Flow

godux gives go unidirectional data flow:

  • The Action returns a small map with specific directions that are dispatched to a Reducer.
  • The Reducer is a pure function (pure functions don't change original arguments) if relevant to it returns a new Value.
  • The Value becomes the new State of the Store.


  • Global application state is held in the Store, as a single map.
  • State is ready-only (only change it only by replacing it with the Reducer).
  • Changes are made with pure functions - Actions/Reducers that do not change the actual object but make a changed copy.


A Store is basically a container that holds your application state.

    store := godux.NewStore()
    store.Setstate("count", 1)
    store.Setstate("Title", "I like godux!")


Actions are just pure functions which pass on their inputs when they're dispatched. Actions are stored on the

map as
    increment := func(number int) godux.Action {
        return godux.Action{
            Type:  "INCREMENT",
            Value: number,


As in Redux:

"Actions describe the fact that something happened, but don’t specify how the application’s state changes in response. This is the job of a reducer".

Reducers are pure functions that take in actions and the state of the store as inputs and leave them all as they came in (aka. pure)-- especially the original state of the store must not be modified (it's accessed by

    // reducer function
    reducer := func(action godux.Action) interface{} {
        switch action.Type {
        case "INCREMENT":
            return store.GetState("count").(int) + action.Value.(int)
        case "DECREMENT":
            return action.Value.(int) - store.GetState("count").(int)
            return store.GetAllState()
    // Add your reducer function to return new values basend on your state


Dispatching an action is very easy.

    // Receive new value
    newCount := store.Dispatch(increment(1)) // return 2

API Reference

  • Store:

    • godux.newStore()
      : Create a single store with the state of your application (should only be used once).
    • godux.SetState(name string, value interface{})
      : Sets the state of the store.
    • godux.GetState(name string)
      : Return a state's value.
    • godux.GetAllState()
      : Return the whole state as a map.
  • Reducer:
    • store.Reducer(func(action godux.Action))
      : Adding a reducer function to your Store.
  • Dispatch:
    • store.Dispatch(action godux.Action)
      : Dispatching an action to your Reducer.
  • Action:

    • godux.Action( Type string, Value interface{})
      : Adding an easily available Action.


MIT License.

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.