diff --git a/.gitignore b/.gitignore
index 9320650..9d14494 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,7 @@
 .idea
 build
 .gradle
+.kotlin
 kotlin-js-store
 local.properties
 **/.DS_Store
diff --git a/build-logic/build.gradle.kts b/build-logic/build.gradle.kts
index fcebc78..3739322 100644
--- a/build-logic/build.gradle.kts
+++ b/build-logic/build.gradle.kts
@@ -2,12 +2,6 @@ plugins {
     `kotlin-dsl`
 }
 
-repositories {
-    mavenCentral()
-    gradlePluginPortal()
-    google()
-}
-
 dependencies {
     api(libs.kotlinPlugin)
     api(libs.androidPlugin)
diff --git a/build-logic/src/main/kotlin/kmp-library-convention.gradle.kts b/build-logic/src/main/kotlin/kmp-library-convention.gradle.kts
index a49935f..d8c112b 100644
--- a/build-logic/src/main/kotlin/kmp-library-convention.gradle.kts
+++ b/build-logic/src/main/kotlin/kmp-library-convention.gradle.kts
@@ -1,5 +1,3 @@
-@file:Suppress("UNUSED_VARIABLE")
-
 plugins {
     kotlin("multiplatform")
     id("publication-convention")
diff --git a/compose/src/main/kotlin/app/meetacy/di/android/compose/viewmodel/viewmodel.kt b/compose/src/main/kotlin/app/meetacy/di/android/compose/viewmodel/viewmodel.kt
index e8cd945..bf65946 100644
--- a/compose/src/main/kotlin/app/meetacy/di/android/compose/viewmodel/viewmodel.kt
+++ b/compose/src/main/kotlin/app/meetacy/di/android/compose/viewmodel/viewmodel.kt
@@ -1,20 +1,61 @@
-@file:Suppress("UNUSED_VARIABLE")
-
 package app.meetacy.di.android.compose.viewmodel
 
 import androidx.compose.runtime.Composable
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import app.meetacy.di.DI
+import app.meetacy.di.builder.DIBuilder
 import app.meetacy.di.builder.di
 import app.meetacy.di.dependency.Dependency
+import app.meetacy.di.factory.create
+import app.meetacy.di.factory.factory0
 import kotlinx.coroutines.CoroutineScope
 import kotlin.reflect.typeOf
 
 val DI.viewModelScope: CoroutineScope by Dependency
 
 @Composable
-inline fun <reified T : Any> DI.viewModel(name: String? = null) = viewModel { get<T>(name) }
+inline fun <reified R : Any> DI.viewModel(name: String? = null) = viewModel { create<R>(name) }
+
+@Composable
+inline fun <reified T1, reified R : Any> DI.viewModel(
+    arg1: T1,
+    name: String? = null
+): R = viewModel { create<T1, R>(arg1, name) }
+
+@Composable
+inline fun <reified T1, reified T2, reified R : Any> DI.viewModel(
+    arg1: T1,
+    arg2: T2,
+    name: String? = null
+): R = viewModel { app.meetacy.di.factory.create<T1, T2, R>(arg1, arg2, name) }
+
+@Composable
+inline fun <reified T1, reified T2, reified T3, reified R : Any> DI.viewModel(
+    arg1: T1,
+    arg2: T2,
+    arg3: T3,
+    name: String? = null
+): R = viewModel { app.meetacy.di.factory.create<T1, T2, T3, R>(arg1, arg2, arg3, name) }
+
+@Composable
+inline fun <reified T1, reified T2, reified T3, reified T4, reified R : Any> DI.viewModel(
+    arg1: T1,
+    arg2: T2,
+    arg3: T3,
+    arg4: T4,
+    name: String? = null
+): R = viewModel { app.meetacy.di.factory.create<T1, T2, T3, T4, R>(arg1, arg2, arg3, arg4, name) }
+
+@Composable
+inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified R : Any> DI.viewModel(
+    arg1: T1,
+    arg2: T2,
+    arg3: T3,
+    arg4: T4,
+    arg5: T5,
+    name: String? = null
+): R = viewModel { app.meetacy.di.factory.create<T1, T2, T3, T4, T5, R>(arg1, arg2, arg3, arg4, arg5, name) }
 
 @Composable
 inline fun <reified T : Any> DI.viewModel(crossinline factory: DI.() -> T): T {
@@ -35,3 +76,7 @@ inline fun <reified T : Any> DI.viewModel(crossinline factory: DI.() -> T): T {
 internal open class DIViewModel<T : Any> : ViewModel() {
     lateinit var underlying: T
 }
+
+fun DIBuilder.users() {
+    val userViewModel by factory0(fun DI.() = 0)
+}
diff --git a/core/src/commonMain/kotlin/app/meetacy/di/DI.kt b/core/src/commonMain/kotlin/app/meetacy/di/DI.kt
index 2d8227c..bd0e085 100644
--- a/core/src/commonMain/kotlin/app/meetacy/di/DI.kt
+++ b/core/src/commonMain/kotlin/app/meetacy/di/DI.kt
@@ -1,8 +1,6 @@
 package app.meetacy.di
 
 import app.meetacy.di.annotation.DIDsl
-import app.meetacy.di.builder.DIBuilder
-import app.meetacy.di.builder.di
 import app.meetacy.di.dependency.*
 import kotlin.reflect.KType
 import kotlin.reflect.typeOf
diff --git a/core/src/commonMain/kotlin/app/meetacy/di/builder/DIBuilder.kt b/core/src/commonMain/kotlin/app/meetacy/di/builder/DIBuilder.kt
index 18c1b3a..c9f656c 100644
--- a/core/src/commonMain/kotlin/app/meetacy/di/builder/DIBuilder.kt
+++ b/core/src/commonMain/kotlin/app/meetacy/di/builder/DIBuilder.kt
@@ -42,11 +42,21 @@ public class DIBuilder(dependencies: Dependencies) {
         )
     }
 
+    public inline fun <reified T> register(
+        name: String? = null,
+        provider: DependencyProvider<T>
+    ) {
+        register(
+            key = DependencyKey(typeOf<T>(), name),
+            provider = provider
+        )
+    }
+
     public inline fun <reified T> constant(
         name: String,
         value: T
     ) {
-        factory(name) { value }
+        register<T>(name) { value }
     }
 
     public inline fun <reified T> constant(value: T): DIBuilderConstantDelegate<T> {
@@ -79,29 +89,6 @@ public class DIBuilder(dependencies: Dependencies) {
         )
     }
 
-
-    public inline fun <reified T> factory(
-        name: String? = null,
-        crossinline factory: DI.() -> T
-    ) {
-        val key = DependencyKey<T>(
-            type = typeOf<T>(),
-            name = name
-        )
-        val provider = DependencyProvider { di -> di.factory() }
-        register(key, provider)
-    }
-
-    public inline fun <reified T> factory(
-        noinline factory: DI.() -> T
-    ): DIBuilderFactoryDelegate<T> {
-        return DIBuilderFactoryDelegate(
-            di = this,
-            type = typeOf<T>(),
-            factory = factory
-        )
-    }
-
     public fun build(): DI = DI(
         dependencies = Dependencies(dependencies.toList())
     )
diff --git a/core/src/commonMain/kotlin/app/meetacy/di/builder/DIBuilderDelegates.kt b/core/src/commonMain/kotlin/app/meetacy/di/builder/DIBuilderDelegates.kt
index 0a5e848..22cc1d7 100644
--- a/core/src/commonMain/kotlin/app/meetacy/di/builder/DIBuilderDelegates.kt
+++ b/core/src/commonMain/kotlin/app/meetacy/di/builder/DIBuilderDelegates.kt
@@ -46,23 +46,3 @@ public class DIBuilderSingletonDelegate<T>(
         return ReadOnlyProperty { _, _ -> }
     }
 }
-
-public class DIBuilderFactoryDelegate<T>(
-    private val di: DIBuilder,
-    private val type: KType,
-    private val factory: DI.() -> T
-) {
-    public operator fun provideDelegate(
-        thisRef: Any?,
-        property: KProperty<*>
-    ): ReadOnlyProperty<Any?, Unit> {
-        di.register(
-            key = DependencyKey(
-                type = type,
-                name = property.name
-            ),
-            provider = { di -> di.factory() }
-        )
-        return ReadOnlyProperty { _, _ -> }
-    }
-}
diff --git a/core/src/commonMain/kotlin/app/meetacy/di/dependency/DIDelegates.kt b/core/src/commonMain/kotlin/app/meetacy/di/dependency/DIDelegates.kt
index 6cba70a..51006da 100644
--- a/core/src/commonMain/kotlin/app/meetacy/di/dependency/DIDelegates.kt
+++ b/core/src/commonMain/kotlin/app/meetacy/di/dependency/DIDelegates.kt
@@ -1,7 +1,9 @@
 package app.meetacy.di.dependency
 
 import app.meetacy.di.DI
+import app.meetacy.di.internal.LazyFactory
 import kotlin.reflect.KProperty
+import kotlin.reflect.KType
 import kotlin.reflect.typeOf
 
 public object Dependency {
@@ -11,9 +13,16 @@ public object Dependency {
     ): T = thisRef.get(typeOf<T>(), property.name)
 }
 
+@Suppress("UNCHECKED_CAST")
 public class InnerDependency(public val di: DI) {
+    private val lazy = LazyFactory<Any?>()
+
+    public fun <T> getValue(property: KProperty<*>, type: KType): T {
+        return lazy.get { di.get(type, property.name) } as T
+    }
+
     public inline operator fun <reified T> getValue(
         thisRef: Any?,
         property: KProperty<*>
-    ): T = di.get(typeOf<T>(), property.name)
+    ): T = getValue(property, typeOf<T>())
 }
diff --git a/core/src/commonMain/kotlin/app/meetacy/di/factory/Factory0.kt b/core/src/commonMain/kotlin/app/meetacy/di/factory/Factory0.kt
new file mode 100644
index 0000000..1dcb9dd
--- /dev/null
+++ b/core/src/commonMain/kotlin/app/meetacy/di/factory/Factory0.kt
@@ -0,0 +1,61 @@
+package app.meetacy.di.factory
+
+import app.meetacy.di.DI
+import app.meetacy.di.builder.DIBuilder
+import app.meetacy.di.builder.DIBuilderSingletonDelegate
+import app.meetacy.di.internal.LazyFactory
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+public fun interface Factory0<R> {
+    public fun create(): R
+}
+
+// DI Extensions
+
+public fun <R> DI.create(
+    factoryType: KType,
+    name: String? = null
+): R = get<Factory0<R>>(factoryType, name).create()
+
+public inline fun <reified R> DI.create(
+    name: String? = null
+): R = create(typeOf<Factory0<R>>(), name)
+
+// DI Delegates
+
+public inline fun <reified R> DI.creating(): Factory0Dependency<R> =
+    Factory0Dependency(
+        di = this,
+        factoryType = typeOf<Factory0<R>>()
+    )
+
+public class Factory0Dependency<R>(
+    private val di: DI,
+    private val factoryType: KType
+) {
+    private val lazy = LazyFactory<R>()
+
+    public operator fun getValue(
+        thisRef: Any?,
+        property: KProperty<*>
+    ): R = lazy.get { di.create(factoryType, property.name) }
+}
+
+// DIBuilder Extensions
+
+public inline fun <reified R> DIBuilder.factory0(
+    name: String? = null,
+    crossinline factory: DI.() -> R
+) {
+    singleton(name) {
+        Factory0 { factory() }
+    }
+}
+
+public inline fun <reified R> DIBuilder.factory0(
+    crossinline factory: DI.() -> R
+): DIBuilderSingletonDelegate<Factory0<R>> = singleton {
+    Factory0 { factory() }
+}
diff --git a/core/src/commonMain/kotlin/app/meetacy/di/factory/Factory1.kt b/core/src/commonMain/kotlin/app/meetacy/di/factory/Factory1.kt
new file mode 100644
index 0000000..9f070e1
--- /dev/null
+++ b/core/src/commonMain/kotlin/app/meetacy/di/factory/Factory1.kt
@@ -0,0 +1,79 @@
+package app.meetacy.di.factory
+
+import app.meetacy.di.DI
+import app.meetacy.di.builder.DIBuilder
+import app.meetacy.di.builder.DIBuilderSingletonDelegate
+import app.meetacy.di.internal.LazyFactory
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+public fun interface Factory1<R1, T> {
+    public fun create(arg1: R1): T
+}
+
+// DI Extensions
+
+public fun <T1, R> DI.create(
+    factoryType: KType,
+    arg1: T1,
+    name: String? = null
+): R = get<Factory1<T1, R>>(
+    type = factoryType,
+    name = name
+).create(arg1)
+
+public inline fun <reified T1, reified R> DI.create(
+    arg1: T1,
+    name: String? = null
+): R = create(
+    factoryType = typeOf<Factory1<T1, R>>(),
+    arg1 = arg1,
+    name = name
+)
+
+// DI Delegates
+
+public inline fun <reified T1, reified R> DI.creating(
+    arg1: T1
+): Factory1Dependency<T1, R> = Factory1Dependency(
+    di = this,
+    arg1 = arg1,
+    factoryType = typeOf<Factory1<T1, R>>()
+)
+
+public class Factory1Dependency<T1, R>(
+    private val di: DI,
+    private val arg1: T1,
+    private val factoryType: KType
+) {
+    private val lazy = LazyFactory<R>()
+
+    public operator fun getValue(
+        thisRef: Any?,
+        property: KProperty<*>
+    ): R = lazy.get {
+        di.create(
+            factoryType = factoryType,
+            arg1 = arg1,
+            name = property.name
+        )
+    }
+}
+
+// DIBuilder Extensions
+
+public inline fun <reified T1, reified R> DIBuilder.factory1(
+    name: String? = null,
+    crossinline factory: DI.(arg1: T1) -> R
+) {
+    singleton(name) {
+        Factory1 { arg1: T1 -> factory(arg1) }
+    }
+}
+
+public inline fun <reified T1, reified R> DIBuilder.factory1(
+    crossinline factory: DI.(arg1: T1) -> R
+): DIBuilderSingletonDelegate<Factory1<T1, R>> = singleton {
+    Factory1 { arg1: T1 -> factory(arg1) }
+}
diff --git a/core/src/commonMain/kotlin/app/meetacy/di/factory/Factory2.kt b/core/src/commonMain/kotlin/app/meetacy/di/factory/Factory2.kt
new file mode 100644
index 0000000..466708e
--- /dev/null
+++ b/core/src/commonMain/kotlin/app/meetacy/di/factory/Factory2.kt
@@ -0,0 +1,86 @@
+package app.meetacy.di.factory
+
+import app.meetacy.di.DI
+import app.meetacy.di.builder.DIBuilder
+import app.meetacy.di.builder.DIBuilderSingletonDelegate
+import app.meetacy.di.internal.LazyFactory
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+public fun interface Factory2<R1, R2, T> {
+    public fun create(arg1: R1, arg2: R2): T
+}
+
+// DI Extensions
+
+public fun <T1, T2, R> DI.create(
+    factoryType: KType,
+    arg1: T1,
+    arg2: T2,
+    name: String? = null
+): R = get<Factory2<T1, T2, R>>(
+    type = factoryType,
+    name = name
+).create(arg1, arg2)
+
+public inline fun <reified T1, reified T2, reified R> DI.create(
+    arg1: T1,
+    arg2: T2,
+    name: String? = null
+): R = create(
+    factoryType = typeOf<Factory2<T1, T2, R>>(),
+    arg1 = arg1,
+    arg2 = arg2,
+    name = name
+)
+
+// DI Delegates
+
+public inline fun <reified T1, reified T2, reified R> DI.creating(
+    arg1: T1,
+    arg2: T2
+): Factory2Dependency<T1, T2, R> = Factory2Dependency(
+    di = this,
+    arg1 = arg1,
+    arg2 = arg2,
+    factoryType = typeOf<Factory2<T1, T2, R>>()
+)
+
+public class Factory2Dependency<T1, T2, R>(
+    private val di: DI,
+    private val arg1: T1,
+    private val arg2: T2,
+    private val factoryType: KType
+) {
+    private val lazy = LazyFactory<R>()
+
+    public operator fun getValue(
+        thisRef: Any?,
+        property: KProperty<*>
+    ): R = lazy.get {
+        di.create(
+            factoryType = factoryType,
+            arg1 = arg1,
+            arg2 = arg2,
+            name = property.name
+        )
+    }
+}
+
+// DIBuilder Extensions
+
+public inline fun <reified T1, reified T2, reified R> DIBuilder.factory2(
+    name: String? = null,
+    crossinline factory: DI.(arg1: T1, arg2: T2) -> R
+) {
+    singleton(name) {
+        Factory2 { arg1: T1, arg2: T2 -> factory(arg1, arg2) }
+    }
+}
+
+public inline fun <reified T1, reified T2, reified R> DIBuilder.factory2(
+    crossinline factory: DI.(arg1: T1, arg2: T2) -> R
+): DIBuilderSingletonDelegate<Factory2<T1, T2, R>> = singleton {
+    Factory2 { arg1: T1, arg2: T2 -> factory(arg1, arg2) }
+}
diff --git a/core/src/commonMain/kotlin/app/meetacy/di/factory/Factory3.kt b/core/src/commonMain/kotlin/app/meetacy/di/factory/Factory3.kt
new file mode 100644
index 0000000..8ef7a7e
--- /dev/null
+++ b/core/src/commonMain/kotlin/app/meetacy/di/factory/Factory3.kt
@@ -0,0 +1,93 @@
+package app.meetacy.di.factory
+
+import app.meetacy.di.DI
+import app.meetacy.di.builder.DIBuilder
+import app.meetacy.di.builder.DIBuilderSingletonDelegate
+import app.meetacy.di.internal.LazyFactory
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+public fun interface Factory3<R1, R2, R3, T> {
+    public fun create(arg1: R1, arg2: R2, arg3: R3): T
+}
+
+// DI Extensions
+
+public fun <T1, T2, T3, R> DI.create(
+    factoryType: KType,
+    arg1: T1,
+    arg2: T2,
+    arg3: T3,
+    name: String? = null
+): R = get<Factory3<T1, T2, T3, R>>(
+    type = factoryType,
+    name = name
+).create(arg1, arg2, arg3)
+
+public inline fun <reified T1, reified T2, reified T3, reified R> DI.create(
+    arg1: T1,
+    arg2: T2,
+    arg3: T3,
+    name: String? = null
+): R = create(
+    factoryType = typeOf<Factory3<T1, T2, T3, R>>(),
+    arg1 = arg1,
+    arg2 = arg2,
+    arg3 = arg3,
+    name = name
+)
+
+// DI Delegates
+
+public inline fun <reified T1, reified T2, reified T3, reified R> DI.creating(
+    arg1: T1,
+    arg2: T2,
+    arg3: T3
+): Factory3Dependency<T1, T2, T3, R> = Factory3Dependency(
+    di = this,
+    arg1 = arg1,
+    arg2 = arg2,
+    arg3 = arg3,
+    factoryType = typeOf<Factory2<T1, T2, R>>()
+)
+
+public class Factory3Dependency<T1, T2, T3, R>(
+    private val di: DI,
+    private val arg1: T1,
+    private val arg2: T2,
+    private val arg3: T3,
+    private val factoryType: KType
+) {
+    private val lazy = LazyFactory<R>()
+
+    public operator fun getValue(
+        thisRef: Any?,
+        property: KProperty<*>
+    ): R = lazy.get {
+        di.create(
+            factoryType = factoryType,
+            arg1 = arg1,
+            arg2 = arg2,
+            arg3 = arg3,
+            name = property.name
+        )
+    }
+}
+
+// DIBuilder Extensions
+
+public inline fun <reified T1, reified T2, reified T3, reified R> DIBuilder.factory3(
+    name: String? = null,
+    crossinline factory: DI.(arg1: T1, arg2: T2, arg3: T3) -> R
+) {
+    singleton(name) {
+        Factory3 { arg1: T1, arg2: T2, arg3: T3 -> factory(arg1, arg2, arg3) }
+    }
+}
+
+public inline fun <reified T1, reified T2, reified T3, reified R> DIBuilder.factory3(
+    crossinline factory: DI.(arg1: T1, arg2: T2, arg3: T3) -> R
+): DIBuilderSingletonDelegate<Factory3<T1, T2, T3, R>> = singleton {
+    Factory3 { arg1: T1, arg2: T2, arg3: T3 -> factory(arg1, arg2, arg3) }
+}
diff --git a/core/src/commonMain/kotlin/app/meetacy/di/factory/Factory4.kt b/core/src/commonMain/kotlin/app/meetacy/di/factory/Factory4.kt
new file mode 100644
index 0000000..2bf2a45
--- /dev/null
+++ b/core/src/commonMain/kotlin/app/meetacy/di/factory/Factory4.kt
@@ -0,0 +1,100 @@
+package app.meetacy.di.factory
+
+import app.meetacy.di.DI
+import app.meetacy.di.builder.DIBuilder
+import app.meetacy.di.builder.DIBuilderSingletonDelegate
+import app.meetacy.di.internal.LazyFactory
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+public fun interface Factory4<R1, R2, R3, R4, T> {
+    public fun create(arg1: R1, arg2: R2, arg3: R3, arg4: R4): T
+}
+
+// DI Extensions
+
+public fun <T1, T2, T3, T4, R> DI.create(
+    factoryType: KType,
+    arg1: T1,
+    arg2: T2,
+    arg3: T3,
+    arg4: T4,
+    name: String? = null
+): R = get<Factory4<T1, T2, T3, T4, R>>(
+    type = factoryType,
+    name = name
+).create(arg1, arg2, arg3, arg4)
+
+public inline fun <reified T1, reified T2, reified T3, reified T4, reified R> DI.create(
+    arg1: T1,
+    arg2: T2,
+    arg3: T3,
+    arg4: T4,
+    name: String? = null
+): R = create(
+    factoryType = typeOf<Factory4<T1, T2, T3, T4, R>>(),
+    arg1 = arg1,
+    arg2 = arg2,
+    arg3 = arg3,
+    arg4 = arg4,
+    name = name
+)
+
+// DI Delegates
+
+public inline fun <reified T1, reified T2, reified T3, reified T4, reified R> DI.creating(
+    arg1: T1,
+    arg2: T2,
+    arg3: T3,
+    arg4: T4
+): Factory4Dependency<T1, T2, T3, T4, R> = Factory4Dependency(
+    di = this,
+    arg1 = arg1,
+    arg2 = arg2,
+    arg3 = arg3,
+    arg4 = arg4,
+    factoryType = typeOf<Factory2<T1, T2, R>>()
+)
+
+public class Factory4Dependency<T1, T2, T3, T4, R>(
+    private val di: DI,
+    private val arg1: T1,
+    private val arg2: T2,
+    private val arg3: T3,
+    private val arg4: T4,
+    private val factoryType: KType
+) {
+    private val lazy = LazyFactory<R>()
+
+    public operator fun getValue(
+        thisRef: Any?,
+        property: KProperty<*>
+    ): R = lazy.get {
+        di.create(
+            factoryType = factoryType,
+            arg1 = arg1,
+            arg2 = arg2,
+            arg3 = arg3,
+            arg4 = arg4,
+            name = property.name
+        )
+    }
+}
+
+// DIBuilder Extensions
+
+public inline fun <reified T1, reified T2, reified T3, reified T4, reified R> DIBuilder.factory4(
+    name: String? = null,
+    crossinline factory: DI.(arg1: T1, arg2: T2, arg3: T3, arg4: T4) -> R
+) {
+    singleton(name) {
+        Factory4 { arg1: T1, arg2: T2, arg3: T3, arg4: T4 -> factory(arg1, arg2, arg3, arg4) }
+    }
+}
+
+public inline fun <reified T1, reified T2, reified T3, reified T4, reified R> DIBuilder.factory4(
+    crossinline factory: DI.(arg1: T1, arg2: T2, arg3: T3, arg4: T4) -> R
+): DIBuilderSingletonDelegate<Factory4<T1, T2, T3, T4, R>> = singleton {
+    Factory4 { arg1: T1, arg2: T2, arg3: T3, arg4: T4 -> factory(arg1, arg2, arg3, arg4) }
+}
diff --git a/core/src/commonMain/kotlin/app/meetacy/di/factory/Factory5.kt b/core/src/commonMain/kotlin/app/meetacy/di/factory/Factory5.kt
new file mode 100644
index 0000000..e67295c
--- /dev/null
+++ b/core/src/commonMain/kotlin/app/meetacy/di/factory/Factory5.kt
@@ -0,0 +1,107 @@
+package app.meetacy.di.factory
+
+import app.meetacy.di.DI
+import app.meetacy.di.builder.DIBuilder
+import app.meetacy.di.builder.DIBuilderSingletonDelegate
+import app.meetacy.di.internal.LazyFactory
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+public fun interface Factory5<R1, R2, R3, R4, R5, T> {
+    public fun create(arg1: R1, arg2: R2, arg3: R3, arg4: R4, arg5: R5): T
+}
+
+// DI Extensions
+
+public fun <T1, T2, T3, T4, T5, R> DI.create(
+    factoryType: KType,
+    arg1: T1,
+    arg2: T2,
+    arg3: T3,
+    arg4: T4,
+    arg5: T5,
+    name: String? = null
+): R = get<Factory5<T1, T2, T3, T4, T5, R>>(
+    type = factoryType,
+    name = name
+).create(arg1, arg2, arg3, arg4, arg5)
+
+public inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified R> DI.create(
+    arg1: T1,
+    arg2: T2,
+    arg3: T3,
+    arg4: T4,
+    arg5: T5,
+    name: String? = null
+): R = create(
+    factoryType = typeOf<Factory5<T1, T2, T3, T4, T5, R>>(),
+    arg1 = arg1,
+    arg2 = arg2,
+    arg3 = arg3,
+    arg4 = arg4,
+    arg5 = arg5,
+    name = name
+)
+
+// DI Delegates
+
+public inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified R> DI.creating(
+    arg1: T1,
+    arg2: T2,
+    arg3: T3,
+    arg4: T4,
+    arg5: T5
+): Factory5Dependency<T1, T2, T3, T4, T5, R> = Factory5Dependency(
+    di = this,
+    arg1 = arg1,
+    arg2 = arg2,
+    arg3 = arg3,
+    arg4 = arg4,
+    arg5 = arg5,
+    factoryType = typeOf<Factory2<T1, T2, R>>()
+)
+
+public class Factory5Dependency<T1, T2, T3, T4, T5, R>(
+    private val di: DI,
+    private val arg1: T1,
+    private val arg2: T2,
+    private val arg3: T3,
+    private val arg4: T4,
+    private val arg5: T5,
+    private val factoryType: KType
+) {
+    private val lazy = LazyFactory<R>()
+
+    public operator fun getValue(
+        thisRef: Any?,
+        property: KProperty<*>
+    ): R = lazy.get {
+        di.create(
+            factoryType = factoryType,
+            arg1 = arg1,
+            arg2 = arg2,
+            arg3 = arg3,
+            arg4 = arg4,
+            arg5 = arg5,
+            name = property.name
+        )
+    }
+}
+
+// DIBuilder Extensions
+
+public inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified R> DIBuilder.factory5(
+    name: String? = null,
+    crossinline factory: DI.(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) -> R
+) {
+    singleton(name) {
+        Factory5 { arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5 -> factory(arg1, arg2, arg3, arg4, arg5) }
+    }
+}
+
+public inline fun <reified T1, reified T2, reified T3, reified T4, reified T5, reified R> DIBuilder.factory5(
+    crossinline factory: DI.(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) -> R
+): DIBuilderSingletonDelegate<Factory5<T1, T2, T3, T4, T5, R>> = singleton {
+    Factory5 { arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5 -> factory(arg1, arg2, arg3, arg4, arg5) }
+}
diff --git a/core/src/commonMain/kotlin/app/meetacy/di/internal/LazyFactory.kt b/core/src/commonMain/kotlin/app/meetacy/di/internal/LazyFactory.kt
new file mode 100644
index 0000000..b275820
--- /dev/null
+++ b/core/src/commonMain/kotlin/app/meetacy/di/internal/LazyFactory.kt
@@ -0,0 +1,14 @@
+package app.meetacy.di.internal
+
+internal class LazyFactory<R> {
+    private var cached: R? = null
+
+    /**
+     * It's not guaranteed that [block] will be called once
+     */
+    inline fun get(block: () -> R): R {
+        val cached = cached ?: block()
+        this.cached = cached
+        return cached
+    }
+}
diff --git a/core/src/commonMain/kotlin/app/meetacy/di/internal/Parametrize.kt b/core/src/commonMain/kotlin/app/meetacy/di/internal/Parametrize.kt
new file mode 100644
index 0000000..56b1789
--- /dev/null
+++ b/core/src/commonMain/kotlin/app/meetacy/di/internal/Parametrize.kt
@@ -0,0 +1,26 @@
+package app.meetacy.di.internal
+
+import kotlin.reflect.KClassifier
+import kotlin.reflect.KType
+import kotlin.reflect.KTypeProjection
+
+@PublishedApi
+internal fun KType.parametrize(
+    vararg parameters: KTypeProjection
+): KType = object : KType {
+    override val arguments = parameters.toList()
+    override val classifier: KClassifier? = this@parametrize.classifier
+    override val isMarkedNullable: Boolean = this@parametrize.isMarkedNullable
+}
+
+@PublishedApi
+internal fun KType.parametrize(
+    vararg parameters: KType
+): KType = parametrize(
+    *parameters.map { type ->
+        KTypeProjection(
+            variance = null,
+            type = type
+        )
+    }.toTypedArray()
+)
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 1264407..c30dce0 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -1,12 +1,12 @@
 [versions]
 
-kotlin = "1.8.10"
+kotlin = "1.9.22"
 androidGradle = "7.3.0"
 composeRuntime = "1.3.3"
 composeCompiler = "1.4.4"
 lifecycle = "2.6.1"
 
-mdi = "0.0.25"
+mdi = "0.0.26"
 
 [libraries]