A redux standard for Kotlin that supports multiplatform projects.

Full documentation at http://reduxkotlin.org.

Provide a standard redux implementation for Kotlin. In doing so will foster a ecosystem of middleware, store enhancers, & dev tools. These core values will guide descisions for the project:

• core redux-kotlin will be a minimal implementation that other libraries can build upon
• modular development (follow example of https://github.com/reduxjs)
• support for all platforms supported by Kotlin multiplatform (JVM, iOS, Native, JS, WASM)
• developed in open and enable discussion for all interested parties via open channels (slack, github, etc. TBD)
• not owned by a individual or company

Redux in Kotlin, and in mobile in particular, may differ a bit from javascript. Many have found the basic pattern useful on Android & iOS leading to tens of opensource redux libraries in Kotlin, Java, and Swift, yet an ecosystem has yet to emerge. A port of javascript redux is a good starting point for creating a standard and will aid in cross-pollination of middleware, store enhancers, & dev tools from the javascript world.

Redux has proven helpful for state management in mobile. A multiplatform Kotlin implementation & ecosystem will increase developer productivity and code reuse across platforms.

Droidcon NYC Slides Video TBA

Artifacts are hosted on Maven Central. Replace <version> with the latest release shown by the badge above.

Requirements:

• Kotlin 1.9 or newer (the published artefacts are built with Kotlin 2.3)
• JVM/Android consumers: JDK 17+ on Android; library bytecode is JVM 17
• Android: minSdk 21 or higher
• Supported KMP targets: jvm, js (browser/node), android, iosArm64, iosX64, iosSimulatorArm64, macosArm64, macosX64, linuxArm64, linuxX64, mingwX64

One dependency for the common redux-kotlin stack. For Jetpack / Multiplatform Compose apps:

kotlin {
    sourceSets {
        commonMain { //   <---  name may vary on your project
            dependencies {
                implementation("org.reduxkotlin:redux-kotlin-bundle-compose:<version>")
            }
        }
    }
}

For everything else (no Compose runtime pulled in):

implementation("org.reduxkotlin:redux-kotlin-bundle:<version>")

redux-kotlin-bundle transitively brings the core, the concurrent store (lock-free reads + serialized writes), granular field-level subscriptions, ModelState multi-model state (plus granular subscriptions over it), the multi-store registry, and the routed-reducer DSL. redux-kotlin-bundle-compose adds the Compose State<T> bindings and saveable snapshot persistence on top.

val store = createConcurrentModelStore {
    model(UserModel()) {
        on<LoggedIn>  { s, a -> s.copy(user = a.user) }
        on<LoggedOut> { s, _ -> s.copy(user = null) }
    }
}
store.dispatch(LoggedIn("ann"))

See the Bundle guide and the TaskFlow sample — a Compose Multiplatform Kanban app built on redux-kotlin-bundle-compose end-to-end.

Every module is published individually. Import the BOM once to keep versions aligned, then add only what you need without repeating versions:

dependencies {
    implementation(platform("org.reduxkotlin:redux-kotlin-bom:<version>"))
    implementation("org.reduxkotlin:redux-kotlin")
    implementation("org.reduxkotlin:redux-kotlin-concurrent")
}

Usage is very similar to JS Redux and those docs will be useful https://redux.js.org/. These docs are not an intro to Redux, and just documentation on Kotlin specific bits. For more info on Redux in general, check out https://redux.js.org/.

Create an AppState class

data class AppState(val user: User, val feed: List<Feed>)

Create Reducers:

val reducer: Reducer<AppState> = { state, action ->
    when (action) {
        is UserLoggedInAction -> state.copy(user = action.user)
            ...
    }
}

Create Middleware: There are a few ways to create middleware:

Using a curried function stored in a val/var:

val loggingMiddleware: Middleware = { store ->
    { next ->
        { action ->
            //log here
            next(action)
        }
    }
}

Using a function:

fun loggingMiddleware(store: Store) = { next: Dispatcher ->
    { action: Any ->
        //log here
        next(action)
    }
}

Using the convenience helper function middleware:

val loggingMiddleware = middleware { store, next, action ->
    //log here
    next(action)
}

Create a store

val store = createStore(reducer, AppState(user, listOf()), applyMiddleware(loggingMiddleware))

You then will have access to dispatch and subscribe functions from the store.

For thread-safe access from multiple threads, use createConcurrentStore from redux-kotlin-concurrent (lock-free reads, serialized writes) — the older createThreadSafeStore / createSynchronizedStoreEnhancer are deprecated; see the threading docs.

The repo ships a DevTools family for inspecting a running redux-kotlin app:

• In-app drawer (redux-kotlin-devtools-inapp) — a Compose Multiplatform overlay with Actions / State / Diff / Pipeline / Outputs tabs, swapped out at release time by redux-kotlin-devtools-inapp-noop.
• Standalone desktop monitor (redux-kotlin-devtools-standalone) — observe any app (including headless/native) from outside its process via the WebSocket bridge.
• CLI (redux-kotlin-devtools-cli) — the rk-devtools terminal tool: capture, query, diff, and tail action streams.
• Remote streaming (redux-kotlin-devtools-remote) — stream to the Redux DevTools browser extension.

See the integration guide and the website DevTools page.

Optional companion modules in this repo build on the core contracts — Compose bindings (redux-kotlin-compose), async actions (redux-kotlin-thunk), granular subscriptions, multi-store registries, routing, and the one-dependency bundles. See the ecosystem page for the full list. Raise an issue to add your external extension!

Want to give feedback, contribute, or ask questions?

• Chat on #redux slack channel
• Use Trello boards
• Raise GitHub issues
• Ask questions on GitHub discussions