Como Desenvolvemos Software para Cada Plataforma
Por que um .exe não roda no Linux
Cada sistema operacional define seu próprio formato de executável — a estrutura binária que diz ao kernel como carregar o programa na memória, onde fica o código, onde ficam os dados, e quais bibliotecas ele precisa. São três formatos incompatíveis entre si:
| SO | Formato de executável | Extensão típica |
|---|---|---|
| Windows | PE (Portable Executable) | .exe, .dll |
| Linux / Android | ELF (Executable and Linkable Format) | sem extensão, .so |
| macOS / iOS | Mach-O | .app (pacote), .dylib |
Um .exe compilado para Windows contém instruções de máquina x86/x64 empacotadas no formato PE — o kernel Linux simplesmente não sabe interpretar esse cabeçalho, mesmo que a CPU seja a mesma. É por isso que rodar software Windows no Linux exige uma camada de tradução como o Wine, e não apenas "copiar o arquivo".
SDKs e ferramentas nativas por plataforma
| Plataforma | IDE/Toolchain principal | Linguagens nativas | API/Framework do SO |
|---|---|---|---|
| Windows | Visual Studio, MSVC | C++, C#, Rust | Win32 API, .NET, WinRT/UWP |
| Linux | GCC/Clang, qualquer editor | C, C++, Rust, Python | POSIX, GTK, Qt |
| macOS | Xcode | Swift, Objective-C | Cocoa (AppKit) |
| Android | Android Studio | Kotlin, Java, C/C++ (via NDK) | Android SDK |
| iOS | Xcode | Swift, Objective-C | UIKit / SwiftUI |
Escrever um app "nativo" significa usar diretamente essas APIs — o resultado tem o melhor desempenho e a integração mais fiel com o sistema (notificações, atalhos, aparência), mas o código não roda em nenhuma outra plataforma sem reescrita.
Compilação nativa vs. execução gerenciada (managed)
- Nativo: o compilador (GCC, Clang, MSVC) traduz o código-fonte diretamente para instruções da CPU alvo, embaladas no formato de executável do SO. Roda sem camada intermediária — mais rápido, mas precisa ser recompilado para cada combinação de SO + arquitetura de CPU.
- Gerenciado (managed): o compilador gera um bytecode intermediário, independente de CPU, que roda dentro de uma máquina virtual (JVM para Java, ART para Android/Kotlin, CLR para C#/.NET). A promessa histórica do Java — "escreva uma vez, rode em qualquer lugar" — vem exatamente daqui: o mesmo
.classroda em qualquer SO que tenha uma JVM instalada.
Frameworks multiplataforma (cross-platform)
Reescrever o mesmo app 5 vezes (uma por SO) é caro. Por isso existem frameworks que compartilham código entre plataformas, com diferentes trade-offs entre desempenho e reaproveitamento:
| Framework | Como funciona | Reaproveitamento | Desempenho |
|---|---|---|---|
| Electron | Empacota um navegador Chromium + Node.js; a interface é HTML/CSS/JS | Altíssimo (desktop) | Baixo (consome muita RAM) |
| Qt / GTK | Biblioteca de UI nativa em C++, compilada para cada SO | Alto (código C++ comum) | Alto (nativo de verdade) |
| Flutter | Motor gráfico próprio (Skia) desenha a UI pixel a pixel, mesmo código Dart para todas as plataformas | Muito alto | Alto |
| React Native | Lógica em JavaScript, mas a UI é traduzida para componentes nativos reais do SO | Alto | Médio-alto |
| .NET MAUI / Kotlin Multiplatform | Compartilha lógica de negócio; UI pode ser nativa por plataforma | Médio-alto | Alto |
Um app bancário que precisa de máxima confiança de UI tende a ir nativo (Swift + Kotlin separados). Um app interno de produtividade, onde velocidade de entrega importa mais que desempenho máximo, se beneficia de Flutter/React Native/Electron.
Distribuição: como o software chega ao usuário
| SO | Formato de instalador tradicional | Loja oficial | Instalação fora da loja |
|---|---|---|---|
| Windows | .exe, .msi | Microsoft Store | Sim, livre |
| Linux | .deb, .rpm, ou formatos universais Flatpak/Snap/AppImage | Depende da distro (repositórios) | Sim, livre |
| macOS | .dmg, .pkg | Mac App Store | Sim, mas exige assinatura/notarização (Gatekeeper) |
| Android | .apk direto | Play Store | Sim (com aviso de segurança) |
| iOS | — | App Store | Não, salvo exceções regionais recentes |
Quanto mais uma plataforma restringe a instalação a uma loja única (iOS, e cada vez mais macOS), mais o fabricante consegue revisar o software antes que chegue ao usuário — trocando liberdade do desenvolvedor por uma camada extra de curadoria e segurança.
Próximo: Drivers e Bibliotecas
Todo esse software — nativo ou gerenciado — eventualmente precisa falar com o hardware de verdade. É aí que entram drivers e bibliotecas compartilhadas.