A tiny, Compose-first MVI toolkit designed to be easy to learn, portable across KMP targets, and simple to embed in existing apps. It provides just enough structure to build unidirectional data flows without locking you into a large framework.

• Reducer: pure (State, Event) -> State
• SideEffect: suspend (State, Event) -> Unit
• Interactor: orchestrates a source Flow + Event stream into a StateFlow

• Minimal surface area that fits naturally with Kotlin Flow and Jetpack/Compose Multiplatform
• Works across Kotlin Multiplatform targets (Android, iOS, Desktop, etc.)
• Does not prescribe navigation, DI, or data layers

// build.gradle.kts
dependencies {
    implementation("tv.dpal:flowvi:<version>")
            
    // optional
    implementation("tv.dpal:flowvi-compose:<version>")
}

Define your State and Event, create reducers and side-effects, and wire them up in your Composable using rememberInteractor from mvi:compose.

data class CounterState(val value: Int = 0)

sealed interface CounterEvent {
    data object Increment : CounterEvent
    data object Decrement : CounterEvent
}

val counterReducer = Reducer<CounterState, CounterEvent> { state, event ->
    when (event) {
        CounterEvent.Increment -> state.copy(value = state.value + 1)
        CounterEvent.Decrement -> state.copy(value = state.value - 1)
    }
}

val logSideEffect: SideEffect<CounterState, CounterEvent> = { state, event ->
    // fire-and-forget logging, analytics, etc.
}

@Composable
fun CounterScreen() {
    val interactor = rememberInteractor(
        initialState = CounterState(),
        reducers = listOf(counterReducer),
        sideEffects = listOf(logSideEffect),
        source = { initial -> flow { emit(initial) } }, // no upstream flow in this example
    )

    val state by interactor.state.collectAsState()

    // UI... dispatch events with interactor(CounterEvent.Increment)
}

• State: a snapshot of UI data. Note: if using other wrappers they may have restrictions. ex: State must be @Serializable to enable automatic persistence via rememberSaveable in :mvi:compose.
• Event: user or system intent (button clicks, results, timers, etc.)
• Reducer: pure function that computes the next state. Side-effect free.
• SideEffect: suspend function to perform I/O, navigation, any async task. Dispatch follow-up events if needed.
• Interactor: coordinates the loop; exposes state: StateFlow<State> and a function-call operator fun invoke(event) to dispatch.

• Upstream source Provide a Flow<State> for your upstream data (e.g., repositories). The interactor will fold events on top of the latest upstream emission.

rememberInteractor(
    initialState = MyState(),
    reducers = reducers,
    sideEffects = sideEffects,
    source = { initial -> repo.stateFlow() },
)

• State restoring rememberSaveable is used under the hood with kotlinx.serialization. If your State is not serializable, provide your own saver or disable persistence by wrapping rememberInteractor.

• Threading

  • Reductions run on the collector’s context; side-effects are dispatched on Dispatchers.Default.
  • Keep reducers pure; perform I/O in side-effects and dispatch new events when done.

• Lifecycle The returned Interactor is hosted by the provided CoroutineScope (defaults to a Compose scope). On Android, it behaves like a view-model–scoped state holder.