Cómo ver el uso de memoria RAM en Linux (y por qué no se la «come»)

free: el resumen en un segundo

free está instalado en prácticamente todas las distribuciones (forma parte del paquete procps o procps-ng). Si usas -h, te muestra las cifras en unidades legibles:

free -h

               total        used        free      shared  buff/cache   available
Mem:            61Gi        19Gi        22Gi       1,7Gi        22Gi        42Gi
Swap:           93Gi       4,0Gi        89Gi

El uso de Gi no es un error: se trata de gibibytes (potencias de 1024). Por este motivo, un equipo de 64 GB aparece como 61Gi. Si prefieres utilizar potencias de 1000, añade --si.

available contra free: la que te tiene que importar

Fíjate en el ejemplo: hay 22Gi «libres» y 42Gi «disponibles». La diferencia es casi toda la caché.

Cada vez que lees un archivo, Linux guarda una copia en la RAM (la caché de páginas). Si vuelves a abrirlo, se carga desde la memoria en lugar de hacerlo desde el disco y el proceso es muchísimo más rápido. Esta caché no tiene un dueño asignado: cuando un programa necesita memoria, el núcleo la utiliza y la reparte sin que tengas que hacer nada.

Así que:

• free es RAM que no está haciendo absolutamente nada. Que sea baja no es malo; es lo esperable al cabo de un rato de uso.
• available es lo que tienes de verdad para abrir más programas sin tirar de swap. Esa es la cifra que hay que vigilar.

La columna available no es la simple suma de free y buff/cache. Existen partes de la caché que no se pueden liberar, como la memoria compartida y los archivos guardados en tmpfs (la columna shared), por lo que el núcleo realiza una estimación más prudente. Además, en las versiones actuales de free, used se calcula como total − available, así que tampoco esperes que las columnas sumen a la perfección.

Opciones de free que sí vas a usar

• free -h -w: separa buffers y cache en dos columnas en lugar de juntarlas.
• free -h -t: añade una fila Total con RAM y swap sumadas.
• free -h -s 2: repite la salida cada 2 segundos (con -c 5, para después de 5 veces). Si te gusta más, watch -n 2 free -h hace lo mismo y refresca la pantalla.
• free -h -L: todo en una sola línea, cómodo para scripts o barras de estado.
• free -h -v: añade la fila Comm, con la memoria que los programas han reservado frente al límite que admite el sistema. Reservar no es usar, así que suele salir un número alto que asusta más de lo que debería.
• free -m o free -g: fuerza mebibytes o gibibytes. Para un script, free -b da bytes exactos.

Por ejemplo, si quieres obtener solo la memoria disponible en megas para usarla en un script:

free -m | awk '/^Mem:/ {print $7}'

/proc/meminfo: los datos en bruto

free, top y casi todos los monitores obtienen sus cifras del mismo sitio: el archivo /proc/meminfo. Este no se encuentra en el disco, sino que el núcleo lo genera cada vez que se lee, tal y como ocurre con todo lo que hay en /proc (lo contamos en «Todo es un archivo» en Linux).

head -5 /proc/meminfo

MemTotal:       64947572 kB
MemFree:        23165852 kB
MemAvailable:   44757152 kB
Buffers:              88 kB
Cached:         18778312 kB

Consta de más de cincuenta líneas, aunque para el día a día te bastan unas pocas:

• MemTotal, MemFree y MemAvailable: lo mismo que total, free y available de free, en kilobytes.
• Cached: la caché de páginas.
• Shmem: memoria compartida y tmpfs. Esto no se libera vaciando la caché.
• SReclaimable: caché interna del núcleo (por ejemplo, nombres de archivos y carpetas) que también se puede recuperar.
• SwapTotal y SwapFree: el tamaño de la swap y lo que queda.
• AnonPages: la memoria «de verdad» de los programas, la que no viene de ningún archivo. Si un programa tiene una fuga de memoria, aquí se nota.

Para extraer únicamente la información que te interesa, grep es tu mejor aliado:

grep -E '^(MemTotal|MemAvailable|Shmem|SwapFree):' /proc/meminfo

Si quieres conocer el significado exacto de cada línea, puedes consultarlo en la documentación del núcleo, concretamente en el apartado de /proc/meminforef.

top, htop y btop en directo

free te indica cuánto queda; para ver quién está gastando, necesitas un monitor en tiempo real.

top: el que siempre está

top viene incluido en cualquier Linux, incluso en un servidor pelado. En la parte superior muestra dos líneas de memoria:

MiB Mem :  63425,4 total,  22703,5 free,  19636,2 used,  23492,5 buff/cache
MiB Swap:  96193,0 total,  92056,8 free,   4136,2 used.  43789,1 avail Mem

Son las mismas cifras de free, en mebibytes. El avail Mem al final de la segunda línea es la columna available, aunque aparezca en la línea de la swap.

Debajo aparece la lista de procesos. Por defecto, el orden es según la CPU; pulsa M (mayúscula) para ordenar por memoria, o arranca directamente así:

top -o %MEM

Las columnas relevantes son RES (la RAM física que ocupa el proceso) y %MEM (ese mismo dato expresado como porcentaje del total). VIRT es la memoria virtual reservada, que casi siempre es enorme y no significa gran cosa. Para salir, pulsa q.

htop: lo mismo, pero cómodo

htop es la versión más intuitiva de top: incluye colores, barras, soporte para ratón y visualización de procesos en árbol. Si no lo tienes instalado:

sudo apt install htop      # Debian, Ubuntu, Mint
sudo dnf install htop      # Fedora
sudo pacman -S htop        # Arch, CachyOS, Manjaro

En la barra Mem superior, la parte verde representa la memoria utilizada por los programas; los demás colores (azul, amarillo…) corresponden a búferes y caché, que son recuperables. Para ordenar por memoria, pulsa M o haz clic en la cabecera MEM%. Con F5 puedes ver los procesos en árbol, algo muy útil en el caso de los navegadores que abren decenas de procesos hijos.

btop: el más vistoso

btop muestra la CPU, la memoria, los discos, la red y los procesos mediante paneles con gráficas. Se encuentra en los repositorios de casi todas las distribuciones bajo el nombre btop. El panel de memoria desglosa la usada, la disponible, la caché y la libre, y dibuja una gráfica para cada una, por lo que se ve de un vistazo si la memoria sube sin parar. En la lista de procesos, puedes cambiar el orden usando las flechas izquierda y derecha o pinchando en la columna.

vmstat: la memoria en movimiento

Mientras que free es una foto, vmstat es un vídeo. Le indicas un intervalo en segundos y el comando muestra una línea cada vez:

vmstat 1 5

procs -----------memory---------- ---swap-- -----io---- -system-- -------cpu-------
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st gu
 0  0 4235512 23165852  88 24055856 67  174  1942  2204 11430   6  3  1 96  0  0  0
 0  0 4235508 23191712  88 24055912  4    0     4   172 4938 4656  1  0 98  0  0  0
 0  0 4235508 23198724  88 24055904  0    0     0   360 3665 4077  1  0 99  0  0  0

El 1 indica el intervalo en segundos y el 5, el número de veces que se ejecuta. Si quitas el 5, el comando seguirá funcionando hasta que pulses Ctrl+C.

Las cifras van en kilobytes. Lo que te interesa:

• swpd: cuánta swap está ocupada.
• free, buff y cache: como en free.
• si y so: lo que entra desde la swap (swap in) y lo que sale hacia ella (swap out) cada segundo. Esta es la columna que de verdad delata un problema.

No es grave que haya algo de swap ocupada (swpd): puede tratarse de memoria que nadie ha tocado en horas. Lo malo es ver valores altos en si y so línea tras línea: eso significa que el sistema está moviendo memoria al disco y trayéndola de vuelta sin parar. Es lo que se conoce como thrashing, y se nota porque el equipo va a tirones aunque la CPU esté tranquila.

Otras dos opciones útiles:

• vmstat -S M 1: las cifras en megabytes en lugar de kilobytes.
• vmstat -s: un resumen largo, una métrica por línea.

Cuánta RAM gasta cada programa

ps: la lista ordenada

Para ver de un tirón los procesos que más memoria ocupan:

ps aux --sort=-%mem | head

O, si quieres solo las columnas que importan:

ps -eo pid,comm,rss --sort=-rss | head

El signo menos de --sort=-rss ordena de mayor a menor. La columna RSS se muestra en kilobytes; divide entre 1024 para obtener megas. head deja solo las diez primeras líneas.

RSS, PSS y USS, sin complicarse

Aquí está la trampa: los programas comparten memoria. Si tienes abiertos diez procesos que usan la misma biblioteca, esta se encuentra una sola vez en la RAM, pero cada proceso la cuenta como suya. Por eso existen tres formas de medirla:

Un ejemplo real con una shell abierta: su RSS es de unos 5 MB, pero su PSS se queda en menos de 2 MB, porque gran parte de lo que «ocupa» lo comparte con otras shells y programas.

Para el día a día:

• ¿Qué pasaría si cierro este programa? Mira la USS: es lo que recuperas.
• ¿Cuánto pesa de verdad un navegador con veinte procesos? Suma su PSS. Sumar la RSS lo infla.
• ¿Cuál está más gordo a primera vista? Con la RSS de top o ps basta.

smem: RSS, PSS y USS en una tabla

smem muestra las tres columnas para cada proceso. En Debian, Ubuntu y Fedora se encuentra en los repositorios (sudo apt install smem o sudo dnf install smem), mientras que en Arch y sus derivadas está en el AUR. Algunos usos:

smem -k -s pss -r | head     # procesos ordenados por PSS, de mayor a menor
smem -k -t                   # con una fila de totales al final
smem -k -u                   # agrupado por usuario
smem -k -w                   # resumen del sistema: núcleo, programas y caché

-k muestra las unidades en formato legible (K, M, G). Ten en cuenta que, sin sudo, solo ve tus propios procesos, que suele ser justo lo que quieres.

Sin instalar nada: smaps_rollup

Si no quieres instalar smem, el núcleo proporciona la PSS de cada proceso en /proc/<PID>/smaps_rollup. Obtén el número del proceso con pgrep y léelo:

pgrep -x firefox | head -1                       # te da el PID, por ejemplo 4321
grep -E '^(Rss|Pss|Private)' /proc/4321/smaps_rollup

Rss y Pss son lo que parecen. La USS es la suma de Private_Clean y Private_Dirty.

Memoria por servicio con systemd

Los procesos individuales no siempre cuentan la historia completa. Un servicio como una base de datos, Docker o el servidor de sonido puede lanzar varios procesos, y lo que interesa saber es cuánto gasta el conjunto. systemd coloca cada servicio en su propio grupo de control (cgroup) y lleva la cuenta por ti.

systemd-cgtop: un top por grupos

systemd-cgtop -m

Su funcionamiento es similar al de top, pero cada línea representa un grupo: system.slice agrupa los servicios del sistema y user.slice tus sesiones, donde cada aplicación de escritorio tiene su propio grupo. La opción -m sirve para ordenar por memoria. Si quieres realizar una sola pasada sin usar la pantalla interactiva:

systemd-cgtop -m -1 --depth=1

user.slice                       3259      -    25.1G        -        -
/                                3912      -    19.2G        -        -
system.slice                      244      -     4.9G        -        -
init.scope                          1      -    24.3M        -        -

--depth=1 se mantiene en el primer nivel; súbelo a 2 o 3 para ver cada servicio. La memoria de un grupo incluye la caché de los archivos que ha leído, así que puede salir más alta que la suma de sus procesos.

systemctl status: un servicio concreto

Si sospechas de un servicio en particular, systemctl status lo indica en la línea Memory:

systemctl status systemd-journald

     Memory: 21M (peak: 26.9M, swap: 860K, swap peak: 1.4M)

Aparte del consumo actual, muestra el pico alcanzado desde el arranque y la cantidad de memoria en swap. Si necesitas el dato exacto para usarlo en un script:

systemctl show systemd-journald -p MemoryCurrent -p MemoryPeak

Para los servicios de tu usuario (por ejemplo, PipeWire), añade --user: systemctl --user status pipewire.

Si un servicio tiene una fuga, verás que MemoryCurrent crece día tras día. La solución rápida es reiniciarlo con sudo systemctl restart <servicio>; la definitiva, actualizarlo o avisar a sus desarrolladores.

Swap y zram

La swap es el lugar donde Linux aloja la memoria que no se está utilizando cuando la RAM es insuficiente. Tradicionalmente, consiste en un archivo o una partición en el disco. Por su parte, la zram es una swap que reside en la propia RAM, aunque comprimida: en vez de escribir en el disco, comprime las páginas y las almacena en la memoria. Fedora y CachyOS, entre otras, la traen activada de serie.

Qué swap tienes

swapon --show

NAME           TYPE       SIZE USED PRIO
/swap/swapfile file        32G   0B   10
/dev/zram0     partition 61,9G   4G  100

En el ejemplo hay dos: un archivo de swap de 32 GB en el disco y una zram. La columna PRIO determina el orden: se utiliza primero la de prioridad más alta, que en este caso es la zram (100), y el archivo solo se emplea si la zram se llena. Si swapon --show no muestra nada, no tienes swap.

Cuánto está comprimiendo la zram

zramctl

NAME       ALGORITHM DISKSIZE DATA  COMPR   TOTAL STREAMS MOUNTPOINT
/dev/zram0 zstd         61,9G 3,7G 989,7M 1014,6M         [SWAP]

• DISKSIZE: el tamaño máximo que puede llegar a contener. No es RAM reservada: no gasta nada mientras está vacía.
• DATA: cuánto hay guardado, sin comprimir.
• COMPR y TOTAL: cuánto ocupa de verdad en la RAM, comprimido y con sus datos de gestión.

En el ejemplo, 3,7 GB de datos ocupan apenas 1 GB de RAM: casi una relación de 4 a 1 con zstd. Por eso la zram suele merecer la pena incluso en equipos con mucha memoria.

swappiness: las ganas de usar la swap

sysctl vm.swappiness

Es un valor entre 0 y 200 que indica la preferencia del núcleo al mandar memoria de los programas a la swap en lugar de liberar caché de archivosref. El valor predeterminado es 60. En el caso de zram, muchas distribuciones lo elevan por encima de 100 (en el equipo del ejemplo es 150), ya que la swap en RAM comprimida es rápida y resulta rentable usarla antes.

Qué módulos de RAM tienes puestos

Hasta aquí todo era sobre cómo se usa la memoria. Si lo que quieres es saber qué RAM tienes físicamente (cuántos módulos, de qué tipo, a qué velocidad y si quedan ranuras libres para ampliar), necesitas leer la información del firmware. Para ello hace falta sudo.

dmidecode

sudo dmidecode -t memory

Genera un bloque Memory Device por cada ranura, esté ocupada o no. Para quedarte con la información útil:

sudo dmidecode -t memory | grep -E 'Size|Type:|Speed|Locator|Part Number'

Fíjate en estos campos:

• Size: la capacidad del módulo. Si pone No Module Installed, esa ranura está libre.
• Locator: el nombre de la ranura (DIMM_A1, ChannelA-DIMM0…).
• Type: DDR4, DDR5, LPDDR5…
• Speed y Configured Memory Speed: la velocidad máxima del módulo y a la que funciona de verdad. Si la segunda es bastante más baja, quizá no tengas activado el perfil XMP o EXPO en la BIOS.
• Part Number: el modelo exacto, por si quieres comprar otro igual.

Al principio también aparece un bloque Physical Memory Array con Maximum Capacity (el máximo que admite la placa, aunque a veces el fabricante lo rellena mal) y Number Of Devices (las ranuras).

lshw

lshw ofrece un resumen más breve. Si no lo tienes instalado, el paquete se llama igual:

sudo lshw -short -C memory

Al usar -short aparece una línea por cada elemento: la caché del procesador, cada banco de memoria con su descripción y tamaño, y la memoria total del sistema.

Sin terminal: monitores gráficos

Si prefieres no abrir una terminal, los entornos de escritorio más completos incluyen su propio monitor, similar al Administrador de tareas de Windows.

• KDE Plasma: Monitor del sistema (plasma-systemmonitor). Lo abres desde el menú de aplicaciones. En la pestaña de procesos puedes ordenar por memoria y, con el botón derecho en las cabeceras, añadir columnas como la memoria compartida. Las páginas de resumen tienen gráficas de memoria y swap, y puedes crear las tuyas.
• GNOME: Monitor del sistema (gnome-system-monitor). La pestaña Recursos dibuja la memoria y la swap en el tiempo; en Procesos, pincha en la columna Memoria para ordenar.
• Recursos (Resources), una aplicación más moderna disponible en Flathub, enseña la memoria, la swap y el consumo por aplicación con una pinta muy cuidada. Funciona en cualquier escritorio.

Estas herramientas leen los mismos datos que free y top, así que vale todo lo dicho: la caché no es memoria «perdida» y lo que hay que mirar es lo disponible.

KDE y GNOME disponen de widgets o extensiones que añaden un indicador de RAM al panel para tenerlo siempre a la vista.

¿Cuándo debo preocuparme?

Tener la memoria «llena» no es lo mismo que tener memoria insuficiente. Estas son las señales que sí indican que te falta RAM o que algún proceso se está pasando de la raya.

1. available se queda muy baja

Si available cae de forma sostenida por debajo del 5-10 % del total mientras usas el equipo normalmente, te estás quedando corto. Un pico puntual al abrir un juego o compilar no cuenta; lo que importa es que se mantenga en ese valor.

2. La swap no para de moverse

vmstat 1

Valores altos y continuos en si y so (a partir de la segunda línea) indican que el sistema está moviendo memoria hacia y desde la swap constantemente. Esto se traduce en tirones, ventanas que tardan en reaccionar y un disco que no deja de trabajar.

3. La presión de memoria sube

El núcleo mide cuánto tiempo pasan los programas esperando debido a la falta de memoria:

cat /proc/pressure/memory

some avg10=0.00 avg60=0.00 avg300=0.00 total=12222380
full avg10=0.00 avg60=0.00 avg300=0.00 total=11883329

some indica el porcentaje de tiempo en el que al menos un programa estuvo bloqueado esperando memoria, mientras que full representa el tiempo en que lo estuvieron todos a la vez. Las tres medias corresponden a los últimos 10, 60 y 300 segundos. En un equipo sano, todos los valores se mantienen en cero o muy cerca de él; si full supera unos pocos puntos, el sistema está sufriendo.

4. Han matado programas: el OOM killer

Cuando la memoria se agota por completo, el núcleo elige un proceso y lo mata para salvar el resto del sistema. Se trata del OOM killer (Out Of Memory). Si un programa se te ha cerrado de repente y sin mostrar ningún error, búscalo de esta forma:

journalctl -k | grep -iE 'out of memory|oom-kill'

Si tienes suerte, no aparecerá nada. Si el núcleo ha matado algún proceso, verás líneas como Out of memory: Killed process 4321 (firefox) con el nombre del programa y la cantidad de memoria que ocupaba. Para revisar solo el arranque anterior, añade -b -1 a journalctl.

Aparte del núcleo, Fedora y Ubuntu utilizan systemd-oomd, que interviene previamente: cierra el grupo de procesos que más consume cuando la presión de memoria se dispara. Sus decisiones se guardan en su propio registro:

journalctl -u systemd-oomd

Si journalctl no muestra nada sin sudo, es que tu usuario no pertenece al grupo que puede leer el registro del sistema; en ese caso, repite el comando con sudo delante.

Y si se confirma, ¿qué hago?

• Busca al culpable con top, htop o smem. A menudo es un navegador con demasiadas pestañas o un programa con una fuga.
• Activa zram si no tienes ninguna swap: es la forma más barata de ganar margen.
• Si tu uso normal llena la RAM a diario, toca ampliar. Tienes una guía para elegir la cantidad en cuánta RAM se necesita en 2026.

Liberar memoria (y cuándo no)

drop_caches: casi nunca sirve

Por internet circula este comando para «liberar RAM»:

sync; echo 3 | sudo tee /proc/sys/vm/drop_caches

Le indica al núcleo que elimine la caché de archivos (el 1), la caché de nombres de carpetas y archivos (el 2) o ambas (el 3)ref. El sync previo escribe en el disco lo que esté pendiente. Se utiliza tee porque sudo echo 3 > ... no funciona: la redirección la ejecuta tu shell, que no tiene los permisos necesarios.

¿Funciona? Sí: free mostrará mucha más memoria libre. ¿Sirve? Casi nunca:

• No ganas memoria disponible. Esa caché ya contaba en available: el núcleo la habría soltado él solo en cuanto un programa la hubiese pedido.
• El equipo va más lento un rato. Todo lo que estaba en caché hay que volver a leerlo del disco.
• No dura. En unos minutos de uso, la caché vuelve a llenarse, como debe ser.

Solo tiene sentido en casos concretos, como cuando se quiere medir la velocidad de un disco sin que la caché falsee la prueba. Para el uso diario, ni lo toques, y mucho menos lo pongas en un cron.

/dev/shm y tmpfs: esto sí ocupa RAM de verdad

Existe un tipo de memoria que no se libera sola: la de los sistemas de archivos tmpfs, que almacenan archivos directamente en la RAM (o en swap). El contenido de estos sistemas cuenta en la columna shared de free y no desaparece hasta que se borran los archivos o se reinicia el equipo.

Para ver cuáles tienes y cuánto ocupan:

df -h -t tmpfs

Filesystem      Size  Used Avail Use% Mounted on
tmpfs            31G  1,7G   30G   6% /dev/shm
tmpfs            13G  7,8M   13G   1% /run

El Size es solo el límite: un tmpfs vacío no consume nada. Lo que ocupa RAM de verdad es Used. Los sitios típicos son:

• /dev/shm: memoria compartida entre programas. Navegadores, juegos y algunas aplicaciones la usan, y si se cierran mal pueden dejar archivos olvidados.
• /tmp: en Arch, Fedora y otras distribuciones es un tmpfs. Lo que descargas o descomprimes ahí está en tu RAM.
• /run/user/<tu UID>: archivos temporales de tu sesión.

Para ver qué hay en /dev/shm:

ls -lh /dev/shm
du -sh /dev/shm/* 2>/dev/null | sort -h

Lo que sí funciona

• Cerrar el programa que más gasta. Parece obvio, pero es lo único que libera memoria de verdad.
• Reiniciar el servicio con fuga (sudo systemctl restart <servicio>) si systemctl status muestra que crece sin parar.
• Vaciar la swap no hace falta. Se puede hacer con swapoff y swapon, pero si no te queda RAM suficiente para recibir lo que hay en ella, el sistema se atascará o el OOM killer empezará a matar programas. Lo que está en swap volverá a la RAM solo cuando se use.

Chuleta de comandos

Encontrarás todos los comandos de este artículo en una tabla. La última columna indica si es necesario añadir sudo delante.

Si solo te vas a quedar con uno, que sea free -h. Y si solo vas a mirar una columna, que sea available.

Preguntas frecuentes