Comme vous le savez probablement, Kotlin/Multiplatform vous permet de partager tout ce qui est propre à votre application et qui apporte de la valeur d'un point de vue métier. Une fois écrit, il ne vous reste qu'à le déployer dans vos applications natives !
Cependant, rien n'est aussi simple. Vous aurez toujours besoin de fonctionnalités de la plateforme pour prendre en charge des tâches nécessaires à votre métier, mais qui n'en font pas partie intégrante : persistance des données, requêtes HTTP, manipulation des dates et des heures, etc. Certaines peuvent être résolues avec des librairies existantes, et parfois la librairie qui fait exactement ce dont vous avez besoin n'existe tout simplement pas.
Apple investit massivement dans Swift, son langage de programmation maison, et a désormais décidé de n'exposer les nouvelles API d'iOS qu'en Swift. Cela peut poser problème, car Kotlin/Native sait exécuter du code C et Objective-C, mais pas du code Swift directement.
Tout n'est pas perdu pour autant : Swift s'interface plutôt bien avec Objective-C, nous pouvons donc utiliser Objective-C comme pont entre Swift et Kotlin.
Sachant que l'ABI de Swift est stable depuis 2019, je trouve malheureux que JetBrains n'ait pas investi dans la possibilité de faire tourner du code Swift depuis Kotlin. Cela dit, vu la complexité de la chose, je comprends le choix de concentrer l'effort sur des besoins moins spécifiques.

Un exemple d'API iOS uniquement exposée en Swift est l'API CryptoKit, introduite avec iOS 13. Imaginons que nous voulions utiliser l'algorithme ChaCha20-Poly1305 qu'elle fournit.
Pour mémoire, ChaCha20-Poly1305, affectueusement surnommé ChaChaPoly, est un chiffrement authentifié qui, comme son nom l'indique, permet de chiffrer et d'authentifier un message secret. Il est très utilisé dans les protocoles modernes, car il s'optimise très bien sur les processeurs X86 et ARM standards.
L'exemple utilisé dans cet article (ChaCha20-Poly1305) vient d'un besoin réel de l'un de mes clients, qui devait accéder à cette primitive de chiffrement depuis son code métier. Cet article existe parce que, pour permettre à du code Kotlin d'appeler du code Swift, il faut résoudre un véritable puzzle dont la documentation de chaque pièce est soit absente, soit très partielle : le pont Objective-C, l'en-tête de pontage (bridging header), l'export statique de la librairie, l'import de la librairie via le cinterop de Kotlin, et la manipulation de la mémoire native en Kotlin/Native.
Certes, pour une application, il est possible (et même, soyons pragmatiques, souhaitable) d'utiliser le pattern d'injection de dépendances pour que l'application accède à du code écrit en Swift. Cette approche n'est pas possible pour une librairie : le puzzle est donc nécessaire dans ce cas.
Tout d'abord, nous devons créer un projet Xcode qui fournira un pont Objective-C vers l'API Swift que nous voulons consommer. Pour cela, nous allons créer une librairie statique Swift.

CryptoKit n'étant disponible qu'en Swift, nous devons créer une librairie statique Swift et écrire notre propre API en façade par-dessus.

Nous devons permettre à notre API de renvoyer soit un résultat de type données, soit une erreur. Le type Result de Swift n'est pas disponible en Objective-C, car il ne sait pas gérer les génériques Swift. Écrivons donc le nôtre.
@objc public class DataResult: NSObject {
@objc public private(set) var success: Data?
@objc public private(set) var failure: Error?
private init(_ success: Data?, _ failure: Error?) {
super.init()
self.success = success
self.failure = failure
}
public convenience init(success: Data) {
self.init(success, nil)
}
public convenience init(failure: Error) {
self.init(nil, failure)
}
public convenience init(_ block: () throws -> Data) {
do {
let data = try block()
self.init(success: data)
} catch {
self.init(failure: error)
}
}
}Xcode génère automatiquement une couche d'interopérabilité Objective-C. Pour cela, deux conditions doivent être réunies :
• Une classe Swift exposée à Objective-C doit étendre NSObject
• Tous les symboles exposés à Objective-C, qu'il s'agisse de classes, de méthodes ou de propriétés, doivent être publics et annotés avec @objc.
Comme vous pouvez le voir dans ce code, nous avons uniquement annoté la classe DataResult et ses deux propriétés. Les constructeurs ne sont pas annotés, car un DataResult ne sera construit qu'en Swift.
Nous pouvons maintenant écrire notre couche d'interopérabilité :
@objc public class SwiftChachaPoly : NSObject {
@objc public class func encrypt(key: Data, nonce: Data, aad: Data?, plaintext: Data) -> DataResult {
DataResult {
let symKey = SymmetricKey(data: key)
let chaNonce: ChaChaPoly.Nonce = try ChaChaPoly.Nonce(data: nonce)
let sealedBox: ChaChaPoly.SealedBox
if let aad = aad {
sealedBox = try ChaChaPoly.seal(plaintext, using: symKey, nonce: chaNonce, authenticating: aad)
} else {
sealedBox = try ChaChaPoly.seal(plaintext, using: symKey, nonce: chaNonce)
}
return sealedBox.ciphertext + sealedBox.tag
}
}
@objc public class func decrypt(key: Data, nonce: Data, authenticatedData: Data, ciphertextAndTag: Data) -> DataResult {
DataResult {
let tagIndex = ciphertextAndTag.endIndex - 16
let ciphertext = ciphertextAndTag[ciphertextAndTag.startIndex ..< tagIndex]
let tag = ciphertextAndTag[tagIndex ..< ciphertextAndTag.endIndex]
let symKey = SymmetricKey(data: key)
let chaNonce: ChaChaPoly.Nonce = try ChaChaPoly.Nonce(data: nonce)
let sealedBox: ChaChaPoly.SealedBox = try ChaChaPoly.SealedBox(nonce: chaNonce, ciphertext :ciphertext, tag: tag)
return try ChaChaPoly.open(sealedBox, using: symKey, authenticating: authenticatedData)
}
}
}Comme DataResult, la classe SwiftChachaPoly suit les mêmes conventions d'interopérabilité Objective-C. Ses fonctions prennent des paramètres Data, automatiquement traduits en NSData côté Objective-C, et renvoient notre propre DataResult.
En interne, ces fonctions utilisent CryptoKit et sa classe ChaChaPoly ainsi que ses sous-classes. Ces types ne sont volontairement pas exposés à Objective-C : seule une interface simple, facilement traduisible, l'est.
Il reste une dernière chose à configurer dans Xcode : l'en-tête Objective-C d'interopérabilité Swift généré automatiquement.
Nous devons d'abord créer un fichier d'en-tête de pontage (bridging header) vide, et le déclarer dans la configuration de la librairie statique. Même vide, cet en-tête indique à Xcode qu'il doit lancer la génération de l'interopérabilité Objective-C.

Nous devons aussi exporter l'en-tête d'interopérabilité généré avec la librairie statique compilée. On y parvient avec une phase de build « Run Script ».

Désormais, une fois la librairie compilée, elle génère un en-tête Objective-C qui expose notre propre API ChachaPoly.
Revenons à notre projet de librairie Kotlin/Multiplatform.
Pour utiliser dans notre code Kotlin/Native la librairie statique que nous venons de créer, nous devons demander à Kotlin/Native de générer sa propre couche d'interopérabilité pour l'API Objective-C définie dans l'en-tête.
Pour cela, nous devons ajouter une phase d'interopérabilité (interop) à notre build. Ces phases se configurent à l'aide d'une définition et d'une configuration Gradle.
Si nous voulons ajouter une phase d'interop « SwiftChachaPoly », nous devons créer un fichier src/nativeInterop/cinterop/SwiftChachaPoly.def :
package = swift.chachaPoly language = Objective-C headers = SwiftChachaPoly/SwiftChachaPoly-Swift.h headerFilter = SwiftChachaPoly/* staticLibraries = libSwiftChachaPoly.a libraryPaths.ios_x64 = SwiftChachaPoly/build/Release-iphonesimulator libraryPaths.ios_arm64 = SwiftChachaPoly/build/Release-iphoneos linkerOpts = -L/usr/lib/swift linkerOpts.ios_x64 = -ios_simulator_version_min 13.0.0 -L/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphonesimulator/ linkerOpts.ios_arm64 = -iphoneos_version_min 13.0.0 -L/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/iphoneos/
Dans ce fichier, nous définissons le package dans lequel vivra le code Kotlin généré. Nous définissons aussi l'en-tête que l'outil d'interopérabilité doit lire pour trouver l'API à laquelle nous voulons accéder, et la librairie statique à embarquer avec la librairie Kotlin et à lier plus tard. Enfin, nous ajoutons quelques options de l'éditeur de liens nécessaires pour lier une librairie contenant du code Swift.
J'aimerais attirer votre attention sur les options « -*_version_min », car elles imposent que l'application iOS qui utilisera la librairie cible iOS 13 ou plus récent. L'interopérabilité Swift avec des librairies statiques requiert au minimum cette version d'iOS. Au moment de la rédaction, iOS 13 ou plus récent représente un peu plus de 90 % des appareils iOS.
Ensuite, nous devons configurer Gradle pour ajouter la phase d'interopérabilité définie :
val iosTarget: (String, KotlinNativeTarget.() -> Unit) -> KotlinNativeTarget =
if (System.getenv("SDK_NAME")?.startsWith("iphoneos") == true)
::iosArm64
else
::iosSimulatorArm64
iosTarget("ios") {
val platform = when (preset?.name) {
"iosSimulatorArm64" -> "iphonesimulator"
"iosArm64" -> "iphoneos"
else -> error("Unsupported target $name")
}
compilations.getByName("main") {
cinterops.create("SwiftChachaPoly") {
includeDirs.headerFilterOnly(
"$rootDir/SwiftChachaPoly/build/Release-$platform/include"
)
}
}
}Avec cela, nous pouvons lancer la tâche Gradle cinteropSwiftChachaPolyIos, qui générera le code Kotlin permettant d'accéder à l'API Objective-C.
Enfin, nous pouvons écrire notre propre pont Kotlin pour utiliser cette API ChachaPoly.
Nous devons d'abord convertir les ByteArray vers et depuis NSData :
internal inline fun ByteArray.toData(): NSData {
if (isEmpty()) return NSData()
val pinned = pin()
return NSData.create(
bytesNoCopy = pinned.addressOf(offset),
length = length.toULong(),
deallocator = { _, _ -> pinned.unpin() }
)
}
internal fun NSData.toByteArray(): ByteArray {
val size = length.toInt()
val bytes = ByteArray(size)
if (size > 0) {
bytes.usePinned { pinned ->
memcpy(pinned.addressOf(0), this.bytes, this.length)
}
}
return bytes
}Notez que lors de la conversion d'un ByteArray en NSData, nous utilisons l'épinglage d'objets (object pinning), afin que le NSData accède directement à la mémoire du tableau d'octets et évite ainsi toute copie.
Cette optimisation n'est pas possible dans l'autre sens : nous devons donc copier la mémoire lors de la conversion d'un NSData en tableau d'octets.
Nous pouvons ensuite écrire notre façade Kotlin de l'API :
actual object ChachaPoly {
private fun DataResult.unwrap(): NSData {
this.failure()?.let { error(it.description ?: "unknown error") }
return success() ?: error("Invalid result")
}
actual fun encrypt(
key: ByteArray,
nonce: ByteArray,
aad: ByteArray,
plaintext: ByteArray
): ByteArray {
autoreleasepool {
return SwiftChachaPoly.encryptWithKey(
key.toData(),
nonce.toData(),
aad.toData(),
plaintext.toData()
).unwrap().toByteArray()
}
}
actual fun decrypt(
key: ByteArray,
nonce: ByteArray,
aad: ByteArray,
ciphertextAndTag: ByteArray
): ByteArray {
require(ciphertextAndTag.size >= 16) {
"ciphertextAndTag should be at least 16 bytes long"
}
autoreleasepool {
return SwiftChachaPoly.decryptWithKey(
key.toData(),
nonce.toData(),
aad.toData(),
ciphertextAndTag.toData()
).unwrap().toByteArray()
}
}
}Comme vous pouvez le constater, une fois tout en place, nous n'avons besoin que d'une simple façade qui transforme les arguments et les types de retour.
Nous utilisons une fonction d'extension unwrap personnalisée sur DataResult pour lever une exception en cas d'échec. Nous utilisons aussi autoreleasepool pour garantir que tous les NSData créés dans ces méthodes sont correctement libérés au retour de la méthode.
Il ne nous reste donc plus qu'à tester ces fonctions, pour nous assurer que tout fonctionne ensemble.
Nous pouvons écrire un test Kotlin/Multiplatform très simple qui vérifie cette implémentation de ChaCha20-Poly1305 :
class ChachaPolyTests {
@Test fun `encrypt & decrypt simple text`() {
val key =
"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
.fromHex()
val nonce = "00000000fedcba9876543210".fromHex()
val plaintext = "Hello, world!".encodeToByteArray()
val aad = ByteArray(0)
val ciphertextAndTag = ChachaPoly.encrypt(
key, nonce, aad, plaintext
)
assertEquals(
"295de91218883c99efed30a0ea56db82d1f05aa5350f49f32f923ce345",
ciphertextAndTag.toHex()
)
val otherPlaintext = ChachaPoly.decrypt(
key, nonce, aad, ciphertextAndTag
)
assertTrue(plaintext.contentEquals(otherPlaintext))
}
}Ce test crée une fausse clé de chiffrement et un nonce, chiffre le message « Hello, World! » et vérifie les octets obtenus. Il le déchiffre ensuite et vérifie que le message déchiffré est égal au « Hello, World! » d'origine.
Ainsi, nous pouvons nous assurer que notre chaîne Kotlin-vers-Objective-C-vers-Swift fonctionne comme prévu.
Au final, cela fait pas mal de plomberie pour une seule primitive de chiffrement. Mais pour une librairie, où l'injection de dépendances n'est pas une option, on ne peut pas y couper ; j'espère que cet article vous évitera de chercher une documentation absente ou éparpillée. J'aimerais bien que tout cela devienne beaucoup plus simple un jour.
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.
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
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
02/11/2026
Inara : injectez vos dépendances à la compilation
J'ai créé Kodein, et pourtant je crois aujourd'hui qu'il nuit à l'écosystème Kotlin Multiplatform. Voici Inara, un Kotlin Symbol Processor qui résout vos dépendances à la compilation, et découvrez pourquoi nous mettons Kodein en fin de vie.
Lire plus
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
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
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