Aller au contenu

Inara : injectez vos dépendances à la compilation

  • Architecture
  • 7 min.

Laissez-moi vous raconter une petite histoire.

En 2015, j'ai créé Kodein (KOtlin DEpendency INjection), un framework d'injection de dépendances. Ce fut la toute première librairie Kotlin/Multiplatform non JetBrains à être publiée.
En 2018, frustré par la complexité que Kodein imposait, Arnaud Giuliani a lancé Koin : un concurrent direct de Kodein.
En 2020, il est devenu évident que Koin gagnait la course des librairies de DI, grâce à l'excellent travail et à l'investissement d'Arnaud. Nous avons commencé à nous demander en interne si Kodein valait encore la peine d'être maintenu, et nous avons décidé de le garder : il avait toujours ses utilisateurs fidèles.
Depuis 2022, j'ai fini par ne plus aimer le paradigme qu'utilisaient des librairies comme Kodein et Koin, alors j'ai cessé de les utiliser complètement.

Nous voici donc : j'ai créé Kodein, et pourtant je crois aujourd'hui qu'il nuit à l'écosystème Kotlin Multiplatform.

Quand je défendais Kodein, voici l'objection que j'entendais sans cesse :

J'aime l'injection de dépendances, mais je déteste les frameworks de DI. Ils sont trop complexes et trop magiques. Je fais mes propres modules à la main, et cela me suffit largement.

Beaucoup de développeurs raisonnables.

Et en 2022, j'ai commencé à tenir moi-même ce raisonnement. Un conteneur de DI traditionnel me mettait mal à l'aise : son algorithme de résolution du graphe à l'exécution et son célèbre paradigme « demande-moi un type, et je te donne une instance depuis le contexte ». Je veux comprendre ce qui se passe dans mon code, et contrôler son comportement.


Que veux-je dire par « je fais mes propres modules à la main » ?
Très simplement : je conçois une suite d'interfaces qui fournissent mes dépendances (les modules) et je les implémente. Voici à quoi cela ressemble :

custom-di.kt
// module definition
interface NetworkModule {
  val baseUrl: String
  fun httpClient(): HttpClient
}

// App module implementation
class AppNetworkModule : NetworkModule {
  // Value
  override val baseUrl = "https://kodein-koders.com/wp-json/"

  // Singleton
  private val _httpClient by lazy { KtorHttpClient(baseUrl) }
  override fun httpClient() = _httpClient
}

// Test module implementation
@UsesMock(HttpClient::class)
class TestNetworkModule(mocker: Mocker) : NetworkModule {
  override val baseUrl = "http://test-wp-json.api"
  override fun httpClient() = mocker.mock<MockHttpClient>()
}

// ListViewModel does not know of the module
fun ListViewModel(module: NetworkModule) = ListViewModel(
  httpClient = module.httpClient()
)

Dans mes projets, je veux :

  • Aucun surcoût à l'exécution : une dépendance existe dans une interface de module, ou elle n'existe pas. Impossible de demander une dépendance sans savoir si elle existe.
  • Discriminant explicite : je ne demande pas un HttpClient quelconque ; je demande NetworkModule.httpClient(). Le sens d'une dépendance vient du nom du membre, pas seulement de son type de retour.
  • Modules composables : comme les modules sont des interfaces, je peux facilement écrire interface AppModule : NetworkModule, DatabaseModule.
  • Présence légère : les classes métier (ici ListViewModel) ne connaissent pas les modules. Elles restent indépendantes de l'architecture et se concentrent uniquement sur la logique métier.

Mais écrire une couche à la main, même légère, reste fastidieux et source d'erreurs.
Alors...

Voici Inara : l'injection de dépendances à la compilation pour Kotlin Multiplatform

Inara est un Kotlin Symbol Processor (KSP) qui écrit à votre place cette fine couche de modules basés sur des interfaces.

Voici comment définir et implémenter le même module :

Inara-di.kt
@DIModule
interface NetworkModule {
  val baseUrl: String
  fun httpClient(): HttpClient
}

fun main() {
  val network = NetworkModule(
    baseUrl = value("https://api.example.com"),
    httpClient = single { HttpClient(baseUrl) },
  )
  //... do stuff!
}

fun test(mocker: Mocker) {
  val network = NetworkModule(
    baseUrl = value("http://test-wp-json.api"),
    httpClient = provider { mocker.mock<HttpClient>() },
  )
  //... test stuff!
}

Inara n'a aucun surcoût à l'exécution, car elle résout tout à la compilation, non pas grâce à une mécanique interne complexe, mais grâce à une simple syntaxe Kotlin.
Elle repose sur mon architecture de « DI manuelle », et hérite donc aussi des discriminants explicites (par conception), des modules composables et, surtout, de la présence légère.

VM-Factories.kt
@DIFactory(builds = ListViewModel::class, from = NetworkModule::class)
object VMFactory

//Usage
val listVM = VMFactory.ListViewModel(network)

Par ailleurs, Inara gère nativement les bindings sous forme de valeurs, les bindings suspendus, l'extension et le remplacement (overwrite), ainsi que la portée par module.

un binding est une valeur

Comme chaque interface de module est réifiée par une fonction constructeur qui prend des Bindings, vous pouvez déléguer la création d'un binding en particulier.

fun httpClientBinding(
  test: Boolean = false
) : Binding<NetworkModule, Unit, HttpClient> =
  if (test) Binding.provider { MockHttpClient() }
  else Binding.single { HttpClient(baseUrl) }

Inara a des opinions tranchées

Après des années passées à satisfaire tout le monde dans Kodein (notamment en ajoutant un nouveau comportement chaque fois qu'on me le demandait), j'ai fini par comprendre quelque chose. Un bon outil se définit autant par ce qu'il ne fait pas que par ce qu'il fait. Avec Kodein, je voulais un outil « universel ». Avec Inara, certainement pas.

  • Pas de modules mutables. L'immutabilité est l'avenir de Kotlin, de la JVM et de la programmation en général.
    Toute logique d'architecture mutable me met profondément mal à l'aise.
  • Pas de modules globaux. Les contextes globaux nuisent à la testabilité et, plus important encore, à l'isolation.
    L'idée même d'une logique complexe ou d'un état métier global me retourne l'estomac.

En bref, je veux écrire du code qui soit, par ordre d'importance, correct, isolé, idempotent, et seulement ensuite facile à écrire.

À propos de Koin

Oui, je sais que le comportement par défaut de Koin est un conteneur global et mutable, et que cela a certainement contribué à son succès. À cause de cela, j'ai fini par faire des concessions dans Kodein et par y intégrer ces concepts. Vous imaginez ce que j'en pensais...

Je suis très heureux qu'Inara prenne une autre voie. Mon orgueil retombe peut-être un peu. Je veux désormais que les librairies m'aident, moi, à écrire du code avec lequel je suis à l'aise. Plus tout le monde, plus l'ensemble de l'écosystème Kotlin, juste moi (et les développeurs qui pensent comme moi).

L'avenir de Kodein DI

Avec l'annonce officielle d'Inara, nous avons décidé de mettre Kodein en fin de vie. Nous continuerons à maintenir sa version actuelle, mais nous cesserons d'y ajouter des fonctionnalités.

Si vous aimez la façon dont Kodein fonctionnait et dont il structurait vos modules et vos applications, nous vous encourageons chaleureusement à migrer vers Koin. Il prend en charge tout ce que fait Kodein, et bien plus encore (avec de meilleures optimisations et intégrations).

Et si les prémisses et les promesses d'Inara vous parlent, voici où aller ensuite :

Kodein a été ma première librairie, et Inara est celle que j'écrirais aujourd'hui. J'aimerais beaucoup savoir ce que vous en pensez.


Rejoignez la discussion :

Meet Inara: compile-time dependency injection for Kotlin Multiplatform, with no runtime overhead and plain Kotlin. I created Kodein, but I no longer like the paradigm behind it. Inara is what I would write today. kodein-koders.com/en/blog/inar... #Kotlin #KMP

[image or embed]

— kodein-koders.bsky.social (@kodein-koders.bsky.social) 9:06 AM · Nov 3, 2026

Ces articles pourraient vous plaire

Tutoriels, retours d'expérience et bonnes pratiques autour de KOSI et de l'écosystème Kotlin, par ceux qui maintiennent les librairies.

Kotlin Multiplatform Architecture Technique
8 min.

17/11/2026

Inara n’a rien de magique : lisez le code qu’elle écrit

Dans la plupart des frameworks de DI, un module est un sac anonyme de bindings, et les dépendances sont recherchées par type. Inara donne une identité aux modules. Ouvrons le capot et lisons le code qu'elle génère : aucun tour de magie, seulement du Kotlin ordinaire que vous pouvez parcourir d'un Cmd+clic.

Lire plus
Opinion
9 min.

09/11/2026

LARPing enthusiasm : le spectre du désengagement

Je peux confier le travail à l'IA, pas le jugement ni le sens du produit. Récit d'un glissement vers le désengagement, et d'une reconquête en cours.

Lire plus
IA Kotlin Multiplatform Opinion
8 min.

26/10/2026

Les agents de code ont tué les frameworks multiplateformes !

Avec les agents, écrire deux fois du code natif ne coûte presque plus rien : le multiplateforme est-il mort ? Pas vraiment : c'est la question qui a changé. Partagez ce qui doit être identique, et vérifiez-le une seule fois.

Lire plus
Opinion
6 min.

19/10/2026

LARPing enthusiasm : la frénésie créative de l’IA

L'IA me permet de construire en quelques semaines ce qui demandait des années, et c'est grisant comme une drogue. Est-ce que je crée vraiment, ou est-ce que je joue l'enthousiasme ? Une réflexion personnelle sur la volonté, l'agentivité et le code partagé.

Lire plus
Kotlin Multiplatform Technique
9 min.

17/10/2026

MocKMP : un processeur de mocking pour Kotlin/Multiplatform

Envie d'exécuter vos tests unitaires sur toutes les cibles Kotlin/Multiplatform ? MocKMP génère mocks et fakes à la compilation avec un Kotlin Symbol Processor, sans réflexivité, et conserve une API de mocking familière.

Lire plus
Kotlin Multiplatform Technique
10 min.

04/09/2025

Utiliser Swift dans une librairie Kotlin/Multiplatform

Besoin d'utiliser une API iOS réservée à Swift, comme CryptoKit, dans votre librairie Kotlin/Multiplatform ? Salomon montre comment la relier via Objective-C et le cinterop de Kotlin/Native, avec du code testé.

Lire plus