---
title: "How to Install Kotlin in 2026: Windows, Mac, Linux e Android Studio"
url: "https://kotlin.dev.br/perguntas/como-instalar-kotlin/"
markdown_url: "https://kotlin.dev.br/perguntas/como-instalar-kotlin.MD"
description: "How to install Kotlin in 2026: passo a passo para Windows, macOS, Linux, IntelliJ IDEA, Android Studio, SDKMAN!, Homebrew, JDK 17 e JDK 21."
date: "2026-01-30"
author: "Karina Melo"
---

# How to Install Kotlin in 2026: Windows, Mac, Linux e Android Studio

How to install Kotlin in 2026: passo a passo para Windows, macOS, Linux, IntelliJ IDEA, Android Studio, SDKMAN!, Homebrew, JDK 17 e JDK 21.


## Como instalar Kotlin?

<div data-growth-refresh="2026-06-15-install-kotlin-gsc">

**Quick answer in English:** the easiest way to install Kotlin is to install IntelliJ IDEA Community Edition or Android Studio; both already include Kotlin support. For command-line use on macOS or Linux, install SDKMAN! and run `sdk install kotlin`. On Windows, install IntelliJ IDEA or Android Studio first; if you want a terminal setup, install JDK 21 and use the Kotlin compiler through Gradle or WSL + SDKMAN!. You also need a JDK, preferably JDK 17 or JDK 21.

**Resposta rápida em português:** a forma mais simples de instalar Kotlin é usar o IntelliJ IDEA Community Edition ou o Android Studio, porque eles já vêm com suporte a Kotlin. No Windows, comece pelo IntelliJ/Android Studio; no macOS e Linux, use SDKMAN! com `sdk install kotlin`; no macOS com Homebrew, `brew install kotlin` também funciona. Você também precisa de um JDK, de preferência JDK 17 ou JDK 21.

</div>

Tá pronto pra botar a mão na massa? Então bora instalar o Kotlin no seu computador. Existem várias formas de fazer isso, e vou te mostrar as principais.

### How to install Kotlin: escolha o caminho certo

Antes do passo a passo, escolha pelo seu objetivo:

| Objetivo | Melhor instalação | Comando ou download |
|---|---|---|
| Aprender Kotlin do zero | IntelliJ IDEA Community | Baixar em `jetbrains.com/idea/download` |
| Criar app Android | Android Studio | Baixar em `developer.android.com/studio` |
| Windows com terminal | JDK 21 + Gradle ou WSL | `java -version` e projeto Gradle Kotlin |
| macOS/Linux no terminal | SDKMAN! | `sdk install kotlin` |
| macOS com Homebrew | Homebrew | `brew install kotlin` |
| Testar sem instalar | Kotlin Playground | `play.kotlinlang.org` |

Se você pesquisou **"how to install Kotlin"** e só quer começar rápido: instale o IntelliJ, crie um projeto Kotlin/JVM e rode o arquivo `Main.kt`. Se você já usa terminal, instale JDK 21 + SDKMAN! + Kotlin.

### Opção 1: IntelliJ IDEA (Recomendada)

A forma mais simples de começar é instalando o **IntelliJ IDEA Community Edition**, que é gratuito e já vem com suporte completo a Kotlin embutido:

1. Acesse [jetbrains.com/idea/download](https://www.jetbrains.com/idea/download/)
2. Baixe a **Community Edition** (gratuita)
3. Instale normalmente no seu sistema operacional
4. Abra o IntelliJ e crie um novo projeto Kotlin

Pronto! Sem configuração extra, sem dor de cabeça. O IntelliJ cuida de tudo pra você.

O IntelliJ também oferece recursos avançados como autocompletar inteligente, refatoração automatizada, depuração integrada e suporte nativo a [Gradle](/glossario/gradle-plugin/). Para quem está começando, a experiência de desenvolvimento é muito superior a usar apenas um editor de texto simples.

### Opção 2: Android Studio (Para desenvolvimento mobile)

Se seu foco é Android, o **Android Studio** é o caminho:

1. Acesse [developer.android.com/studio](https://developer.android.com/studio)
2. Baixe e instale o Android Studio
3. Ele já vem com Kotlin configurado por padrão

O Android Studio é baseado no IntelliJ IDEA, então a experiência é bem parecida, mas com ferramentas extras voltadas para mobile: emulador de dispositivos, inspetor de layout, profiler de performance e integração com o Google Play. Se quiser um passo a passo detalhado, confira nosso [tutorial de Kotlin com Android Studio](/tutoriais/kotlin-android-studio/) e o [guia de desenvolvimento Android](/guias/guia-kotlin-android-desenvolvimento/).


### Install Kotlin on Windows in 2026

For most Windows users, the fastest and least error-prone path is still **IntelliJ IDEA Community Edition**. It bundles Kotlin project templates, detects the JDK automatically and creates a runnable `Main.kt` without requiring you to edit `PATH` by hand. If your goal is Android, use **Android Studio** instead, because it installs the Android SDK, emulator and Gradle integration in the same flow.

A practical Windows setup looks like this:

1. Install **JDK 21** from Eclipse Temurin, Microsoft Build of OpenJDK or another trusted distribution.
2. Install **IntelliJ IDEA Community**.
3. Create a new **Kotlin/JVM** project with Gradle.
4. Run the generated `main` function from the IDE.
5. Only after that, configure terminal usage if you really need `kotlinc` globally.

To check the JDK from PowerShell, run:

```powershell
java -version
where java
```

If `java -version` fails, fix Java before installing Kotlin tooling. Most Kotlin installation problems on Windows are actually JDK or `PATH` problems. For command-line heavy work, many developers prefer **WSL + SDKMAN!**, because it matches the Linux/macOS instructions and makes version switching easier.

### Install Kotlin on Linux in 2026

On Linux, **SDKMAN!** is usually better than distro packages because it gives you current Kotlin and Java versions. Some distributions ship an older compiler, which can confuse beginners when a tutorial expects newer language features. Use distro packages only when you need system-managed tooling for a locked-down environment.

Recommended Linux flow:

```bash
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install java 21-tem
sdk install kotlin
java -version
kotlin -version
```

If you are setting up a real backend or Android project, do not depend on a global compiler forever. Let **Gradle** pin the Kotlin plugin version in `build.gradle.kts`, then use the project wrapper (`./gradlew`) so the whole team builds with the same version. See also our guide to [Gradle with Kotlin](/tutoriais/kotlin-gradle-tutorial/) and the comparison [Gradle Kotlin DSL vs Groovy](/comparacoes/gradle-kotlin-vs-groovy/).

### Install Kotlin from command line with SDKMAN!

For English readers: SDKMAN! is the most convenient command-line installer for Kotlin on macOS and Linux because it manages Kotlin versions and JDK versions in one place. Install SDKMAN!, open a new terminal, then run `sdk install kotlin` and check `kotlin -version`.

### Opção 3: Linha de comando (SDKMAN!)

Pra quem curte o terminal, o **SDKMAN!** é a forma mais prática de gerenciar o Kotlin no macOS e Linux:

```bash
# Instalar o SDKMAN!
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"

# Instalar o Kotlin
sdk install kotlin

# Verificar a instalação
kotlin -version
```

Depois de instalado, você pode compilar e rodar arquivos Kotlin direto pelo terminal:

```bash
# Criar um arquivo
echo 'fun main() { println("Kotlin instalado com sucesso!") }' > ola.kt

# Compilar e rodar
kotlinc ola.kt -include-runtime -d ola.jar
java -jar ola.jar
```

A grande vantagem do SDKMAN! é que ele permite ter **múltiplas versões** do Kotlin instaladas ao mesmo tempo e alternar entre elas facilmente com `sdk use kotlin <versão>`. Isso é muito útil quando você trabalha em projetos que exigem versões diferentes.

### Install Kotlin on macOS with Homebrew

If your search intent is specifically **brew Kotlin** or **install Kotlin Mac**, Homebrew works well for one global Kotlin version. Use SDKMAN! instead when you need to switch versions per project.

### Opção 4: Homebrew (macOS)

No macOS, se você já usa Homebrew:

```bash
brew install kotlin
kotlin -version
```

Simples e direto. A desvantagem em relação ao SDKMAN! é que o Homebrew gerencia apenas uma versão por vez. Se você precisa alternar entre versões, o SDKMAN! é a melhor escolha.

### Opção 5: Snap (Linux)

No Linux, além do SDKMAN!, você pode instalar via Snap em distribuições que suportam esse gerenciador:

```bash
sudo snap install kotlin --classic
kotlin -version
```

Para distribuições baseadas em Debian/Ubuntu que preferem usar o gerenciador de pacotes nativo, verifique se o Kotlin está disponível nos repositórios oficiais da sua distro.

### Opção 6: Sem instalar nada

Se quiser apenas testar a linguagem antes de instalar qualquer coisa, use o **Kotlin Playground** direto no navegador:

```kotlin
// Cole isso em play.kotlinlang.org e clique em Run
fun main() {
    val linguagem = "Kotlin"
    val versao = "2.1"

    println("$linguagem $versao rodando no navegador!")
    println("Nenhuma instalacao necessaria")
}
```

Acesse [play.kotlinlang.org](https://play.kotlinlang.org/) e comece a codar imediatamente. O Playground suporta até importações de bibliotecas como `kotlinx.coroutines`, então dá pra testar bastante coisa sem instalar nada. Para aprender sobre [coroutines](/perguntas/o-que-sao-coroutines/) e [funções](/glossario/fun/) da linguagem, o Playground é um ótimo ponto de partida.

### Pré-requisitos importantes

Independente da opção escolhida, você precisa do **JDK (Java Development Kit)** instalado, já que Kotlin roda na JVM. O IntelliJ e o Android Studio geralmente cuidam disso automaticamente, mas se for usar a linha de comando:

```bash
# Instalar JDK via SDKMAN!
sdk install java 21-tem

# Verificar
java -version
```

A versão recomendada do JDK é a **17 ou superior** (LTS). O JDK 21 é a versão LTS mais recente e funciona muito bem com Kotlin. Evite usar versões muito antigas (abaixo do 11), pois algumas funcionalidades mais novas do Kotlin podem não funcionar corretamente.

### Configurando o Gradle

Para projetos mais estruturados, você vai precisar do [Gradle](/tutoriais/kotlin-gradle-tutorial/) como ferramenta de build. A boa notícia é que o IntelliJ e o Android Studio configuram o Gradle automaticamente ao criar um novo projeto. Se quiser configurar manualmente, o arquivo `build.gradle.kts` básico fica assim:

```kotlin
plugins {
    kotlin("jvm") version "2.1.0"
    application
}

repositories {
    mavenCentral()
}

dependencies {
    testImplementation(kotlin("test"))
}

application {
    mainClass.set("MainKt")
}
```

Temos um [tutorial completo de Gradle com Kotlin](/tutoriais/kotlin-gradle-tutorial/) que cobre tudo isso em detalhes.

### Verificação rápida da instalação

Depois de instalar, rode estes comandos:

```bash
java -version
kotlin -version
kotlinc -version
```

Crie também um arquivo `Main.kt`:

```kotlin
fun main() {
    println("Kotlin instalado com sucesso")
}
```

E execute:

```bash
kotlinc Main.kt -include-runtime -d app.jar
java -jar app.jar
```

Se isso imprimir `Kotlin instalado com sucesso`, a instalação básica está funcionando. Para um primeiro projeto real, siga para [primeiro programa em Kotlin](/tutoriais/primeiro-programa-kotlin/) ou [Kotlin com Gradle](/tutoriais/kotlin-gradle-tutorial/).

### Dicas de solução de problemas

Às vezes a instalação não sai de primeira. Aqui vão alguns problemas comuns e como resolver:

**"kotlin: command not found"** -- Isso acontece quando o Kotlin não está no PATH do sistema. Se usou SDKMAN!, execute `source "$HOME/.sdkman/bin/sdkman-init.sh"` ou reinicie o terminal. No macOS com Homebrew, verifique se `/opt/homebrew/bin` está no seu PATH. No Windows, prefira rodar pelo IntelliJ/Gradle antes de tentar instalar `kotlinc` globalmente.

**"Error: JAVA_HOME is not set"** -- O Kotlin precisa do JDK pra funcionar. Instale o JDK conforme descrito acima e configure a variável de ambiente `JAVA_HOME` apontando para o diretório de instalação. Em projetos Gradle, confirme também com `./gradlew -version`.

**Versão do Kotlin incompatível com o projeto** -- Se ao abrir um projeto você vê erros de compatibilidade, verifique a versão do Kotlin configurada no `build.gradle.kts` e certifique-se de que o JDK instalado é compatível. O IntelliJ geralmente sugere a correção automaticamente.

**IntelliJ lento ou travando** -- Aumente a memória alocada para o IDE em Help > Change Memory Settings. Para projetos Kotlin, 2 GB de heap é um bom ponto de partida.

### E agora?

Com o Kotlin instalado, o próximo passo é criar seu primeiro projeto. Recomendo começar com algo simples: uma calculadora, uma lista de tarefas ou qualquer coisa que te motive a escrever código. O importante é praticar!

Se quiser um caminho estruturado, siga esta ordem:

1. [Primeiro programa em Kotlin](/tutoriais/primeiro-programa-kotlin/) -- o famoso "Olá, mundo" e seus primeiros passos
2. [Variáveis e tipos](/tutoriais/variaveis-e-tipos/) -- entenda [val](/glossario/val/), [var](/glossario/var/) e o sistema de tipos
3. [Estruturas condicionais](/tutoriais/estruturas-condicionais/) -- if, [when](/glossario/when/) e expressões
4. [Funções em Kotlin](/tutoriais/funções-kotlin/) -- como criar e usar funções
5. [Classes e objetos](/tutoriais/classes-e-objetos-kotlin/) -- programação orientada a objetos

Aqui no **Kotlin Brasil** você encontra vários tutoriais e o [guia completo de Kotlin](/guias/guia-completo-kotlin/) pra te acompanhar nessa jornada.