Swift no Linux: instalação, Hello World e primeiro projeto

Quer experimentar Swift no Linux sem começar por um projeto enorme? Vamos instalar a linguagem, executar um Hello World, gerar um binário e montar uma pequena ferramenta de terminal com argumentos. O objetivo é sair deste artigo com código funcionando e entender a diferença entre swift, swiftc e Swift Package Manager.

Antes de instalar: linguagem Swift não é OpenStack Swift

Este tutorial trata da linguagem de programação. O pacote chamado swift no Debian pertence ao OpenStack, um sistema de armazenamento de objetos. Não use apt install swift como atalho para instalar o compilador deste artigo: confira sempre a descrição do pacote.

Use uma distribuição e arquitetura presentes nas opções oficiais de instalação do Swift no Linux. Os exemplos de preparação abaixo usam Ubuntu/Debian e Bash. Veja a distribuição e a arquitetura antes de escolher qualquer download:

cat /etc/os-release
uname -m

Para começar, reserve uma pasta no seu usuário e tenha acesso à internet. Dependências do sistema podem exigir sudo; o projeto e os comandos de compilação não precisam ser executados como root.

Instale com Swiftly e confira a assinatura

O Swiftly gerencia as toolchains da linguagem. Na consulta de 12/09/2026, a página oficial indicava Swift 6.3.3 e Swiftly 1.1.2. As versões podem mudar: confira a instrução oficial do Swiftly antes de repetir o procedimento no futuro.

sudo apt update && sudo apt install -y ca-certificates curl gnupg tar

Baixe o instalador, as chaves publicadas pelo projeto e a assinatura. A variável ARCH deve corresponder a uma arquitetura oferecida pelo site, como x86_64 o aarch64:

mkdir -p "$HOME/Downloads/swiftly-linuxpro"
cd "$HOME/Downloads/swiftly-linuxpro"
ARCH="$(uname -m)"
ARQUIVO="swiftly-1.1.2-${ARCH}.tar.gz"
BASE="https://download.swift.org/swiftly/linux"

curl -fLO "$BASE/$ARQUIVO" &&
curl -fLO "$BASE/$ARQUIVO.sig" &&
curl -fL https://www.swift.org/keys/all-keys.asc -o swift-keys.asc &&
gpg --import swift-keys.asc &&
gpg --verify "$ARQUIVO.sig" "$ARQUIVO"

Se a verificação falhar, pare: não extraia nem execute aquele arquivo. Depois de confirmar a assinatura, inicialize o Swiftly:

tar -xzf "$ARQUIVO" &&
./swiftly init --quiet-shell-followup &&
. "${SWIFTLY_HOME_DIR:-$HOME/.local/share/swiftly}/env.sh" &&
hash -r

swift --version
swiftc --version

A inicialização baixa a toolchain e informa os pacotes necessários que estiverem faltando. Siga essas orientações para a sua distribuição. O arquivo de ambiente ajusta a sessão atual; em outro terminal, confira novamente swift --version. Não reutilize listas antigas de bibliotecas do Ubuntu 16.04.

Hello World básico: um arquivo e uma linha

Comece fora da pasta do instalador. Crie um diretório de estudos e um arquivo chamado hello.swift:

mkdir -p "$HOME/projetos/swift-linuxpro"
cd "$HOME/projetos/swift-linuxpro"
cat > hello.swift <<'SWIFT'
print("Hello, world!")
SWIFT

swift hello.swift

A saída esperada é:

Hello, world!

Aqui, print escreve uma mensagem na saída padrão. A chamada swift hello.swift executa o arquivo sem você administrar manualmente um executável. É um bom caminho para pequenos experimentos; não é necessário criar um pacote para cada teste.

Compile o mesmo programa com swiftc

Agora gere um executável com nome definido:

swiftc hello.swift -o hello
./hello

A mensagem é a mesma, mas o fluxo mudou: primeiro você compilou; depois executou ./hello. Quando alterar o código, rode o compilador novamente para atualizar o binário. O prefixo ./ indica que o arquivo está no diretório atual.

Um binário compilado no seu computador não é automaticamente compatível com todo Linux. Arquitetura, bibliotecas e runtime do ambiente de destino importam. Para distribuição mais controlada, estude o Swift SDK for Static Linux; isso é uma etapa posterior ao Hello World.

Crie uma ferramenta com Swift Package Manager

Quando o código ganha mais arquivos e dependências, use o Swift Package Manager, que acompanha a toolchain. Em vez de gerenciar tudo manualmente, ele organiza o manifesto e a compilação. Crie um projeto novo dentro do diretório de estudos:

mkdir OlaLinux
cd OlaLinux
swift package init --name OlaLinux --type executable
swift run OlaLinux

O modelo inicial já imprime uma saudação. Na toolchain Swift 6.3.3 testada nesta revisão, Package.swift é o manifesto e Sources/OlaLinux/OlaLinux.swift é o ponto de entrada. Confira a estrutura criada pela sua versão antes de editar arquivos. O guia oficial de ferramentas de linha de comando explica esse fluxo.

Substitua o conteúdo de Sources/OlaLinux/OlaLinux.swift pelo exemplo abaixo. Ele aceita um nome no terminal e usa LinuxPro quando nenhum argumento é informado:

@main
struct OlaLinux {
    static func saudacao(para pessoa: String) -> String {
        return "Olá, \(pessoa)! Swift está rodando no Linux."
    }

    static func main() {
        let nome = CommandLine.arguments.dropFirst().first ?? "LinuxPro"
        print(saudacao(para: nome))
    }
}

swift run OlaLinux
swift run OlaLinux Nilton

As mensagens esperadas são, respectivamente:

Olá, LinuxPro! Swift está rodando no Linux.
Olá, Nilton! Swift está rodando no Linux.

O marcador @main define o ponto de entrada, que chama main(). Neste código, let declara um valor que não será reatribuído. CommandLine.arguments contém os argumentos do processo; dropFirst() pula o nome do executável e first obtém o próximo item, se existir. O operador ?? fornece o valor padrão. A função recebe um nome e devolve a mensagem usando interpolação de strings.

Para estudar a sintaxe com mais calma, siga o tour oficial da linguagem Swift. Para uma CLI com opções, ajuda e validação de entradas, o próximo passo é o Swift Argument Parser; não precisamos adicionar dependências para esta primeira saudação.

Adicione um teste automatizado

O modelo testado também criou uma pasta de testes. Substitua Tests/OlaLinuxTests/OlaLinuxTests.swift pelo exemplo abaixo, que verifica a mensagem produzida pela função sem depender da saída do terminal:

import Testing
@testable import OlaLinux

@Test func saudacaoIncluiNome() {
    #expect(OlaLinux.saudacao(para: "Nilton") ==
        "Olá, Nilton! Swift está rodando no Linux.")
}

swift test

A anotação @Test identifica o teste e #expect confere o resultado. Se você mudar a saudação, atualize a expectativa conscientemente; uma falha deve provocar investigação, não ser escondida. O @testable import permite testar a lógica interna deste módulo.

Gere a versão release e faça um teste rápido

Dentro da pasta que contém Package.swift, compile a configuração release e execute o resultado:

swift build -c release
.build/release/OlaLinux Nilton

Um teste simples de saída ajuda a detectar regressões ao modificar esse exemplo:

test "$(.build/release/OlaLinux Nilton)" =   "Olá, Nilton! Swift está rodando no Linux." && echo "OK"

Isso é apenas uma verificação básica do programa, não uma suíte completa de testes. Em um projeto maior, separe a lógica em módulos testáveis. Para publicar o projeto no Git, mantenha o código e o manifesto; a pasta de resultados .build/ não precisa entrar no repositório.

Alternativa: experimente usando Docker

Se o Docker já está instalado, a imagem oficial do Swift permite testar sem instalar a toolchain no host. Este exemplo fixa a versão usada na revisão e não precisa de modo privilegiado:

docker run --rm swift:6.3.3 swift --version

cd "$HOME/projetos/swift-linuxpro"
docker run --rm   --mount "type=bind,source=$PWD,target=/work,readonly"   -w /work swift:6.3.3 swift hello.swift

A montagem é somente leitura porque esse comando apenas executa o script. A primeira chamada pode baixar a imagem. Para aprender o básico de containers, veja também o curso de Docker. Não misture sem cuidado arquivos de build gerados em containers com os do seu host.

Editor e problemas comuns

No VS Code, instale a extensão Swift e abra a pasta do projeto, não apenas um arquivo avulso. Ela integra navegação de código, depuração e recursos de testes; o guia oficial de configuração detalha o ambiente. O blog também tem um guia de VS Code no Ubuntu.

• swift: command not found: carregue novamente o arquivo env.sh do Swiftly, execute hash -r no Bash e confira command -v swift.
• Biblioteca ou linker ausente: leia a mensagem e as dependências indicadas para sua distribuição. A documentação de instalação manual lista requisitos por sistema; não crie links simbólicos aleatórios entre versões de bibliotecas.
• Package.swift não encontrado: execute pwd e ls; os comandos de pacote devem partir da pasta OlaLinux.
• Erro envolvendo @main: este exemplo usa código no topo de main.swift. Não adicione ao mesmo executável um segundo ponto de entrada com @main.
• Versão inesperada: use type -a swift para descobrir se outra instalação está antes do Swiftly no PATH. Não apague uma toolchain antiga antes de identificar qual caminho está em uso.

O registro de 2017 e o próximo passo

O tutorial original usava Swift 3.1.1, Ubuntu 16.04 e extração manual da toolchain em /usr/local. Esse é o contexto histórico, não a receita recomendada nesta revisão. Downloads manuais continuam disponíveis, mas exigem escolher a toolchain correta e suas dependências; o Swiftly simplifica esse gerenciamento.

Você agora tem três caminhos claros: executar um arquivo para experimentar, usar swiftc para gerar um binário e usar SwiftPM para organizar um projeto. Como exercício, faça a saudação receber um segundo argumento e trate a ausência desse valor. Depois compare a experiência com Python e com o nosso panorama de linguagens de programação.