Cómo instalar Swift en Linux

Durante más de una década, la imagen del iOS developer ha estado intrínsecamente ligada a un ecosistema de hardware específico: el Mac. Si querías entrar en el jardín amurallado de Apple, necesitabas la llave de aluminio. Sin embargo, el panorama del desarrollo de software es dinámico, y la evolución de Swift como lenguaje ha roto muchas de esas cadenas.

Hoy en día, la programación Swift ya no es exclusiva de los sistemas operativos de Cupertino. Desde que Apple liberó Swift como código abierto en 2015, el lenguaje ha madurado increíblemente en otras plataformas, siendo Linux el principal beneficiario fuera del entorno Apple.

Si eres un desarrollador curioso, un amante del software libre, o simplemente buscas optimizar costos en servidores de integración continua (CI/CD), te habrás preguntado: ¿Es posible desarrollar para el ecosistema de Apple usando Linux?

La respuesta corta es: Sí, pero con un gran asterisco.

Este tutorial no solo te guiará paso a paso en la instalación de Swift en Linux. También, y más importante, definirá la realidad de qué puedes (y qué no puedes) hacer en este entorno, y cómo un flujo de trabajo híbrido puede convertirte en un iOS developer más versátil y valioso.

La Cruda Realidad: ¿Qué podemos hacer realmente en Linux?

Antes de abrir la terminal, debemos gestionar las expectativas. Como iOS developer acostumbrado a la magia de Xcode y las Previews de SwiftUI en tiempo real, el aterrizaje en Linux puede ser confuso si no se aclaran los límites.

Lo que NO puedes hacer en Linux (todavía):

Debes entender esto alto y claro: No puedes compilar ni ejecutar aplicaciones con interfaz gráfica nativa para iOS, macOS o watchOS en Linux.

• No existe Xcode para Linux.
• No puedes usar el Simulador de iOS.
• No puedes renderizar vistas de SwiftUI ni usar UIKit o AppKit. Estos frameworks propietarios dependen de bibliotecas de bajo nivel (como Cocoa) que solo existen en macOS.
• No puedes firmar aplicaciones ni subirlas a la App Store Connect.

Lo que SÍ puedes hacer en Linux (y por qué es increíble):

Si no podemos ver la UI, ¿para qué sirve entonces?

1. Lógica de Negocio Compartida (The Core): Puedes desarrollar toda la lógica de tu aplicación (modelos de datos, algoritmos, llamadas a redes, parsing de JSON, tests unitarios) en un paquete de Swift puro. Este paquete se desarrolla en Linux y luego se importa en Xcode en un Mac para conectarlo a la interfaz de SwiftUI. Esto fomenta una arquitectura limpia y separable.
2. Server-Side Swift (Backend): Esta es la joya de la corona de Swift en Linux. Usando frameworks como Vapor, puedes escribir el backend de tu app iOS usando el mismo lenguaje que el frontend. Esto permite compartir modelos (Codable structs) entre el servidor y la app, reduciendo errores drásticamente.
3. Herramientas de Línea de Comandos (CLI): Crear scripts potentes y herramientas de automatización para tu equipo.
4. Integración Continua (CI): Los servidores Linux son más baratos que los Mac en la nube. Puedes usar Linux para ejecutar tus tests unitarios y validar la lógica de tu código Swift en cada pull request.

Si tu objetivo es ser un arquitecto de software completo en el ecosistema Apple, dominar Swift en Linux es un superpoder.

Prerrequisitos del Sistema

Para este tutorial, nos centraremos en Ubuntu, ya que es la distribución de Linux con el soporte más oficial y robusto por parte del equipo central de Swift. Las versiones LTS (Long Term Support) como Ubuntu 20.04, 22.04 o la reciente 24.04 son ideales.

Asegúrate de tener conocimientos básicos de la terminal y permisos de superusuario (sudo).

Paso 1: Instalación de Dependencias

Swift no es una isla; necesita ciertas bibliotecas del sistema para funcionar, especialmente para manejar cadenas de texto (Unicode), redes y concurrencia.

Abre tu terminal y actualiza tu lista de paquetes, luego instala los componentes necesarios. El paquete crucial aquí es clang (el compilador de C/C++ que usa Swift internamente) y libicu-dev para el manejo de texto internacional.

sudo apt-get update
sudo apt-get install \
          binutils \
          git \
          gnupg2 \
          libc6-dev \
          libcurl4-openssl-dev \
          libedit2 \
          libgcc-9-dev \
          libpython3.8 \
          libsqlite3-0 \
          libstdc++-9-dev \
          libxml2 \
          libz3-dev \
          pkg-config \
          tzdata \
          unzip \
          zlib1g-dev

Nota: Dependiendo de tu versión exacta de Ubuntu, es posible que necesites ajustar ligeramente las versiones de las librerías (por ejemplo, libpython3 o libgcc). Si el comando falla, el gestor de paquetes te sugerirá las versiones correctas.

Paso 2: El Método Moderno: Usando Swiftly (Recomendado)

Históricamente, instalar Swift implicaba descargar un archivo .tar.gz gigante, verificar firmas GPG manualmente, descomprimirlo y configurar variables de entorno. Era un proceso propenso a errores.

Afortunadamente, la comunidad ha madurado y ahora tenemos Swiftly. Swiftly es un instalador y gestor de versiones de CLI para Swift, similar a lo que nvm es para Node.js o rustup para Rust. Es la forma más fácil y mantenible de tener Swift en Linux.

2.1. Descargar e instalar Swiftly

Ejecuta el siguiente comando en tu terminal para descargar el script de instalación oficial:

curl -L https://swift-server.github.io/swiftly/swiftly-install.sh | bash

Sigue las instrucciones en pantalla. Al finalizar, te pedirá que reinicies tu terminal o que ejecutes un comando source para actualizar tu PATH. Hazlo para que el comando swiftly esté disponible.

2.2. Instalar la última versión de Swift

Ahora que tienes el gestor, instalar Swift es tan simple como:

swiftly install latest

Este comando buscará la versión estable más reciente de Swift compatible con tu distribución de Linux, la descargará y la configurará.

2.3. Verificación

Una vez finalizado el proceso, verifica que todo esté en orden pidiéndole a Swift su versión:

swift --version

Deberías ver una salida similar a: Swift version 5.10 (swift-5.10-RELEASE) Target: x86_64-unknown-linux-gnu.

¡Felicidades! Ya tienes el compilador de Swift y el gestor de paquetes (SwiftPM) listos en tu máquina Linux.

Paso 3: Configurando el Entorno de Desarrollo (Tu “Xcode” en Linux)

Un iOS developer se siente desnudo sin un buen IDE. En Linux, no tenemos Xcode, pero tenemos la segunda mejor opción, y en opinión de muchos para ciertos flujos de trabajo, una opción superior: Visual Studio Code (VS Code).

VS Code es ligero, rápido y tiene un ecosistema de extensiones brutal. Pero la clave es que Apple y la comunidad de Swift Server Workgroup mantienen oficialmente la extensión de Swift para VS Code.

3.1. Instalar VS Code

Si aún no lo tienes, descárgalo desde su sitio web oficial o instálalo vía Snap en Ubuntu:

sudo snap install code --classic

3.2. La Extensión Oficial de Swift

Abre VS Code, ve a la pestaña de extensiones (el icono de los cubos en la barra lateral izquierda) y busca “Swift”.

Instala la extensión creada por el Swift Server Workgroup.

¿Por qué es vital esta extensión? Esta extensión no es solo un resaltador de sintaxis. Integra SourceKit-LSP (Language Server Protocol) en VS Code. SourceKit es el mismo motor que impulsa a Xcode. Esto significa que tendrás:

• Autocompletado inteligente (IntelliSense) de alta calidad.
• “Ir a la definición” y búsqueda de referencias.
• Resaltado de errores y advertencias en tiempo real.
• Integración con el depurador LLDB para poner puntos de ruptura (breakpoints) y examinar variables.

Sin esta extensión, la programación Swift en Linux es como programar en el Bloc de notas. Con ella, es una experiencia profesional de primer nivel.

Paso 4: Tu Primer Proyecto Swift en Linux (Hola Mundo)

Vamos a probar que todo el sistema funciona creando un pequeño proyecto. En Linux, trabajamos casi exclusivamente con Swift Packages (SPM). No hay archivos .xcodeproj ni .xcworkspace aquí.

1. Crear una carpeta para el proyecto:

mkdir MiPrimerSwiftLinux
cd MiPrimerSwiftLinux

2. Inicializar un paquete ejecutable:

Le decimos a Swift que queremos crear una herramienta de línea de comandos.

swift package init --type executable

Esto generará una estructura de carpetas básica:

• Package.swift: El manifiesto de tu proyecto (dependencias, targets).
• Sources/: Donde vive tu código fuente.
• Tests/: Donde viven tus pruebas unitarias.

3. Abrir en VS Code:

code .

Al abrir la carpeta, la extensión de Swift detectará el archivo Package.swift y comenzará a indexar el proyecto. Verás una notificación en la esquina inferior derecha preguntando si quieres descargar dependencias y construir el proyecto. Dile que sí.

Ejecutar el código:

Abre el archivo Sources/main.swift. Verás un simple print("Hello, world!").

Abre la terminal integrada de VS Code (Ctrl + ` o Ver -> Terminal) y ejecuta:

swift run

1. Swift compilará tu código y mostrará: Hello, world!.

Paso 5: El Flujo de Trabajo Híbrido: De Linux a iOS/SwiftUI

Ahora que tienes Swift corriendo en Linux, ¿cómo se conecta esto con tu trabajo como iOS developer y SwiftUI?

Imagina que estás construyendo una aplicación compleja que necesita validar reglas de negocio complicadas, quizás para una app de finanzas o salud.

El escenario ideal:

1. En Linux (VS Code): Creas un Swift Package llamado CoreLogic. Dentro, defines tus structs que conforman Codable. Escribes funciones puras que reciben datos y devuelven resultados. Escribes una batería exhaustiva de tests unitarios usando XCTest (que sí está disponible en Linux).
   • Ventaja: Te obligas a escribir código desacoplado de la interfaz de usuario. Tu lógica no sabe qué es una UIView o un View de SwiftUI. Es código puro, testeable y portable.
2. En el Mac (Xcode): Creas tu proyecto de aplicación iOS. Vas a “File -> Add Packages…” y añades tu paquete CoreLogic (puede estar en un repositorio git privado).
3. Integración con SwiftUI: En tus ViewModels de SwiftUI en el Mac, importas CoreLogic. Usas las estructuras y funciones que creaste y testeaste en Linux. La UI de SwiftUI se limita a mostrar los datos que tu lógica central le proporciona.

// Ejemplo conceptual en tu Mac, dentro de un ViewModel de SwiftUI
import SwiftUI
import CoreLogic // <-- Tu paquete desarrollado en Linux

@MainActor
class ContentViewModel: ObservableObject {
    @Published var data: MySharedModel?

    func loadData() {
        // Usamos la lógica agnóstica de plataforma creada en Linux
        let logicProcessor = BusinessLogicProcessor()
        self.data = logicProcessor.calculateComplexStuff()
    }
}

Este flujo de trabajo te convierte en un desarrollador más disciplinado y te prepara para un futuro donde el código se comparte cada vez más entre frontend, backend e incluso diferentes plataformas móviles (como Android, que también puede empezar a usar Swift en ciertas capas).

Conclusión

Instalar Swift en Linux no es solo un truco técnico para impresionar a tus colegas. Es un paso hacia la madurez como ingeniero de software en el ecosistema Apple.

Si bien es cierto que no podrás diseñar tus vistas de SwiftUI directamente en Ubuntu, la capacidad de aislar tu lógica de negocio, trabajar en el backend con Server-Side Swift y entender cómo funciona tu herramienta principal bajo el capó te hará un iOS developer mucho más completo.

El futuro de la programación Swift es multiplataforma. Rompe las cadenas del hardware único, abraza el pingüino, y verás cómo tu comprensión del desarrollo mejora exponencialmente.

Si tienes cualquier duda sobre este artículo, contacta conmigo y estaré encantado de ayudarte 🙂. Puedes contactar conmigo en mi perfil de X o en mi perfil de Instagram