ff-multiconverter, multimedia, audio, video, linux, ubuntu ubuntu kylin, china, releases, linux terminal, ubuntu, linux, comandos, shell conky, gadgets, ubuntu, linux SpeedTest-Cli, velocidad, red, consola, terminal tag foto 6 pinta, grafica, linux, ubuntu djl, juegos, yum, synaptic, paquetes ubuntu, releases, canonical psensor, ubuntu, linux, sistema, monitor
Mostrando las entradas con la etiqueta MATE. Mostrar todas las entradas

Guía de MATE entorno de escritorio clásico y ligero: Pluma editor de texto.

Pluma es el editor de texto oficial del entorno de escritorio MATE. Si bien busca la simplicidad y la facilidad de uso, Pluma es un potente editor de texto de propósito general. Se puede utilizar para crear y editar todo tipo de archivos de texto.

Pluma cuenta con un sistema de complementos flexible que permite añadir dinámicamente nuevas funciones avanzadas a la propia Pluma.

¿Qué es Pluma?

Pluma es el editor de texto oficial de MATE. Está diseñado como un editor gráfico ligero, sencillo de utilizar y suficientemente potente para editar tanto documentos de texto normales como archivos de configuración y código fuente.

Forma parte del conjunto de aplicaciones de MATE Desktop Environment y es, conceptualmente, el sucesor de Gedit 2.x dentro del ecosistema MATE.

Su nombre hace referencia a "pluma" (pluma estilográfica), siguiendo la tradición de nombres de aplicaciones del escritorio.

Una forma sencilla de situarlo es:

                         MATE
                          │
                          ▼
                    ┌───────────┐
                    │   Pluma   │
                    │           │
                    │ Editor de │
                    │   texto   │
                    └─────┬─────┘
                          │
             ┌────────────┼────────────┐
             ▼            ▼            ▼
          archivos      código       texto
          .txt          .py          .conf
             │            │            │
             └────────────┼────────────┘
                          ▼
                     sistema de
                      archivos

Pero Pluma no es simplemente un "bloc de notas". Internamente tiene una arquitectura bastante interesante basada en GTK, un modelo de documento propio, resaltado de sintaxis, búsqueda/reemplazo, pestañas y un sistema de complementos.


1. ¿Qué problema resuelve Pluma?

Su objetivo principal es permitir trabajar con texto plano de forma gráfica.

Por ejemplo:

notas.txt
config.conf
script.sh
programa.py
index.html
style.css
README.md

Puedes abrir cualquiera de estos archivos en Pluma.

A diferencia de un procesador de textos como LibreOffice Writer, Pluma trabaja principalmente con texto sin formato.

Esto significa que si escribes:

Hola mundo
Este es un archivo de texto.

el archivo contiene esencialmente:

H o l a _ m u n d o \n
E s t e _ e s _ u n _ a r c h i v o...

y no información compleja de formato como:

fuente = Arial
tamaño = 14
negrita = true
color = azul

2. Pluma frente a un procesador de textos

Es importante distinguir:

Pluma
Procesador de textos

Texto plano
Documento enriquecido

Código fuente
Documentos formateados

Configuración
Informes visuales

Scripts
Cartas

Markdown
Documentos con estilos

Archivos .conf
.odt, .docx, etc.

Por ejemplo:

Pluma
 └── /etc/archivo.conf

es un uso natural.

Mientras que:

LibreOffice Writer
 └── informe.odt

es un uso diferente.

Pluma está mucho más cerca conceptualmente de:

nano
vim
gedit
Kate
Mousepad

que de:

LibreOffice Writer
Microsoft Word

3. Arquitectura general

Una manera útil de visualizar Pluma es:

                       PLUMA
                         │
          ┌──────────────┼──────────────┐
          │              │              │
          ▼              ▼              ▼
       GTK/GtkSource   Document       Plugins
          │              │              │
          │              │              │
          ▼              ▼              ▼
       interfaz      texto en RAM    funciones
          │              │
          └──────────────┼──────────────┘
                         ▼
                    archivo en disco

Hay una distinción fundamental:

El archivo del disco y el documento que estás editando en Pluma son dos estados diferentes.

Cuando haces:

Archivo → Abrir

Pluma lee el archivo.

El contenido pasa a memoria.

Trabajas sobre esa copia en memoria.

Cuando haces:

Archivo → Guardar

Pluma escribe el contenido de nuevo al almacenamiento.


4. El modelo documento en memoria

Supongamos que tienes:

/home/usuario/documento.txt

con:

Hola
Mundo

Cuando lo abres:

DISCO
 │
 │ lectura
 ▼
PLUMA
 │
 ▼
Documento en memoria

Puedes cambiarlo:

Hola
Mundo

a:

Hola
Mundo desde MATE

pero hasta que guardes:

Ctrl+S

el archivo original puede seguir siendo:

Hola
Mundo

Por tanto:

                  RAM
                   │
             documento editado
                   │
              Ctrl + S
                   │
                   ▼
                 DISCO

Este concepto es básico para entender cualquier editor de texto.


5. Pestañas

Pluma permite trabajar con múltiples documentos mediante pestañas.

Por ejemplo:

┌─────────────────────────────────────────────────┐
│ [config.conf] [script.sh] [README.md] [+]       │
├─────────────────────────────────────────────────┤
│                                                 │
│ #!/bin/bash                                     │
│ echo "Hola"                                     │
│                                                 │
└─────────────────────────────────────────────────┘

Cada pestaña representa un documento diferente.

Conceptualmente:

Ventana Pluma
│
├── Documento A
│
├── Documento B
│
└── Documento C

Esto permite trabajar con varios archivos sin tener que abrir una ventana independiente para cada uno.


6. Ventanas y documentos

También puedes tener varias ventanas de Pluma.

Por ejemplo:

Ventana 1
├── main.py
├── config.py
└── README.md

Ventana 2
├── servidor.conf
└── logs.txt

Esto permite separar proyectos o tareas.


7. Resaltado de sintaxis

Esta es una de las características que hacen que Pluma sea mucho más que un editor de texto básico.

Puede utilizar resaltado de sintaxis para diferentes lenguajes y formatos.

Por ejemplo, un archivo Python:

def saludar(nombre):
    print("Hola", nombre)

puede aparecer visualmente con diferentes colores para:

def          → palabra reservada
saludar      → función
nombre       → variable
"Hola"       → cadena

En un archivo Bash:

#!/bin/bash

echo "Hola"

Pluma puede distinguir:

#!/bin/bash    → comentario/directiva
echo           → comando
"Hola"         → cadena

La idea es:

texto original
      │
      ▼
analizador de sintaxis
      │
      ▼
tokens
      │
      ▼
colores/estilos

Esto no modifica el archivo.

El color es solamente una representación visual.


8. GtkSourceView

Una pieza tecnológica muy importante detrás de Pluma es GtkSourceView.

GtkSourceView proporciona componentes especializados para editores de texto basados en GTK, incluyendo funcionalidades como:

  • resaltado de sintaxis;
  • regiones de texto;
  • números de línea;
  • modos de lenguaje;
  • marcado;
  • otras capacidades de edición.

Por eso Pluma puede ofrecer funcionalidades propias de un editor de código sin convertirse en un IDE completo.

La arquitectura conceptual sería:

Pluma
  │
  ▼
GtkSourceView
  │
  ├── texto
  ├── sintaxis
  ├── estilos
  ├── números de línea
  └── navegación

9. Detección del lenguaje

Cuando abres:

programa.py

Pluma puede reconocer que se trata de Python.

Con:

script.sh

puede reconocer Bash/Shell.

Con:

archivo.html

puede reconocer HTML.

Con:

archivo.css

puede reconocer CSS.

Esto permite activar automáticamente un esquema de resaltado apropiado.

También puedes seleccionar manualmente el modo de lenguaje cuando sea necesario.


10. Números de línea

Una característica muy útil para programación es mostrar:

 1  #!/usr/bin/env python3
 2
 3  def main():
 4      print("Hola")
 5
 6  main()

Los números de línea permiten referirse fácilmente a posiciones concretas:

"El error está en la línea 42."

Esto resulta especialmente útil cuando trabajas con compiladores, intérpretes o logs.


11. Búsqueda

Pluma incorpora búsqueda de texto.

Por ejemplo, en un archivo grande puedes buscar:

localhost

y navegar entre las coincidencias.

Conceptualmente:

Documento
│
├── línea 10
├── línea 23 ← localhost
├── línea 87
├── línea 142 ← localhost
└── línea 300

La búsqueda evita tener que recorrer manualmente todo el documento.


12. Reemplazar

También puedes sustituir texto.

Por ejemplo:

localhost

por:

192.168.1.100

en un documento.

El flujo es:

Buscar
   ↓
Encontrar coincidencia
   ↓
Reemplazar
   ↓
Siguiente coincidencia

Dependiendo de la versión/configuración también puedes realizar reemplazos múltiples.


13. Búsqueda sensible a mayúsculas

Una opción habitual es distinguir:

Hola

de:

hola

Es decir:

Hola ≠ hola

cuando está activada la sensibilidad a mayúsculas/minúsculas.

Esto resulta importante en programación porque muchos lenguajes son case-sensitive.


14. Deshacer y rehacer

Pluma mantiene un historial de modificaciones.

Por ejemplo:

Estado 1
Hola

Estado 2
Hola mundo

Estado 3
Hola mundo desde MATE

Puedes retroceder:

Ctrl+Z

y volver:

Estado 2

Después puedes rehacer la operación.

Conceptualmente:

Editar
  │
  ▼
historial
  │
  ├── undo
  │
  └── redo

Esto es fundamental en cualquier editor.


15. Copiar, cortar y pegar

Pluma utiliza las operaciones tradicionales:

Ctrl+C
Ctrl+X
Ctrl+V

para:

copiar
cortar
pegar

También puedes seleccionar:

una palabra
una línea
varias líneas
un bloque de texto

y manipularlo.


16. Autoguardado y archivos modificados

Cuando modificas un documento, Pluma necesita distinguir:

archivo guardado

de:

archivo modificado

Por ejemplo:

config.conf

puede pasar a:

config.conf *

o mostrar alguna indicación equivalente de modificación según la interfaz/tema.

El asterisco representa conceptualmente:

contenido en memoria ≠ contenido en disco

Cuando haces:

Ctrl+S

se sincronizan:

RAM ↔ DISCO

17. Codificación de caracteres

Esta es una característica técnicamente muy importante.

Un archivo de texto no es simplemente "letras".

En disco se almacenan bytes.

Por ejemplo:

A

tiene una representación determinada.

Pero:

á
ñ
€
中

requieren una codificación capaz de representarlos.

Una de las más importantes actualmente es:

UTF-8

Por eso Pluma necesita manejar correctamente las codificaciones de caracteres.

Puedes encontrarte con archivos en:

UTF-8
ISO-8859-1
Windows-1252

entre otras.

Si una codificación se interpreta incorrectamente puedes obtener algo como:

España

en lugar de:

España

La gestión de codificaciones es, por tanto, fundamental para un editor de texto Linux.


18. Finales de línea

Otra característica que normalmente pasa desapercibida es el tipo de salto de línea.

Unix/Linux utiliza normalmente:

LF

Windows tradicionalmente:

CRLF

y sistemas antiguos como ciertos entornos de Macintosh utilizaban:

CR

Conceptualmente:

Linux:
línea 1\n
línea 2\n

Windows:
línea 1\r\n
línea 2\r\n

Un editor como Pluma debe ser capaz de trabajar con estas diferencias para evitar problemas al mover archivos entre sistemas.

Esto es especialmente importante para programación y scripts.


19. Guardar archivos

Cuando guardas un documento, Pluma tiene que realizar varias operaciones:

Documento en memoria
        │
        ▼
determinar codificación
        │
        ▼
determinar formato de texto
        │
        ▼
escribir bytes
        │
        ▼
archivo

El resultado es un archivo de texto que otras aplicaciones pueden leer.

Por ejemplo:

Pluma
 ↓
script.sh
 ↓
Bash
 ↓
ejecución

Pluma no interpreta el script.

Simplemente lo edita.


20. Pluma como editor de código

Aunque no es un IDE completo, Pluma resulta bastante útil para programación.

Por ejemplo:

Proyecto
├── main.py
├── config.py
├── utils.py
└── README.md

Puedes abrir los archivos en pestañas:

[main.py] [config.py] [utils.py] [README.md]

y utilizar:

  • resaltado;
  • búsqueda;
  • reemplazo;
  • indentación;
  • números de línea;
  • plugins;
  • navegación.

Pero no deberías confundirlo con un IDE como:

Visual Studio Code
PyCharm
Eclipse

Un IDE integra muchas más funciones de desarrollo.


21. Sangría e indentación

Pluma proporciona herramientas para facilitar la escritura de código estructurado.

Por ejemplo:

if usuario:
    print("Hola")

La indentación es especialmente importante en Python.

También es útil para:

Python
C
C++
Java
JavaScript
HTML
CSS
Bash

etc.


22. Espacios y tabuladores

En programación hay una diferencia entre:

TAB

y:

ESPACIOS

Pluma permite configurar aspectos relacionados con la indentación para adaptar el comportamiento del editor a las preferencias del usuario o del proyecto.

Por ejemplo:

Tab → 4 espacios

puede hacer que al pulsar Tab se inserten cuatro espacios.

Esto puede ser importante para mantener un estilo coherente.


23. Ajuste de línea

Imagina una línea enorme:

Lorem ipsum dolor sit amet consectetur adipiscing elit ...

Sin ajuste:

Lorem ipsum dolor sit amet consectetur adipiscing elit consectetur...
                                                           →

Con ajuste:

Lorem ipsum dolor sit amet consectetur adipiscing elit
consectetur adipiscing elit...

El ajuste de línea cambia cómo se visualiza el texto, pero no necesariamente introduce saltos de línea reales en el archivo.

Esta distinción es importante:

ajuste visual
     ≠
salto de línea real

24. Barra de estado

La interfaz puede mostrar información contextual del documento, como:

Línea 42, columna 17

y otra información relacionada con:

  • posición del cursor;
  • estado del documento;
  • lenguaje;
  • codificación.

Esto resulta particularmente útil para programación.


25. Ir a una línea concreta

Si un compilador dice:

error en línea 157

no quieres desplazarte manualmente por cientos de líneas.

Una función de navegación permite ir directamente a una posición concreta.

Conceptualmente:

Ctrl+L
   ↓
157
   ↓
línea 157

El nombre exacto del atajo puede variar según la versión/configuración, pero la funcionalidad de navegación por posición es una característica típica del editor.


26. Múltiples documentos

Una de las ventajas del sistema de pestañas es poder comparar archivos.

Por ejemplo:

[config.old] [config.new]

y desplazarte entre ellos.

Esto permite tareas como:

archivo original
       ↓
archivo modificado
       ↓
comparación visual

Aunque para diferencias avanzadas existen herramientas especializadas como:

diff
meld

Pluma sirve muy bien para una comparación manual básica.


27. Plugins

Una de las características más interesantes de Pluma es su arquitectura de complementos/plugins.

En lugar de incorporar absolutamente todas las funcionalidades al núcleo, ciertas capacidades pueden añadirse como extensiones.

Conceptualmente:

                    PLUMA
                      │
              ┌───────┴───────┐
              │               │
             núcleo         plugins
              │               │
              │       ┌───────┼───────┐
              │       │       │       │
              ▼       ▼       ▼       ▼
           edición   Git   terminal  otros

Esto permite mantener el editor relativamente sencillo mientras se añaden capacidades según las necesidades.


28. Ejemplos de funcionalidades mediante plugins

Dependiendo de la versión y los complementos disponibles, el ecosistema de Pluma puede proporcionar funcionalidades como:

  • navegador de archivos;
  • terminal integrado;
  • integración con sistemas de control de versiones;
  • herramientas de documentos;
  • snippets;
  • selección avanzada;
  • ejecución de comandos;
  • soporte adicional para lenguajes.

La disponibilidad exacta depende de la versión de Pluma y de los paquetes de plugins instalados.

Esto es importante porque no todas las instalaciones de MATE tienen exactamente los mismos plugins habilitados.


29. Terminal integrado

Algunas instalaciones pueden disponer de un complemento que permite abrir una terminal dentro de Pluma.

Conceptualmente:

┌──────────────────────────────────────┐
│ Pluma                                │
├──────────────────────────────────────┤
│ #!/bin/bash                          │
│ echo "Hola"                          │
│                                      │
├──────────────────────────────────────┤
│ $ ./script.sh                        │
│ Hola                                 │
└──────────────────────────────────────┘

Esto puede ser especialmente cómodo para programación.

Editas:

script.sh

y ejecutas:

./script.sh

sin abandonar el editor.


30. Sistema de snippets

Otro concepto interesante es el de fragmentos de código (snippets).

Por ejemplo, en vez de escribir repetidamente:

if __name__ == "__main__":
    main()

un sistema de snippets puede permitir insertar automáticamente una plantilla.

Conceptualmente:

abreviatura
   ↓
snippet
   ↓
código completo

Esto puede acelerar considerablemente determinadas tareas de programación.


31. Integración con Git

Dependiendo de los plugins instalados, Pluma puede ofrecer cierta integración con sistemas de control de versiones.

Por ejemplo, un proyecto:

proyecto/
├── .git/
├── main.py
├── config.py
└── README.md

puede abrirse en Pluma mientras otras herramientas gestionan Git.

Es importante distinguir:

Pluma
   ↓
edición

Git
   ↓
control de versiones

Pluma no sustituye a Git.


32. Archivos de configuración

Pluma es especialmente útil para editar archivos de configuración Linux.

Por ejemplo:

~/.bashrc
~/.profile
~/.config/...

y muchos otros archivos de texto.

Aquí aparece una característica interesante de los editores gráficos Linux:

Pluma
  │
  ├── usuario
  │
  └── permisos
          │
          ▼
      archivo

Si intentas modificar un archivo que tu usuario no puede escribir, Pluma no puede simplemente saltarse los permisos del sistema.

Esto es una propiedad de seguridad del sistema operativo.


33. Root y permisos

Supongamos:

/etc/algo.conf

pertenece a:

root:root

y tu usuario no tiene permisos de escritura.

Abrirlo con Pluma no convierte mágicamente al editor en root.

Puedes leerlo, pero guardar puede fallar.

La razón es:

Pluma
  │
  ▼
usuario actual
  │
  ▼
kernel Linux
  │
  ▼
permisos del archivo

El kernel es quien decide si puedes escribir.

Esto es una distinción importante entre:

editor gráfico

y:

privilegios del sistema

34. UTF-8 y Unicode

Pluma está pensado para trabajar en entornos modernos donde Unicode/UTF-8 es la codificación habitual.

Esto permite editar:

Español
Português
Français
Ελληνικά
Русский
中文
日本語
العربية

etc.

Pero nuevamente:

Unicode

es un estándar de caracteres, mientras:

UTF-8

es una forma concreta de codificarlos como bytes.


35. Soporte de archivos grandes

Pluma está pensado principalmente para archivos de texto de tamaño razonable.

No es buena idea asumir que es la herramienta ideal para abrir:

archivo.log

de varios gigabytes.

Para archivos gigantes pueden ser más apropiadas herramientas como:

less
tail
grep
awk
sed

Por ejemplo:

less enorme.log

o:

tail -f enorme.log

Pluma está optimizado para editar, no para analizar logs gigantescos.


36. Seguridad y archivos remotos

Pluma puede trabajar con archivos accesibles a través de las capacidades de acceso de archivos proporcionadas por el entorno GTK/GIO, dependiendo de la configuración y versión.

Esto significa que el concepto de:

archivo local

puede extenderse a recursos accesibles mediante mecanismos de escritorio.

Pero para administración remota avanzada normalmente es más apropiado utilizar:

ssh
scp
sftp
rsync

y después editar localmente o utilizar herramientas especializadas.


37. Integración con el gestor de archivos Caja

Dentro del ecosistema MATE, Caja es el administrador de archivos.

Una interacción típica sería:

Caja
 │
 │ doble clic
 ▼
archivo.txt
 │
 ▼
Pluma

Por ejemplo:

/home/usuario/documentos/notas.txt

puede abrirse desde Caja con Pluma.

Esto genera una experiencia bastante integrada:

Caja → localizar archivo
          ↓
       Pluma
          ↓
       editar
          ↓
       guardar

38. Asociación de archivos

MATE/Linux utiliza asociaciones para decidir qué aplicación debe abrir determinados tipos de archivos.

Por ejemplo:

.txt → Pluma
.py  → Pluma
.conf → Pluma

aunque las asociaciones concretas dependen de tu sistema.

Así, cuando haces doble clic sobre un archivo de texto, el escritorio puede decidir:

archivo
  ↓
MIME type
  ↓
aplicación asociada
  ↓
Pluma

39. ¿Qué es un MIME type?

Linux no siempre determina el tipo de archivo simplemente por su extensión.

Puede utilizar información MIME.

Por ejemplo:

archivo.txt

puede identificarse como:

text/plain

mientras:

archivo.html

puede identificarse como:

text/html

Esto ayuda al escritorio a decidir qué aplicación utilizar.


40. Interfaz gráfica

La interfaz de Pluma sigue una filosofía tradicional de aplicaciones GTK.

Normalmente encontramos:

┌─────────────────────────────────────────────────┐
│ Archivo  Editar  Ver  Buscar  Herramientas ... │
├─────────────────────────────────────────────────┤
│ [Nuevo] [Abrir] [Guardar] ...                   │
├─────────────────────────────────────────────────┤
│  1  #!/usr/bin/env python3                      │
│  2                                             │
│  3  print("Hola")                              │
│  4                                             │
│  5                                             │
├─────────────────────────────────────────────────┤
│ Línea 3, Columna 12      Python       UTF-8    │
└─────────────────────────────────────────────────┘

La interfaz busca ser familiar para usuarios de editores gráficos tradicionales.


41. Menús principales

Dependiendo de la versión, normalmente encontrarás funciones agrupadas alrededor de:

Archivo
Editar
Ver
Buscar
Herramientas
Ayuda

Desde ahí se accede a operaciones como:

Nuevo
Abrir
Guardar
Guardar como
Cerrar

Guía de MATE entorno de escritorio clásico y ligero: Mozo editor de menús,

Mozo es un editor de menús para MATE que utiliza la especificación de menús de freedesktop.org. Es una bifurcación de Alacarte.

 

¿Qué es Mozo?

Mozo es el editor gráfico de menús de MATE. Permite modificar la estructura del menú de aplicaciones del escritorio sin tener que editar manualmente los archivos .desktop y los archivos XML que definen la organización del menú.

Forma parte del ecosistema de aplicaciones de MATE Desktop Environment y está pensado para integrarse con el sistema de menús basado en freedesktop.org.

La idea fundamental es esta:

                 ESCRITORIO MATE
                       │
                       ▼
                ┌─────────────┐
                │    Mozo     │
                │             │
                │ Editor de   │
                │ menús       │
                └──────┬──────┘
                       │
                       ▼
              configuración del
               menú de aplicaciones
                       │
             ┌─────────┴─────────┐
             ▼                   ▼
       archivos .desktop    archivos XML
             │                   │
             └─────────┬─────────┘
                       ▼
                 MENÚ DE MATE

Mozo no es el menú en sí. Es una herramienta para editar la información que posteriormente utilizan el panel y el menú de aplicaciones de MATE.


1. ¿Qué problema resuelve Mozo?

En Linux, las aplicaciones gráficas normalmente no aparecen en el menú simplemente porque exista un ejecutable en:

/usr/bin/

Por ejemplo:

/usr/bin/firefox
/usr/bin/gedit
/usr/bin/vlc

El menú necesita información adicional:

Nombre: Firefox
Descripción: Navegador web
Icono: firefox
Comando: firefox
Categoría: Internet

Esa información se almacena principalmente mediante archivos:

.desktop

Por ejemplo, conceptualmente:

[Desktop Entry]
Name=Firefox
Comment=Web Browser
Exec=firefox
Icon=firefox
Type=Application
Categories=Network;WebBrowser;

Mozo proporciona una interfaz gráfica para modificar este tipo de información y, sobre todo, decidir cómo aparece organizada en el menú.


2. La arquitectura que hay detrás

Para comprender Mozo en profundidad conviene separar tres elementos:

Aplicación
    │
    ▼
archivo .desktop
    │
    ▼
sistema de menús
    │
    ▼
MATE panel / menú

El archivo .desktop describe una aplicación.

El sistema de menús determina dónde aparece.

Mozo actúa sobre esa configuración.

Por tanto:

          .desktop
             │
             │ describe
             ▼
        Aplicación
             │
             │ pertenece a
             ▼
          Categorías
             │
             ▼
       Sistema de menú
             │
             ▼
       Menú de MATE

3. ¿Qué es un archivo .desktop?

Un .desktop es, simplificando, el equivalente Linux de una "ficha" que describe una aplicación gráfica.

Por ejemplo:

[Desktop Entry]
Name=Mi aplicación
Comment=Una aplicación de ejemplo
Exec=/usr/local/bin/mi-programa
Icon=mi-icono
Terminal=false
Type=Application
Categories=Utility;

Aquí encontramos información como:

Campo
Función

Name
Nombre mostrado

Comment
Descripción

Exec
Programa que se ejecuta

Icon
Icono

Terminal
Si necesita terminal

Type
Tipo de entrada

Categories
Categorías

NoDisplay
Si debe ocultarse del menú

Hidden
Si la entrada está oculta

Mozo trabaja sobre este ecosistema.


4. Mozo no modifica el ejecutable

Esto es muy importante.

Si tienes:

/usr/bin/mi-programa

y utilizas Mozo para cambiar:

Nombre:
"Mi programa"

por:

"Mi fantástico programa"

Mozo no modifica:

/usr/bin/mi-programa

Modifica la información utilizada para presentar el programa en el menú.

Es decir:

                  Mozo
                   │
                   ▼
       información del menú
                   │
                   ▼
             .desktop
                   │
                   ▼
       "cómo aparece"
                   │
                   ▼
          aplicación real

5. Crear lanzadores personalizados

Una de las funciones más útiles de Mozo es la posibilidad de crear un lanzador.

Imagina que tienes un programa que puedes ejecutar desde:

/opt/mis-programas/editor

pero no tiene una entrada en el menú.

Puedes crear desde Mozo una nueva entrada con:

Nombre:
Editor especial

Comando:
/opt/mis-programas/editor

Comentario:
Mi editor personalizado

Icono:
...

Entonces puedes conseguir:

Aplicaciones
 └── Oficina
      └── Editor especial

sin tener que escribir manualmente el archivo .desktop.


6. Crear una entrada para cualquier comando

Esto abre posibilidades interesantes.

Por ejemplo, puedes crear un lanzador para:

htop

o:

mate-terminal

o incluso:

mate-terminal --working-directory=/home/usuario/proyecto

Así puedes transformar un comando en una aplicación accesible desde el menú gráfico.

Conceptualmente:

Mozo
 │
 ├── Nombre
 ├── Comando
 ├── Comentario
 └── Icono
       │
       ▼
   .desktop
       │
       ▼
 menú MATE

7. Organización jerárquica

Mozo permite trabajar con la estructura jerárquica del menú.

Por ejemplo:

Aplicaciones
│
├── Accesorios
│   ├── Calculadora
│   ├── Editor de texto
│   └── Terminal
│
├── Gráficos
│   ├── Visor de imágenes
│   └── Editor de imágenes
│
├── Internet
│   ├── Navegador
│   └── Cliente de correo
│
├── Oficina
│   ├── Procesador de textos
│   └── Hoja de cálculo
│
└── Sonido y vídeo
    ├── Reproductor
    └── Grabador

Puedes modificar esta estructura mediante la interfaz gráfica.

Esto es especialmente útil si tienes muchas aplicaciones instaladas y quieres construir una organización personalizada.


8. Crear submenús

No solamente puedes modificar entradas.

También puedes crear categorías/submenús personalizados.

Por ejemplo:

Aplicaciones
│
├── Desarrollo
│   ├── IDE
│   ├── Terminal
│   ├── Git
│   └── Docker
│
├── Servidores
│   ├── SSH
│   ├── Logs
│   └── Monitorización
│
└── Mis aplicaciones
    ├── Aplicación A
    ├── Aplicación B
    └── Aplicación C

Esto es una de las funciones que hacen que Mozo sea mucho más interesante que simplemente editar nombres de aplicaciones.


9. Mover aplicaciones

Puedes cambiar la posición de las entradas dentro de una categoría.

Por ejemplo:

Internet
├── Firefox
├── Thunderbird
├── Transmission
└── Cliente IRC

podría reorganizarse como:

Internet
├── Firefox
├── Cliente IRC
├── Thunderbird
└── Transmission

Esto afecta principalmente a la presentación del menú, no al funcionamiento de las aplicaciones.


10. Ocultar aplicaciones

Otra función importante es ocultar entradas que no quieres que aparezcan.

Supongamos que tienes:

Aplicaciones
├── Desarrollo
├── Juegos
├── Oficina
├── Programación
└── Utilidades

pero no quieres que:

Juegos

aparezca.

Puedes ocultar la entrada correspondiente.

Esto no significa necesariamente que el programa haya sido desinstalado.

Simplemente deja de aparecer en el menú.

Es una distinción fundamental:

Visible en menú
       ≠
Instalado en sistema

11. El concepto de "ocultar" en .desktop

Aquí aparece un detalle técnico interesante.

Los archivos .desktop pueden contener propiedades como:

NoDisplay=true

o:

Hidden=true

Estas propiedades tienen significados distintos dentro de la especificación de Desktop Entry.

Por eso, cuando utilizas Mozo para ocultar algo, no debes imaginar que está borrando la aplicación.

La idea es modificar la forma en que la entrada es presentada por el sistema de menús.


12. Desactivar una categoría completa

La misma idea puede aplicarse a categorías.

Por ejemplo:

Aplicaciones
├── Accesorios
├── Educación
├── Gráficos
├── Internet
├── Oficina
└── Juegos

Puedes decidir que determinada categoría no aparezca.

El programa y sus archivos siguen existiendo, pero el menú deja de mostrar esa parte de la estructura.


13. Iconos

Mozo permite asociar iconos a los lanzadores.

Esto es importante porque un .desktop puede especificar:

Icon=firefox

o una ruta de icono.

El sistema de iconos de MATE/GTK se encarga posteriormente de resolver ese nombre.

Conceptualmente:

Mozo
 │
 │ Icon = "mi-icono"
 ▼
.desktop
 │
 ▼
GTK / icon theme
 │
 ▼
imagen

Esto significa que el icono que ves en el menú puede proceder del tema de iconos instalado en el sistema.


14. Nombre visible vs nombre real

Mozo permite modificar el nombre que ve el usuario.

Por ejemplo, el archivo podría representar originalmente:

Name=LibreOffice Writer

y podrías presentar algo como:

Name=Procesador de textos

La aplicación real no cambia.

Es simplemente una capa de presentación.

Esto resulta muy útil para construir un menú más adaptado a tus necesidades.


15. El campo Exec

Probablemente uno de los campos técnicamente más importantes es:

Exec=

Por ejemplo:

Exec=firefox

significa que al activar el lanzador se ejecutará:

firefox

Otro ejemplo:

Exec=mate-terminal

y otro:

Exec=mate-terminal --working-directory=/home/usuario/proyecto

Mozo proporciona una interfaz gráfica para especificar el comando que debe ejecutarse.

Por eso puede funcionar como una especie de constructor visual de archivos .desktop.


16. Lanzadores que utilizan terminal

Existe además el concepto:

Terminal=true

Esto indica que el programa necesita ejecutarse dentro de una terminal.

Por ejemplo, un programa de consola podría tener:

[Desktop Entry]
Name=Mi programa
Exec=/usr/local/bin/programa
Terminal=true
Type=Application

Entonces el entorno de escritorio sabe que debe abrir una terminal para ejecutarlo.

Esto permite que Mozo pueda utilizarse no solamente para programas GTK gráficos, sino también para determinados programas de consola.


17. Aplicaciones de escritorio vs comandos

Podemos pensar en tres niveles:

Programa gráfico
firefox
   ↓
ventana gráfica
Programa de consola
htop
   ↓
terminal
Comando personalizado
script.sh
   ↓
acción personalizada

Mozo puede crear entradas que actúen como lanzadores para estos distintos casos, siempre que la configuración del .desktop sea adecuada.


18. ¿Dónde se almacenan las modificaciones?

Aquí entramos en una parte especialmente importante.

Linux tiene normalmente varias ubicaciones relacionadas con los archivos .desktop.

A nivel global pueden existir entradas en:

/usr/share/applications/

y a nivel del usuario:

~/.local/share/applications/

Las modificaciones personalizadas de un usuario suelen aprovechar la jerarquía de configuración del usuario en lugar de modificar directamente los archivos proporcionados por los paquetes del sistema.

Esto es fundamental porque:

/usr/share/applications/

puede ser gestionado por el sistema de paquetes.

Si modificases directamente esos archivos, una actualización podría sobrescribir tus cambios.

La separación:

Sistema
/usr/share/applications/

Usuario
~/.local/share/applications/

permite mantener personalizaciones independientes.


19. ¿Por qué esto es importante?

Supongamos que un paquete instala:

/usr/share/applications/programa.desktop

y tú lo modificas directamente.

Después haces:

sudo apt upgrade

El paquete puede reemplazar el archivo.

En cambio, una personalización de usuario puede utilizar:

~/.local/share/applications/

para modificar la presentación sin tocar el archivo original.

Por eso es mucho más seguro trabajar mediante las herramientas de configuración del escritorio.


20. El sistema de menús de freedesktop.org

Mozo no inventa desde cero el sistema de menús.

MATE participa en el ecosistema Linux de estándares de escritorio, especialmente en las especificaciones de freedesktop.org.

Dos piezas particularmente importantes son:

Desktop Entry Specification

y:

Desktop Menu Specification

La primera describe los lanzadores:

.desktop

La segunda define cómo organizar las aplicaciones en menús.

Por eso el flujo es más o menos:

Aplicación
     │
     ▼
Desktop Entry
     │
     │ .desktop
     ▼
Sistema de menús
     │
     │ categorías
     ▼
MATE
     │
     ▼
Menú de aplicaciones

Mozo proporciona una interfaz gráfica sobre buena parte de esta configuración.


21. Mozo y los archivos XML

Hay una segunda capa que suele pasar desapercibida.

La estructura de los menús puede estar relacionada con archivos XML de menú, por ejemplo:

/etc/xdg/menus/

y configuraciones específicas del usuario.

El sistema de menús puede utilizar información de este tipo para determinar:

qué categorías existen
qué entradas pertenecen a cada categoría
en qué orden aparecen
qué elementos se excluyen

Por eso la arquitectura es más compleja que simplemente:

leer todos los .desktop

El sistema combina Desktop Entries + reglas de menú.


22. Categorías de las aplicaciones

Una aplicación puede declarar categorías:

Categories=AudioVideo;

o:

Categories=Graphics;

o:

Categories=Network;WebBrowser;

Estas categorías ayudan al entorno de escritorio a decidir dónde colocarla.

Por ejemplo:

Categories=Graphics;

sugiere:

Aplicaciones
 └── Gráficos
       └── Aplicación

Mientras:

Categories=Network;

puede llevarla hacia:

Aplicaciones
 └── Internet
       └── Aplicación

Mozo permite modificar la organización resultante de una manera mucho más amigable.


23. Mozo no es simplemente un editor de texto

Podrías hacer todo esto manualmente con:

nano ~/.local/share/applications/mi-programa.desktop

pero Mozo evita tener que conocer todos los campos y sintaxis.

En vez de:

[Desktop Entry]
Name=...
Exec=...
Icon=...
Type=Application
Categories=...

trabajas con una interfaz gráfica.

Por eso su objetivo puede resumirse como:

convertir la edición técnica del sistema de menús en una tarea gráfica.


24. ¿Qué pasa cuando pulsas una aplicación en el menú?

Supongamos que creaste:

Aplicaciones
 └── Desarrollo
      └── Mi IDE

y haces clic en Mi IDE.

El flujo aproximado es:

clic
 │
 ▼
menú MATE
 │
 ▼
entrada .desktop
 │
 ▼
Exec=/opt/mi-ide/bin/ide
 │
 ▼
sistema de escritorio
 │
 ▼
proceso
 │
 ▼
/opt/mi-ide/bin/ide

Mozo no participa permanentemente en este proceso.

Mozo fue utilizado previamente para configurar la entrada.

Esto es importante:

Mozo
  ↓
CONFIGURACIÓN

MATE Menu
  ↓
LECTURA DE CONFIGURACIÓN

Aplicación
  ↓
EJECUCIÓN

25. Mozo y el menú del panel

En MATE normalmente puedes acceder al menú de aplicaciones mediante el panel.

Por ejemplo:

┌───────────────────────────────────────────────────────┐
│ Aplicaciones | Lugares | Sistema                      │
└───────────────────────────────────────────────────────┘

Mozo modifica la información que ese menú utiliza.

Por tanto, si creas:

Desarrollo
 └── Herramientas
      └── Mi aplicación

el menú puede mostrar esa nueva estructura después de que se actualice/refresque.


26. Personalización por usuario

Una de las ventajas de este sistema es que las modificaciones pueden ser específicas para cada usuario.

Imagina dos usuarios:

usuario1
usuario2

Pueden tener:

usuario1:
Aplicaciones
 ├── Desarrollo
 └── Servidores

usuario2:
Aplicaciones
 ├── Oficina
 └── Multimedia

aunque ambos tengan instaladas exactamente las mismas aplicaciones.

Esto se consigue gracias a la separación entre:

configuración del sistema

y:

configuración del usuario

27. Mozo y administración del sistema

Hay que tener cuidado con una confusión frecuente.

Si instalas una aplicación para todo el sistema:

sudo apt install programa

el .desktop normalmente pertenece al sistema.

Pero si personalizas el menú desde tu usuario, no necesariamente necesitas modificar ese archivo global.

Es preferible pensar en:

/usr/share/applications/

como:

"lo que proporcionan las aplicaciones instaladas"

y:

~/.local/share/applications/

como:

"mis modificaciones y lanzadores personales".


28. ¿Puede Mozo desinstalar programas?

No.

Si eliminas una entrada del menú:

Mozo
 ↓
Eliminar entrada

eso no equivale necesariamente a:

sudo apt remove programa

La diferencia es:

Eliminar del menú
        ≠
Desinstalar aplicación

Mozo trabaja sobre la presentación y configuración del menú.

El gestor de paquetes trabaja sobre el software instalado.


29. ¿Puede Mozo modificar el programa?

Tampoco.

Por ejemplo, si tienes:

Firefox

y en Mozo cambias:

Firefox

por:

Navegador web

Firefox seguirá siendo exactamente el mismo programa.

Mozo modifica:

cómo se presenta

no:

cómo funciona internamente

30. Una de las grandes ventajas: crear un menú "personal"

Aquí es donde Mozo resulta especialmente interesante.

Puedes construir una estructura adaptada a tu forma de trabajar.

Por ejemplo:

Aplicaciones
│
├── Trabajo
│   ├── Correo
│   ├── Navegador
│   └── Oficina
│
├── Desarrollo
│   ├── IDE
│   ├── Terminal
│   ├── Git
│   └── Docker
│
├── Administración
│   ├── Monitor del sistema
│   ├── Logs
│   └── Servicios
│
└── Multimedia
    ├── Música
    └── Vídeo

La clasificación puede ser mucho más útil que la clasificación original proporcionada por los desarrolladores de cada aplicación.


31. Un ejemplo práctico

Supongamos que tienes un script:

/home/usuario/scripts/backup.sh

Actualmente tienes que abrir una terminal y escribir:

/home/usuario/scripts/backup.sh

Con Mozo podrías crear:

Nombre:
Backup

Comando:
/home/usuario/scripts/backup.sh

Categoría:
Herramientas

y asociarle un icono.

Entonces obtienes:

Aplicaciones
 └── Herramientas
      └── Backup

Al hacer clic:

Backup
  │
  ▼
.desktop
  │
  ▼
Exec=/home/usuario/scripts/backup.sh
  │
  ▼
backup.sh

Esto convierte Mozo en una herramienta bastante potente para construir pequeños lanzadores personalizados.


32. Mozo como "editor de la base de datos" del menú

Aunque técnicamente no es una base de datos, una analogía útil es imaginar el sistema de menús como una colección estructurada:

Aplicaciones
│
├── entradas
│    ├── nombre
│    ├── comando
│    ├── icono
│    └── categorías
│
└── categorías
     ├── nombre
     ├── orden
     └── entradas

Mozo te proporciona una GUI para modificar esa estructura.

Por eso:

Mozo

se puede entender como:

una interfaz gráfica para administrar la estructura y las entradas del menú de aplicaciones de MATE.


33. Qué ocurre internamente

Podemos representar el funcionamiento completo así:

                 ┌─────────────────────┐
                 │       MOZO          │
                 │                     │
                 │ Editor gráfico      │
                 │ del menú            │
                 └──────────┬──────────┘
                            │
             ┌──────────────┴──────────────┐
             │                             │
             ▼                             ▼
       Desktop Entries                Menús
          .desktop                     XML
             │                             │
             └──────────────┬──────────────┘
                            │
                            ▼
                    Sistema de menús
                            │
                            ▼
                     MATE Panel/Menu
                            │
                            ▼
                       Usuario hace
                          clic
                            │
                            ▼
                          Exec
                            │
                            ▼
                        Programa

Y esta separación es la clave para entenderlo.


34. Características principales de Mozo

En términos prácticos, sus funciones más importantes son:

  • Crear nuevos lanzadores.
  • Editar lanzadores existentes.
  • Cambiar nombres.
  • Cambiar comentarios/descripciones.
  • Cambiar comandos.
  • Cambiar iconos.
  • Crear submenús.
  • Mover entradas.
  • Organizar categorías.
  • Ocultar aplicaciones.
  • Ocultar categorías.
  • Crear estructuras personalizadas.
  • Trabajar con configuraciones de usuario.
  • Integrarse con el sistema de menús de MATE.
  • Utilizar los estándares de entradas .desktop.
  • Evitar que tengas que editar manualmente archivos de configuración.

35. Lo más importante que debes recordar

Si reducimos todo Mozo a cinco conceptos:

              MOZO
                │
       ┌────────┼────────┐
       ▼        ▼        ▼
   Lanzadores  Menús   Categorías
       │        │        │
       └────────┼────────┘
                ▼
         .desktop + reglas
                │
                ▼
          Menú de MATE

Y hay tres cosas que no debes confundir:

Mozo
  ↓
EDITOR DEL MENÚ


MATE Menu
  ↓
PRESENTA EL MENÚ


.desktop
  ↓
DESCRIBE LA APLICACIÓN

Mientras que:

/usr/bin/programa

es el programa real.


La idea fundamental

La mejor manera de entender Mozo es verlo como una capa intermedia entre las aplicaciones instaladas y la interfaz gráfica del escritorio:

                 APLICACIONES
                      │
          ┌───────────┴───────────┐
          │                       │
          ▼                       ▼
      programa                 .desktop
     /usr/bin/...                 │
                                  │
                                  ▼
                               MOZO
                                  │
                         organización/
                          personalización
                                  │
                                  ▼
                           SISTEMA DE MENÚ
                                  │
                                  ▼
                         MENÚ DE MATE

Mozo no ejecuta las aplicaciones, no las instala y no las desinstala. Su trabajo consiste en editar cómo las aplicaciones y los lanzadores se organizan y presentan dentro del menú de MATE.

Y precisamente por estar basado en .desktop y en las especificaciones de menús de freedesktop.org, Mozo no es solamente una herramienta visual: es una interfaz gráfica sobre una parte importante de la infraestructura que Linux utiliza para construir sus menús de aplicaciones.

Guía de MATE entorno de escritorio clásico y ligero: Terminal MATE.

Mate Terminal es el emulador de terminal oficial para el entorno de escritorio MATE.

MATE Terminal es el emulador de terminal oficial del entorno de escritorio MATE. Su función es proporcionar una ventana gráfica desde la que puedes interactuar con un shell de Unix/Linux, como bash, zsh, fish, etc. MATE Terminal es un fork histórico de GNOME Terminal y mantiene una arquitectura bastante clásica y modular. MMATEwiki+1

Una distinción muy importante es esta:

MATE Terminal no es el shell.

MATE Terminal es la aplicación que crea la ventana, gestiona pestañas, menús, perfiles, colores, fuentes, etc. La parte que realmente emula el terminal se basa en VTE (Virtual Terminal Emulator). GGitHub+1

Por ejemplo, cuando abres:

mate-terminal

la cadena conceptual es aproximadamente:

MATE Terminal
      │
      ├── Ventana GTK
      │
      ├── Pestaña / Terminal
      │       │
      │       └── VTE
      │             │
      │             └── PTY
      │                   │
      │                   └── Shell
      │                         │
      │                         └── bash / zsh / fish...
      │
      └── Perfil / configuración

Esto permite entender bastante bien qué hace cada componente.


1. Terminal emulator ≠ shell

Esta es probablemente la cuestión más importante para entender MATE Terminal.

Supongamos que ejecutas:

ls -lah

MATE Terminal no interpreta ls.

Lo que sucede es aproximadamente:

  1. MATE Terminal crea una sesión de terminal.
  2. Esa sesión utiliza VTE para representar el terminal virtual.
  3. Se crea un PTY (pseudo-terminal).
  4. Se inicia el shell configurado para tu usuario.
  5. El shell recibe:
ls -lah
  1. El shell localiza y ejecuta /usr/bin/ls.
  2. ls produce texto.
  3. Ese texto vuelve a través del PTY.
  4. VTE interpreta las secuencias de terminal y las dibuja.
  5. MATE Terminal presenta el resultado en la ventana.

Por eso puedes cambiar:

bash

por:

zsh

o:

fish

sin necesidad de cambiar de emulador de terminal.

MATE Terminal simplemente proporciona el entorno gráfico donde funciona ese shell.


2. ¿Qué significa "emular un terminal"?

Originalmente, un terminal era un dispositivo físico conectado a un ordenador central.

Por ejemplo, terminales como:

  • VT100
  • VT220
  • xterm

tenían una serie de capacidades y protocolos para representar texto, mover el cursor, cambiar colores, borrar regiones de pantalla, etc.

MATE Terminal emula ese comportamiento.

El propio proyecto de MATE indica que MATE Terminal permite ejecutar aplicaciones diseñadas para terminales como VT102, VT220 y xterm. MMATE

Por ejemplo, cuando ejecutas:

printf '\033[31mHola\033[0m\n'

el programa no está diciendo directamente:

"pinta esto de rojo en una ventana GTK".

Está enviando una secuencia de escape ANSI/VT.

VTE interpreta esa secuencia y MATE Terminal termina mostrando:

Hola

en rojo.

Esto es fundamental para entender por qué funcionan programas como:

htop
vim
nano
tmux
less
top
mc
ssh

etc.


3. VTE: el motor que está "debajo"

Una de las características arquitectónicas más interesantes de MATE Terminal es que la emulación propiamente dicha no está implementada íntegramente en MATE Terminal.

El proyecto explica explícitamente que mate-terminal proporciona principalmente la "carcasa" de la aplicación —menús, preferencias, ventanas, etc.— mientras que la emulación terminal procede del widget VTE. GGitHub

VTE significa:

Virtual Terminal Emulator

y es una biblioteca/widget para aplicaciones GTK. GGitHub

Esto separa responsabilidades:

                    MATE Terminal
                         │
          ┌──────────────┼──────────────┐
          │              │              │
       ventanas       perfiles       menús
          │              │              │
          └──────────────┼──────────────┘
                         │
                        VTE
                         │
                     terminal
                     emulator
                         │
                        PTY
                         │
                       shell

Esta arquitectura también explica por qué muchas características de terminal son compartidas conceptualmente con otros terminales GTK que utilizan VTE.


4. Pestañas

Una de las características más prácticas es poder tener varios terminales dentro de una misma ventana.

Por ejemplo:

┌──────────────────────────────────────────────────────┐
│ [Servidor] [Código] [Logs] [+]                       │
├──────────────────────────────────────────────────────┤
│                                                      │
│ $ ssh servidor                                      │
│                                                      │
│                                                      │
└──────────────────────────────────────────────────────┘

Cada pestaña representa una sesión de terminal independiente.

Puedes tener:

Pestaña 1 → bash → ~/proyecto
Pestaña 2 → ssh servidor
Pestaña 3 → tail -f /var/log/...
Pestaña 4 → htop

MATE documenta explícitamente la posibilidad de abrir múltiples terminales dentro de una sola ventana mediante pestañas. MMATE+1

También puedes combinar pestañas y ventanas:

Ventana 1
 ├── Tab 1
 ├── Tab 2
 └── Tab 3

Ventana 2
 ├── Tab 1
 └── Tab 2

5. Perfiles: una de sus características más interesantes

MATE Terminal utiliza un sistema de perfiles.

La idea es que no tengas que configurar individualmente cada terminal.

Puedes crear, por ejemplo:

Perfil "Normal"
Perfil "Root"
Perfil "Servidor"
Perfil "Programación"
Perfil "Logs"

Cada perfil puede definir diferentes características visuales y de comportamiento.

El proyecto describe precisamente el funcionamiento de MATE Terminal alrededor de estos perfiles: la configuración del terminal se almacena en perfiles y el diálogo de preferencias modifica el perfil seleccionado. GGitHub

Por ejemplo:

Perfil normal
Fondo: negro
Texto: gris claro
Fuente: Monospace 11
Cursor: bloque
Perfil servidor
Fondo: azul oscuro
Texto: blanco
Fuente: Monospace 11
Perfil root
Fondo: rojo oscuro
Texto: blanco

Esto último puede ser particularmente útil para diferenciar visualmente:

usuario@pc

de:

root@pc

y evitar cometer errores trabajando como administrador.


6. Personalización visual

MATE Terminal permite modificar considerablemente su apariencia.

Entre las configuraciones importantes están:

  • fuente;
  • tamaño de fuente;
  • colores;
  • color de fondo;
  • color del texto;
  • cursor;
  • desplazamiento;
  • transparencia;
  • título;
  • comportamiento de la terminal;
  • perfiles.

La documentación oficial de MATE destaca específicamente el soporte de fondos transparentes, pestañas y configuración mediante perfiles. MMATE

Por ejemplo:

┌──────────────────────────────┐
│ $ neofetch                   │
│                              │
│ OS: Linux                    │
│ DE: MATE                     │
│ Terminal: MATE Terminal     │
└──────────────────────────────┘

Puedes hacer que el fondo sea semitransparente para que se vea parcialmente el escritorio.


7. Zoom

MATE Terminal también permite modificar el tamaño de visualización del terminal.

Internamente existe incluso una opción:

--zoom=ZOOM

donde:

1.0 = tamaño normal

según la documentación de la aplicación. MMATEwiki+1

Esto es diferente de cambiar permanentemente la fuente del perfil.

Es útil, por ejemplo, para:

  • presentaciones;
  • trabajar temporalmente con una fuente grande;
  • leer logs;
  • reducir el tamaño para mostrar más información.

8. Directorio de trabajo

Puedes indicarle a MATE Terminal en qué directorio debe iniciar una terminal.

Por ejemplo:

mate-terminal --working-directory=/home/usuario/proyecto

Esto significa que el shell comenzará en:

/home/usuario/proyecto

en lugar del directorio predeterminado.

La opción está documentada oficialmente como:

--working-directory=DIRNAME

7. Zoom

MATE Terminal también permite modificar el tamaño de visualización del terminal.

1.0 = tamaño normal

según la documentación de la aplicación.

Es útil, por ejemplo, para:

  • presentaciones;
  • trabajar temporalmente con una fuente grande;
  • leer logs;
  • reducir el tamaño para mostrar más información.
MMATEwiki+1

Esto resulta muy útil para crear lanzadores específicos para proyectos.


9. Ejecutar comandos automáticamente

MATE Terminal puede utilizarse también para abrir una terminal y ejecutar un comando.

Por ejemplo:

mate-terminal --command="htop"

o utilizando:

mate-terminal -x htop

La interfaz de línea de comandos proporciona tanto --command/-e como --execute/-x. MMATEwiki

Esto permite crear lanzadores del tipo:

"Monitor del sistema"
        ↓
mate-terminal -x htop

o:

"Logs del servidor"
        ↓
mate-terminal -x tail -f /var/log/syslog

10. Control mediante línea de comandos

MATE Terminal tiene una interfaz de línea de comandos bastante completa.

Por ejemplo:

mate-terminal --help

muestra las opciones disponibles.

Hay opciones para:

  • crear ventanas;
  • crear pestañas; seleccionando "caracteres de un archivo"; útil para conexiones remotas puedes hacer
  • elegir perfiles;
  • definir títulos;
  • elegir directorios;
  • ejecutar comandos;
  • cambiar zoom;
  • mostrar/ocultar la barra de menú;
  • maximizar;
  • pantalla completa;
  • definir geometría;
  • seleccionar la pestaña activa.

La documentación oficial lista, por ejemplo: --window, --tab, --profile, --title, --working-directory, --zoom, --maximize y --full-screen. MMATEwiki


11. Ventanas

Además de pestañas, puedes trabajar con varias ventanas independientes:

┌───────────────┐       ┌───────────────┐
│ Terminal 1    │       │ Terminal 2    │
│               │       │               │
│ $ vim main.c  │       │ $ make        │
│               │       │               │
└───────────────┘       └───────────────┘

Puedes incluso controlar la geometría mediante:

mate-terminal --geometry=80x24

La sintaxis permite especificar columnas, filas y posición de la ventana. MMATEwiki+1


12. Pantalla completa

También puede funcionar en pantalla completa:

mate-terminal --full-screen

Esto resulta especialmente cómodo cuando trabajas con:

vim
tmux
htop
mc

o cualquier aplicación de terminal que necesite mucho espacio vertical/horizontal.

También existe:

mate-terminal --maximize

para iniciar la ventana maximizada. MMATEwiki


13. Copiar y pegar

MATE Terminal trabaja con el portapapeles del entorno gráfico y permite copiar texto seleccionado y pegarlo en la terminal.

Hay una peculiaridad importante en los terminales Linux:

Ctrl+C

normalmente no significa copiar.

En una terminal significa enviar una señal de interrupción al proceso.

Por eso, tradicionalmente, para copiar/pegar se utilizan:

Ctrl+Shift+C
Ctrl+Shift+V

Esto permite hacer cosas como:

sudo apt install paquete

copiar el comando desde un navegador y pegarlo en MATE Terminal.


14. Selección de texto

Cuando seleccionas texto dentro del terminal, MATE Terminal puede trabajar con él como texto normal.

Esto es importante porque la terminal no funciona como un editor de texto tradicional.

Por ejemplo, el contenido:

usuario@equipo:~/proyecto$ ls -la
total 32
drwxr-xr-x  4 usuario usuario 4096 ...

es generado por un proceso y mostrado por VTE.

Puedes seleccionar:

usuario@equipo:~/proyecto$ ls -la

y copiarlo.

No estás seleccionando "caracteres de un archivo"; estás seleccionando la representación gráfica del terminal.


15. Hipervínculos y URLs

MATE Terminal también puede reconocer direcciones URL y permitir interactuar con ellas.

Por ejemplo:

https://www.example.com

puede detectarse como una dirección y abrirse desde el terminal. MATE destaca explícitamente esta capacidad. MMATE

Esto es particularmente útil cuando un programa imprime:

Documentation:
https://...

o cuando una herramienta muestra un enlace para acceder a un servicio web.


16. Scrollback

La terminal necesita conservar una cantidad de texto anterior para que puedas desplazarte hacia arriba.

Por ejemplo:

┌──────────────────────────┐
│ línea 800                │
│ línea 801                │
│ línea 802                │
│ línea 803                │
│ línea 804                │
├──────────────────────────┤
│ $                        │
└──────────────────────────┘

Puedes subir y revisar lo que ocurrió anteriormente.

Esto es especialmente útil con:

make
gcc ...
apt ...
journalctl

etc.

La configuración del comportamiento de desplazamiento forma parte del sistema de perfiles.


17. Compatibilidad con programas de terminal

Aquí aparece otra ventaja importante de utilizar VTE.

Aplicaciones como:

vim
nano
less
top
htop
tmux
ssh
mc

no necesitan saber que estás utilizando MATE Terminal.

Ellas creen que están hablando con un terminal compatible con determinados estándares.

Por ejemplo:

vim
 │
 ├── stdin
 ├── stdout
 ├── stderr
 └── secuencias ANSI/VT
          ↓
         PTY
          ↓
         VTE
          ↓
    MATE Terminal

Eso es exactamente lo que hace posible que un programa de consola tenga colores, menús, cursor, movimiento por la pantalla, ventanas internas, etc.


18. ¿Qué es un PTY?

Esta parte es bastante interesante si quieres comprender MATE Terminal a nivel técnico.

PTY significa:

Pseudo-Terminal

Es un mecanismo del kernel que proporciona una pareja:

PTY master
PTY slave

Conceptualmente:

MATE Terminal
      │
      │ lee/escribe
      ▼
  PTY master
      │
      │
  PTY slave
      │
      ▼
    shell
      │
      ▼
   comandos

El shell piensa que está conectado a un terminal real.

Por eso, si ejecutas:

tty

puedes obtener algo como:

/dev/pts/0

En otra pestaña podrías obtener:

/dev/pts/1

Eso significa que cada sesión tiene su propio pseudo-terminal.


19. ¿Qué ocurre al abrir una nueva pestaña?

Supongamos:

mate-terminal

y después:

Ctrl+Shift+T

La nueva pestaña no es simplemente "otra vista" de la misma terminal.

Conceptualmente tienes:

Ventana
│
├── Pestaña A
│    ├── VTE
│    ├── PTY
│    └── shell A
│
└── Pestaña B
     ├── VTE
     ├── PTY
     └── shell B

Por eso puedes hacer:

Tab A → cd ~/proyecto
Tab B → cd /var/log

sin que una cambie el directorio de la otra.


20. Gestión de sesiones

MATE Terminal también tiene una cierta integración con la gestión de sesiones del escritorio.

El proyecto distingue entre:

Perfil

Define cómo debe comportarse y verse el terminal.

Sesión

Guarda información relacionada con las ventanas/pestañas abiertas y sus perfiles.

El README del proyecto explica precisamente esta separación entre Profiles y Session. GGitHub

Es importante no confundir esto con programas como tmux.

Por ejemplo:

MATE session management

y:

tmux

son cosas diferentes.

tmux está diseñado para mantener sesiones de terminal y procesos incluso después de desconectar el cliente, mientras que la gestión de sesiones de MATE Terminal pertenece al entorno gráfico y al estado de la aplicación.


21. Integración con MATE

MATE Terminal no es un terminal genérico elegido arbitrariamente para MATE: forma parte del conjunto de aplicaciones del escritorio.

El ecosistema MATE incluye, entre otras:

Caja       → administrador de archivos
Pluma      → editor de texto
Atril      → visor de documentos
Engrampa   → gestor de archivos comprimidos
MATE Terminal → terminal

MATE presenta oficialmente Terminal como su aplicación de emulación de terminal para acceder al shell Unix dentro del entorno MATE. MMATE

Esto permite que la aplicación siga la filosofía general de MATE:

Además de pestañas, puedes trabajar con varias ventanas independientes:

┌───────────────┐       ┌───────────────┐
│ Terminal 1    │       │ Terminal 2    │
│               │       │               │
│ $ vim main.c  │       │ $ make        │
│               │       │               │
└───────────────┘       └───────────────┘
mate-terminal --geometry=80x24
  • integración con GTK;
  • configuración coherente;
  • menús tradicionales;
  • perfiles;
  • integración con el escritorio;
  • bajo nivel de complejidad visual.

22. GTK

MATE Terminal es una aplicación basada en GTK.

Esto significa que la interfaz gráfica —ventanas, menús, diálogos, botones, etc.— se integra con el toolkit utilizado por MATE.

Pero nuevamente:

GTK
 ↓
interfaz gráfica

VTE
 ↓
emulación del terminal

PTY
 ↓
comunicación con el proceso

Shell
 ↓
interpretación de comandos

Son capas diferentes.


23. ¿Es un terminal "potente"?

Depende de qué entendamos por potente.

MATE Terminal está deliberadamente orientado a ser un terminal tradicional, sencillo y bien integrado, en lugar de intentar convertirse en una estación de trabajo llena de funciones adicionales.

Su conjunto principal de capacidades es:

  • múltiples ventanas;
  • múltiples pestañas;
  • perfiles;
  • personalización de colores;
  • fuentes;
  • transparencia;
  • zoom;
  • ejecución de comandos;
  • directorios de trabajo;
  • pantalla completa;
  • enlaces;
  • integración GTK/MATE;
  • compatibilidad mediante VTE;
  • opciones de línea de comandos.

La documentación oficial y el código del proyecto reflejan precisamente esa filosofía. MMATEwiki+1


24. Algo que NO hace MATE Terminal

Es importante distinguirlo de terminales modernos que incorporan funcionalidades adicionales.

MATE Terminal no pretende ser:

un IDE
un gestor SSH
un multiplexor
un shell
un editor
un administrador de servidores

Por ejemplo, para conexiones remotas puedes hacer:

ssh usuario@servidor

pero el soporte SSH lo proporciona:

OpenSSH

no MATE Terminal.

De igual manera:

tmux

es quien proporciona el multiplexado de sesiones.

Y:

bash

es quien interpreta los comandos.


25. Un ejemplo completo

Imagina que abres MATE Terminal y escribes:

ssh usuario@192.168.1.100

La arquitectura sería aproximadamente:

┌─────────────────────────────────────┐
│           MATE Terminal             │
│                                     │
│   ┌─────────────────────────────┐   │
│   │             VTE             │   │
│   │                             │   │
│   │ $ ssh usuario@192.168.1.100 │   │
│   │                             │   │
│   └──────────────┬──────────────┘   │
└──────────────────┼──────────────────┘
                   │
                  PTY
                   │
                 shell
                   │
                  ssh
                   │
              red / TCP
                   │
                   ▼
             servidor remoto

MATE Terminal se ocupa principalmente de presentar e interactuar con el terminal.

ssh se ocupa de la conexión.

El shell se ocupa de interpretar los comandos.

El kernel proporciona el PTY.

VTE se ocupa de la emulación.


26. Opciones interesantes de mate-terminal

Puedes explorar todas las opciones con:

mate-terminal --help-all

y específicamente:

mate-terminal --help-terminal
mate-terminal --help-window-options
mate-terminal --help-terminal-options

Entre las opciones oficiales encontramos:

--window
--tab
--profile=PROFILE-NAME
--title=TITLE
--working-directory=DIRNAME
--zoom=ZOOM
--maximize
--full-screen
--show-menubar
--hide-menubar
--geometry=GEOMETRY

además de las opciones para ejecutar comandos. MMATEwiki


27. Una característica interesante: títulos

Puedes establecer el título desde la línea de comandos:

mate-terminal --title="Servidor de producción"

Esto resulta muy práctico cuando tienes varias ventanas abiertas.

Puedes terminar teniendo:

┌──────────────────────┐
│ Servidor producción  │
└──────────────────────┘

┌──────────────────────┐
│ Desarrollo           │
└──────────────────────┘

┌──────────────────────┐
│ Logs                 │
└──────────────────────┘

Además, versiones recientes del proyecto han incorporado mejoras relacionadas con los títulos de las pestañas; por ejemplo, la rama 1.27.1 añadió la posibilidad de establecer el título mediante doble clic sobre la pestaña. GGitHub


28. Su relación con GNOME Terminal

MATE Terminal tiene un origen bastante claro:

GNOME Terminal
       │
       │ fork
       ▼
 MATE Terminal

El propio proyecto lo describe como un fork de GNOME Terminal. GGitHub

Esto es importante históricamente porque explica muchas semejanzas entre ambos.

Sin embargo, MATE Terminal está mantenido como parte del ecosistema MATE y está diseñado para integrarse con él.


29. MATE Terminal frente a otros terminales

Conceptualmente podríamos comparar:

Terminal
Filosofía

MATE Terminal
Tradicional, integrado con MATE

GNOME Terminal
Integrado con GNOME

Konsole
Integrado con KDE

XTerm
Minimalista y clásico

Alacritty
Orientado a rendimiento/renderizado moderno

Kitty
Muy avanzado y extensible

Tilix
Terminal GTK con enfoque en paneles/división

Terminator
Multiplexado visual de terminales

MATE Terminal destaca especialmente si quieres:

un terminal clásico, sencillo, configurable y perfectamente integrado con MATE.


30. En resumen: las capas

Si quieres quedarte con un modelo mental preciso, piensa en MATE Terminal así:

                         ESCRITORIO MATE
                              │
                              ▼
                       ┌─────────────┐
                       │ MATE Terminal│
                       │             │
                       │ ventanas    │
                       │ pestañas    │
                       │ perfiles    │
                       │ menús       │
                       │ preferencias│
                       └──────┬──────┘
                              │
                              ▼
                         ┌─────────┐
                         │   VTE   │
                         │         │
                         │ emula   │
                         │ terminal│
                         └────┬────┘
                              │
                              ▼
                         ┌─────────┐
                         │   PTY   │
                         └────┬────┘
                              │
                              ▼
                         ┌─────────┐
                         │  SHELL  │
                         │ bash    │
                         │ zsh     │
                         │ fish    │
                         └────┬────┘
                              │
                              ▼
                         PROGRAMAS
                    ls / vim / ssh / etc.

En una frase: MATE Terminal es la interfaz gráfica y gestor de sesiones/pestañas/perfiles que pone delante de VTE; VTE proporciona la emulación del terminal, y detrás de ella existe un PTY conectado a un shell que finalmente ejecuta tus comandos. Esa separación es la clave para comprender cómo funciona realmente. GGitHub+1

Si quieres profundizar técnicamente, el siguiente nivel interesante es analizar qué ocurre exactamente desde que pulsas una tecla hasta que aparece un carácter en pantalla, incluyendo PTY → termios → shell → ANSI escape sequences → VTE → GTK, porque ahí se entiende de verdad cómo funciona un terminal Linux por dentro.

Guía de MATE entorno de escritorio clásico y ligero: Monitor del sistema MATE.

El monitor del sistema mate permite visualizar y controlar los procesos que se ejecutan en el sistema. Se puede acceder a mapas de memoria detallados, enviar señales y finalizar los procesos.

Además, el monitor del sistema mate ofrece una visión general del uso de recursos del sistema, incluyendo la asignación de memoria y CPU, así como el uso de la red. También permite consultar información del sistema de archivos, como el dispositivo, el tipo, los puntos de montaje y el uso del disco.

La pestaña Sistema mostrará información básica sobre su sistema, como el nombre de host, el kernel, la versión de MATE, la memoria instalada y la información del procesador.

 

  1. ¿Qué es el Monitor del sistema MATE?

    El Monitor del sistema de MATE, cuyo programa es normalmente mate-system-monitor, es la herramienta gráfica de MATE para observar y administrar los procesos y recursos del sistema.

    Su función es bastante diferente de las aplicaciones que vimos antes:

    • Atril → visualQué aplicaciones están ralentiza documentos.
    • Engrampa → administra archivadores.
    • MATE Calculator → realiza cálculos.
    • Centro de Control MATE → configura el escritorio.
    • MATE System Monitorobserva qué está haciendo el sistema y qué recursos está utilizando.

    Es un programa especialmente útil para responder preguntas como:

    ¿Qué proceso está consumiendo toda la CPU?

    ¿Cuánta memoria RAM estoy utilizando?

    ¿Qué procesos están ejecutándose?

    ¿Qué aplicaciones están ralentizando el equipo?

    ¿Cuántos núcleos tiene mi procesador?

    ¿Cómo está evolucionando el consumo de CPU, RAM o swap?

    ¿Qué proceso necesito terminar?


    1. ¿Cómo funciona?

    La idea fundamental es que MATE System Monitor no genera por sí mismo los datos del sistema.

    El sistema operativo Linux ya mantiene información sobre:

    • procesos;
    • CPU;
    • memoria;
    • dispositivos;
    • carga;
    • interfaces de red;
    • almacenamiento;
    • etc.

    El Monitor del sistema consulta esa información y la transforma en una interfaz gráfica comprensible.

    Conceptualmente:

                        Linux / kernel
                             │
                ┌────────────┼─────────────┐
                │            │             │
                ▼            ▼             ▼
             procesos       CPU          memoria
                │            │             │
                └────────────┼─────────────┘
                             │
                             ▼
                    MATE System Monitor
                             │
                 ┌───────────┼───────────┐
                 ▼           ▼           ▼
              procesos     recursos    gráficos
    

    Por eso el programa puede considerarse principalmente un frontend gráfico de información que el sistema operativo ya proporciona.


    2. Su relación con /proc

    En Linux existe un sistema de archivos virtual llamado:

    /proc
    

    que expone información del kernel y de los procesos.

    Por ejemplo:

    /proc/cpuinfo
    /proc/meminfo
    /proc/loadavg
    /proc/<PID>/
    

    Un programa como MATE System Monitor puede obtener información del sistema a través de interfaces del kernel y bibliotecas especializadas que abstraen parte de esa información.

    Por ejemplo, conceptualmente:

    /proc
      │
      ├── CPU
      ├── memoria
      ├── procesos
      └── carga
           │
           ▼
    bibliotecas / APIs
           │
           ▼
    mate-system-monitor
           │
           ▼
    interfaz gráfica
    

    No significa que toda la información provenga literalmente de /proc; dependiendo de la versión y de la función, pueden intervenir otras interfaces del sistema.


    3. Arquitectura general

    Podemos representar la aplicación así:

    ┌─────────────────────────────────────────┐
    │          MATE System Monitor            │
    ├─────────────────────────────────────────┤
    │                                         │
    │  Procesos       Recursos       Sistema  │
    │     │               │             │     │
    │     ▼               ▼             ▼     │
    │   lista          gráficos       datos    │
    │     │               │             │     │
    └─────┼───────────────┼─────────────┼─────┘
          │               │             │
          └───────────────┼─────────────┘
                          ▼
                 APIs / bibliotecas
                          │
                          ▼
                      Linux kernel
    

    Esto es importante porque explica por qué el monitor puede escritorio mostrar información dinámica.

    No abre un archivo una sola vez y se queda con ese resultado.

    Hace algo conceptualmente parecido a:

    leer datos
       ↓
    calcular métricas
       ↓
    mostrar
       ↓
    esperar
       ↓
    volver a leer
       ↓
    actualizar
       ↓
    repetir
    

    4. Actualización periódica

    Los recursos del sistema cambian continuamente.

    Por ejemplo:

    09:30:01 → CPU 12 %
    09:30:02 → CPU 25 %
    09:30:03 → CPU 74 %
    09:30:04 → CPU 41 %
    

    El Monitor del sistema realiza periódicamente nuevas mediciones y actualiza la interfaz.

    Por eso los gráficos parecen "moverse".

    Podemos representarlo:

    t0 ── medir ── mostrar
           │
    t1 ── medir ── mostrar
           │
    t2 ── medir ── mostrar
           │
    t3 ── medir ── mostrar
           │
          ...
    

    La frecuencia exacta de actualización depende de la versión/configuración.


    5. Pestaña Procesos

    Una de las partes más importantes es la lista de procesos.

    Un proceso es, simplificando, una instancia de un programa que está siendo ejecutado por el sistema operativo.

    Por ejemplo:

    firefox
    caja
    mate-panel
    mate-system-monitor
    bash
    systemd
    

    pueden aparecer como procesos.

    La interfaz normalmente muestra información como:

    • nombre;
    • PID;
    • usuario;
    • porcentaje de CPU;
    • memoria;
    • estado;
    • prioridad;
    • tiempo de ejecución.

    6. ¿Qué es un PID?

    Cada proceso tiene un identificador numérico:

    PID = Process ID

    Por ejemplo:

    firefox
    PID 5231
    

    Otro:

    caja
    PID 4310
    

    El PID permite identificar inequívocamente un proceso mientras ese proceso exista.

    Desde terminal podemos ver algo equivalente mediante:

    ps
    

    o:

    ps aux
    

    MATE System Monitor simplemente presenta esta información de una forma gráfica y mucho más cómoda.


    7. CPU por proceso

    La columna de CPU permite saber qué procesos están consumiendo capacidad de procesamiento.

    Podemos encontrar algo como:

    Proceso              CPU
    --------------------------------
    Firefox              35 %
    Compilador           22 %
    Caja                  1 %
    Panel                 0 %
    

    Esto permite localizar rápidamente al responsable de una carga elevada.

    Pero hay un detalle importante:

    100 % de CPU no significa necesariamente que todo el procesador esté ocupado.

    Dependiendo de cómo se contabilice el uso, un proceso puede consumir aproximadamente un núcleo lógico completo.

    Por ejemplo, en un sistema con:

    8 CPU lógicas
    

    un proceso utilizando aproximadamente un núcleo puede aparecer cerca de:

    100 %
    

    mientras el sistema completo todavía tiene capacidad disponible.


    8. CPU total

    Además de los procesos individuales, el Monitor del sistema muestra el uso global del procesador.

    Por ejemplo:

    CPU
    100% ┤
     80% ┤          ████
     60% ┤      ████    ███
     40% ┤  ████
     20% ┤██
      0% └──────────────────
    

    Esto permite observar tendencias.

    Por ejemplo:

    CPU baja
       ↓
    abrir aplicación
       ↓
    CPU sube
       ↓
    aplicación termina de cargar
       ↓
    CPU baja
    

    9. Sistemas multinúcleo

    Los procesadores modernos tienen varios núcleos y/o hilos de ejecución.

    Por ejemplo:

    CPU
    ├── Core 0
    ├── Core 1
    ├── Core 2
    └── Core 3
    

    El Monitor del sistema puede mostrar información sobre el uso de CPU de acuerdo con las capacidades de la versión instalada.

    Esto permite detectar situaciones como:

    Core 0 → 100 %
    Core 1 → 5 %
    Core 2 → 4 %
    Core 3 → 3 %
    

    que indican una carga muy diferente de:

    Core 0 → 80 %
    Core 1 → 75 %
    Core 2 → 83 %
    Core 3 → 78 %
    

    10. Memoria RAM

    Otra de las funciones fundamentales es observar la memoria.

    El monitor puede representar:

    Memoria:
    ████████████░░░░░░░░
            60 %
    

    y mostrar valores como:

    • memoria utilizada;
    • memoria disponible;
    • memoria total;
    • swap.

    Esto ayuda a diagnosticar problemas de memoria.


    11. ¿Qué significa realmente "RAM usada"?

    Esta es una de las partes que más confunden a los usuarios de Linux.

    Supongamos:

    RAM total = 16 GB
    

    y el monitor muestra:

    12 GB utilizados
    

    Eso no significa necesariamente que 12 GB estén siendo utilizados exclusivamente por aplicaciones.

    Linux utiliza memoria libre como:

    • caché;
    • buffers;
    • estructuras internas;
    • páginas reutilizables.

    Por eso:

    RAM aparentemente ocupada
    

    no equivale automáticamente a:

    RAM agotada
    

    Una interpretación más útil suele considerar también la memoria disponible.


    12. Swap

    El swap es espacio utilizado por el sistema como respaldo de memoria virtual.

    Puede estar basado en:

    • una partición;
    • un archivo de swap.

    Conceptualmente:

    RAM
     │
     │ insuficiente / presión de memoria
     ▼
    swap
     │
     ▼
    almacenamiento
    

    El Monitor del sistema puede mostrar el uso de swap.

    Si observás:

    RAM → casi llena
    SWAP → aumentando constantemente
    

    puede indicar presión significativa de memoria.

    Pero utilizar algo de swap no significa automáticamente que exista un problema.


    13. Memoria virtual

    Cada proceso no trabaja simplemente con una pequeña región física de RAM.

    Linux proporciona a cada proceso un espacio de direcciones virtual.

    Conceptualmente:

    Proceso A
    ┌───────────────────────┐
    │ memoria virtual       │
    └───────────────────────┘
               │
               ▼
          memoria física
               │
          ┌────┴────┐
          ▼         ▼
          RAM      swap
    

    Por eso las cifras de memoria que aparecen para un proceso pueden tener significados diferentes:

    • memoria virtual;
    • memoria residente;
    • memoria compartida;
    • memoria privada.

    Esta es una de las razones por las que no conviene interpretar una única columna como "cantidad exacta de RAM que este programa está consumiendo".


    14. Procesos hijos

    Los programas pueden crear otros procesos.

    Por ejemplo:

    Firefox
      ├── proceso A
      ├── proceso B
      └── proceso C
    

    o:

    terminal
       └── bash
            └── programa
    

    El sistema operativo mantiene relaciones de:

    PPID
    

    es decir, Parent Process ID.

    El Monitor del sistema puede representar estas relaciones jerárquicamente, dependiendo del modo de visualización.

    Esto permite comprender mejor qué procesos pertenecen a qué aplicación.


    15. Estados de procesos

    Los procesos pueden encontrarse en diferentes estados.

    Conceptualmente:

    Running
    Sleeping
    Stopped
    Zombie
    
    Running

    El proceso está ejecutándose o listo para ejecutarse.

    Sleeping

    Está esperando algún evento.

    Esto no significa que esté consumiendo CPU continuamente.

    Stopped

    Su ejecución está detenida.

    Zombie

    El proceso ya terminó, pero su proceso padre todavía no ha recogido correctamente su estado de terminación.

    Los estados son parte del modelo de procesos de Linux.


    16. Terminar un proceso

    Una de las funciones más conocidas del Monitor del sistema es finalizar procesos.

    Por ejemplo:

    Firefox
    PID 5231
    

    podría seleccionarse y finalizarse.

    Pero internamente no se trata simplemente de:

    "borrar el programa".

    Se envía una señal al proceso.

    Conceptualmente:

    MATE System Monitor
            │
            ▼
        enviar señal
            │
            ▼
          PID 5231
            │
            ▼
          proceso
    

    Linux proporciona señales como:

    SIGTERM
    SIGKILL
    SIGSTOP
    SIGCONT
    

    entre muchas otras.


    17. Terminar vs matar

    Esta diferencia es importante.

    Una terminación normal puede solicitarse mediante:

    SIGTERM
    

    La idea es:

    "Por favor, terminá correctamente."

    El proceso puede:

    • cerrar archivos;
    • guardar información;
    • liberar recursos;
    • ejecutar rutinas de limpieza.

    En cambio:

    SIGKILL
    

    es mucho más contundente:

    "El kernel debe terminar este proceso."

    El proceso no puede capturar ni ignorar SIGKILL.

    Por eso, desde el punto de vista práctico:

    SIGTERM
       ↓
    primera opción
    

    y:

    SIGKILL
       ↓
    último recurso
    

    cuando una aplicación realmente no responde.


    18. Cambiar la prioridad

    Los procesos de Linux tienen prioridades asociadas a su planificación.

    Una herramienta gráfica puede permitir modificar la prioridad de determinados procesos mediante nice.

    Conceptualmente:

    proceso A → prioridad normal
    proceso B → prioridad baja
    proceso C → prioridad alta
    

    El valor nice modifica cómo el proceso compite por CPU.

    Por ejemplo:

    nice
    

    y:

    renice
    

    son herramientas tradicionales para esto.

    Hay que tener cuidado con aumentar la prioridad de procesos arbitrariamente, porque puede perjudicar al resto del sistema.


    19. Gráficos de recursos

    El Monitor del sistema no muestra únicamente números.

    Una de sus características más útiles es representar los datos como gráficos.

    Por ejemplo:

    CPU
    100% ┤       ╭─╮
     75% ┤   ╭───╯ ╰──╮
     50% ┤───╯        ╰──
     25% ┤
      0% └─────────────────
    

    Esto permite detectar rápidamente:

    • picos;
    • cargas sostenidas;
    • períodos de inactividad;
    • comportamiento periódico.

    Un número aislado:

    CPU = 82 %
    

    dice poco.

    Un gráfico:

    20 → 30 → 50 → 90 → 95 → 93 → 90 → 30 → 15
    

    cuenta una historia mucho más útil.


    20. Historial

    Los gráficos permiten observar una ventana temporal del comportamiento del sistema.

    Por ejemplo:

    CPU:
      ┌─────────────────────────┐
      │    /\       /\          │
      │___/  \_____/  \________ │
      └─────────────────────────┘
    

    Esto permite distinguir:

    Pico ocasional
    ______/‾‾\______
    

    de:

    Carga constante
    ████████████████
    

    y de:

    Carga periódica
    _/‾\_/‾\_/‾\_/‾\_
    

    Cada patrón puede tener causas diferentes.


    21. Red

    Dependiendo de la versión, configuración y distribución, MATE System Monitor puede mostrar estadísticas relacionadas con tráfico de red.

    Conceptualmente:

    Entrada
    ↓
    ██████████
    
    Salida
    ↑
    ████
    

    Esto permite observar:

    • datos recibidos;
    • datos enviados;
    • actividad de red.

    No debe confundirse con un analizador de paquetes.

    El Monitor del sistema no sustituye a Wireshark, tcpdump u otras herramientas de análisis de tráfico.

    Su objetivo es mostrar estadísticas generales de utilización.


    22. Discos y almacenamiento

    La aplicación puede proporcionar información relacionada con los recursos del sistema, pero nuevamente hay que distinguir entre:

    uso de almacenamiento
    

    y:

    actividad de E/S
    

    El almacenamiento puede tener:

    500 GB total
    350 GB utilizados
    150 GB libres
    

    mientras que la actividad de E/S puede ser:

    lectura → 50 MB/s
    escritura → 10 MB/s
    

    Son conceptos diferentes.

    Un sistema puede tener mucho espacio libre y, al mismo tiempo, estar realizando una gran cantidad de operaciones de disco.


    23. Información del sistema

    El Monitor del sistema puede proporcionar datos generales del equipo.

    Dependiendo de la versión puede incluir información sobre:

    • nombre del sistema;
    • versión del kernel;
    • hardware;
    • procesadores;
    • memoria;
    • almacenamiento;
    • versión del escritorio.

    Esto permite obtener rápidamente una fotografía del sistema.


    24. Carga del sistema

    Linux utiliza el concepto de load average.

    Puede verse mediante:

    uptime
    

    o:

    cat /proc/loadavg
    

    y normalmente se presentan tres valores:

    1 min
    5 min
    15 min
    

    Por ejemplo:

    0.20 0.35 0.40
    

    La carga representa, interpretación aproximada es que existe suficiente trabajo para mantener ocup utilizarlo como herramienta gráfica de diagnóstico sin abandonar el entorno monitor compara cuánto Su funcionamiento se basa en consultar periódicamente información proporcionada por Linux y transformarla en listas, estadísticas y gráficos compr simplificando, cuántas tareas están compitiendo o esperando determinados recursos de ejecución.

    No debe interpretarse directamente como:

    "CPU al 20 %"
    

    porque load average y porcentaje de CPU son métricas diferentes.


    25. Load average en un sistema multinúcleo

    Este detalle es muy importante.

    Supongamos que tenemos:

    8 CPU lógicas
    

    Una carga cercana a:

    8.0
    

    no significa necesariamente:

    800 % de CPU
    

    Una interpretación aproximada es que existe suficiente trabajo para mantener ocupadas unas ocho unidades de ejecución.

    Por eso la carga debe analizarse teniendo en cuenta la cantidad de CPUs disponibles.


    26. Procesos del sistema vs aplicaciones

    En la lista pueden aparecer procesos que el usuario no reconoce:

    systemd
    dbus-daemon
    udisksd
    gvfsd
    polkitd
    

    Esto es normal.

    Un escritorio Linux moderno está formado por muchos servicios pequeños.

    Por ejemplo:

    MATE
     │
     ├── panel
     ├── settings daemon
     ├── Caja
     ├── Marco
     ├── notificaciones
     ├── energía
     ├── D-Bus
     └── servicios del sistema
    

    El Monitor del sistema permite ver este ecosistema.


    27. D-Bus

    Muchas aplicaciones de escritorio Linux se comunican mediante D-Bus.

    Por ejemplo:

    Aplicación A
         │
         ▼
       D-Bus
         │
         ▼
    Servicio B
    

    Esto permite que distintos componentes se comuniquen sin tener que estar directamente acoplados.

    MATE System Monitor puede coexistir con este sistema, pero no debe confundirse con D-Bus.

    Es decir:

    MATE System Monitor
    

    observa y administra procesos.

    Mientras:

    D-Bus
    

    es un mecanismo de comunicación entre procesos.


    28. Biblioteca GTK

    MATE System Monitor utiliza las tecnologías gráficas del ecosistema MATE/GTK.

    Esto le proporciona:

    • ventanas GTK;
    • menús;
    • listas;
    • diálogos;
    • botones;
    • integración visual con MATE;
    • accesibilidad.

    Por eso visualmente encaja con el resto de aplicaciones del escritorio.


    29. Integración con MATE

    El programa está pensado específicamente para formar parte de MATE.

    La arquitectura puede verse:

                             MATE
                              │
           ┌──────────────────┼───────────────────┐
           │                  │                   │
          Caja              Marco              Panel
           │                  │                   │
           └──────────────────┼───────────────────┘
                              │
                              ▼
                      System Monitor
                              │
                              ▼
                        Linux system
    

    Esto permite utilizarlo como herramienta gráfica de diagnóstico sin abandonar el entorno.


    30. Diferencia con top

    En terminal podemos utilizar:

    top
    

    top muestra información dinámica sobre:

    • procesos;
    • CPU;
    • memoria;
    • carga.

    MATE System Monitor hace algo conceptualmente similar, pero proporciona una interfaz gráfica.

    Comparación:

    Característica
    MATE System Monitor
    top

    GUI

    Procesos

    CPU

    RAM

    Load average
    ✅*

    Terminar procesos

    Gráficos

    Cómodo para principiantes

    ⚠️

    Automatización
    limitada
    excelente

    Servidores sin GUI

    * Dependiendo de versión/interfaz.


    31. Diferencia con htop

    htop también es un monitor interactivo de procesos.

    Por ejemplo:

    htop
    ────────────────────────────
    CPU  ███████████░░
    MEM  ██████░░░░░░
    SWP  ░░░░░░░░░░░░
    

    MATE System Monitor:

    ┌─────────────────────────────┐
    │ MATE System Monitor         │
    ├─────────────────────────────┤
    │ Procesos                    │
    │ CPU                         │
    │ Memoria                     │
    │ Recursos                    │
    └─────────────────────────────┘
    

    La diferencia fundamental es:

    htop
    → herramienta de terminal
    
    MATE System Monitor
    → herramienta gráfica de escritorio
    

    32. ¿Es un antivirus?

    No.

    El Monitor del sistema no analiza archivos buscando malware.

    Puede mostrar:

    proceso sospechoso
    

    pero eso no significa que pueda determinar automáticamente:

    "esto es malware"
    

    Para seguridad existen otras herramientas.

    El monitor sirve para observar:

    qué está ejecutándose
    

    no para decidir automáticamente:

    qué es malicioso
    

    33. ¿Es un administrador de servicios?

    Tampoco.

    Un proceso puede estar relacionado con un servicio, pero:

    proceso
    

    y:

    servicio
    

    no son exactamente lo mismo.

    En sistemas modernos con systemd, la administración de servicios se realiza normalmente mediante:

    systemctl
    

    Por ejemplo:

    systemctl status nombre-servicio
    

    El Monitor del sistema observa principalmente procesos y recursos, mientras que systemctl administra unidades de systemd.


    34. ¿Puede sustituir a systemctl?

    No.

    Por ejemplo:

    systemctl start nginx
    systemctl stop nginx
    systemctl restart nginx
    

    son operaciones de administración de servicios.

    MATE System Monitor está orientado a:

    ver proceso
    ↓
    analizar consumo
    ↓
    terminarlo si corresponde
    

    No es un reemplazo completo de systemd.


    35. Administración de procesos

    La posibilidad de finalizar procesos es una de las características más delicadas.

    Imaginemos:

    Proceso:
    mi_programa
    PID:
    3456
    CPU:
    95 %
    

    Podés seleccionar el proceso.

    Pero hay que preguntarse:

    ¿Por qué consume 95 %?

    Puede ser:

    • una operación legítima;
    • una compilación;
    • procesamiento de vídeo;
    • cálculo científico;
    • una aplicación bloqueada;
    • un proceso del sistema.

    Por eso el monitor debe utilizarse primero como herramienta de diagnóstico, y después como herramienta de intervención.


    36. Árbol de procesos

    El árbol de procesos es particularmente útil para comprender relaciones entre programas.

    Por ejemplo:

    systemd
     ├── dbus
     ├── display manager
     └── sesión MATE
          ├── mate-panel
          ├── marco
          ├── caja
          ├── mate-settings-daemon
          └── aplicaciones
               ├── firefox
               └── atril
    

    Esto permite comprender que una aplicación gráfica no existe aislada.

    Forma parte de una jerarquía de procesos.


    37. Privilegios

    Un usuario normal puede observar gran cantidad de información.

    Pero ciertas operaciones administrativas pueden requerir privilegios.

    Por ejemplo:

    usuario
       │
       ├── ver sus procesos
       └── administrar sus procesos
    

    mientras:

    root
       │
       └── administrar prácticamente todos los procesos
    

    Esto depende de las políticas del sistema.

    Por eso puede ocurrir que algunas operaciones estén disponibles para un proceso y no para otro.


    38. Proceso y hilo

    Hay otra cuestión técnica interesante.

    Un proceso puede contener varios hilos (threads).

    Por ejemplo:

    Firefox
     │
     ├── thread 1
     ├── thread 2
     ├── thread 3
     └── thread 4
    

    Los hilos permiten ejecutar distintas partes de un programa de manera concurrente.

    Dependiendo de la vista y de la versión, el Monitor del sistema puede representar procesos de manera diferente y no necesariamente exponer todos los detalles de hilos como lo harían herramientas especializadas.

    Para análisis profundo:

    ps -eLf
    

    o:

    top -H
    

    pueden proporcionar más información.


    39. Consumo de CPU: cómo se calcula

    El porcentaje de CPU no es simplemente una propiedad fija del proceso.

    El monitor compara cuánto tiempo de CPU recibió un proceso durante un intervalo.

    Conceptualmente:

    t0
     ↓
    leer contador CPU
     ↓
    esperar
     ↓
    t1
     ↓
    leer contador nuevamente
     ↓
    calcular diferencia
    

    Si un proceso recibió mucho tiempo de CPU durante ese intervalo:

    uso CPU ↑
    

    Si recibió poco:

    uso CPU ↓
    

    Esto explica por qué el valor cambia continuamente.


    40. Consumo de memoria: instantánea

    La memoria se comporta de forma diferente.

    El sistema mantiene diferentes contadores y métricas, por lo que el monitor puede consultar:

    RAM total
    RAM libre
    RAM disponible
    memoria residente
    swap
    

    y convertirlos en:

    MB
    GB
    %
    

    Por eso una medición de memoria suele ser más parecida a una fotografía del estado actual que a una medición de actividad durante un intervalo.


    41. Diagnóstico de un equipo lento

    Una de las mejores aplicaciones prácticas del Monitor del sistema es diagnosticar lentitud.

    Un procedimiento razonable sería:

    Paso 1

    Mirar CPU:

    CPU → 95 %
    
    Paso 2

    Ordenar procesos por CPU.

    Encontrar:

    programa → 90 %
    
    Paso 3

    Observar memoria:

    RAM → 95 %
    SWAP → aumentando
    
    Paso 4

    Observar gráficos.

    Si la CPU está baja pero el equipo sigue lento, puede ser necesario investigar:

    • E/S de disco;
    • memoria;
    • procesos bloqueados;
    • almacenamiento;
    • red;
    • problemas del sistema.

    El monitor no necesariamente identifica la causa automáticamente, pero proporciona las primeras evidencias.


    42. Ejemplo práctico

    Supongamos que el equipo está muy lento.

    Abrimos MATE System Monitor:

    CPU      20 %
    RAM      45 %
    SWAP      0 %
    

    Entonces aparentemente:

    CPU → normal
    RAM → normal
    swap → normal
    

    Podríamos investigar otras causas.

    En cambio:

    CPU      100 %
    RAM       50 %
    SWAP       0 %
    

    y encontramos:

    ffmpeg → 98 %
    

    probablemente la explicación sea sencilla:

    ffmpeg está realizando procesamiento intensivo
    

    Otro caso:

    CPU      20 %
    RAM       99 %
    SWAP      80 %
    

    sugiere una situación completamente diferente:

    presión de memoria
    

    43. Consumo de recursos vs problema

    Es importante no interpretar automáticamente:

    CPU alta = problema
    

    Por ejemplo:

    compilación
    renderizado
    codificación de vídeo
    cálculo científico
    

    pueden utilizar:

    CPU → 100 %
    

    durante largos períodos de forma completamente normal.

    El problema es más probable cuando:

    CPU alta
    +
    sin una tarea que lo justifique
    +
    comportamiento anómalo
    

    El monitor ayuda a encontrar la diferencia.


    44. Ligereza

    MATE System Monitor está diseñado para ser relativamente sencillo y adecuado para un entorno de escritorio tradicional.

    Pero hay una paradoja interesante:

    Un monitor de sistema también consume recursos.

    Para funcionar tiene que:

    • leer información;
    • calcular estadísticas;
    • actualizar gráficos;
    • dibujar la interfaz.

    Por eso no debe utilizarse con una frecuencia de actualización absurdamente alta esperando que sea completamente "gratis".

    En condiciones normales, su consumo es pequeño comparado con las aplicaciones que suele monitorizar.


    45. Características principales

    Característica
    MATE System Monitor

    Lista de procesos

    PID

    Usuario del proceso

    CPU por proceso

    Memoria por proceso

    Estado del proceso

    Árbol de procesos

    Finalizar procesos

    Señales/procesos
    ✅*

    Prioridad/nice
    ✅*

    Gráfico CPU

    Gráfico memoria

    Swap

    Información del sistema

    Carga del sistema
    ✅*

    Red
    ✅*

    Disco/E/S
    depende de versión

    Interfaz GTK

    Integración MATE

    Administración de servicios systemd

    Antivirus

    Analizador de paquetes de red

    Monitorización remota avanzada

    * Algunas capacidades y columnas dependen de la versión instalada y de la distribución.


    46. Diferencia con herramientas especializadas

    MATE System Monitor es una herramienta generalista.

    Para un análisis profundo existen herramientas más especializadas:

    ps
    → fotografía de procesos
    
    top
    → monitorización interactiva
    
    htop
    → monitorización interactiva avanzada
    
    free
    → memoria
    
    vmstat
    → memoria/procesos/I/O
    
    iostat
    → almacenamiento/I/O
    
    ss
    → conexiones de red
    
    iotop
    → procesos que realizan I/O
    
    systemctl
    → servicios systemd
    

    MATE System Monitor intenta reunir una parte importante de esta información en una única interfaz gráfica.


    47. Cómo encaja con el resto de MATE

    Podemos situarlo dentro del ecosistema que venimos analizando:

                        ESCRITORIO MATE
                              │
          ┌───────────────────┼──────────────────┐
          │                   │                  │
          ▼                   ▼                  ▼
       Atril              Engrampa          Calculadora
     documentos          archivadores          cálculo
          │                   │                  │
          └───────────────────┼──────────────────┘
                              │
                        Centro de Control
                              │
                              ▼
                        configuración
                              │
                              ▼
                     Monitor del sistema
                              │
                              ▼
                        estado del SO
    

    Esto permite distinguir dos grandes grupos:

    Aplicaciones de trabajo
    Atril
    Engrampa
    Calculadora
    Caja
    Pluma
    
    Herramientas del propio entorno
    Centro de Control
    Monitor del sistema
    Settings Daemon
    Power Manager
    Marco
    Panel
    

    48. Arquitectura resumida

    Si queremos comprenderlo técnicamente en una sola imagen:

                             USUARIO
                                │
                                ▼
                   ┌─────────────────────────┐
                   │   MATE System Monitor   │
                   │      GTK / interfaz     │
                   └────────────┬────────────┘
                                │
                        consulta periódica
                                │
                  ┌─────────────┼──────────────┐
                  │             │              │
                  ▼             ▼              ▼
              procesos         CPU          memoria
                  │             │              │
                  └─────────────┼──────────────┘
                                │
                         APIs del sistema
                                │
                      ┌─────────┴─────────┐
                      │                   │
                      ▼                   ▼
                   /proc                kernel
                      │                   │
                      └─────────┬─────────┘
                                ▼
                          datos del SO
    

    Y cuando el usuario decide intervenir:

    Usuario
       │
       ▼
    selecciona proceso
       │
       ▼
    MATE System Monitor
       │
       ▼
    solicita operación
       │
       ▼
    kernel / APIs de procesos
       │
       ▼
    SIGTERM / SIGKILL / prioridad...
       │
       ▼
    proceso
    

    49. Lo más importante para entenderlo

    Hay tres conceptos que resumen prácticamente todo el programa:

    1. Observación
    ¿Qué está haciendo el sistema?
    
    2. Diagnóstico
    ¿Por qué está utilizando tantos recursos?
    
    3. Intervención
    ¿Qué proceso necesito detener o modificar?
    

    Por eso MATE System Monitor no es solamente un "administrador de tareas". Es una interfaz gráfica para observar el modelo de procesos y recursos de Linux y realizar determinadas operaciones sobre ellos.


    Resumen final

    MATE System Monitor (mate-system-monitor) es el monitor gráfico de procesos y recursos del entorno MATE. Su funcionamiento se basa en consultar periódicamente información proporcionada por Linux y transformarla en listas, estadísticas y gráficos comprensibles.

    Sus características principales son:

    • visualización de procesos;
    • PID y usuario;
    • consumo de CPU;
    • consumo de memoria;
    • estados de procesos;
    • jerarquía padre/hijo;
    • información general del sistema;
    • gráficos históricos de recursos;
    • memoria RAM y swap;
    • carga del sistema;
    • información de CPU;
    • determinadas estadísticas de red y E/S según versión;
    • finalización de procesos;
    • operaciones sobre procesos;
    • modificación de prioridad;
    • actualización dinámica;
    • interfaz gráfica GTK integrada con MATE.

    Y su arquitectura fundamental es:

                 MATE System Monitor
                          │
                          ▼
                 APIs del sistema
                          │
                 ┌────────┼────────┐
                 ▼        ▼        ▼
              procesos   CPU     memoria
                 │        │        │
                 └────────┼────────┘
                          ▼
                       Linux
                      / kernel
    

    La gran diferencia respecto del Centro de Control MATE que vimos antes es que el Centro de Control configura cómo funciona el escritorio, mientras que MATE System Monitor observa cómo está funcionando el sistema en ese momento y permite intervenir sobre determinados procesos.

    En términos de MATE:

    Centro de Control
         ↓
    "¿Cómo quiero que funcione MATE?"
    
    System Monitor
         ↓
    "¿Qué está haciendo Linux/MATE ahora mismo?"
    

    Y esa distinción es fundamental para entender la arquitectura completa del escritorio MATE.