Quelles sont les architectures iOS / Swift les plus récentes ?

Le développement iOS a beaucoup évolué ces dernières années, surtout avec l’arrivée de SwiftUI et de la montée en puissance des architectures réactives. Aujourd’hui, plusieurs modèles existent pour organiser une application propre, testable et évolutive.

Dans cet article, on explore quelques architectures modernes utilisées en Swift : MVI, VIPER, MVVM-C et TCA.

1. MVI (Model – View – Intent)

MVI est une architecture populaire dans les environnements réactifs (Android, web), mais elle est de plus en plus utilisée avec SwiftUI. Le principe : l’interface utilisateur est un simple résultat d’un état.

  • La View affiche l’état courant.
  • Une Intent représente une action de l’utilisateur.
  • Un Store / ViewModel transforme ces actions en un nouvel état.

Cycle unidirectionnel :

Intent ? Store/ViewModel ? State ? View

Exemple simple en Swift


struct CounterState {
    var value: Int = 0
}

enum CounterIntent {
    case increment
}

class CounterStore: ObservableObject {
    @Published private(set) var state = CounterState()

    func send(_ intent: CounterIntent) {
        switch intent {
        case .increment:
            state.value += 1
        }
    }
}

SwiftUI se marie particulièrement bien avec MVI grâce à sa gestion déclarative de l’UI et sa philosophie « l’interface = fonction de l’état ».

2. VIPER

VIPER est une architecture très structurée, utilisée surtout dans les projets iOS complexes. Elle découpe fortement les responsabilités.

VIPER signifie :

  • View
  • Interactor
  • Presenter
  • Entity
  • Router

VIPER est réputée pour être extrêmement testable et modulaire, mais peut sembler verbeuse, car chaque écran est découpé en plusieurs fichiers.

Parfait pour :

  • grosses applications professionnelles,
  • équipes nombreuses,
  • besoin de séparation stricte des responsabilités.

3. MVVM-C (Model – View – ViewModel – Coordinator)

MVVM est une architecture classique iOS, mais elle devient encore meilleure lorsqu’on y ajoute les Coordinators.

  • View : affiche les données
  • ViewModel : contient la logique
  • Model : données métier
  • Coordinator : gère la navigation entre écrans

Les coordinators permettent de retirer toute la logique de navigation des ViewControllers, ce qui évite une architecture trop lourde au niveau de l'UI.

Très utilisé avec UIKit, mais reste valable avec SwiftUI.

4. TCA (The Composable Architecture)

TCA est une architecture moderne, très appréciée avec SwiftUI. Elle a été créée par Point-Free et repose sur plusieurs principes forts :

  • État unique et clair
  • Actions décrites explicitement
  • Architecture totalement unidirectionnelle
  • Tests ultra faciles (réducteurs testables)
  • Composabilité extrême (petits modules assemblés ensemble)

TCA ressemble à MVI, mais de manière plus structurée et très bien outillée.

Exemple minimal en TCA


struct Counter: Reducer {
    struct State { var value = 0 }
    enum Action { case increment }

    func reduce(into state: inout State, action: Action) -> Effect {
        switch action {
        case .increment:
            state.value += 1
            return .none
        }
    }
}

TCA est aujourd’hui l’un des modèles les plus solides pour les applications SwiftUI de moyenne ou grande taille.

Quelle architecture choisir ?

  • Pour SwiftUI moderne : MVI, MVVM-C ou TCA
  • Pour UIKit classique : MVVM-C, VIPER
  • Pour un projet complexe en équipe : VIPER ou TCA
  • Pour un projet simple ou moyen : MVVM ou MVI

Conclusion

L’écosystème iOS évolue vite, mais plusieurs architectures modernes permettent aujourd’hui d’écrire du code plus clair, prévisible et testable. Que tu utilises SwiftUI ou UIKit, il existe un modèle adapté à ton projet : du simple MVVM au puissant TCA, en passant par MVI ou VIPER.