Se você trabalha com dados e sempre associou notebooks interativos ao Python e Jupyter, é hora de conhecer o Kotlin Notebook. Integrado ao IntelliJ IDEA e com suporte a bibliotecas poderosas como DataFrame e Kandy, o Kotlin Notebook está se consolidando como uma alternativa real para análise de dados — com a vantagem de tipagem estática e toda a expressividade do Kotlin.

Com as novidades de 2026 e palestras dedicadas na KotlinConf 2026 e IntelliJ IDEA Conf, a ferramenta ganha cada vez mais atenção. Neste artigo, você vai aprender o que é, como funciona e como começar a usar na prática.

O que é o Kotlin Notebook?

O Kotlin Notebook é um ambiente de desenvolvimento interativo baseado em células, integrado diretamente ao IntelliJ IDEA. Ele permite:

  • Executar código Kotlin em células com resultado imediato
  • Misturar código, texto em Markdown e visualizações no mesmo documento
  • Explorar dados com feedback instantâneo
  • Exportar como .ipynb (compatível com Jupyter)

O Kotlin Notebook é baseado no Kotlin Kernel para Jupyter Notebooks, o que garante compatibilidade com Jupyter, Datalore e outras ferramentas do ecossistema.

Setup: zero configuração

A melhor parte? O plugin do Kotlin Notebook já vem bundled e habilitado no IntelliJ IDEA. Basta criar um novo arquivo .ipynb e começar a escrever código Kotlin. Não precisa instalar interpretadores Python, ambientes virtuais ou dependências externas.

Carregando e explorando dados com DataFrame

A biblioteca Kotlin DataFrame permite carregar, filtrar, transformar e analisar dados estruturados com uma API tipada e idiomática.

Importando a dependência

Em uma célula do notebook, basta usar a anotação %use:

%use dataframe

Lendo um arquivo CSV

val dados = DataFrame.read("vendas-2026.csv")
dados.head(5)

A saída aparece como uma tabela formatada diretamente no notebook, semelhante a um pandas.DataFrame no Python.

Filtrando e transformando dados

// Filtrando vendas acima de R$ 1000
val vendasAltas = dados
    .filter { "valor"<Double>() > 1000.0 }
    .sortByDesc("valor")

vendasAltas.head(10)

Agrupando e agregando

// Total de vendas por região
val totalPorRegiao = dados
    .groupBy("regiao")
    .aggregate {
        sum("valor") into "total_vendas"
        count() into "quantidade"
    }
    .sortByDesc("total_vendas")

totalPorRegiao

A grande vantagem sobre Python é que o DataFrame do Kotlin gera tipos automaticamente a partir dos dados. Quando você carrega um CSV, as colunas viram propriedades tipadas — erros de nome de coluna são pegos em tempo de compilação, não em runtime.

Conectando com bancos de dados

O DataFrame também suporta leitura direta de SQL:

%use dataframe

val conexao = "jdbc:postgresql://localhost:5432/meubanco"
val query = "SELECT nome, departamento, salario FROM funcionarios"
val funcionarios = DataFrame.readSqlQuery(conexao, query)

funcionarios
    .filter { "salario"<Double>() > 8000.0 }
    .groupBy("departamento")
    .aggregate {
        mean("salario") into "salario_medio"
        count() into "total"
    }

Se você já trabalha com bancos de dados em Kotlin usando Exposed, o DataFrame complementa como ferramenta de análise exploratória.

Visualizando dados com Kandy

O Kandy é a biblioteca de visualização oficial do ecossistema Kotlin, construída sobre o LetsPlot. Ela oferece uma DSL type-safe para criar gráficos diretamente no notebook.

Importando o Kandy

%use kandy

Gráfico de barras

val regioes = listOf("Sudeste", "Sul", "Nordeste", "Centro-Oeste", "Norte")
val vendas = listOf(45000, 32000, 28000, 18000, 12000)

plot {
    bars {
        x(regioes) { axis.name = "Região" }
        y(vendas) { axis.name = "Vendas (R$)" }
        fillColor = Color.hex("#7F52FF") // Roxo Kotlin
    }
    layout.title = "Vendas por Região — 2026"
}

Gráfico de linhas com séries temporais

val meses = listOf("Jan", "Fev", "Mar", "Abr", "Mai", "Jun")
val receita = listOf(120000, 135000, 128000, 142000, 155000, 148000)
val custos = listOf(95000, 98000, 102000, 99000, 105000, 108000)

plot {
    line {
        x(meses) { axis.name = "Mês" }
        y(receita) { axis.name = "Valor (R$)" }
        color = Color.hex("#7F52FF")
        width = 2.5
    }
    line {
        x(meses)
        y(custos)
        color = Color.hex("#E87D3E")
        width = 2.5
    }
    layout {
        title = "Receita vs Custos — 1º Semestre 2026"
        size = 800 to 400
    }
}

Gráfico de dispersão

val experiencia = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val salarios = listOf(4500, 5200, 6100, 7800, 8500, 9200, 10500, 11800, 13000, 15000)

plot {
    points {
        x(experiencia) { axis.name = "Anos de Experiência" }
        y(salarios) { axis.name = "Salário (R$)" }
        size = 5.0
        color = Color.hex("#7F52FF")
    }
    layout.title = "Experiência vs Salário — Devs Kotlin no Brasil"
}

Se você se interessa pela relação entre experiência e salário, temos artigos detalhados sobre salários de dev Kotlin e mercado de trabalho.

Casos de uso práticos

O Kotlin Notebook não é só para data scientists. Veja onde ele brilha:

1. Prototipagem rápida de APIs

Testar endpoints antes de integrar no projeto principal:

@file:DependsOn("io.ktor:ktor-client-core:3.1.2")
@file:DependsOn("io.ktor:ktor-client-cio:3.1.2")
@file:DependsOn("io.ktor:ktor-client-content-negotiation:3.1.2")
@file:DependsOn("io.ktor:ktor-serialization-kotlinx-json:3.1.2")

import io.ktor.client.*
import io.ktor.client.request.*
import io.ktor.client.statement.*

val client = HttpClient()
val response = client.get("https://api.github.com/repos/JetBrains/kotlin")
println(response.bodyAsText().take(500))

Se você trabalha com Ktor, o notebook é perfeito para experimentação rápida.

2. Análise de logs e métricas

Carregar logs de produção e analisar padrões:

%use dataframe

val logs = DataFrame.read("app-logs-2026-04.csv")

// Erros por hora do dia
val errosPorHora = logs
    .filter { "level"<String>() == "ERROR" }
    .groupBy("hora")
    .count()
    .sortBy("hora")

errosPorHora

3. Documentação executável

Combinar Markdown e código para criar documentação que realmente roda:

## Exemplo de uso do nosso SDK

O trecho abaixo mostra como autenticar e buscar dados:

val sdk = MeuSDK(apiKey = "demo-key")
val resultado = sdk.buscarDados(filtro = "ativo")
resultado.forEach { println(it) }

4. Preparação de dados para Machine Learning

Se você está explorando Kotlin para IA e Machine Learning, o Notebook é ideal para a etapa de preparação de dados — limpeza, normalização e feature engineering.

Kotlin Notebook vs Jupyter com Python

AspectoKotlin NotebookJupyter (Python)
TipagemEstática (erros em compile time)Dinâmica (erros em runtime)
IDEIntelliJ IDEA nativoNavegador ou VS Code
AutocompletarCompleto, com tiposLimitado
PerformanceJVM (rápido para processamento)Interpretado
Ecossistema de dadosDataFrame + Kandypandas + matplotlib/seaborn
InteroperabilidadeJava, Kotlin, KMPPython
Formato.ipynb compatível.ipynb nativo

Para quem já programa em Kotlin e precisa analisar dados, o Kotlin Notebook elimina a troca de contexto para Python. Você usa a mesma linguagem do backend, do Android e do Compose Multiplatform.

Dicas para começar

  1. Atualize o IntelliJ IDEA para a versão 2025.1 ou superior
  2. Crie um novo Kotlin Notebook: File → New → Kotlin Notebook
  3. Use %use para importar bibliotecas: %use dataframe, %use kandy
  4. Explore dados reais: comece com um CSV pequeno do seu projeto
  5. Exporte como .ipynb para compartilhar com colegas que usam Jupyter

Recursos e próximos passos

O Kotlin Notebook está evoluindo rapidamente. Na KotlinConf 2026 (maio, em Munique), haverá palestras dedicadas sobre análise de dados com Kotlin, incluindo workshops práticos com DataFrame e Kandy.

Para aprofundar, confira estes conteúdos relacionados:

Conclusão

O Kotlin Notebook transforma o IntelliJ IDEA em um ambiente completo para análise de dados, prototipagem e documentação interativa. Com DataFrame para manipulação de dados e Kandy para visualização, você tem um stack 100% Kotlin — sem precisar alternar para Python.

Se você é dev Kotlin e precisa explorar dados, gerar relatórios ou prototipar rapidamente, o Notebook é uma ferramenta que vale conhecer. Comece com um CSV do seu projeto e veja como a tipagem estática e o autocompletar do IntelliJ IDEA fazem diferença na produtividade.

Embora Python com Jupyter ainda domine data science, o Kotlin Notebook oferece vantagens únicas para quem já trabalha no ecossistema JVM — especialmente a tipagem estática e o autocomplete inteligente do IntelliJ.

Para mais conteúdo sobre o ecossistema Kotlin em português, explore nosso glossário, tutoriais e guias completos.