El Viaje de una Tecla: Qué sucede cuando presionas "a" en Linux

Estás frente a tu terminal Linux. Presionas la tecla “a”. En menos de un parpadeo, esa letra aparece en tu pantalla. Pero, ¿qué ocurrió en ese instante? Acompáñame en este viaje por las capas de tu sistema.

Capa 1: El Hardware Habla

Todo comienza en tu teclado. Al presionar “a”:

1. Se cierra un circuito bajo la tecla
2. El controlador del teclado detecta la posición y genera un scancode (un número que identifica la tecla física)
3. Este código viaja por USB/PS2 hacia tu computadora

El scancode de “a” es 0x1E. No es la letra “a”, es solo “la tecla en esa posición fue presionada”.

Capa 2: La Interrupción

Tu CPU está ocupada ejecutando miles de tareas. ¿Cómo sabe que presionaste algo?

1. El controlador de teclado envía una interrupción de hardware (IRQ)
2. La CPU pausa lo que estaba haciendo
3. Consulta la tabla de interrupciones para saber qué hacer
4. Ejecuta el manejador de interrupciones del teclado

CPU trabajando → IRQ del teclado → Pausa → Maneja evento → Continúa

Capa 3: El Kernel Traduce

El kernel de Linux entra en acción:

1. Lee el scancode del puerto del teclado
2. Consulta el keymap (mapa de teclado) configurado
3. Traduce 0x1E → 'a' (o 'A' si Shift estaba presionado)
4. Coloca el carácter en un buffer de entrada

Scancode 0x1E + Keymap ES → 'a'

Capa 4: El TTY Recibe

Linux usa el subsistema TTY (TeleTYpewriter, herencia de los años 60):

1. El kernel envía 'a' al dispositivo TTY asociado a tu terminal (/dev/pts/0 por ejemplo)
2. El line discipline del TTY procesa el carácter
3. Por defecto, está en modo canónico: acumula caracteres hasta que presiones Enter
4. También maneja el echo: mostrar lo que escribes

Kernel → TTY (/dev/pts/0) → Line Discipline → Buffer de línea
                                           → Echo activado ✓

Capa 5: El Emulador de Terminal

Si usas una terminal gráfica (GNOME Terminal, Konsole, Alacritty):

1. El emulador lee del TTY esclavo
2. Recibe la 'a' que el kernel puso ahí
3. Actualiza su buffer interno de pantalla
4. Determina dónde dibujar (fila, columna del cursor)
5. Busca el glifo de “a” en la fuente configurada

Capa 6: El Renderizado

Finalmente, ver la letra en pantalla:

1. El emulador envía comandos al servidor gráfico (X11/Wayland)
2. Este actualiza el framebuffer de tu GPU
3. La GPU envía la señal a tu monitor
4. Los píxeles se iluminan formando la letra “a”

Terminal → X11/Wayland → GPU → Monitor → Tus ojos 👁️

El Diagrama Completo

┌─────────────┐
│   Teclado   │ ─── Scancode 0x1E ───┐
└─────────────┘                       │
                                      ▼
┌─────────────────────────────────────────────────┐
│                     KERNEL                       │
│  ┌───────────┐    ┌─────────┐    ┌───────────┐  │
│  │ IRQ Handler│ → │ Keymap  │ → │    TTY    │  │
│  │           │    │ 0x1E→'a'│    │  + Echo   │  │
│  └───────────┘    └─────────┘    └───────────┘  │
└─────────────────────────────────────────────────┘
                                      │
                                      ▼
┌─────────────────────────────────────────────────┐
│              ESPACIO DE USUARIO                  │
│  ┌─────────────┐    ┌──────────┐    ┌────────┐  │
│  │  Emulador   │ → │ X11/Way- │ → │  GPU   │  │
│  │  Terminal   │    │  land    │    │        │  │
│  └─────────────┘    └──────────┘    └────────┘  │
└─────────────────────────────────────────────────┘
                                      │
                                      ▼
                              ┌─────────────┐
                              │   Monitor   │
                              │     "a"     │
                              └─────────────┘

¿Cuánto tiempo toma?

Todo este proceso ocurre en 1-10 milisegundos típicamente. La mayor latencia suele estar en:

• El emulador de terminal (renderizado)
• La sincronización con el monitor (vsync)

Por eso terminales como Alacritty o Kitty (aceleradas por GPU) se sienten más “instantáneas”.

Conclusión

Una simple “a” atraviesa:

1. Hardware → circuitos y scancodes
2. Interrupciones → la CPU se entera
3. Kernel → traducción y TTY
4. Emulador → interpreta y dibuja
5. GPU → píxeles en pantalla

La próxima vez que escribas en tu terminal, recuerda: hay décadas de ingeniería trabajando para que esa letra aparezca en menos de lo que dura un parpadeo.

---

Este post es parte de la serie “El Viaje de la Información”, donde exploramos qué sucede realmente cuando interactuamos con nuestros sistemas.