KO | EN

GitLite

Minimalist Open Source Repository Search Engine

gitlite — search

#dsh #dsh-plugin #typescript #developer-tools #claude-code #ai-agent #codex #deepseek-harness #ai-agents #cli #react #mcp

Flywheel

★ 45 Open GitHub ↗

A simple and predictable state management library inspired by Redux for Kotlin Multiplatform using the concepts of actors.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# **Flywheel**

[![Maven Central](https://img.shields.io/maven-central/v/com.msabhi/flywheel?style=flat)](https://search.maven.org/search?q=com.msabhi.flywheel)
[![GitHub License](https://img.shields.io/badge/license-Apache%20License%202.0-blue.svg?style=flat)](http://www.apache.org/licenses/LICENSE-2.0)
[![Kotlin](https://img.shields.io/badge/kotlin-2.3.0-blue.svg?logo=kotlin)](http://kotlinlang.org)
[![Coroutines](https://img.shields.io/badge/coroutines-1.10.2-blue.svg?logo=kotlin)](https://github.com/Kotlin/kotlinx.coroutines)
![badge-android](https://img.shields.io/badge/platform-android-3DDC84.svg?style=flat)
![badge-jvm](https://img.shields.io/badge/platform-jvm-red.svg?style=flat)
![badge-apple](https://img.shields.io/badge/platform-iOS%20%7C%20macOS%20%7C%20tvOS%20%7C%20watchOS-lightgrey?style=flat)
![badge-js](https://img.shields.io/badge/platform-js-yellow.svg?style=flat)
![badge-linux](https://img.shields.io/badge/platform-linux-important.svg?style=flat)
![badge-windows](https://img.shields.io/badge/platform-windows-informational.svg?style=flat)
![badge-native](https://img.shields.io/badge/platform-native-lightgrey.svg?style=flat)

A simple and predictable state management library inspired by [Flux](https://facebook.github.io/flux/docs/in-depth-overview) + [Elm](https://guide.elm-lang.org/architecture/) + [Redux](https://github.com/reactjs/redux). Flywheel is built on top of [Corotuines](https://kotlinlang.org/docs/coroutines-overview.html) using the concepts of [structured concurrency](https://kotlinlang.org/docs/coroutines-basics.html#structured-concurrency). At the core, lies the [State Machine](https://en.wikipedia.org/wiki/Finite-state_machine) which is based on [actor model](https://en.wikipedia.org/wiki/Actor_model).

## **Why Flywheel?**

The goal was to make the state management concept of Redux simple, understandable & easy to use in Kotlin based projects. To achieve that, we adapted only the core concepts from Redux and slightly modified them. We excluded Android, Apple or any platform-specific dependencies. It is just pure Kotlin. By doing so, you are free to choose your architecture that best suits your codebase, no need to make any big refactor to fit in Flywheel. Don't be fooled by its simplicity, Flywheel got you covered for all practical use-cases. Even if we missed anything, it can be easily extended to support your use cases.

## **Getting started**

#### In Kotlin Multiplatfrom project:

```Kotlin
kotlin {
  sourceSets {
      val commonMain by getting {
          dependencies {
              implementation("com.msabhi:flywheel:1.3.0")
          }
      }
  }
}
```

#### In Android / Gradle project:

```Kotlin
dependencies {

implementation("com.msabhi:flywheel-android:1.3.0")
}
```

#### In Apple platforms (Swift Package Manager)
[![](https://img.shields.io/endpoint?url=https%3A%2F%2Fswiftpackageindex.com%2Fapi%2Fpackages%2Fabhimuktheeswarar%2FFlywheel%2Fbadge%3Ftype%3Dswift-versions)](https://swiftpackageindex.com/abhimuktheeswarar/Flywheel)
[![](https://img.shields.io/endpoint?url=https%3A%2F%2Fswiftpackageindex.com%2Fapi%2Fpackages%2Fabhimuktheeswarar%2FFlywheel%2Fbadge%3Ftype%3Dplatforms)](https://swiftpackageindex.com/abhimuktheeswarar/Flywheel)

In Xcode, go to **File → Add Package Dependencies** and enter the repository URL:

```
https://github.com/abhimuktheeswarar/Flywheel.git
```

Or add it to your `Package.swift`:

```swift
// swift-tools-version:5.9
import PackageDescription

let package = Package(
    name: "YOUR_PROJECT_NAME",
    dependencies: [
        .package(url: "https://github.com/abhimuktheeswarar/Flywheel.git", from: "1.3.0"),
    ]
)
```

Each GitHub release includes a `Flywheel.xcframework.zip` artifact with a matching `Package.swift` manifest containing the URL and checksum.

#### Building the XCFramework locally

The XCFramework is not checked into the repository. To build it from source:

```bash
# Build and copy into flywheel/xcframework/ for local SPM use
./gradlew :flywheel:copyXCFrameworkToRepo

# Build, zip and generate a release-ready Package.swift with checksum
./gradlew :flywheel:generatePackageSwift

# Full release prep: build XCFramework, generate Package.swift, copy to repo root
./gradlew prepareSpmRelease
```

## **Usage**

This is how a simple counter example looks like.

1. Define a state.

```Kotlin
    data class CounterState(val counter: Int = 0) : State
    ```

2. Define actions that can change the state.

```Kotlin
    sealed interface CounterAction : Action {

object IncrementAction : CounterAction

object DecrementAction : CounterAction
    }
    ```

3. Define a reducer that updates the state based on the action & current state.

```Kotlin
    val reduce = reducerForAction<CounterAction, CounterState> { action, state ->
        with(state) {
            when (action) {
                is CounterAction.IncrementAction -> copy(counter = counter + 1)
                is CounterAction.DecrementAction -> copy(counter = counter - 1)
            }
        }
    }
    ```

4. Create a StateReserve.

```Kotlin
    val stateReserve = StateReserve(
        config = getDefaultStateReserveConfig(),
        initialState = InitialState.set(CounterState()),
        reduce = reduce,
        middlewares = null)
    ```

5. Listen for state changes

```Kotlin
    stateReserve.states.collect { state -> println(state.counter) }
    ```

6. Send actions to StateReserve to update the state.

```Kotlin
    stateReserve.dispatch(IncrementAction)
    ```

7. To update the state based on its current value (e.g. from concurrent SideEffects), dispatch a `ReduceAction` — an action that carries a delta and its own merge. Its `reduce` is applied atomically against the **current** state on the state machine, so concurrent updates compose instead of overwriting each other. Do the heavy computation first, then dispatch only the precomputed delta.

```Kotlin
    data class AddToCountAction(val amount: Int) : ReduceAction<CounterState> {
        override fun reduce(state: CounterState) = state.copy(counter = state.counter + amount)
    }

stateReserve.dispatch(AddToCountAction(5))
    ```

### To learn more about Flywheel, head on over to our [wiki](https://github.com/abhimuktheeswarar/Flywheel/wiki).

## **License**

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
```

Flywheel

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README