Decompose

---

Decompose is a Kotlin Multiplatform library for breaking down your code into tree-structured lifecycle-aware business logic components (aka BLoC), with routing functionality and pluggable UI (Jetpack/Multiplatform Compose, Android Views, SwiftUI, Kotlin/React, etc.).

Please see the project website for documentation and APIs.

Should you have any questions or ideas - there is Discussions section. Also welcome to the Kotlin Slack channel - #decompose! You can also try using DeepWiki!

• Decompose breaks the code down into small and independent components and organizes them into trees. Each parent component is only aware of its immediate children.
• Decompose draws clear boundaries between UI and non-UI code, which gives the following benefits:
  • Better separation of concerns
  • Pluggable platform-specific UI (Compose, SwiftUI, Kotlin/React, etc.)
  • Business logic code is testable with pure multiplatform unit tests
• Navigation state is fully exposed - plug any UI you want, animate as you like using your favourite UI framework's API or use predefined API.
• Navigation is a pure function from the old state to a new one - navigate without limits.
• Proper dependency injection (DI) and inversion of control (IoC) via constructor, including but not limited to type-safe arguments.
• Shared navigation logic
• Lifecycle-aware components
• Components in the back stack are not destroyed, they continue working in background without UI
• State preservation (automatically on Android, manually on all other targets via kotlinx-serialization)
• Instances retaining (aka ViewModels) over configuration changes (mostly useful in Android)

Please check the Installation section of the documentation.

In general, Decompose supports the following targets: android, jvm, ios, watchos, tvos, macos, wasmJs, js. However, some modules do not support all targets or the support depends on the Decompose version. Please see the installation docs for details.

Here are some key concepts of the library, more details can be found in the documentation.

• Component - every component represents a piece of logic with its own lifecycle, the UI is optional and is plugged externally
• ComponentContext - every component has its own [ComponentContext], which makes components lifecycle-aware and allows state preservation, instances retaining (aka AndroidX ViewModel) and back button handling
• Child Stack - enables navigation between child components, nested navigation is also supported
• Child Slot - allows only one child component at a time, or none
• Child Pages - a list of child components with one selected component (e.g. pager-like navigation)
• Child Panels - a multi-pane navigation
• Generic Navigation - provides a way to create your own custom navigation model, when none of the predefined models fit your needs
• Lifecycle - provides a way to listen for lifecycle events in components
• StateKeeper - makes it possible to preserve state or data in a component when it gets destroyed
• InstanceKeeper - retains instances in your components (similar to AndroidX ViewModel)
• BackPressedHandler - provides a way to handle and intercept back button presses

Decompose is a library that can be used as a framework. In its core, Decompose just manipulates instances of ComponentContext with strict parent-child relationship, which is also called "navigation". The possibility of creating custom implementations of the ComponentContext interface allows adding custom properties and functions, as well as storing additional data in each instance of ComponentContext. This makes it a very powerful tool with various use cases.

The "component" term is just one of the possible usages, the recommended one. The Decompose-Router library is a great example of leveraging Decompose to create a custom navigation solution with a completely different API.

Please refer to the Quick start section of the docs.

Check out the Samples section of the docs for a full description of each sample.

Check out the template repository which may be used to kick-start a project for you.

Checkout a voluntary list of projects/companies using Decompose: https://github.com/arkivanov/Decompose/discussions/366. Feel free to add your project!

• Decompose — experiments with Kotlin Multiplatform lifecycle-aware components and navigation

• Fully cross-platform Kotlin applications (almost)

• A comprehensive thirty-line navigation for Jetpack/Multiplatform Compose - if you find Decompose verbose and would prefer something built on top of Compose.

• "Component-based Approach" series by Artur Artikov

  • Part 1: Fighting Complexity in Android Applications
  • Part 2: Implementing Screens with the Decompose Library

Twitter: @arkann1985

If you like this project you can always ;-)