Contenido.

Gestión de paquetes en Arch Linux.................................................................................................................................2

Código fuente.............................................................................................................................................................2

Librerías y dependencias............................................................................................................................................3

Anatomía de un paquete Arch...................................................................................................................................4

Instalación manual de un paquete Arch.....................................................................................................................7

Repositorios...............................................................................................................................................................8

Pacman.......................................................................................................................................................................9

Comandos de pacman..............................................................................................................................................15

Operación -Q.......................................................................................................................................................15

Operación -S........................................................................................................................................................15

Operación -R........................................................................................................................................................15

Operación -D.......................................................................................................................................................16

Operación -U.......................................................................................................................................................16

Creación de paquetes Arch............................................................................................................................................17

Introducción.............................................................................................................................................................17

Los shell script..........................................................................................................................................................17

El script PKGBUILD....................................................................................................................................................17
Gestión de paquetes en Arch
Linux.
Código fuente.

Si no eres programador, probablemente nunca te hayas preguntado qué hay detrás de los programas que
usas día a día. Desde las aplicaciones que usas en tu teléfono hasta las que usas en tu computadora,
todas ellas comparten una naturaleza; a saber, que están hechas con un lenguaje de programación. Un
lenguaje de programación es un lenguaje formal (es decir, un lenguaje con reglas gramaticales bien
definidas) que le proporciona a una persona, en este caso el programador, la capacidad de escribir (o
programar) una serie de instrucciones o secuencias de órdenes en forma de algoritmos con el fin de
realizar diversas tareas. Existen muchos lenguajes de programación, entre los más conocidos están
Python, Java, C, C++, etcétera. En lo que sigue, nos ocuparemos de explicar en un lenguaje sencillo qué
es lo que se hace cuando se crea un programa nuevo, desde la escritura del mismo en el lenguaje de
programación hasta la instalación del programa en nuestra computadora. Para este propósito, debemos
definir antes conceptos importantes. El primer concepto con el que nos debemos familiarizar es el de
código fuente.

Por código fuente se entiende todo texto legible por un ser humano y redactado en un lenguaje de
programación determinado. El objetivo del código fuente es crear instrucciones claras para la computadora
y que esta sea capaz de traducirlas a su propio lenguaje (binario) para poder ejecutarlas. De este modo, el
código fuente es la base de los programas. Todos los programas que usted conoce están escritos en algún
lenguaje de programación.

Ya tenemos el código fuente, ¿Y ahora? ¿Cuál es la magia que hace posible que un código fuente se
ejecute? Pues bien, una vez teniendo el código fuente de un programa, lo que sigue es compilarlo.
Compilar un programa no es más que traducir el código fuente al lenguaje que entienden las
computadoras. Recordemos que el código fuente está escrito en algún lenguaje de programación, la
cuestión es que una computadora no entiende ese lenguaje. El lenguaje de la computadora es el de ceros
y unos, ósea, el llamado código binario. La compilación es fundamental, pues es la única manera posible
de que la computadora entienda y luego ejecute las sentencias, las órdenes e instrucciones determinadas
por el código fuente. El proceso de compilación se hace mediante un programa llamado compilador. Si
bien los pasos a seguir para la compilación de los programas en general es parecido, es normal que
algunos programas requieran de pasos extras para poder compilarlos de manera correcta. Es por ello que
en el código fuente el creador del programa suele incluir un archivo de texto que le indica al usuario cuáles
son los pasos a seguir para poder compilar el programa exitosamente.

Muy bien, ya tenemos nuestro código fuente y lo hemos compilado con las instrucciones que nos dio el
creador, ¿Qué sigue? Una vez compilado el código fuente, se habrán creado un conjunto de archivos
llamados archivos binarios. Un archivo binario es un archivo informático que contiene información
codificada en binario para el propósito de almacenamiento y procesamiento en computadoras. Los
archivos binarios son precisamente los que nuestra computadora usa para hacer funcionar el programa y
podamos usarlo. Si nosotros intentamos abrir un archivo binario, lo que veremos será un montón de
caracteres ininteligibles, pues estos archivos están hechos para ser entendidos por la computadora, no por
los humanos. Entre estos archivos obtenidos de la compilación, habrá uno que al ejecutarlo se inicie el
programa. Usualmente este archivo tiene por nombre el nombre del programa. Así, podríamos nosotros
tomar los archivos binarios y compartirlos con otros usuarios para que puedan ejecutarlos en sus
computadoras y usar el programa (siempre que se use el mismo sistema operativo en los equipos).
Los paquetes Arch.
Ya hemos visto que para poder usar un programa necesitamos únicamente los archivos binarios obtenidos
de la compilación del código fuente, pero cabe preguntarse lo siguiente: ¿Qué relación tiene lo anterior con
la noción de "instalar un programa"? Es decir, ¿Para qué "instalamos" los programas si podemos
únicamente usar los binarios para ejecutar las aplicaciones? La respuesta a estas preguntas es bastante
interesante, y conforme continúe leyendo este texto usted mismo se podrá responder. El secreto está en
entender la naturaleza de los denominados "paquetes Arch". Veamos lo que son.

Seguramente usted está familiarizado con la instalación de programas en Windows. El proceso

básicamente consiste en ejecutar un archivo con extensión .exe y seguir un conjunto de instrucciones
bastante sencillas e intuitivas. En el sistema Arch Linux la instalación de programas y otras herramientas
útiles para nuestro sistema como temas (en algunos casos), documentación, idiomas, plugins,
extensiones, etc. es distinta. En lugar de los archivos con extensión .exe, en Arch Linux los archivos
binarios de los programas vienen empaquetados con el programa tar y comprimidos desde diciembre del
2019 con el programa zstd, de modo que sus extensiones son .tar.zst. Anteriormente se usaba el
programa gzip para comprimir, así que es posible aún en nuestros días ver algunos paquetes con la
extensión .tar.gz. Con el tiempo, estos irán desapareciendo. Si el lector no está familiarizado con los
conceptos de empaquetar y comprimir archivos, una búsqueda en Google será suficiente para entender
estos sencillos conceptos.

Un paquete .tar.zst destinado a la instalación en Arch, sigue un estricto protocolo en su elaboración que
garantiza una homogeneidad en todo el sistema. El paquete no es solo un archivo de archivos. Es parte de
un todo más grande y describe, como veremos más adelante, su relación con otros paquetes. De aquí en
adelante llamaremos a estos paquetes "paquetes Arch".

Librerías y dependencias.

Antes de profundizar en los paquetes Arch, conviene conocer los conceptos de "librerías" y
"dependencias" en los sistemas GNU/Linux.

Para que un programa funcione en nuestra computadora, se necesitan ciertos archivos especiales que
tienen como propósito cumplir una tarea específica en el funcionamiento dicho programa. A dichos
archivos se les conoce como librerías. Así, se dice que el programa X "depende" de cierta librería para
funcionar. En consecuencia, decimos que la librería en cuestión es una dependencia del programa X. Si
dicha librería no se encuentra instalada en el sistema, el programa que la necesita no podrá funcionar
correctamente, y decimos entonces que hay "problemas de dependencias". Sin embargo, no todas las
dependencias de un programa son librerías, con frecuencia sucede que un programa X precisa que en el
sistema se encuentre ya instalado otro programa Y para su correcto funcionamiento, de modo que un
programa puede ser también una dependencia. La cuestión importante a tratar es que en los sistemas
GNU/Linux existen dos tipos de librerías; las librerías estáticas y las librerías dinámicas. Veamos las
diferencias.

Librerías estáticas: Estás librerías son usadas exclusivamente por el programa al que pertenecen. En
Windows tienen la extensión .lib y en GNU/Linux la extensión .a.

Librerías dinámicas: Estás librerías, a diferencia de las estáticas, son compartidas por distintos programas.
En Windows tienen la extensión .dll mientras que en GNU/Linux .so.

La ventaja de las librerías dinámicas reside en que solamente es necesario una copia de la librería, la cual
es compartida por todas las aplicaciones que la necesitan, ahorrando espacio en disco duro y optimizando
el funcionamiento del sistema. La librería estática, en cambio, requiere que cada programa disponga de su
propia copia y la incluya como parte del programa en sí, de manera que al usar dos programas que usan
una misma librería, ésta estará en ejecución dos veces demandando más trabajo por parte del hardware.
Sin embargo, el uso de librerías dinámicas puede traer problemas. Por ejemplo, distintos programas
pueden necesitar de una misma librería pero en versiones distintas; es decir, un programa precisa que la
librería en cuestión esté en su versión 2.0 mientras que otro programa la necesita en su versión 2.3. Lo
mismo puede ocurrir con los programas que son dependencias de otros programas. Esto puede ocasionar
un conflicto y hacer que los programas no funcionen correctamente, ya que Arch Linux no permite que un
mismo programa o librería esté instalado varias veces, aún cuando sea en versiones diferentes. Por lo
tanto, se requiere un sistema eficiente que gestione las relaciones entre programas y dependencias de
forma que haya un equilibrio evitando conflictos entre los diferentes programas. El programa pacman es el
encargado de solucionar estos problemas, pero antes de ver su funcionamiento, conviene conocer el
contenido de un paquete Arch.

Anatomía de un paquete Arch.

Nota: recordemos que en los sistemas GNU/Linux los archivos cuyo nombre empieza por un punto son
archivos que están ocultos, de modo que para verlos hay que especificarlo en el explorador de archivos
que estemos usando. Si se está usando la terminal, el comando ls -a los mostrará.

Por el momento no discutiremos el proceso de elaboración de un paquete Arch ni la manera de

descargarlos, simplemente mostraremos el contenido de uno. Para analizar la anatomía de un paquete
Arch, usaremos el paquete del navegador Firefox. En mi caso, he creado una carpeta llamada firefox en mi
carpeta de Descargas y ahí he descargado el paquete. Analicemos en detalle los comandos que introduje
en la terminal.

En un principio, solo se halla el archivo firefox-88.0-1-x86_64.pkg.tar.zst, tal como indica el resultado del
segundo comando que ejecuté. Para ver su contenido, lo primero que hay que hacer es descomprimirlo
con el programa zstd, para ello ejecutamos el comando unzstd firefox-88.0-1-x86_64.pkg.tar.zs. En
consecuencia aparecerá otro archivo llamado firefox-88.0-1-x86_64.pkg.tar, tal como indica la salida del
cuarto comando. El quinto comando; tar -xf firefox-88.0-1-x86_64.pkg.tar, lo que hace es desempaquetar
el archivo firefox-88.0-1-x86_64.pkg.tar con el programa tar. El resultado aparentemente es la obtención
de la carpeta llamada usr, ello lo indica el sexto comando. El séptimo comando muestra todos los archivos
incluyendo los ocultos. Así, podemos ver el contenido completo del paquete Arch, el cual consiste en:
-Los archivos binarios para instalar: estos archivos corresponden a la aplicación en sí, y es, entre otras
cosas, el contenido de la carpeta usr.

-El archivo .PKGINFO: es un archivo de texto que contiene toda la información que pacman necesita para
manejar paquetes, dependencias, etc. Más adelante, cuando veamos el funcionamiento de pacman
profundizaremos en dicha información.

-El archivo .BUILDINFO: este es un archivo de texto que cumple una función un poco técnica, así que no
le prestaremos mucha atención. Contiene la información necesaria para compilaciones reproducibles. Este
archivo está presente solo si el paquete está construido con pacman 5.1 o más reciente. Consulte
BUILDINFO (5) para más detalles.

-El archivo .MTREE: la función de este archivo es la de revisar que el paquete cumpla con ciertos aspectos
de seguridad. Para los entendidos en la materia, contiene hashes y marcas de tiempo de los archivos, que
se incluyen en la base de datos local para que pacman pueda verificar la integridad del paquete.

-El archivo .INSTALL: un archivo opcional que se utiliza para ejecutar comandos después de la etapa de
instalación / actualización / eliminación del paquete. (Este archivo solo está presente si se especifica
durante la creación del paquete). En nuestro caso, no existe el archivo, pero otros paquetes podrían
contenerlo.

-El archivo .Changelog: es otro archivo opcional guardado por el mantenedor del paquete que documenta
los cambios del paquete. En nuestro caso tampoco existe.

Ahora notemos algo interesante del contenido de la carpeta usr. Al entrar en ella podremos notar que
existe una carpeta llamada lib, y esta a su vez tiene otra carpeta llamada firefox. La siguiente imagen
muestra el contenido de esta ultima carpeta en la salida del tercer comando

Notemos que existe un archivo llamado firefox, el cual podemos ejecutar con el comando ./firefox. Al
hacerlo, el resultado es el siguiente.
Como se puede observar, se ha abierto la aplicación para poder usarla. En principio, muchos programas
que no requieran dependencias pueden ser usados siguiendo los pasos anteriores. Sin embargo, el
programa no está "instalado" formalmente, de modo que nuestro sistema no lo detectará como tal.

Instalación manual de un paquete Arch.

Como ya se ha mencionado, los paquetes Arch están diseñados para que su contenido pueda extraerse
en cualquier sistema que tenga los programas tar y zstd. Esta propiedad aparentemente trivial es
importante para la portabilidad y la recuperación ante posibles desastres. Por el momento no nos
ocuparemos de mostrar qué es y cómo se usa el programa pacman, solo es importante saber que una de
sus funciones es la de instalar paquetes de forma automática. Supongamos ahora que por alguna razón,
pacman se eliminó de nuestro sistema y que por lo tanto, no puede más instalar paquetes Arch. Podría
descargar el paquete Arch de pacman, pero no podría instalarlo porque irónicamente precisa de pacman
para hacerlo. Ahora supongamos que afortunadamente, conoce la estructura de un paquete Arch y, por lo
tanto, puede descargar el paquete de pacman e instalarlo manualmente (más adelante veremos cómo). De
esta manera recuperaría la instalación del programa pacman y podría con normalidad instalar otros
paquetes Arch a través de este. Si por alguna desgracia además el programa tar ha desaparecido, solo
será necesario copiarlo desde otra computadora (ya que tar opera de manera completamente autónoma,
sin dependencias, así una copia simple será suficiente). Esto último no se mostrará cómo hacerlo, pero es
importante saber que se puede hacer.

Volvamos a nuestro caso hipotético donde se ha eliminado pacman y no podemos instalar paquetes Arch.
La solución a este problema sería entonces, descargar el paquete de pacman (más adelante veremos de
dónde se descargan los paquetes) y extraer su contenido en la raíz / del sistema, de manera que cada
archivo vaya a donde tenga que ir, pues recordemos que el empaquetado .tar preserva las ubicaciones
relativas entre las carpetas. De esta forma pacman quedaría instalado nuevamente en nuestro equipo. Sin
embargo, no es recomendable instalar paquetes Arch de esta manera, salvo en casos extremos como el
descrito anteriormente. Si lo hacemos, muchos procesos importantes no se llevan acabo de manera
correcta. La instalación de paquetes a través de pacman u otro gestor de paquetes es lo que debemos
procurar para mantener a nuestros programas funcionando de manera correcta. Por lo tanto, en lo que
sigue nos ocuparemos en el análisis del funcionamiento de pacman, pero antes, vale la pena saber que
son los repositorios.

Repositorios.

Hasta el momento hemos estudiado lo que son los paquetes Arch y su contenido, pero no hemos dicho de
dónde se descargan. Para ello debemos explicar lo que son los repositorios, para finalmente mostrar cómo
se usa pacman en la instalación de programas.

Seguramente está familiarizado con la instalación de aplicaciones en su teléfono desde tiendas como
Apple App Store o Google Play Store. Lo que sucede en estos casos es que nosotros buscamos la
aplicación en la tienda, la descargamos y la instalamos, así de sencillo. Algo parecido pasa en Arch Linux
y muchas otras distribuciones de Linux. Un repositorio no es más que una computadora que aloja un
montón de paquetes Arch. Nosotros desde nuestra computadora nos conectamos a dicho repositorio para
buscar los programas que queremos y posteriormente descargarlos e instalarlos. En la actualidad Arch
Linux cuenta con 7 repositorios oficiales. Veamos un poco de historia.

Originalmente, cuando Arch Linux era usada por muy pocos usuarios, solo había un repositorio conocido
como [official] (ahora [core]). Este repositorio contenía básicamente las aplicaciones preferidas de Judd
Vinet. En aquel entonces existían algunos usuarios a los que no les gustaba las selecciones de Judd, así
que comenzaron a crear sus propios paquetes. Estos paquetes fueron incorporados a un repositorio
llamado [unofficial] y fueron mantenidos por algunos desarrolladores de Judd. Con el tiempo estos dos
repositorios consiguieron apoyo por parte de todos los desarrolladores. Como los nombres [oficial] y
[unoficial] ya no reflejaban su verdadero propósito fueron renombrados a [current] y [extra].

Poco tiempo después, [current] fue renombrado a [core] para prevenir confusiones sobre lo que contenía.
Los repositorios ahora se encuentran atendidos por igual por los desarrolladores y la comunidad, pero
[core] tiene algunas diferencias, la principal es que los paquetes para el CD de instalación y las
liberaciones de instantáneas (“snapshots”) son tomados solo de [core].

En algún momento se descubrió que existían muchos paquetes que los desarrolladores no querían
mantener. Así, uno de los desarrolladores (Xentac) creó el “Repositorio de Usuarios de Confianza”
(Trusted User Repositories) que era básicamente un repositorio no oficial en el cual los llamados "usuarios
de onfianza" podían colocar paquetes que ellos hubieran creado. Este sistema funcionó por un tiempo,
pero luego los usuarios de confianza comenzaron a descuidar su repositorio. Posteriormente los usuarios
de confianza fueron congregados en un grupo más unido y ahora mantienen colectivamente el repositorio
[community]. Los usuarios de confianza aun son un grupo separado de los desarrolladores de Arch Linux y
no existe mucha comunicación entre ambos grupos. Sin embargo, los paquetes que son muy populares
aun siguen pasando desde [community] a [extra], en ocasiones.

Por otra parte, y dado a numerosos problemas causados por un kernel introducido en [core] , fue
presentada la norma “política del visto bueno del núcleo” (core signoff policy). Desde entonces, todas las
actualizaciones de los paquetes depositados en [core] tienen que ser presentados primero a través del
repositorio [testing] , y únicamente después de varios vistos buenos (“signoffs”) de otros desarrolladores se
les permite moverse a core.

En resumen, tenemos que los repositorios oficiales en la actualidad son:

1. core

2. extra

3. community

4. multilib
5. testing

6. community-testing

7. multilib-testing

Para ver en detalle qué tipos de paquetes hay en cada uno consulta
https://wiki.archlinux.org/index.php/Official_repositories_(Español)

Con la información dada hasta el momento, puede parecer que la descarga e instalación de paquetes Arch
es muy complicada. Lo que sigue es ver cómo pacman facilita la tarea de búsqueda, descarga, instalación
y desinstalación de un programa. Más aún, pacman nos ayuda a obtener información específica de un
paquete así como resolver conflictos con dependencias. Es pacman, en resumen, una herramienta muy
poderosa que debemos aprender a utilizar.

Pacman.

El programa pacman se usa por medio de la línea de comandos. Todo usuario experimentado en Linux
sabe que la mejor forma de aprender a usar un programa de terminal es leyendo el manual del programa.
Podemos acceder al manual de pacman ejecutando man pacman en nuestra terminal. Sin embargo, el
propósito de esta guía es mostrar de forma didáctica la gestión de paquetes en Arch Linux, de manera que
a continuación se mostrará un caso donde se exponga el proceso de instalación y desinstalación de un
paquete partiendo desde la búsqueda del mismo en los repositorios.

Supongamos que estamos interesados en instalar un programa para editar videos pero no sabemos que
opciones existen. El primer paso, es sincronizar nuestra computadora con los repositorios para tener una
lista actualizada de los paquetes disponibles. Los repositorios están en constante cambio, así que es
importante esta sincronización. Para ello ejecutamos en nuestra terminal sudo pacman -Sy.

Una vez hecho esto, pacman conocerá el estado actual de los repositorios y su contenido, de manera que
podemos proceder a buscar nuestro programa.
El segundo paso es buscar en los repositorios aquellos programas cuyas características sean la edición de
video, para ello ejecutamos pacman -Ss video editor (aclaremos que las palabras "video" y "editor"
corresponden a patrones de búsqueda para pacman).

Nos aparecen entonces varios paquetes que cumplen con nuestra búsqueda "video editor", seguidos de
una pequeña descripción (notemos también que se específica el repositorio al que pertenece el paquete).
Supongamos que nos llama la atención el programa kdenlive (el primer resultado, perteneciente al
repositorio extra), así que nos gustaría obtener información sobre él. Para ello ejecutamos pacman -Si
kdenlive.
En consecuencia obtenemos información del paquete, tal como su versión, sus dependencias, su
mantenedor, etc. Al parecer cumple con lo que buscamos, así que lo siguiente es instalarlo, y para ello
ejecutamos sudo pacman -S kdenlive.

De esta manera, pacman buscará si es necesario instalar dependencias faltantes, así como verificar que la
instalación de kdenlive no genere conflictos con otros paquetes instalados. En nuestro caso, es necesario
instalar el propio kdenlive y otras 29 dependencias. Notemos que nos pregunta si queremos continuar con
la instalación, a lo que respondemos que sí tecleando la letra “s” y presionando enter. El proceso de
descarga e instalación de los paquetes comenzará. Una vez finalizada la instalación, podemos proceder a
usar el programa.

Supongamos que pasa el tiempo y sale una nueva versión de kdenlive o de cualquier otro programa que
tengamos instalado. Lo que sigue entonces sería actualizar los programas y dependencias, y para ello
pacman también nos ayuda. El comando pacman -Syu sincroniza nuestra computadora con los
repositorios y en caso de haber actualizaciones pacman las instalará.
En nuestro caso, se pueden actualizar 4 paquetes, tal como se muestra en la imagen. Al confirmar que
queremos continuar con la instalación, pacman se encargará del resto.

Finalmente, supongamos que deseamos desinstalar kdenlive porque ya no lo utilizamos. Para ello
ejecutamos sudo pacman -Rns kdenlive, con lo que se procederá con la eliminación de kdenlive y todas
sus dependencias, procurando no generar conflictos con otros paquetes.
El proceso anterior, desde la sincronización con los repositorios hasta la instalación del paquete es lo que
usualmente se hace para instalar paquetes Arch. Una recomendación es que antes de instalar algún
programa se sincronicen los repositorios y se actualice el sistema. Para ello siempre es recomendable
instalar un paquete mediante el comando pacman -Syu nombre_del_paquete.

Comandos de pacman.

Pacman cuenta con muchas funciones de gran utilidad. A continuación se listan las órdenes más
importantes que pueden ejecutarse.

Operación -Q.

pacman -Q [paquete] Revisa si el paquete especificado está instalado en el sistema.

pacman -Qs [búsqueda] Revisa si hay un paquete instalado con las características de búsqueda que se
ponen (usualmente se debe escribir en inglés). Ejemplo; pacman -Qs video editor.

pacman -Qi [paquete] muestra información del paquete instalado (su versión, dependencias, etc.). De
hecho, la información desplegada por este comando es precisamente el contenido del archivo .PKGINFO.

pacman -Qm muestra todos los paquetes instalados de fuentes externas a los repositorios oficiales.

pacman -Qd muestra los paquetes instalados como dependencias.

pacman -Qt Muestra solo paquetes que no son requeridos (ni opcionalmente) por ningún otro paquete
instalado. La orden -Qtt muestra los paquetes que son requeridos opcionalmente por otros paquetes.

pacman -Qdt muestra paquetes huérfanos, esto es, paquetes que se instalaron como dependencias pero
que ya no son requeridos por ningún paquete instalado.

Operación -S.

pacman -Sy sincroniza los repositorios.

pacman -Su actualiza todos los programas y sus dependencias de ser necesario.
pacman -Syu primero sincroniza los repositorios y luego actualiza todos los programas.

pacman -Ss [búsqueda] Revisa los paquetes de los repositorios con las características de búsqueda que
se ponen (usualmente se debe escribir en inglés). Ejemplo; pacman -Qs video editor.

pacman -Si [paquete] muestra información del paquete (su versión, dependencias, etc.). La informacion
desplegada es la que contiene el archivo .PKGINFO.

pacman -S [paquete 1] [paquete 2] ... [paquete n] instala los n paquetes especificados. Además instalará
los paquetes incluyendo sus dependencias obligatorias. También ofrecerá instalar dependencias
opcionales.

pacman -Sw [paquete 1] [paquete 2] ... [paquete n] Descarga los n paquetes especificados pero no los
instala. Los paquetes y las dependencias requeridas se descargarán en la carpeta de caché de pacman
ubicado en /var/cache/pacman/pkg

pacman -Sc Elimina los paquetes de la caché que ya no están instalados, así como las bases de datos de
sincronización que no se utilizan actualmente para liberar espacio en el disco. Cuando pacman descarga
paquetes, los guarda en un directorio de caché ubicado en /var/cache/pacman/pkg. Además, cada que
actualizamos los repositorios, cada sincronización se guarda y no se eliminan incluso si se eliminan del
archivo de configuración pacman.conf. La instrucción -Sc elimina solo los paquetes que ya no están
instalados; mientras que -Scc elimina todos los archivos de la caché. En ambos casos, tendrá una opción
de sí o no para eliminar paquetes y / o bases de datos descargadas no utilizadas.

Operación -R.

pacman -R [paquete] Elimina el paquete especificado, pero no borra sus dependencias.

pacman -Rs [paquete] Elimina el paquete especificado y sus dependencias. Una dependencia no se
eliminará si es que otro paquete requiere de ella. Además, si una dependencia fue instalada explícitamente
tampoco se eliminará con esta orden. Esta orden es recursiva, en el sentido de que de ser posible, se
eliminarán dependencias de dependencias.

pacman -Rns [paquete] Hace lo mismo que el comando anterior pero elimina además los archivos de
configuración.

pacman -Rc [paquete] Elimina el paquete especificado y sus dependencias. Esta orden es peligrosa pues
puede eliminar una dependencia requerida por otro paquete. También es recursiva.

Operación -D.

pacman -Dk Compruebe que la base de datos de paquetes local no sea inconsistente. Esto es, verificará
que todos los archivos requeridos estén presentes y que los paquetes instalados tengan las dependencias
requeridas, no entren en conflicto y que varios paquetes no posean el mismo archivo. La instrucción -Dkk,
comprobará además la sincronización de las bases de datos para garantizar que todas las dependencias
especificadas estén disponibles.

Operación -U.

pacman -U [paquete] Instala el paquete especificado. Este comando se usa para instalar paquetes que ya
hemos descargado. Recordemos que el comando pacman -Sw nos permite descargar paquetes pero no
instalarlos, y estos se guardan en /var/cache/pacman/pkg. Así, podemos instalar un paquete previamente
descargado con el comando pacman -U /var/cache/pacman/pkg/nombre_del_paquete.
Creación de paquetes Arch.
Introducción.

El propósito de esta sección es explicar de manera sencilla e intuitiva el proceso de elaboración de un

paquete Arch. No se pretende que usted aprenda a hacer paquetes Arch, simplemente que entienda el
protocolo que se lleva a cabo. En la wiki oficial de Arch Linux se halla toda la documentación necesaria
para aprender a crear paquetes Arch. Nuestro objetivo aquí es pues, exponer en un lenguaje accesible
para todos, los pasos que se siguen en la creación de un paquete.

Los shell script.

Un shell script es un archivo de texto ejecutable donde se escriben órdenes que serán llevadas a cabo por
la terminal. Podemos decir que es un "programa" utilizado para automatizar procesos que requieren la
ejecución y combinación de muchos comandos, de manera que la ejecución del script se encarga de todo
el trabajo. Obviamente en este texto no mostraremos cómo hacer shell scripts, lo importante es saber
unicamente que son archivos que al ejecutarse llevan a cabo todas las instrucciones que le hallamos
indicado.

Es mediante un shell script especial, llamado PKGBUILD, que se construyen los paquetes Arch, logrando
así que todos los paquetes Arch sean creados de la misma manera.

El script PKGBUILD.

El archivo PKGBUILD es el shell script usado para la creación de paquetes Arch. Para crear un
PKGBUILD lo que se hace es tomar un archivo base de referencia ubicado en /usr/share/pacman/, e
introducir en él toda la información que nos pide, algo así como rellenar un formulario (es recomendable
que vea por su cuenta el contenido de dicho archivo de referencia para que conozca la información
requerida de la que estamos hablando). Entre la información requerida se encuentra el nombre del
programa, su versión, dependencias, nombre del creador del paquete, etcétera. Además, en el script
también debe incluirse la programación de todas las instrucciones para la descarga del código fuente y su
correcta compilación.

Supongamos que ya tenemos el archivo PKGBUILD de nuestro programa. Lo que sigue es ejecutar otro
script, que lo provee pacman, llamado makepkg. Al ejecutar el comando makepkg desde la terminal en la
carpeta donde está nuestro PKGBUILD, se procederá con la descarga del código fuente y su compilación,
tal como se indica en el mismo PKGBUILD, así como el empaquetado y compresión de los archivos
binarios resultantes, además de la creación de los archivos que todo paquete Arch tiene (.MTREE,
.PKGINFO, etc). El resultado de la ejecución de makepkg será un archivo con extensión .tar.zst. Dicho
archivo es el paquete Arch del programa, y está listo para ser instalado con pacman.

Lo descrito anteriormente por supuesto no son todas las acciones que hace el script makepkg. Se trata
solo de una explicación general. El script makepkg consta de cerca de 1500 líneas de código y puede ser
consultado en https://git.archlinux.org/pacman.git/tree/scripts/makepkg.sh.in

Lo importante es notar que la creación de paquetes Arch sigue el mismo conjunto de normas. Estos
paquetes están formados por elementos con características comunes, lo que permite establecer entre ellos
una relación de semejanza y uniformidad.