---
title: "Kotlin Pode Ser Usado para Desenvolver para iOS? | Kotlin Brasil"
url: "https://kotlin.dev.br/perguntas/kotlin-para-ios/"
markdown_url: "https://kotlin.dev.br/perguntas/kotlin-para-ios.MD"
description: "Saiba como usar Kotlin para criar aplicativos iOS com Kotlin Multiplatform. Veja exemplos práticos, vantagens e limitações da tecnologia."
date: "2025-10-06"
author: "Karina Melo"
---

# Kotlin Pode Ser Usado para Desenvolver para iOS? | Kotlin Brasil

Saiba como usar Kotlin para criar aplicativos iOS com Kotlin Multiplatform. Veja exemplos práticos, vantagens e limitações da tecnologia.


## Kotlin pode ser usado para desenvolver para iOS?

**Sim, Kotlin pode ser usado para desenvolvimento iOS através do Kotlin Multiplatform (KMP)**. Essa tecnologia permite compartilhar código Kotlin entre Android, iOS, desktop e web, mantendo a interface nativa de cada plataforma. Vamos explorar como isso funciona na prática, quais são as possibilidades e limitações, e se vale a pena investir nessa abordagem.

### O que é Kotlin Multiplatform?

Kotlin Multiplatform é uma tecnologia desenvolvida pela JetBrains que permite escrever lógica de negocios em Kotlin e compartilha-la entre diferentes plataformas. Para iOS especificamente, o KMP compila o código Kotlin para binarios nativos usando o compilador Kotlin/Native, que gera frameworks que podem ser consumidos diretamente pelo Swift ou Objective-C.

O ponto fundamental e que o KMP não substitui a UI nativa. No iOS, você continua usando SwiftUI ou UIKit para construir a interface. O que muda e que a lógica por tras da interface (regras de negócio, acesso a API, manipulação de dados) pode ser escrita uma única vez em Kotlin.

### Como funciona na prática

Um projeto KMP tipico e organizado em modulos:

```kotlin
// Modulo compartilhado (shared) - roda em Android e iOS

// Definicao de uma interface expect/actual para funcionalidades de plataforma
expect class Plataforma() {
    val nome: String
}

// Logica de negocios compartilhada
class RepositorioUsuario(private val api: ApiServico) {

    suspend fun buscarUsuarios(): List<Usuario> {
        return api.obterUsuarios()
            .filter { it.ativo }
            .sortedBy { it.nome }
    }

    suspend fun buscarUsuarioPorId(id: Long): Resultado<Usuario> {
        return try {
            val usuario = api.obterUsuario(id)
            Resultado.Sucesso(usuario)
        } catch (e: Exception) {
            Resultado.Erro("Falha ao buscar usuario: ${e.message}")
        }
    }
}

// Modelo compartilhado
data class Usuario(
    val id: Long,
    val nome: String,
    val email: String,
    val ativo: Boolean
)

sealed class Resultado<out T> {
    data class Sucesso<T>(val dados: T) : Resultado<T>()
    data class Erro(val mensagem: String) : Resultado<Nothing>()
}
```

No lado iOS, o código Swift consome esse modulo compartilhado de forma natural:

```kotlin
// Implementacao especifica para iOS (actual)
actual class Plataforma actual constructor() {
    actual val nome: String = "iOS ${UIDevice.current.systemVersion}"
}
```

### Bibliotecas multiplataforma essenciais

O ecossistema KMP tem crescido rapidamente, e várias bibliotecas populares já oferecem suporte multiplataforma:

```kotlin
// Ktor para chamadas HTTP multiplataforma
class ApiServico {
    private val client = HttpClient {
        install(ContentNegotiation) {
            json(Json {
                prettyPrint = true
                isLenient = true
                ignoreUnknownKeys = true
            })
        }
    }

    suspend fun obterUsuarios(): List<Usuario> {
        return client.get("https://api.exemplo.com/usuarios").body()
    }
}

// SQLDelight para banco de dados local multiplataforma
// As queries SQL são compartilhadas entre plataformas
// CREATE TABLE Usuario (
//     id INTEGER PRIMARY KEY,
//     nome TEXT NOT NULL,
//     email TEXT NOT NULL
// );
```

Principais bibliotecas multiplataforma:
- **Ktor**: cliente HTTP
- **SQLDelight**: banco de dados local
- **Koin**: injeção de dependências
- **Kotlinx.serialization**: serialização JSON
- **Kotlinx.coroutines**: programação assíncrona
- **Kotlinx.datetime**: manipulação de datas

### Vantagens de usar Kotlin para iOS

1. **Compartilhamento de lógica**: escrever regras de negócio uma única vez reduz bugs e inconsistencias entre plataformas
2. **Equipe unificada**: desenvolvedores Kotlin podem contribuir para ambas as plataformas
3. **Kotlin/Native performatico**: o código compilado roda com performance proxima ao nativo
4. **UI permanece nativa**: a experiência do usuário não e comprometida, pois SwiftUI e UIKit continuam sendo usados
5. **Adoção gradual**: você pode começar compartilhando apenas um modulo e expandir aos poucos
6. **Empresas de referência**: Netflix, Cash App, Philips e VMware já usam KMP em producao

### Limitações e desafios

1. **Curva de aprendizado**: configurar o ambiente e entender o sistema expect/actual leva tempo
2. **Necessidade de conhecer Swift**: para a camada de UI, você ainda precisa de Swift ou Objective-C
3. **Mac obrigatório**: para compilar para iOS, você precisa de um Mac com Xcode instalado
4. **Ecossistema ainda em amadurecimento**: embora tenha crescido muito, nem todas as bibliotecas iOS tem equivalente KMP
5. **Debug entre plataformas**: debugar problemas específicos do iOS em código Kotlin pode ser mais trabalhoso

### KMP vs outras abordagens multiplataforma

**KMP vs Flutter:**
- KMP mantém a UI nativa; Flutter usa seu próprio motor de renderizacao
- KMP permite adoção gradual; Flutter exige reescrever toda a UI
- Flutter tem mais widgets prontos; KMP depende dos componentes nativos de cada plataforma

**KMP vs React Native:**
- KMP compila para binario nativo; React Native usa uma ponte JavaScript
- KMP tem melhor performance; React Native pode ter gargalos na ponte
- React Native tem ecossistema mais maduro; KMP esta crescendo rapidamente

### Compose Multiplatform: o futuro da UI

A JetBrains esta desenvolvendo o Compose Multiplatform, que leva o Jetpack Compose para além do Android. Com essa tecnologia, sera possível compartilhar não apenas a lógica, mas também a interface do usuário entre plataformas.

```kotlin
// Compose Multiplatform - UI compartilhada (ainda em evolução para iOS)
@Composable
fun TelaListaUsuarios(viewModel: UsuarioViewModel) {
    val usuarios by viewModel.usuarios.collectAsState()

    LazyColumn {
        items(usuarios) { usuario ->
            CartaoUsuario(usuario)
        }
    }
}

@Composable
fun CartaoUsuario(usuario: Usuario) {
    Card(
        modifier = Modifier
            .fillMaxWidth()
            .padding(8.dp)
    ) {
        Column(modifier = Modifier.padding(16.dp)) {
            Text(text = usuario.nome, style = MaterialTheme.typography.titleMedium)
            Text(text = usuario.email, style = MaterialTheme.typography.bodyMedium)
        }
    }
}
```

O Compose Multiplatform para iOS esta em fase de maturacao, mas já e funcional e promissor. Essa abordagem pode revolucionar o desenvolvimento multiplataforma nos próximos anos.

### Vale a pena usar Kotlin para iOS?

**Sim, se:**
- Você já tem uma equipe que domina Kotlin
- Seu aplicativo tem lógica de negocios complexa que precisa ser consistente entre plataformas
- Você quer reduzir custos mantendo a qualidade nativa da UI
- Sua empresa esta disposta a investir na configuração inicial

**Talvez não, se:**
- Você precisa de um app exclusivamente para iOS (Swift puro seria mais direto)
- Sua equipe não tem experiência com Kotlin
- O app e muito simples e não justifica a complexidade adicional

### Perguntas relacionadas

- [O que é Kotlin Multiplatform?](/perguntas/kotlin-multiplatform-o-que-e/)
- [Kotlin ou Flutter: qual escolher?](/perguntas/kotlin-ou-flutter/)
- [Kotlin pode ser usado para web?](/perguntas/kotlin-para-web/)
- [Kotlin vale a pena em 2026?](/perguntas/kotlin-vale-a-pena-2026/)
- [Apps desktop com Kotlin](/perguntas/kotlin-desktop-apps/)