Cómo crear un paquete Flatpak paso a paso en Linux

Si trabajas con GNU/Linux y te interesa distribuir tus aplicaciones de forma sencilla, tarde o temprano te toparás con Flatpak. Este formato de empaquetado se ha convertido en una de las formas más populares de entregar aplicaciones de escritorio que funcionen igual en casi cualquier distribución, sin pelearte con las dependencias ni con el gestor de paquetes de turno.

En esta guía vamos a ver cómo crear un paquete Flatpak paso a paso, desde cero y con todo lujo de detalles. Verás qué es exactamente Flatpak, por qué tiene tanta importancia hoy en día, qué debes preparar en tu entorno, cómo estructurar el paquete, qué metadatos necesitas, cómo instalarlo, probarlo, exportarlo a un repositorio e incluso qué supone llevarlo a Flathub. Todo con un enfoque práctico y en un tono cercano para que no se te haga cuesta arriba.

Qué es Flatpak y por qué se ha vuelto tan importante

Flatpak es una tecnología de empaquetado y distribución de software para Linux basada en contenedores. La idea es muy simple pero potente: en lugar de depender del gestor de paquetes de cada distribución, la aplicación se empaqueta junto con las librerías y dependencias que necesita, y se ejecuta en un entorno aislado (sandbox) que garantiza un comportamiento consistente en cualquier distro compatible.

En la práctica, un paquete Flatpak incluye la aplicación y todas las bibliotecas necesarias para que funcione, sin interferir con el resto de programas del sistema. Eso evita el clásico infierno de dependencias, reduce conflictos y da al desarrollador el control directo sobre cómo se distribuye y actualiza su aplicación, sin tener que esperar a que un mantenedor de distribución la empaquete.

Para conseguirlo, Flatpak se apoya en entornos de ejecución o runtimes compartidos. Estos runtimes proporcionan una base común (por ejemplo, una versión concreta de la plataforma GNOME) sobre la que se ejecutan múltiples aplicaciones. Así no tienes que empaquetar absolutamente todo en cada app, sino solo lo que no venga ya en el runtime, con lo que se ahorra espacio y se facilita el mantenimiento.

Además, las aplicaciones Flatpak se ejecutan en un sandbox con su propio sistema de permisos. Este modelo te permite controlar el acceso a recursos como el sistema de archivos, la red, el Bluetooth, el audio o el servidor gráfico (X11/Wayland). El aislamiento mejora la seguridad y limita el daño potencial de una aplicación maliciosa o dañada.

Una de las grandes ventajas para usuarios y administradores es que los Flatpak se instalan y actualizan al margen del gestor de paquetes de la distribución. Puedes tener tus aplicaciones Flatpak conviviendo con paquetes nativos sin que se molesten entre sí, e incluso gestionar varias versiones de una misma app de forma simultánea.

Ventajas e inconvenientes de Flatpak frente a otros formatos

El ecosistema GNU/Linux siempre ha tenido múltiples sistemas de empaquetado: deb, rpm, AppImage, Snap, Flatpak… Cada uno resuelve el problema de la distribución de software a su manera. Flatpak destaca sobre todo en el escritorio, y no es casualidad que muchas distros importantes lo soporten de serie.

Entre las principales ventajas de Flatpak desde el punto de vista del usuario podemos destacar:

• Instalación sencilla y universal: con un único formato de paquete puedes instalar la misma app en distribuciones distintas (Debian, Fedora, openSUSE, Arch, etc.) siempre que tengan Flatpak habilitado.
• Aislamiento y seguridad mejorados: las aplicaciones se ejecutan en sandbox con permisos explícitos, reduciendo riesgos y conflictos entre programas.
• Actualizaciones automáticas y centralizadas: con un comando puedes actualizar de golpe todas tus apps Flatpak, sin depender del ciclo de la distro.
• Convivencia de múltiples versiones: es posible tener instalada más de una versión de la misma aplicación, algo muy útil para desarrolladores o entornos de pruebas.
• Menos problemas de compatibilidad: las dependencias vienen controladas por el propio paquete y/o el runtime, con lo que se minimizan los choques con librerías del sistema.

Para los desarrolladores, Flatpak también resulta muy atractivo. Permite publicar la aplicación directamente sin depender de que un mantenedor la empaquete para cada distribución. Una vez subes tu app (por ejemplo, a Flathub), cualquier usuario de Linux con Flatpak habilitado puede instalarla con uno o dos comandos, o incluso desde la tienda de software gráfica de su entorno.

Esta inmediatez significa que una nueva versión de tu aplicación puede llegar al mismo tiempo a usuarios de distintas distribuciones, lo que es especialmente interesante en distros de ciclo lento donde los paquetes oficiales tardan en actualizarse. Además, el entorno runtime ofrece una base homogénea, por lo que se reduce el número de combinaciones de librerías que hay que soportar.

No todo son ventajas. Hay algunos inconvenientes y peajes que hay que tener en cuenta:

• Tamaño de los paquetes: los Flatpak suelen ocupar más espacio que los paquetes nativos tradicionales, porque incluyen dependencias adicionales o comparten runtimes grandes. Esto implica más descarga y más uso de disco.
• Ligera penalización de rendimiento: al ejecutarse en sandbox y tener capas de abstracción extra, en algunos casos puede notarse un pequeño impacto en el rendimiento, aunque normalmente es mínimo para la mayoría de usuarios.
• Dependencia de los repositorios Flatpak: si una app solo se distribuye vía Flathub u otro repositorio Flatpak, estás atado a que ese repo se mantenga vivo y actualizado.
• Complejidad al empaquetar: crear un Flatpak bien hecho, especialmente para despliegue en Flathub, puede ser bastante más laborioso de lo que parece al principio, sobre todo en cuanto a dependencias y metadatos.

Además, al compararlo con otras soluciones como Snap, la experiencia de empaquetar y desplegar puede resultar, siendo sinceros, algo más confusa. Las instrucciones oficiales están algo dispersas, y si tu objetivo es publicar en Flathub, todavía hay más pasos y requisitos que cumplir.

Cómo funciona Flatpak a nivel técnico

Para entender bien cómo crear un paquete Flatpak, viene genial tener clara su arquitectura. Flatpak se basa en dos piezas fundamentales: los runtimes y las aplicaciones. Un runtime es un entorno de ejecución compartido, como por ejemplo org.gnome.Platform/x86_64/3.22, que proporciona una base común de bibliotecas y componentes.

Una aplicación Flatpak declara en sus metadatos qué runtime necesita para funcionar. De esta forma, varias apps pueden usar el mismo runtime, ahorrando espacio y garantizando compatibilidad. El resultado es algo así como “la app se apoya en una plataforma estable y conocida, y todo lo que no venga en esa plataforma se empaqueta dentro de la propia app”.

Las aplicaciones se ejecutan dentro de contenedores aislados que limitan el acceso a recursos críticos. Este aislamiento se gestiona a través de permisos configurables: acceso a red, directorios del sistema de archivos, dispositivos de entrada, audio (PulseAudio), servidor gráfico (X11/Wayland), D-Bus para la comunicación entre procesos, etc.

Una idea clave es que las dependencias se gestionan de forma más predecible. En lugar de confiar en las versiones de librerías del sistema, que pueden variar mucho entre distribuciones y versiones, el desarrollador sabe de antemano qué runtime tendrá disponible y, si necesita algo más reciente o específico, lo incluye directamente en el paquete.

La distribución se realiza normalmente a través de repositorios como Flathub, que actúa como repositorio centralizado de aplicaciones Flatpak. Desde ahí, los usuarios pueden buscar, descargar e instalar apps con un solo comando o desde la tienda gráfica. También es posible crear repositorios propios, algo muy útil en entornos corporativos o educativos donde se despliegan aplicaciones de forma controlada.

Requisitos previos para crear un paquete Flatpak

Antes de ponerte a empaquetar, necesitas tener claro qué pide Flatpak para que todo funcione. Hay tres requisitos básicos: tener Flatpak instalado, disponer de un runtime adecuado y definir la estructura del paquete.

En prácticamente cualquier distribución moderna puedes instalar Flatpak desde el gestor de paquetes de la propia distro. En Arch Linux, por ejemplo, si instalas GNOME con los grupos de paquetes gnome y gnome-extra, Flatpak se instala como dependencia automáticamente. Si no, puedes instalarlo explícitamente con el gestor de la distro (pacman, apt, dnf, zypper, etc.).

El segundo paso es configurar al menos un entorno de ejecución (runtime). Para la mayoría de aplicaciones de escritorio, lo habitual es apoyarse en plataformas como org.gnome.Platform o las que proporciona KDE, siempre en la arquitectura y versión que vayas a usar, por ejemplo x86_64/3.22.

Una vez tienes Flatpak y el runtime listo, toca pensar en la estructura del paquete y en el nombre completo de la aplicación. En Flatpak se utiliza una convención del tipo com.distribuidor.App o org.test.Hello, similar a los identificadores de dominio invertido. Este identificador se usará en todos los comandos y en el manifiesto.

Por último, necesitarás las herramientas de desarrollo correspondientes a tu lenguaje o tecnología, porque parte del proceso implica compilar o preparar los binarios que luego se meterán dentro del contenedor Flatpak. No es lo mismo empaquetar una pequeña shell script que una app compleja en C++, Java, Python o Electron.

Estructura básica de un paquete Flatpak

Un paquete Flatpak no son solo binarios. Incluye varios elementos esenciales que describen la aplicación y permiten integrarla con el escritorio. Entre los componentes típicos que forman parte de un paquete Flatpak podemos mencionar:

• AppData (metadatos de la aplicación): archivos de información sobre la app (generalmente en formato XML) que incluyen descripción, capturas de pantalla, categoría, enlace a la web oficial, etc. Son fundamentales para que las tiendas de software muestren la app correctamente.
• Iconos en varios tamaños: imágenes adaptadas a diferentes densidades de pantalla, incluyendo pantallas de alta resolución. Se instalan en rutas estándar reconocidas por el entorno de escritorio.
• Archivos .desktop: atajos que permiten lanzar la aplicación desde el menú, el lanzador de aplicaciones o el dock del entorno de escritorio.
• Configuración de D-Bus y otros servicios: definiciones para la comunicación con el bus de mensajes del sistema, así como integración con PulseAudio para el sonido y X11/Wayland para la representación gráfica.
• Archivos propios de la aplicación: ejecutables, scripts, librerías adicionales, recursos gráficos, etc. En definitiva, todo lo necesario para que tu programa funcione.

Para entender mejor la estructura, imagina que estás creando un ejemplo muy sencillo, un “Hola mundo” empaquetado con Flatpak. Podrías empezar creando una jerarquía de directorios como esta:

mkdir hello
mkdir hello/files
mkdir hello/files/bin
mkdir hello/export

En la carpeta hello/files/bin colocarías el ejecutable o script que quieras ejecutar, y en hello tendrías los metadatos típicos de Flatpak, como el archivo de aplicación con la sección [Application] donde se especifica el nombre y la orden de lanzamiento.

Un ejemplo simplificado de metadatos podría ser algo así, donde se define el identificador, el runtime y el comando principal que se ejecutará:

[Application] name=org.test.Hello
runtime=org.gnome.Platform/x86_64/3.22
command=hello.sh

Y el archivo hello.sh podría ser una simple shell script con este contenido, que se instalaría dentro de files/bin:

#!/bin/sh
echo "Hello world, from a sandbox"

Este ejemplo es muy básico, pero ilustra la idea de que el paquete Flatpak contiene, por un lado, los archivos de la aplicación y, por otro, toda la información para integrarla y ejecutarla correctamente dentro de un entorno de ejecución concreto.

Pasos generales para crear un paquete Flatpak paso a paso

A partir de todo lo anterior, podemos resumir el flujo básico para empaquetar una aplicación en Flatpak. Estos pasos son válidos tanto para pruebas locales como para publicaciones más serias (aunque, como veremos, Flathub añade requisitos extra):

1. Instalar Flatpak en tu distribución si todavía no lo tienes. Usa el gestor de paquetes nativo (apt, dnf, pacman, etc.).
2. Configurar un runtime adecuado, por ejemplo, añadiendo Flathub como repositorio y descargando el runtime necesario para tu app.
3. Definir la estructura del paquete y su identificador completo (del tipo com.tuempresa.TuApp), además de crear las carpetas de archivos, metadatos, iconos, AppData, etc.
4. Construir el paquete y exportarlo a un repositorio local o remoto, por ejemplo con un comando tipo flatpak build-export repo hello, donde repo es la carpeta de repositorio y hello es el directorio con la build.
5. Instalar el paquete desde ese repositorio y probarlo para comprobar que todo funciona como se espera dentro del sandbox.

El comando flatpak build-export puede combinarse con firmas GPG para garantizar la autenticidad del desarrollador y la integridad del paquete. Esto es especialmente interesante cuando se distribuyen aplicaciones en entornos donde la verificación criptográfica es importante.

Ten en cuenta que los pasos anteriores describen un flujo bastante directo y orientado a la construcción en local. Cuando hablamos de Flathub, la historia se complica un poco, porque el repositorio no acepta paquetes precompilados, sino que compila los Flatpak en sus propios servidores con acceso restringido a la red.

Instalar, ejecutar y gestionar aplicaciones Flatpak desde la terminal

Una vez tienes tu paquete, o quieres probar otros, la gestión de aplicaciones Flatpak desde la línea de comandos es bastante simple. Vamos a ver algunos ejemplos típicos que te ayudan a entender cómo se usaría tu propio paquete una vez empaquetado.

Imagina que has creado un pequeño repositorio llamado tutorial-repo que contiene tu aplicación de ejemplo org.test.Hello. Para añadir ese repositorio e instalar la app únicamente para tu usuario, podrías usar:

flatpak --user remote-add --no-gpg-verify tutorial-repo repo
flatpak --user install tutorial-repo org.test.Hello
flatpak run org.test.Hello

El parámetro --user indica que la instalación se realiza en el directorio personal del usuario, sin requerir permisos de administrador y sin afectar al resto de cuentas del sistema. Es ideal para entornos multiusuario donde cada persona puede decidir qué aplicaciones Flatpak quiere tener.

Un ejemplo clásico es el de instalar un juego como GNOME Chess solo para tu usuario. El comando podría verse así (suponiendo que usas Flathub como repositorio):

flatpak install --user https://dl.flathub.org/repo/appstream/org.gnome.Chess.flatpakref

También puedes instalar aplicaciones indicando directamente el archivo de referencia .flatpakref, como ocurre con GIMP desde Flathub, usando algo como:

flatpak install https://dl.flathub.org/repo/appstream/org.gimp.GIMP.flatpakref

Para mantener todo al día, el comando flatpak update se encarga de actualizar las aplicaciones instaladas. Puedes ejecutarlo de forma periódica o incluso integrarlo en scripts de administración, como se hace en algunos entornos educativos o corporativos donde las aplicaciones se despliegan en modo sistema para todos los usuarios.

Además de instalar y actualizar, Flatpak te permite listar, desinstalar y limpiar aplicaciones y runtimes que ya no uses. La orden de limpieza es especialmente útil para borrar librerías y dependencias huérfanas, liberando espacio en disco después de desinstalar aplicaciones Flatpak.

Flathub, repositorios y despliegue de aplicaciones Flatpak

Flathub se ha consolidado como el repositorio principal y más conocido de aplicaciones Flatpak. Es el lugar donde la mayoría de usuarios buscan nuevos programas y donde muchos desarrolladores publican versiones actualizadas de sus aplicaciones de escritorio.

En Flathub puedes encontrar una enorme variedad de software, organizado por categorías como audio y vídeo, desarrollo, educación, juegos, gráficos, comunicación, productividad, ciencia, utilidades, etc.. Ahí aparecen aplicaciones tan conocidas como VLC, GIMP, LibreOffice, Audacity, Steam, Inkscape, Blender, Signal, Telegram, Calibre y un largo etcétera.

Desde la web de Flathub puedes buscar una aplicación, pulsar en el botón INSTALL y obtener la referencia .flatpakref, que luego se pasa al comando flatpak install. Esta referencia contiene la información necesaria para que Flatpak sepa desde qué remoto descargar la app, qué runtime usar, etc.

Si estás en un entorno más controlado, como una empresa o un instituto, también es posible crear repositorios propios y publicar en ellos tus aplicaciones. En muchos centros educativos, por ejemplo, se usa Ansible u otras herramientas de automatización para desplegar aplicaciones Flatpak en modo sistema, de forma que estén disponibles para todos los usuarios del equipo.

La instalación en modo sistema suele requerir privilegios administrativos, pero ofrece la ventaja de que las apps quedan disponibles de forma centralizada. Por su parte, la instalación con --user es ideal para dar flexibilidad a cada persona sin alterar el conjunto de software base de la máquina.

Crear un paquete Flatpak para publicarlo en Flathub

Aquí viene una de las partes más delicadas. Construir un Flatpak que funcione en tu máquina es solo la mitad de la historia. Si quieres publicarlo en Flathub, el proceso tiene requisitos y limitaciones adicionales que conviene conocer desde el principio para no desesperarse.

Para empezar, las instrucciones de la web principal de Flatpak se centran en un flujo de construcción bastante “abierto”, donde tu entorno de compilación puede acceder a la red para descargar dependencias, clonar repositorios, etc. Sin embargo, Flathub compila los paquetes en sus propios servidores, y allí el proceso de build no tiene acceso a Internet. Esto implica que todo lo que necesites debe estar descrito en el manifiesto con URLs de origen bien definidas.

En otras palabras, si tu aplicación depende de múltiples librerías o módulos externos, necesitas añadir explícitamente las fuentes de cada dependencia en el manifiesto Flatpak, incluso aunque ya tengas un requirements.txt en el caso de Python u otro archivo de dependencias en tu tecnología. Esto puede obligarte a usar scripts auxiliares (a veces poco pulidos) para generar estas secciones, y aun así tendrás que revisar a mano cosas como las dependencias de compilación.

La consecuencia práctica es que resolver todas las dependencias y hacer que la compilación sin red funcione puede llevar horas, especialmente en aplicaciones complejas o con muchas librerías externas. En algunos lenguajes de alto nivel, como Python, dar con todas las dependencias de build correctas puede resultar bastante tedioso.

Otro punto importante es que en Flathub no puedes usar cualquier runtime que te apetezca. Solo puedes apoyarte en los runtimes alojados en el propio Flathub, lo que a veces obliga a compilar e incluir manualmente más dependencias de las que te gustaría. Eso multiplica el trabajo de empaquetado y la cantidad de cosas que tienes que mantener a largo plazo.

Además del manifiesto y las dependencias, Flathub exige un archivo de metadatos bastante detallado, que incluya información como descripción extensa, capturas de pantalla, enlaces, licencias, categorías y, en muchos casos, notas de versión para cada actualización. Esto requiere un mantenimiento continuo cada vez que publicas una versión nueva.

El proceso de despliegue tampoco es trivial. Para publicar en Flathub necesitas solicitar un repositorio específico dentro de la organización Flathub en GitHub, pasar por un proceso de revisión y configurar acciones o flujos de trabajo que se integren con la infraestructura de compilación de Flathub. La documentación menciona GitHub Actions, pero no siempre explica con claridad cómo encajan estas acciones con el repositorio oficial de la organización.

Por todo esto, hay desarrolladores que, tras probar, comentan que crear un Flatpak para Flathub puede resultar frustrante y muy demandante en tiempo, hasta el punto de plantearse formatos alternativos como Snap cuando el objetivo es un despliegue más directo y con menos fricción. Aun así, la ventaja de llegar a una base de usuarios muy amplia y a múltiples distribuciones hace que el esfuerzo merezca la pena en muchos casos.