O Kotlin Multiplatform (KMP) e uma das tecnologias mais promissoras do ecossistema de desenvolvimento moderno. Depois de anos em desenvolvimento e beta, KMP atingiu estabilidade e esta mudando a forma como empresas pensam sobre compartilhamento de codigo. Neste artigo, vamos explorar onde o KMP esta hoje, para onde esta indo e por que voce deveria prestar atencao.

O Que e KMP e Por Que Importa

Kotlin Multiplatform permite que voce escreva codigo Kotlin que compila para multiplas plataformas: JVM (Android, server), nativo (iOS, macOS, Linux, Windows), JavaScript e WebAssembly. A ideia central nao e “write once, run anywhere” como Java prometia, mas sim “write once, adapt where needed”.

// commonMain - Codigo que roda em TODAS as plataformas
interface UserRepository {
    suspend fun getUser(id: String): User?
    suspend fun saveUser(user: User)
    fun observeUsers(): Flow<List<User>>
}

class UserRepositoryImpl(
    private val api: UserApi,
    private val cache: UserCache,
    private val dispatcher: CoroutineDispatcher
) : UserRepository {

    override suspend fun getUser(id: String): User? {
        return withContext(dispatcher) {
            cache.get(id) ?: api.fetchUser(id)?.also { user ->
                cache.save(user)
            }
        }
    }

    override suspend fun saveUser(user: User) {
        withContext(dispatcher) {
            api.updateUser(user)
            cache.save(user)
        }
    }

    override fun observeUsers(): Flow<List<User>> {
        return cache.observeAll()
            .onStart {
                val remote = api.fetchAllUsers()
                cache.saveAll(remote)
            }
    }
}

Esse codigo funciona identicamente no Android, iOS, desktop e server. Apenas as implementacoes especificas de plataforma (como acesso a banco de dados ou sistema de arquivos) precisam de adaptacao.

Estado Atual do KMP

Bibliotecas Estáveis

O ecossistema de bibliotecas KMP cresceu enormemente:

// build.gradle.kts - Dependencias KMP
kotlin {
    sourceSets {
        commonMain.dependencies {
            // Networking
            implementation("io.ktor:ktor-client-core:3.0.0")

            // Serializacao
            implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.0")

            // Coroutines
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")

            // Date/Time
            implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.0")

            // Database
            implementation("app.cash.sqldelight:runtime:2.1.0")

            // DI
            implementation("io.insert-koin:koin-core:4.0.0")
        }
    }
}

Todas essas bibliotecas sao maduras, bem mantidas e usadas em producao por empresas globais.

Empresas Que Usam KMP

A lista de empresas usando KMP em producao e impressionante e continua crescendo:

  • Netflix: Compartilha logica entre Android e iOS
  • Cash App: Pioneira no uso de KMP para mobile
  • Philips: Usa KMP em dispositivos medicos
  • VMware: Compartilha logica em ferramentas enterprise
  • Touchlab: Consultoria especializada em KMP

No Brasil, fintechs e bancos digitais estao adotando KMP para reduzir duplicacao de logica entre plataformas mobile.

Arquitetura de Projetos KMP

Estrutura de Modulos

Uma arquitetura KMP bem organizada segue o principio de separacao por feature:

// Estrutura tipica de projeto KMP
// shared/
//   commonMain/     -> Codigo compartilhado
//   androidMain/    -> Implementacoes Android
//   iosMain/        -> Implementacoes iOS
//   jvmMain/        -> Implementacoes JVM (server)

// Definicao de plataforma
expect class DatabaseDriverFactory {
    fun createDriver(): SqlDriver
}

// androidMain
actual class DatabaseDriverFactory(private val context: Context) {
    actual fun createDriver(): SqlDriver {
        return AndroidSqliteDriver(
            AppDatabase.Schema,
            context,
            "app.db"
        )
    }
}

// iosMain
actual class DatabaseDriverFactory {
    actual fun createDriver(): SqlDriver {
        return NativeSqliteDriver(
            AppDatabase.Schema,
            "app.db"
        )
    }
}

ViewModel Compartilhado

Uma das evolucoes mais significativas e a possibilidade de compartilhar ViewModels entre plataformas:

// commonMain - ViewModel compartilhado
class ProductListViewModel(
    private val repository: ProductRepository
) : ViewModel() {

    private val _uiState = MutableStateFlow(ProductListState())
    val uiState: StateFlow<ProductListState> = _uiState.asStateFlow()

    init {
        loadProducts()
    }

    fun loadProducts() {
        viewModelScope.launch {
            _uiState.update { it.copy(loading = true) }
            repository.getProducts()
                .onSuccess { products ->
                    _uiState.update {
                        it.copy(loading = false, products = products)
                    }
                }
                .onFailure { error ->
                    _uiState.update {
                        it.copy(loading = false, error = error.message)
                    }
                }
        }
    }

    fun search(query: String) {
        viewModelScope.launch {
            val filtered = repository.searchProducts(query)
            _uiState.update { it.copy(products = filtered) }
        }
    }
}

data class ProductListState(
    val loading: Boolean = false,
    val products: List<Product> = emptyList(),
    val error: String? = null
)

O Futuro: Compose Multiplatform

O proximo grande passo do KMP e o Compose Multiplatform, que permite compartilhar ate a camada de UI:

// Compose Multiplatform - UI compartilhada entre Android, iOS e desktop
@Composable
fun ProductListScreen(viewModel: ProductListViewModel) {
    val state by viewModel.uiState.collectAsState()

    Scaffold(
        topBar = {
            TopAppBar(title = { Text("Produtos") })
        }
    ) { padding ->
        when {
            state.loading -> {
                Box(
                    modifier = Modifier.fillMaxSize(),
                    contentAlignment = Alignment.Center
                ) {
                    CircularProgressIndicator()
                }
            }
            state.error != null -> {
                ErrorMessage(
                    message = state.error!!,
                    onRetry = { viewModel.loadProducts() }
                )
            }
            else -> {
                LazyColumn(contentPadding = padding) {
                    items(state.products) { product ->
                        ProductItem(product)
                    }
                }
            }
        }
    }
}

Com Compose Multiplatform, a promessa e: escreva a UI uma vez e rode em Android, iOS, desktop e web. E diferente do Flutter porque usa componentes nativos do Material Design e permite integrar componentes nativos da plataforma quando necessario.

Desafios e Limitacoes Atuais

Nem tudo sao flores. O KMP ainda tem desafios:

Build Times

Projetos KMP grandes podem ter tempos de build significativos. A JetBrains esta trabalhando em melhorias no compilador K2 que prometem reduzir isso substancialmente.

Debugging iOS

Debugar codigo Kotlin rodando no iOS ainda nao e tao fluido quanto debugar codigo Swift nativo. Melhorias estao vindo, mas e uma area que precisa de atencao.

Curva de Aprendizado

Para times que nao conhecem Kotlin, a curva de aprendizado inclui nao apenas a linguagem mas tambem o sistema de build com Gradle, a configuracao de targets e as particularidades de cada plataforma.

Roadmap e Expectativas

A JetBrains tem investido pesadamente no KMP, e as proximas evolucoes incluem:

  • Compose Multiplatform para iOS estavel: A interface compartilhada entre todas as plataformas
  • Melhorias no Kotlin/Native: Performance e tooling para targets nativos
  • Kotlin/WASM: Rodar Kotlin no navegador com performance nativa
  • Integracao com SwiftUI: Melhor interop com o ecossistema Apple
  • Compilador K2: Compilacao mais rapida e recursos novos da linguagem

Como Comecar com KMP

Se voce quer comecar com KMP hoje, siga estes passos:

  1. Domine Kotlin: Certifique-se de que voce conhece bem a linguagem
  2. Crie um projeto KMP simples: Use o wizard do Android Studio ou o KMP plugin do IntelliJ
  3. Comece pela camada de dados: Compartilhe networking e modelos de dados primeiro
  4. Expanda gradualmente: Adicione logica de negocios, ViewModels e eventualmente UI
  5. Contribua para o ecossistema: Muitas bibliotecas precisam de suporte KMP
// Primeiro projeto KMP - Networking compartilhado
// commonMain
class ApiClient(private val httpClient: HttpClient) {
    suspend fun getPosts(): List<Post> {
        return httpClient.get("https://api.example.com/posts").body()
    }
}

@Serializable
data class Post(
    val id: Int,
    val title: String,
    val body: String,
    val userId: Int
)

Conclusao

O futuro do Kotlin Multiplatform e extremamente promissor. A tecnologia saiu do estagio experimental e esta pronta para producao. Com Compose Multiplatform amadurecendo, Kotlin/WASM avancando e o ecossistema de bibliotecas crescendo, KMP esta se posicionando como a plataforma multiplataforma mais completa e robusta do mercado.

Para desenvolvedores e empresas brasileiras, adotar KMP agora significa estar a frente da curva. O investimento em aprendizado hoje se traduz em produtividade e oportunidades amanha. Acompanhe o blog do Kotlin Brasil para ficar por dentro de todas as novidades do ecossistema KMP.