Kotlin Multiplatform (KMP) has become one of the most attractive technologies in modern development. It’s not a new framework, but an extension of the Kotlin language itself that allows writing common code reusable across multiple platforms without sacrificing performance or native integrations.
You’ll learn what it is, how it works and how to start creating your first multi-platform module.
KMP permite escribir:
– Business Logic
– Networking
– Data Management
– Serialization
– Validations
– Authentication Logic
And sharing it among:
– Android
– iOS
– Web (JavaScript)
– Desktop
The key advantage is that it does not replace native interfaces. You can continue creating views in SwiftUI, Jetpack Compose or React, but using the same underlying logic.
A multi-platform project is organized into three blocks:
The system uses the expect/actual pattern to declare common functionalities and then implements them according to the platform.
In IntelliJ IDEA or Android Studio:
Select New Project → Kotlin Multiplatform → KMP Shared Module.
Select platforms: Android + iOS.
This will generate the shared module structure.
Ejemplo básico: un validador de email multiplataforma.
In commonMain:
class EmailValidator { fun isValid(email: String): Boolean { return email.matches(Regex("^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$")) } }
This code will be used by Android, iOS and Web without changes.
Let’s implement a secure hashing function that will depend on specific implementations according to the platform.
In commonMain:
expect class Hasher() { fun sha256(input: String): String }
In androidMain:
actual class Hasher { actual fun sha256(input: String): String { val md = java.security.MessageDigest.getInstance("SHA-256") val digest = md.digest(input.toByteArray()) return digest.joinToString("") { "%02x".format(it) } } }
In iOS (Swift compiled by Kotlin/Native):
actual class Hasher { actual fun sha256(input: String): String { return platform.foundation.NSString.create(input).dataUsingEncoding(4) ?.let { data -> // Native call to CommonCrypto val hash = ByteArray(32) CC_SHA256(data.bytes, data.length.convert(), hash.refTo(0)) hash.joinToString("") { "%02x".format(it) } } ?: "" } }
Here you can see the power of KMP: common logic, native customization where necessary.
In the Android module:
val validator = EmailValidator() println(validator.isValid("[email protected]"))
Step 5: Using it from iOS
KMP exports the module to an Xcode framework:
In SwiftUI:
let validator = SharedEmailValidator() print(validator.isValid(email: "[email protected]"))
Real benefits in 2025 projects
- Reduced maintenance cost.
- Avoids creating separate logic for Android and iOS.
- Flexibility with native code when needed.
- Ideal for large projects, corporate apps, and startups.
- Fits modern architectures like Clean Architecture and MVVM.
When NOT to use Kotlin Multiplatform
– If you want to write shared screens (in that case, better Flutter or React Native).
– If your app has very specific dependencies for each platform.
– If your team is not experienced with Kotlin.
