---
title: Ajustes Generales del Sistema
description: Cosas que puedes hacer para ajustar después de la instalación
tableOfContents:
  minHeadingLevel: 1
  maxHeadingLevel: 4
ai_translated: true
---

import { Tabs, TabItem, Steps, LinkButton, Icon } from '@astrojs/starlight/components';
import ImageComponent from '~/components/image-component.astro';

## Ajustes de Rendimiento de AMD

### Controlador AMD P-State
---------------------------

`amd-pstate` es el controlador de escalado de rendimiento de CPU de AMD que introduce un nuevo mecanismo de control de frecuencia de la CPU en las series modernas de APU y CPU de AMD en el kernel de Linux. El nuevo mecanismo se basa en el Control Colaborativo de Rendimiento del Procesador (CPPC), que proporciona una gestión de frecuencia más precisa que los estados P de hardware ACPI heredados.

Las plataformas de CPU/APU de AMD actuales utilizan el controlador de estados P de ACPI para gestionar la frecuencia y los relojes de la CPU, cambiando solo en 3 estados P. CPPC reemplaza los controles de estados P de ACPI y permite una interfaz flexible y de baja latencia para que el kernel de Linux comunique directamente las sugerencias de rendimiento al hardware.

A continuación se presentan 3 modos de operación del controlador `amd_pstate` y las entradas de la línea de comandos del kernel para usarlos en el arranque:

- AMD P-State (Modo no autónomo): `amd_pstate=passive`
- AMD P-State Guiado (Modo autónomo guiado): `amd_pstate=guided`
- AMD P-State EPP (Modo autónomo): `amd_pstate=active`

:::note
El controlador AMD P-State EPP se utiliza por defecto cuando no se realiza ninguna configuración explícita.
:::

También puedes cambiar entre los modos de operación en tiempo de ejecución para probar las opciones:

- **Modo autónomo**: la plataforma solo considera los valores establecidos para el rendimiento mínimo, el rendimiento máximo y la preferencia de rendimiento energético.
   ```sh
   echo active | sudo tee /sys/devices/system/cpu/amd_pstate/status
   ```

- **Modo autónomo guiado**: la plataforma establece el nivel de rendimiento operativo según la carga de trabajo actual y dentro de los límites establecidos por el SO a través de los registros de rendimiento mínimo y máximo.
   ```sh
   echo guided | sudo tee /sys/devices/system/cpu/amd_pstate/status
   ```

- **Modo no autónomo**: la plataforma obtiene el nivel de rendimiento deseado directamente del SO a través del Registro de Rendimiento Deseado.
   ```sh
   echo passive | sudo tee /sys/devices/system/cpu/amd_pstate/status
   ```

Para más información:

<LinkButton icon="external" href="https://www.kernel.org/doc/html/latest/admin-guide/pm/amd-pstate.html">Documentación de AMD P-State</LinkButton>
<LinkButton icon="external" href="https://www.kernel.org/doc/html/latest/admin-guide/pm/amd-pstate.html#amd-pstate-driver-operation-modes">Modos de Operación del Controlador AMD P-State</LinkButton>
<LinkButton icon="external" href="https://www.kernel.org/doc/html/latest/admin-guide/pm/amd-pstate.html#user-space-interface-in-sysfs-per-policy-control">Interfaz de Espacio de Usuario de AMD P-State</LinkButton>

### Configurando AMD P-State EPP

Para usar el P-State EPP, hay dos gobernadores de escalado de frecuencia de CPU disponibles: `powersave` y `performance`. Se recomienda usar el gobernador powersave y establecer una preferencia.

*   Establecer el gobernador powersave: `sudo cpupower frequency-set -g powersave`
*   Establecer el gobernador performance: `sudo cpupower frequency-set -g performance`

Para establecer una preferencia, ejecuta el siguiente comando con la preferencia deseada:

```sh
echo power | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/energy_performance_preference
```

Preferencias disponibles: `performance`, `power`, `balance_power`, `balance_performance`

<LinkButton icon="external" href="https://lore.kernel.org/lkml/20221219064042.661122-1-perry.yuan@amd.com/">Benchmark Oficial para cada preferencia</LinkButton>

### Optimizador AMD 3D V-Cache

AMD publicó un parche para optimizar la Programación de Caché en CPUs 3D de doble CCD, como 7950X3D y 7900X3D.
Necesitas configurar en la BIOS bajo la Opción CPPC a la Opción "Driver". Esto permitirá sobrescribir con sysfs el modo utilizado.

Hay dos modos:

1. Frecuencia
2. Caché

Si se establece `cache`, el controlador intentará poner las tareas primero en el CCD con la caché más grande, esto es principalmente beneficioso en juegos.
La opción `frequency` intentará poner las tareas en el segundo CCD, que tiene una frecuencia más alta que el CCD de caché 3D.

Frecuencia (Predeterminado):
```sh
echo frequency | sudo tee /sys/bus/platform/drivers/amd_x3d_vcache/AMDI0101:00/amd_x3d_mode
```

Caché:
```sh
echo cache | sudo tee /sys/bus/platform/drivers/amd_x3d_vcache/AMDI0101:00/amd_x3d_mode
```

Después de cambiar los modos, las estadísticas de núcleos preferidos de amd deberían proporcionar un ranking diferente. Puedes leerlo con:
```sh
grep -v /sys/devices/system/cpu/cpu*/cpufreq/amd_pstate_prefcore_ranking
```

### Impulso de Rendimiento de Núcleo AMD P-State

AMD Core Performance Boost aka AMD Turbo Core es una tecnología de escalado dinámico de frecuencia de AMD que permite al
procesor ajustar y controlar dinámicamente la frecuencia de operación del procesador en ciertas versiones de sus procesadores,
lo que permite un mayor rendimiento cuando es necesario mientras mantiene parámetros de energía y térmicos más bajos durante la operación normal.

Para gestionar AMD CPB en CachyOS, puedes usar los siguientes comandos:

```sh
❯ echo 0 | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/boost # Desactiva boost para todos los núcleos
❯ lscpu -ae # Esto muestra que AMD CPB está desactivado globalmente
CPU NODE SOCKET CORE L1d:L1i:L2:L3 ONLINE    MAXMHZ   MINMHZ       MHZ
  0    0      0    0 0:0:0:0          yes 3301.0000 400.0000 1212.8250
  1    0      0    0 0:0:0:0          yes 3301.0000 400.0000 1394.2180
  2    0      0    1 1:1:1:0          yes 3301.0000 400.0000 1204.4600

❯ echo 1 | sudo tee /sys/devices/system/cpu/cpu0/cpufreq/boost # Habilita boost en cpu0
❯ lscpu -ae
CPU NODE SOCKET CORE L1d:L1i:L2:L3 ONLINE    MAXMHZ   MINMHZ       MHZ
  0    0      0    0 0:0:0:0          yes 4564.0000 400.0000 1393.2380
  1    0      0    0 0:0:0:0          yes 3301.0000 400.0000  400.0000
  2    0      0    1 1:1:1:0          yes 3301.0000 400.0000 2157.8469
```

CachyOS también proporciona una versión de `power-profiles-daemon` que hace backport de un commit que habilita
el soporte para AMD CPB. AMD CPB se desactivará si se está usando el perfil `powersave`, y se habilitará en `balanced` o `performance`.

Para más información ver:
- https://lore.kernel.org/linux-pm/1a78eeaa-fadd-4734-aaeb-2fe11e96e198@amd.com/T/#m4a0c8917ea8fb033504055bd61512c80c85410c8
- https://lore.kernel.org/linux-pm/20240624213400.67773-1-mario.limonciello@amd.com/

## Mejoras de Rendimiento

### [Programador I/O ADIOS](https://github.com/firelzrd/adios)

Creado por [firelzrd](https://github.com/firelzrd)

:::note
CachyOS incluye la rama estable de ADIOS en el kernel.

Versión actual en **linux-cachyos**: `3.2.0`

Versión actual en **linux-cachyos-rc**: `3.2.0`
:::

Breve introducción del README:

- *ADIOS (Adaptive Deadline I/O Scheduler) es un programador de E/S de capa de bloques para el kernel de Linux, diseñado para dispositivos de bloques multi-cola modernos (blk-mq). Su objetivo es proporcionar baja latencia para operaciones de E/S combinando principios de programación de plazos con un mecanismo de control de latencia adaptativo basado en aprendizaje.*
  - *Inspirado en y construido sobre conceptos de los programadores de E/S mq-deadline y Kyber. Su característica principal es la capacidad de predecir la latencia de finalización de E/S basada en el rendimiento pasado y las características de la solicitud (tipo de operación, tamaño) y usar esta predicción para ajustar dinámicamente los plazos de las solicitudes y el comportamiento de agrupación.*

TLDR: ADIOS funciona aprendiendo el perfil de latencia de tu dispositivo de almacenamiento y usando ese conocimiento para establecer dinámicamente plazos para solicitudes de E/S. Prioriza las solicitudes en cuatro niveles, desde operaciones críticas del sistema (Nivel 0) hasta tareas en segundo plano (Nivel 3), para asegurar una experiencia de usuario fluida. Aunque se centra en la capacidad de respuesta, su comportamiento puede afinarse a través de configuraciones sysfs para equilibrar latencia y rendimiento.

Para una demostración en vivo, puedes ver este [vídeo](https://www.youtube.com/watch?v=L9WDcEeHgy4)

#### Cómo habilitar ADIOS

<Tabs>
    <TabItem label='Temporalmente (entra en efecto en tiempo de ejecución)'>
        Este método establece el programador para la sesión actual. El cambio se perderá al reiniciar.
        ```sh
        sync && echo adios | sudo tee /sys/block/<tudir>/queue/scheduler
            # Reemplaza <tudir> con el identificador real del dispositivo (p. ej. sda, sdb, nvme0n1)
        ```
    </TabItem>
    <TabItem label='Persistente después del reinicio'>
        <Steps>
            1. Abre o crea un nuevo archivo de reglas udev en tu editor de texto preferido (p. ej., nano, micro, vim)
                ```sh title='Ejemplo'
                sudo nano /etc/udev/rules.d/60-ioschedulers.rules
                ```
            2. Añade las siguientes reglas al archivo. Estas reglas aplican automáticamente un programador de E/S específico basado en el tipo de dispositivo (HDD, SSD o NVMe).
                ```text
                # HDD
                ACTION=="add|change", KERNEL=="sd[a-z]*", ATTR{queue/rotational}=="1", \
                    ATTR{queue/scheduler}="bfq"

                # SSD
                ACTION=="add|change", KERNEL=="sd[a-z]*|mmcblk[0-9]*", ATTR{queue/rotational}=="0", \
                    ATTR{queue/scheduler}="adios"

                # NVMe SSD
                ACTION=="add|change", KERNEL=="nvme[0-9]*", ATTR{queue/rotational}=="0", \
                    ATTR{queue/scheduler}="adios"
                ```
              3. Guarda el archivo y cierra el editor.
              4. Recarga las reglas de `udev` para aplicar los cambios inmediatamente sin reiniciar.
                  ```sh
                  sudo udevadm control --reload-rules
                  sudo udevadm trigger
                  ```
        </Steps>
    </TabItem>
</Tabs>

FAQ:

- Si mejora la capacidad de respuesta, ¿por qué no está habilitado por defecto?
  - ADIOS está aún bajo desarrollo activo y pruebas continuas. Aunque ofrece beneficios significativos para la capacidad de respuesta del escritorio, aún no se considera lo suficientemente estable para ser el predeterminado para todas las cargas de trabajo y tipos de hardware. En algunos casos extremos, errores podrían llevar a problemas como bloqueos del sistema. Por esta razón, es una función opcional para usuarios que deseen probar y beneficiarse de sus últimas mejoras.

### NVIDIA Smooth Motion (Series RTX 40xx & 50xx)

:::note[Compatibilidad de Juegos.]
Juegos que se ejecutan en DX11, DX12 y Vulkan. Ver FAQ para una solución alternativa para OpenGL.

Tanto DXVK como VKD3D funcionan bien.

**Solo se admiten aplicaciones de 64 bits. Smooth Motion no funcionará con aplicaciones de 32 bits (p. ej., juegos antiguos de DX11).**

:::

Cita directa de la documentación de NVIDIA:

*NVIDIA Smooth Motion es un nuevo modelo basado en IA del controlador que ofrece una jugabilidad más fluida al inferir un fotograma adicional entre dos fotogramas renderizados. Para juegos sin Generación de Fotogramas DLSS, NVIDIA Smooth Motion es una nueva opción para mejorar tu experiencia en GeForce RTX 40 Series y GPUs más nuevas.*

- Cómo habilitar NVIDIA Smooth Motion para un juego:
  - Añade la siguiente variable de entorno:
    ```text
    NVPRESENT_ENABLE_SMOOTH_MOTION=1
    ```

FAQ:

- ¿Por qué usar Smooth Motion en lugar de Generación de Fotogramas DLSS?
  - Cuando un juego no tiene soporte para Generación de Fotogramas DLSS, Smooth Motion sirve como alternativa gracias a su modelo basado en IA del controlador.
- ¿Hay alguna desventaja en usar Smooth Motion?
  - Sí, habilitar Smooth Motion puede introducir un ligero retraso de entrada debido al proceso adicional de inferencia de fotogramas.
  - Propenso a causar problemas con superposiciones de terceros. Para evitar esto, incluye la siguiente variable de entorno:
    ```text
    NVPRESENT_QUEUE_FAMILY=1
    ```
    :::note[Puede observarse un impacto en el rendimiento al usar esta variable.]
    :::
- ¿Por qué MangoHud no reporta el aumento de framerate?
  - Actualmente, MangoHud no tiene en cuenta los fotogramas adicionales generados por Smooth Motion, lo que lleva a un framerate reportado engañoso.
    - Usar el contador de FPS integrado del monitor proporcionará el framerate correcto.
- ¿Cómo es la calidad de imagen comparada con Generación de Fotogramas DLSS?
  - La calidad de imagen no es tan buena y puede introducir artefactos, especialmente durante escenas de movimiento rápido.
- ¿Es compatible con herramientas externas de limitación de fotogramas? Ejemplo: MangoHud.
  - No. El límite en el juego debería funcionar bien.
- ¿Se puede combinar Smooth Motion con Generación de Fotogramas DLSS?
  - No. Solo un método de generación de fotogramas puede estar activo a la vez.
- ¿Se puede usar Smooth Motion con aplicaciones OpenGL?
  - No directamente, ya que está implementado como una capa Vulkan, pero es posible aprovechando [Zink](https://docs.mesa3d.org/drivers/zink.html) para traducir llamadas OpenGL a Vulkan:
    ```text
    NVPRESENT_ENABLE_SMOOTH_MOTION=1 zink-run <comando>
    ```
    :::note
    Usar Zink probablemente tendrá un impacto en el rendimiento y puede introducir errores gráficos en algunos juegos.

    Los usuarios de doble GPU necesitan establecer `DRI_PRIME=1` para utilizar la dGPU de Nvidia en lugar de usar métodos más típicos de selección de GPU.
    :::

## Ajustes de Ahorro de Energía

### thermald

`thermald` es un demonio de gestión térmica para sistemas Intel. Monitorea sensores térmicos y aplica acciones de enfriamiento, como límites de energía de CPU o cambios de estado de rendimiento, antes de que el firmware necesite usar estrangulamiento más agresivo.

Es principalmente útil en portátiles, convertibles, tablets, dispositivos handheld y PCs de formato pequeño de Intel que exponen controles térmicos de Intel a través de `/sys/class/thermal`. Los sistemas admitidos comúnmente usan sensores de temperatura de CPU Intel, Intel P-state, Intel power clamp, RAPL, `INT340X` o tablas térmicas ACPI DPTF/adaptive. Las CPUs AMD no son admitidas por `thermald`.

Instala y habilita con:

```sh
sudo pacman -S thermald
sudo systemctl enable --now thermald.service
```

Verifica que se inició correctamente:

```sh
systemctl status thermald.service
journalctl -u thermald.service -b
```

Para más información:

<LinkButton icon="external" href="https://github.com/intel/thermal_daemon">Repositorio upstream de thermald</LinkButton>
<LinkButton icon="external" href="https://man.archlinux.org/man/thermald.8">Página manual de thermald</LinkButton>

### Habilitar RCU Lazy

RCU Lazy ayuda a reducir el consumo de energía en reposo o en sistemas con carga ligera. Esto puede ser útil para portátiles y dispositivos handheld.
La mejora está entre 5-10% en términos de ahorro de energía. Sin embargo, es importante tener en cuenta que esta función de ahorro de energía puede venir a costa de un rendimiento ligeramente reducido dependiendo del escenario.
El kernel linux-cachyos-deckify tendrá esta opción habilitada por defecto, ya que el ahorro de energía es clave y necesario para estos dispositivos.

Para habilitar RCU Lazy, añade el siguiente parámetro a tu lista de parámetros [cmdline](/es/configuration/boot_manager_configuration/) del kernel:
```text
rcutree.enable_rcu_lazy=1
```

## Solución de Problemas de NVIDIA

### Firmware GSP de NVIDIA

El Firmware GSP de NVIDIA puede **"en algunos casos"** llevar a un rendimiento disminuido. Aunque el controlador NVIDIA 555.58.02 ha abordado en gran medida este problema, puede persistir en ciertos sistemas.
Si estás experimentando microcortes en KDE o mal rendimiento en algunos casos, puedes deshabilitar el Firmware GSP con el siguiente archivo de configuración:
`/etc/modprobe.d/nvidia-gsp.conf`

```text
options nvidia NVreg_EnableGpuFirmware=0
```

Después de crear el archivo, ejecuta el siguiente comando:
```sh
sudo mkinitcpio -P
```

:::note
Los [módulos de kernel abiertos](https://github.com/NVIDIA/open-gpu-kernel-modules) de NVIDIA están basados en el firmware GSP. Debido a esto, GSP no puede ser deshabilitado y esta opción de modprobe será ignorada al usarlos. Usa `linux-cachyos-nvidia` o `nvidia-dkms`.
:::

Generalmente se recomienda probar el firmware GSP después de cada nueva instalación del controlador NVIDIA, ya que a menudo introduce beneficiosas características. Además, NVIDIA comenzó principalmente a realizar pruebas de QA usando el firmware GSP.

## Mejoras de Audio y Software

### Mejorando el Sonido de los Altavoces del Portátil

Los altavoces de los portátiles a menudo producen un sonido delgado e insatisfactorio debido a su tamaño compacto y capacidades de hardware limitadas. [EasyEffects](https://wiki.archlinux.org/title/PipeWire#EasyEffects) puede mejorar significativamente la calidad de sonido de los altavoces integrados de tu portátil aplicando varios efectos de audio y configuraciones personalizadas.

Para comenzar necesitas instalar EasyEffects y las dependencias requeridas:

```bash
# Instalar EasyEffects
sudo pacman -S easyeffects
# Instalar plugins adicionales para más efectos
sudo pacman -S lsp-plugins-lv2
sudo pacman -S zam-plugins
sudo pacman -S calf
sudo pacman -S mda.lv2
```

#### Configuración

Sigue estos pasos para configurar EasyEffects:

1. Inicia EasyEffects desde tu menú de aplicaciones o escribiendo `easyeffects` en la terminal.
2. Navega a la pestaña **Output** para gestionar efectos aplicados a tu audio de altavoces.
3. Cambia a la pestaña **Effects** para añadir, modificar o ajustar efectos de audio.

<ImageComponent imgsrc={import('~/assets/images/easyeffects.png')} />

##### Usando Presets de la Comunidad

Para una configuración rápida y efectiva, comienza con **presets creados por la comunidad** adaptados para varios escenarios de audio:

1. Descarga presets del repositorio [EasyEffects Community Presets](https://github.com/wwmm/easyeffects/wiki/Community-presets).
2. En EasyEffects, haz clic en el botón **Presets** y elige **"Import preset from local storage"**.
3. Localiza y selecciona el archivo de preset descargado.
4. Una vez importado, el preset aparecerá en tu lista—haz clic en **"Load"** para aplicarlo a tu salida de audio.

<ImageComponent imgsrc={import('~/assets/images/easyeffects-presets.png')} />

##### Creando un Perfil Personalizado

Para una experiencia de audio más personalizada, crea un perfil personalizado adaptado a los altavoces de tu portátil:

1. Haz clic en el botón **"+"** en el menú Presets para crear un nuevo preset (p. ej., llámalo **"Laptop Speakers"**).
2. Selecciona **"Load"** para activar el nuevo preset.
3. Añade y configura efectos en la pestaña **Output** > **Effects**, experimentando con opciones como ecualizadores, potenciadores de graves o ampliadores de estéreo.

##### Usando el Efecto Convolver (Portátiles Dolby Atmos)

El **efecto Convolver** puede mejorar drásticamente el sonido aplicando respuestas impulsionales que simulan entornos de audio de alta calidad. Sin embargo, requiere una configuración precisa:

1. Añade el efecto **Convolver** a tu cadena de efectos en la pestaña **Effects**.
2. Carga un archivo de respuesta impulsional (en formato `.wav`) específico para tu modelo de portátil, si está disponible. Puedes buscar estos archivos en línea en recursos como:
   - https://wiki.archlinux.org/title/Lenovo_ThinkPad_T14_(AMD)_Gen_4#Speakers
   - https://github.com/m4tx/thinkpad-p14s-g4-linux/#sound
   - https://github.com/shuhaowu/linux-thinkpad-speaker-improvements/
3. **Prevenir el recorte**: El efecto Convolver puede aumentar significativamente el volumen. Añade un efecto **Limiter** después del Convolver en tu cadena de efectos para controlar los picos y evitar distorsión.

<ImageComponent imgsrc={import('~/assets/images/easyeffects-convolver.png')} />

#### Consejos para Resultados Óptimos

- **Experimenta** con diferentes presets para identificar la mejor coincidencia para tu modelo específico de portátil y preferencias personales de sonido.
- **Haz ajustes incrementales** a efectos individuales para prevenir distorsión o salida de sonido antinatural.
- **Compara con alternancia**: Alterna frecuentemente EasyEffects **on/off** para evaluar las mejoras frente al audio predeterminado.
- Busca **presets específicos del dispositivo o respuestas impulsionales de Convolver** para modelos populares de portátiles como **Framework Laptop 13** o **ThinkPad T14** para lograr resultados personalizados.
- **Automatiza el inicio**: Configura EasyEffects para iniciarse automáticamente en el arranque a través de las preferencias de la app para asegurar que tu perfil personalizado esté siempre aplicado.
- **Carga automática de presets para múltiples dispositivos**: Usa la pestaña **PipeWire** > **Presets Autoloading** para asociar presets específicos con diferentes dispositivos de salida (p. ej., Altavoces vs. Auriculares) para un cambio sin problemas. <ImageComponent imgsrc={import('~/assets/images/easyeffects-autoloading.png')} />

#### Alternativa a EasyEffects

Como alternativa puedes probar usando [JDSP4Linux](https://github.com/Audio4Linux/JDSP4Linux), que es un procesador de efectos de audio para clientes PipeWire y PulseAudio.

### OBS Studio

Proporcionamos un paquete personalizado obs-studio-browser en nuestro repositorio que es recomendado sobre el paquete estándar `obs-studio`. Contiene parches para corregir algunos de los problemas comunes como errores cuda y problemas de cámara virtual.

```sh title='Abre una terminal y ejecuta el siguiente comando'
sudo pacman -S obs-studio-browser
# Si previamente tenías el obs-studio instalado entonces pacman te preguntará si
# quieres reemplazarlo, si es así ingresa "Y".
```

## Configuración de Swap

### Cambiar de ZRam a Zswap

Por defecto, CachyOS usa ZRam para la gestión de swap. Sin embargo, si prefieres usar Zswap en su lugar, puedes cambiar fácilmente siguiendo estos pasos:

:::note
Esta guía asume que tienes la configuración predeterminada de CachyOS con ZRam habilitado y no se creó una partición o archivo de swap durante la instalación.
:::

<Steps>
    1. Deshabilita ZRam añadiendo un parámetro del kernel. [Edita tu configuración del gestor de arranque](/es/configuration/boot_manager_configuration) y añade la siguiente línea:
        ```text
        systemd.zram=0
        ```
    2. Habilita Zswap añadiendo el siguiente parámetro del kernel:
        ```text
        zswap.enabled=1 zswap.shrinker_enabled=1 zswap.compressor=lz4 zswap.max_pool_percent=30
        ```
    3. Crea un archivo de override vacío para deshabilitar [la regla udev de CachyOS](https://github.com/CachyOS/CachyOS-Settings/blob/master/usr/lib/udev/rules.d/30-zram.rules) que deshabilita Zswap:
        ```bash
        sudo touch /etc/udev/rules.d/30-zram.rules
        ```
    4. Crea un archivo de swap para Zswap.
        <details>
            <summary>Si estás usando Btrfs:</summary>
                <Steps>
                    1. Crea un subvolumen Btrfs para el archivo de swap:
                        ```bash
                        sudo btrfs subvolume create /swap
                        ```
                    2. Crea un archivo de swap con tu tamaño deseado (p. ej., 8GB) cambiando el parámetro `--size`:
                        ```bash "--size"
                        sudo btrfs filesystem mkswapfile --size 4g --uuid clear /swap/swapfile
                        ```
                    3. Activa el archivo de swap:
                        ```bash
                        sudo swapon /swap/swapfile
                        ```
                    4. Añade el archivo de swap a `/etc/fstab` para hacerlo persistente entre reinicios:
                        ```bash
                        echo "/swap/swapfile none swap defaults 0 0" | sudo tee -a /etc/fstab
                        ```
                </Steps>
        </details>
        <details>
            <summary>Si no estás usando Btrfs:</summary>
            <Steps>
                1. Crea un archivo de swap con tu tamaño deseado (p. ej., 8GB) cambiando el parámetro `count=`:
                    ```bash "count=8"
                    sudo dd if=/dev/zero of=/swapfile bs=1G count=8
                    ```
                2. Establece los permisos correctos para el archivo de swap:
                    ```bash
                    sudo chmod 0600 /swapfile
                    ```
                3. Formatea el archivo de swap:
                    ```bash
                    sudo mkswap /swapfile
                    ```
                4. Añade el archivo de swap a `/etc/fstab` para hacerlo persistente entre reinicios:
                    ```bash
                    echo "/swapfile none swap defaults 0 0" | sudo tee -a /etc/fstab
                    ```
                5. Activa el archivo de swap:
                    ```
                    sudo swapon /swapfile
                    ```
            </Steps>
        </details>
    5. Añade el módulo de compresión lz4 al archivo de configuración `mkinitcpio.conf`:
        1. Abre el archivo con un editor de texto:
            ```bash
            sudo nano /etc/mkinitcpio.conf
            ```
        2. Busca el array `MODULES` y añade `lz4` a él. Debería verse algo como esto:
            ```text
            MODULES=(... lz4)
            ```
        3. Guarda el archivo presionando `Ctrl + O` y `Enter` para confirmar, luego sal del editor con `Ctrl + X`.
    6. Reconstruye tu initramfs para aplicar los cambios. El comando varía dependiendo de tu gestor de arranque:
        <details>
            <summary>systemd-boot</summary>
            ```bash
            sudo sdboot-manage gen
            ```
        </details>
        <details>
            <summary>GRUB</summary>
            ```bash
            sudo grub-mkconfig -o /boot/grub/grub.cfg
            ```
        </details>
        <details>
            <summary>Limine</summary>
            ```bash
            sudo limine-mkinitcpio
            ```
        </details>
    7. Reinicia tu sistema para aplicar todos los cambios.
</Steps>
