¿Quieres probar Swift en Linux sin empezar por un proyecto enorme? Vamos a instalar el lenguaje por el método oficial de swift.org, ejecutar un Hello World, generar un binario y montar una pequeña herramienta de terminal con argumentos. El objetivo es salir de este artículo con código funcionando y entender la diferencia entre swift, swiftc y Swift Package Manager.
Antes de instalar: el lenguaje Swift no es OpenStack Swift
Este tutorial trata sobre el lenguaje de programación. El paquete llamado swift en Debian pertenece a OpenStack, un sistema de almacenamiento de objetos. No lo uses apt install swift como atajo para instalar el compilador de este artículo: consulta siempre la descripción del paquete.
Usa una distribución y arquitectura presentes en las opciones oficiales de instalación de Swift en Linux. Los ejemplos de preparación siguientes usan Ubuntu/Debian y Bash. Comprueba la distribución y la arquitectura antes de empezar:
cat /etc/os-release
uname -mPara empezar, reserva una carpeta en tu usuario y ten acceso a internet. Las dependencias del sistema requieren sudo; Swiftly, la toolchain y los comandos de compilación quedan en tu usuario y no necesitan root.
Instala Swift 6.4 con Swiftly
Swiftly es el instalador oficial: descarga la toolchain, verifica su firma y permite alternar entre versiones. En la consulta de 22/09/2026, la página oficial indicaba Swift 6.4.0, publicado el 15 de septiembre de 2026. Prepara las herramientas básicas:
sudo apt update && sudo apt install -y ca-certificates curl gnupg tarDescarga el instalador indicado por el sitio, la firma y las claves del proyecto. El nombre del archivo usa la arquitectura de la máquina (x86_64 o aarch64) y siempre apunta a la versión actual de Swiftly:
mkdir -p "$HOME/Downloads/swiftly-linuxpro"
cd "$HOME/Downloads/swiftly-linuxpro"
curl -O https://download.swift.org/swiftly/linux/swiftly-$(uname -m).tar.gz
curl -O https://download.swift.org/swiftly/linux/swiftly-$(uname -m).tar.gz.sig
curl --compressed https://www.swift.org/keys/all-keys.asc | gpg --import -
gpg --verify swiftly-$(uname -m).tar.gz.sig swiftly-$(uname -m).tar.gzLa salida debe contener Good signature from "Swift Automatic Signing Key. El aviso de que la clave no está certificada por una firma de confianza es normal cuando la acabas de importar. Si aparece BAD signature, para: no extraigas ni ejecutes el archivo. Con la firma confirmada, ejecuta exactamente el comando de la página oficial:
tar zxf swiftly-$(uname -m).tar.gz && \
./swiftly init --quiet-shell-followup && \
. "${SWIFTLY_HOME_DIR:-$HOME/.local/share/swiftly}/env.sh" && \
hash -rO init descarga poco más de 1 GB, comprueba la firma del toolchain y define Swift 6.4.0 como predeterminado. Al final, imprime un comando apt-get con las dependencias que faltan en el sistema. No te saltes este paso: en Ubuntu 24.04 limpio que usamos en la prueba, swift fallaba con libncurses.so.6: cannot open shared object file hasta instalar la lista indicada, que fue esta:
sudo apt-get -y install binutils git unzip zip gnupg2 libc6-dev libcurl4-openssl-dev \
libedit2 libgcc-13-dev libpython3-dev libstdc++-13-dev libxml2-dev libncurses-dev \
libz3-dev pkg-config tzdata zlib1g-devEn otra distribución o versión, usa la lista que tu swiftly init muestre, no esta. Después comprueba:
swift --version
swiftc --versionLa salida debe mencionar Swift version 6.4.0. El archivo env.sh ajusta la sesión actual; init también configura tu shell para los próximos terminales. Los detalles de cada paso están en la guía oficial Getting Started with Swiftly on Linux.
Hello World básico: un archivo y una línea
Comience fuera de la carpeta del instalador. Cree un directorio de estudio y un archivo llamado hello.swift:
mkdir -p "$HOME/projetos/swift-linuxpro"
cd "$HOME/projetos/swift-linuxpro"
cat > hello.swift <<'SWIFT'
print("Hello, world!")
SWIFT
swift hello.swiftLa salida esperada es:
Hello, world!Aquí, print escribe un mensaje en la salida estándar. La llamada swift hello.swift ejecuta el archivo sin que tengas que gestionar manualmente un ejecutable. Es una buena vía para pequeños experimentos; no es necesario crear un paquete para cada prueba.
Compila el mismo programa con swiftc
Ahora genera un ejecutable con un nombre definido:
swiftc hello.swift -o hello
./helloEl mensaje es el mismo, pero el flujo ha cambiado: primero has compilado; después lo has ejecutado ./hello. Cuando modifiques el código, vuelve a ejecutar el compilador para actualizar el binario. El prefijo ./ indica que el archivo está en el directorio actual.
Un binario compilado en tu equipo no es automáticamente compatible con todo Linux. La arquitectura, las bibliotecas y el runtime del entorno de destino importan. Para una distribución más controlada, estudia el Swift SDK for Static Linux; esto es un paso posterior al Hola Mundo.
Crea una herramienta con Swift Package Manager
Cuando el código gane más archivos y dependencias, usa Swift Package Manager, que acompaña a la toolchain. En lugar de gestionarlo todo manualmente, organiza el manifiesto y la compilación. Crea un proyecto nuevo dentro del directorio de estudio:
mkdir OlaLinux
cd OlaLinux
swift package init --name OlaLinux --type executable
swift run OlaLinuxLa plantilla inicial ya imprime un saludo. En la toolchain Swift 6.4.0 probada en esta revisión, Package.swift es el manifiesto y Sources/OlaLinux/OlaLinux.swift es el punto de entrada. Comprueba la estructura creada por tu versión antes de editar archivos. La guía oficial de herramientas de línea de comandos explica este flujo.
Sustituye el contenido de Sources/OlaLinux/OlaLinux.swift por el ejemplo de abajo. Acepta un nombre en el terminal y usa LinuxPro cuando no se pasa ningún argumento:
@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 NiltonLos mensajes esperados son, respectivamente:
Olá, LinuxPro! Swift está rodando no Linux.
Olá, Nilton! Swift está rodando no Linux.El marcador @main define el punto de entrada, que llama main(). En este código, let declara un valor que no se va a reasignar. CommandLine.arguments contiene los argumentos del proceso; dropFirst() salta el nombre del ejecutable y first obtiene el siguiente elemento, si existe. El operador ?? proporciona el valor por defecto. La función recibe un nombre y devuelve el mensaje usando interpolación de cadenas.
Para estudiar la sintaxis con más calma, sigue el tour oficial del lenguaje Swift. Para una CLI con opciones, ayuda y validación de entradas, el siguiente paso es el Swift Argument Parser; no necesitamos añadir dependencias para este primer saludo.
Añade una prueba automatizada
La plantilla también creó una carpeta de pruebas. Sustituye Tests/OlaLinuxTests/OlaLinuxTests.swift por el ejemplo de abajo, que verifica el mensaje producido por la función sin depender de la salida de la terminal:
import Testing
@testable import OlaLinux
@Test func saudacaoIncluiNome() {
#expect(OlaLinux.saudacao(para: "Nilton") ==
"Olá, Nilton! Swift está rodando no Linux.")
}swift testLa anotación @Test identifica la prueba y #expect compara el resultado. Si cambias el saludo, actualiza la expectativa de forma consciente; un fallo debe provocar una investigación, no ocultarse. El @testable import permite probar la lógica interna de este módulo.
Genera la versión release y haz una prueba rápida
Dentro de la carpeta que contiene Package.swift, compila la configuración release y ejecuta el resultado:
swift build -c release
.build/release/OlaLinux NiltonUna sencilla prueba de salida ayuda a detectar regresiones al modificar este ejemplo:
test "$(.build/release/OlaLinux Nilton)" = "Olá, Nilton! Swift está rodando no Linux." && echo "OK"Esto es solo una comprobación básica del programa, no una suite completa de pruebas. En un proyecto más grande, separe la lógica en módulos testeables. Para publicar el proyecto en Git, mantenga el código y el manifiesto; la carpeta de resultados .build/ no necesita entrar en el repositorio.
Alternativa: prueba usando Docker
Si Docker ya está instalado, la imagen oficial de Swift permite probar sin instalar la toolchain en el host. Este ejemplo fija la versión usada en la revisión y no necesita modo privilegiado:
docker run --rm swift:6.4.0 swift --version
cd "$HOME/projetos/swift-linuxpro"
docker run --rm \
--mount "type=bind,source=$PWD,target=/work,readonly" \
-w /work swift:6.4.0 swift hello.swiftEl montaje es solo de lectura porque este comando solo ejecuta el script. La primera llamada puede descargar la imagen. Para aprender lo básico de containers, vea también el curso de Docker. . No mezcle sin cuidado archivos de build generados en containers con los de su host.
Editor y problemas comunes
En VS Code, instale la extensión Swift y abra la carpeta del proyecto, no solo un archivo suelto. Integra navegación de código, depuración y funciones de pruebas; la guía oficial de configuración detalla el entorno. El blog también tiene una guía de VS Code en Ubuntu.
- swift: comando no encontrado vuelva a cargar el archivo
env.shde Swiftly, ejecutehash -ren Bash y compruebecommand -v swift. - error while loading shared libraries: faltan las dependencias del sistema. Instala la lista que el
swiftly initmostró; la documentación de instalación manual también lista requisitos por sistema. No crees enlaces simbólicos aleatorios entre versiones de bibliotecas. - Package.swift no encontrado: ejecute
pwdels; los comandos de paquete deben partir desde la carpetaOlaLinux. - Error relacionado con @main: un ejecutable solo puede tener un punto de entrada. No mantengas un
main.swiftcon código en la parte superior junto al archivo que usa@main. - Versión inesperada: use
type -a swiftpara descubrir si otra instalación está antes de Swiftly en el PATH. No elimine una toolchain antigua antes de identificar qué ruta está en uso.
El registro de 2017 y el siguiente paso
El tutorial original usaba Swift 3.1.1, Ubuntu 16.04 y extracción manual de la toolchain en /usr/local. Ese es el contexto histórico, no la receta recomendada hoy. Las descargas manuales siguen disponibles, pero exigen elegir la toolchain correcta y sus dependencias; Swiftly simplifica esa gestión y es el primer método indicado por swift.org.
Ahora tiene tres caminos claras: ejecutar un archivo para probar, usar swiftc para generar un binario y usar SwiftPM para organizar un proyecto. Como ejercicio, haga que el saludo reciba un segundo argumento y trate la ausencia de ese valor. Después compare la experiencia con Python, con el Go en Linux y con nuestro panorama de lenguajes de programación.