Skip to main content

Koin

All you need to setting up Koin in your project

Current Versions

You can find all Koin packages on maven central.

Here are the currently available versions:

ProjectVersion
koin-bomMaven Central
koin-coreMaven Central
koin-core-viewmodelMaven Central
koin-core-viewmodel-navigationMaven Central
koin-core-coroutinesMaven Central
koin-testMaven Central
koin-test-junit4Maven Central
koin-androidMaven Central
koin-android-testMaven Central
koin-android-compatMaven Central
koin-androidx-navigationMaven Central
koin-androidx-workmanagerMaven Central
koin-androidx-startupMaven Central
koin-composeMaven Central
koin-compose-viewmodelMaven Central
koin-compose-viewmodel-navigationMaven Central
koin-androidx-composeMaven Central
koin-androidx-compose-navigationMaven Central
koin-ktorMaven Central
koin-ktor3Maven Central
koin-logger-slf4jMaven Central

Gradle Setup

Kotlin

Starting from 3.5.0 you can use BOM-version to manage all Koin library versions. When using the BOM in your app, you don't need to add any version to the Koin library dependencies themselves. When you update the BOM version, all the libraries that you're using are automatically updated to their new versions.

Add koin-bom BOM and koin-core dependency to your application:

implementation(project.dependencies.platform("io.insert-koin:koin-bom:$koin_version"))
implementation("io.insert-koin:koin-core")

If you are using version catalogs:

[versions]
koin-bom = "x.x.x"
...

[libraries]
koin-bom = { module = "io.insert-koin:koin-bom", version.ref = "koin-bom" }
koin-core = { module = "io.insert-koin:koin-core" }
...
dependencies {
implementation(project.dependencies.platform(libs.koin.bom))
implementation(libs.koin.core)
}

Or use an old way of specifying the exact dependency version for Koin:

dependencies {
implementation("io.insert-koin:koin-core:$koin_version")
}

You are now ready to start Koin:

fun main() {
startKoin {
modules(...)
}
}

If you need testing capacity:

dependencies {
// Koin Test features
testImplementation("io.insert-koin:koin-test:$koin_version")
// Koin for JUnit 4
testImplementation("io.insert-koin:koin-test-junit4:$koin_version")
// Koin for JUnit 5
testImplementation("io.insert-koin:koin-test-junit5:$koin_version")
}
info

From now you can continue on Koin Tutorials to learn about using Koin: Kotlin App Tutorial

Android

Add koin-android dependency to your Android application:

dependencies {
implementation("io.insert-koin:koin-android:$koin_android_version")
}

You are now ready to start Koin in your Application class:

class MainApplication : Application() {
override fun onCreate() {
super.onCreate()

startKoin {
modules(appModule)
}
}
}

If you need extra features, add the following needed package:

dependencies {
// Java Compatibility
implementation("io.insert-koin:koin-android-compat:$koin_android_version")
// Jetpack WorkManager
implementation("io.insert-koin:koin-androidx-workmanager:$koin_android_version")
// Navigation Graph
implementation("io.insert-koin:koin-androidx-navigation:$koin_android_version")
// App Startup
implementation("io.insert-koin:koin-androidx-startup:$koin_android_version")
}
info

From now you can continue on Koin Tutorials to learn about using Koin: Android App Tutorial

Jetpack Compose or Compose Multiplatform

Add koin-compose dependency to your multiplatform application, for use Koin & Compose API:

dependencies {
implementation("io.insert-koin:koin-compose:$koin_version")
implementation("io.insert-koin:koin-compose-viewmodel:$koin_version")
implementation("io.insert-koin:koin-compose-viewmodel-navigation:$koin_version")
}

If you are using pure Android Jetpack Compose, you can go with

dependencies {
implementation("io.insert-koin:koin-androidx-compose:$koin_version")
implementation("io.insert-koin:koin-androidx-compose-navigation:$koin_version")
}

Kotlin Multiplatform

Add koin-core dependency to your multiplatform application, for shared Kotlin part:

dependencies {
implementation("io.insert-koin:koin-core:$koin_version")
}
info

From now you can continue on Koin Tutorials to learn about using Koin: Kotlin Multiplatform App Tutorial

Ktor

Add koin-ktor dependency to your Ktor application:

dependencies {
// Koin for Ktor
implementation("io.insert-koin:koin-ktor:$koin_ktor")
// SLF4J Logger
implementation("io.insert-koin:koin-logger-slf4j:$koin_ktor")
}

You are now ready to install Koin feature into your Ktor application:

fun Application.main() {
install(Koin) {
slf4jLogger()
modules(appModule)
}
}
info

From now you can continue on Koin Tutorials to learn about using Koin: Ktor App Tutorial

Koin BOM

The Koin Bill of Materials (BOM) lets you manage all of your Koin library versions by specifying only the BOM’s version. The BOM itself has links to the stable versions of the different Koin libraries, in such a way that they work well together. When using the BOM in your app, you don't need to add any version to the Koin library dependencies themselves. When you update the BOM version, all the libraries that you're using are automatically updated to their new versions.

dependencies {
// Declare koin-bom version
implementation platform("io.insert-koin:koin-bom:$koin_bom")

// Declare the koin dependencies that you need
implementation("io.insert-koin:koin-android")
implementation("io.insert-koin:koin-core-coroutines")
implementation("io.insert-koin:koin-androidx-workmanager")

// If you need specify some version it's just point to desired version
implementation("io.insert-koin:koin-androidx-navigation:1.2.3-alpha03")

// Works with test libraries too!
testImplementation("io.insert-koin:koin-test-junit4")
testImplementation("io.insert-koin:koin-android-test")
}