Extensive architectural framework for developing reactive applications with features like automatic state preservation, remote debugging, error recovery, and a powerful plugin system for reusing business logic.
It adds a plug-in system to your code that helps prevent crashes, handle errors, split responsibilities, reuse code, collect analytics, debug & log operations, monitor & improve performance, achieve thread-safety, save state, manage background jobs, and more.
Usually architecture frameworks mean boilerplate, restrictions, and support difficulty for marginal benefits of "clean code". FlowMVI does not dictate what your code should do or look like. Instead, this library focuses on building a supporting infrastructure to enable new possibilities for your app.
Here's what you get:
Here is an example of your new workflow:
val authStore = store(initial = State.Loading, coroutineScope) {
recover { e: Exception -> // handle errors
updateState { State.Error(e) }
null
}
init { // load data
updateState {
State.Content(user = repository.loadUser())
}
}
reduce { intent: Intent -> // respond to events
when (intent) {
is ClickedSignOut -> updateState<State.Content, _> {
action(ShowMessage("Bye!"))
copy(user = null)
}
}
}
}
FlowMVI lets you scale your app in a way that does not increase complexity. Adding a new feature is as simple as calling a function.
Powerful DSL allows you to hook into various events and amend any part of your logic:
fun analyticsPlugin(analytics: Analytics) = plugin<MVIState, MVIIntent, MVIAction> {
onStart {
analytics.logScreenView(config.name) // name of the screen
}
onIntent { intent ->
analytics.logUserAction(intent.name)
}
onException { e ->
analytics.logError(e)
}
onSubscribe {
analytics.logEngagementStart(config.name)
}
onUnsubscribe {
analytics.logEngagementEnd(config.name)
}
onStop {
analytics.logScreenLeave(config.name)
}
}
Never write analytics, debugging, logging, or state persistence code again.
Using FlowMVI with Compose is a matter of one line of code:
@Composable
fun AuthScreen() {
// subscribe based on system lifecycle - on any platform
val state by authStore.subscribe
when (state) {
is Content -> {
Button(onClick = { store.intent(ClickedSignOut) }) {
Text("Sign Out")
}
}
}
}
Enjoy testable UI and free @Previews.
Bundled Test Harness with minimal verbosity:
authStore.subscribeAndTest {
// turbine + kotest example
intent(ClickedSignOut)
states.test {
awaitItem() shouldBe Content(user = null)
}
actions.test {
awaitItem() shouldBe ShowMessage("Bye!")
}
}
val timer = Timer()
timerPlugin(timer).test(Loading) {
onStart()
// time travel keeps track of all plugin operations for you
assert(timeTravel.starts == 1)
assert(state is DisplayingCounter)
assert(timer.isStarted)
onStop(null)
assert(!timer.isStarted)
}
Finally stop writing UI tests and replace them with unit tests.
IDE plugin generates code and lets you debug and control your app remotely:
Your browser does not support the video element. You can view the demo at our website.
Begin by reading the Quickstart Guide.
Copyright 2022-2026 Respawn Team and contributors
Licensed under the Apache License, Version 2.0 (the );
you may use except compliance the License.
You may obtain a copy of the License at
https:
Unless applicable law agreed to writing, software
distributed under the License distributed an BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express implied.
See the License the specific language governing permissions
limitations under the License.
[versions]
flowmvi = "< Badge above 👆🏻 >"
[dependencies]
# Core KMP module
flowmvi-core = { module = "pro.respawn.flowmvi:core", version.ref = "flowmvi" }
# Test DSL
flowmvi-test = { module = "pro.respawn.flowmvi:test", version.ref = "flowmvi" }
# Compose multiplatform
flowmvi-compose = { module = "pro.respawn.flowmvi:compose", version.ref = "flowmvi" }
# Android (common + view-based)
flowmvi-android = { module = "pro.respawn.flowmvi:android", version.ref = "flowmvi" }
# Multiplatform state preservation
flowmvi-savedstate = { module = "pro.respawn.flowmvi:savedstate", version.ref = "flowmvi" }
# Performance metrics collection
flowmvi-metrics = { module = "pro.respawn.flowmvi:metrics", version.ref = "flowmvi" }
# Remote debugging client
flowmvi-debugger-client = { module = "pro.respawn.flowmvi:debugger-plugin", version.ref = "flowmvi" }
# Essenty (Decompose) integration
flowmvi-essenty = { module = "pro.respawn.flowmvi:essenty", version.ref = "flowmvi" }
flowmvi-essenty-compose = { module = "pro.respawn.flowmvi:essenty-compose", version.ref = "flowmvi" }
dependencies {
val flowmvi = "< Badge above 👆🏻 >"
// Core KMP module
commonMainImplementation("pro.respawn.flowmvi:core:$flowmvi")
// compose multiplatform
commonMainImplementation("pro.respawn.flowmvi:compose:$flowmvi")
// saving and restoring state
commonMainImplementation("pro.respawn.flowmvi:savedstate:$flowmvi")
// metrics collection & export
commonMainImplementation("pro.respawn.flowmvi:metrics:$flowmvi")
// essenty integration
commonMainImplementation("pro.respawn.flowmvi:essenty:$flowmvi")
commonMainImplementation("pro.respawn.flowmvi:essenty-compose:$flowmvi")
// testing DSL
commonTestImplementation("pro.respawn.flowmvi:test:$flowmvi")
// android integration
androidMainImplementation("pro.respawn.flowmvi:android:$flowmvi")
// remote debugging client
androidDebugImplementation("pro.respawn.flowmvi:debugger-plugin:$flowmvi")
}
Powerful plug-in system to reuse any business logic you desire. Write your auth, error handling, analytics, logging, configuration, and any other code once and forget about it, focusing on more important things instead.
Automatically recover from exceptions, prevent crashes, and report them to analytics.
Automatically collect and view logs: forget about Log.e("asdf") sprinkling.
Collect 50+ performance metrics with Prometheus, Grafana, OpenTelemetry export and 5 lines of setup.
Manage concurrent, long-running background jobs with complete thread-safety.
Debounce, retry, batch, throttle, conflate, intercept any operations automatically
Compress, persist, and restore state automatically on any platform
Create compile-time safe state machines with a readable DSL. Forget about casts, inconsistent states, and nulls
Share, distribute, disable, intercept, safely manage side-effects
Build fully async, reactive and parallel apps - with no manual thread synchronization required!
Write simple, familiar MVVM+ code or follow MVI/Redux - no limits or requirements
Build restartable, reusable business logic components with no external dependencies or dedicated lifecycles
No base classes, complicated abstractions, or factories of factories - write simple, declarative logic using a DSL
Automatic multiplatform system lifecycle handling
First class, one-liner Compose Multiplatform support with Previews and UI tests.
Integrates with Decompose, Koin, Kodein, androidx.navigation, Nav3, and more
Dedicated IDE Plugin for debugging and codegen and app for Windows, Linux, macOS
The core library has no dependencies - just coroutines
Extensively covered by 350+ tests
Minimal performance overhead, equal to using a simple Channel, with regular benchmarking
Test any business logic using clean, declarative DSL
Learn more by exploring the sample app in your browser
10 minutes to try by following the Quickstart Guide.
sealed interface State : MVIState {
data object Loading : State
data class Error(val e: Exception) : State
data class Content(val user: User?) : State
}
sealed interface Intent : MVIIntent {
data object ClickedSignOut : Intent
}
sealed interface Action : MVIAction { // optional side-effect
data class ShowMessage(val message: String) : Action
}
Surfaced from shared tags and platforms — no rankings paid for.