Koin 4.1 is Here: Safer Configs, Smarter Scopes & Kotlin Multiplatform Power

Early this year we laid out our Koin Framework 2025 Roadmap, promising that Koin 4.1 would land this year with safer configurations, stronger integrations, and multiplatform polish.

Today, Koin 4.1 is here, and it delivers exactly that—plus a few handy extras you didn’t know you needed.

In a nutshell:
Koin 4.1 gives you reusable configuration blocks, a modular resolver engine, runtime feature flags, WASM-safe UUIDs, archetype-based scopes (including ergonomic ViewModel constructor injection), a unified module/lazy-module DSL with graph verification, first-class Compose 1.8/MPP support (automatic context handling, faster injects, previews), and out-of-the-box Ktor 3.2 integration (inline modules, request scopes, multiplatform artifact).

Here's the full Koin 4.1.0 Changelog

1. Core & Configuration

Reusable Config Objects

What you can do: Pull common DI setup into a variable and mix in platform-specific calls via includes().

fun initKoin(common: KoinAppDeclaration? = null) {
  startKoin {
    includes(common)
    modules(appModule)
  }
}

class MainApp : Application() {
  override fun onCreate() {
    super.onCreate()
    initKoin {
      androidContext(this@MainApp)
      androidLogger()
    }
  }
}

Why it helps:

• DRY across JVM, Android, iOS, WASM.

• Swap in test-only settings without rewriting your startKoin block.

Pluggable Resolver Engine

What you can do: Tie custom resolution logic into Koin via CoreResolver and ResolutionExtension.

startKoin {
  // you can add extensions that modify lookup behavior
}

Why it helps:

• Integrate smoothly with other frameworks (like Ktor’s upcoming default DI).

• Cleaner, more reliable scope traversal—fewer “missing definition” edge cases.

Feature Flags

What you can do: Enable or disable experimental behaviors at runtime.

startKoin {
  options(viewModelScopeFactory())
}

Why it helps:

• Roll out new features incrementally.

• Turn off a flag immediately if something isn’t working in production.

WASM UUID Support

Koin now uses Kotlin 2.1.20’s UUID generator under the hood for WebAssembly targets.

Why it helps:

• Collision-free IDs in the browser or JS runtimes.

• Safe scoping on Kotlin/WASM without extra work.

2. Scoping

Archetype-Based Scopes

What you can do: Define scopes by “archetype” (Activity, Fragment, ViewModel, or your own).

module {
  activityScope {
    scopedOf(::Session)
  }
  fragmentScope {
    // …
  }
}

Then in any Activity:

class MyActivity : AppCompatActivity(), AndroidScopeComponent {
  override val scope: Scope by activityScope()
}

Why it helps:

• Declare lifecycle-based scopes once, reuse everywhere.

• Module definitions read by intent (Activity) instead of concrete types.

Simplified ViewModel Scopes

What you can do: Drop the old ScopeViewModel base class. Just implement KoinScopeComponent.

class MyViewModel : ViewModel(), KoinScopeComponent {
  override val scope = viewModelScope()
  val session by inject<Session>()
}

Why it helps:

• Lifecycle-driven scope open/close with no manual callbacks.

• Straightforward field injection when constructor injection isn’t practical.

Scope Constructor Injection for ViewModels

Flip on the viewModelScopeFactory() option and declare your ViewModel like any other class:

startKoin {
  options(viewModelScopeFactory())
}

module {
  viewModelOf(::MyViewModel)
  viewModelScope {
    scopedOf(::Session)
  }
}

Then in your activity:

class MyActivity : AppCompatActivity() {
  val myVM: MyViewModel by viewModel()
}

Why it helps:

• Dependencies appear in the constructor, not hidden in fields.

• Better type safety and easier refactoring/testing.

Custom Archetypes

You can also define your own archetype if your app has a unique lifecycle:

fun Module.wizardScope(setup: ScopeDSL.() -> Unit) =
  ScopeDSL(WizardScopeArchetype, this).apply(setup)

fun ComponentActivity.createWizardScope() =
 getKoin().createScope(getScopeId(),getScopeName(),this, WizardScopeArchetype)

Why it helps:

• Fully tailor scope lifecycles to your app’s architecture.

• Keep your DI clean even for non-standard flows.

3. Safer Module Configuration

Unified Module + Lazy Module DSL

Combine eager and lazy definitions under one roof:

val appModule     = module { single { A() } }
val lazyModule    = lazyModule { single { B(get()) } }
val config        = moduleConfiguration {
  modules(appModule)
  lazyModules(lazyModule)
}
startKoin {
  moduleConfiguration(config)
}