El núcleo de Linux ha aprendido a hablar otro idioma, y en este caso es Lua. Lourival Vieira Neto publicó Lunatik 5.0 el 5 de octubre de 2026, con eBPF dentro de los scripts Lua y una revisión completa de cada módulo, según consta en la página oficial de la versión. La idea suena a ciencia ficción para quien no vive entre controladores. Escribir programas cortos en un lenguaje sencillo que se ejecutan dentro del propio corazón del sistema, allí donde normalmente solo entra código C compilado con sumo cuidado.
Para entender el salto hay que saber qué pinta cada pieza. El núcleo es el programa que manda sobre el hardware y decide qué paquete pasa, qué proceso corre y qué fichero se toca. eBPF es una tecnología que deja inyectar mini programas verificados en puntos calientes del núcleo sin recompilar nada. Lua es un lenguaje ligero famoso por meterse en videojuegos y routers. Lunatik los casa, porque permite gobernar esos ganchos del núcleo con scripts Lua legibles en lugar de C farragoso.
La versión llega con luces y sombras que conviene contar desde el arranque. Trae mapas eBPF, control de tráfico, planificación a medida y vigilancia de ficheros, todo desde script. Pero exige un núcleo moderno, rompe compatibilidad con scripts de la rama 4.4 y avisa de fallos conocidos que pueden colgar una CPU. Vamos a desmenuzarlo con calma, como se explica un motor potente antes de entregar las llaves.
¿Qué es Lunatik y por qué mete Lua en el kernel?
Lunatik es un conjunto de módulos del núcleo que incrusta un intérprete Lua adaptado para vivir allí dentro. Suena temerario, porque el núcleo no perdona errores y un puntero malo tumba la máquina entera. El proyecto lo resuelve con runtimes controlados, contextos de ejecución declarados y una revisión que en esta versión cierra cuelgues, fugas y llamadas que dormían donde estaba prohibido dormir.
La gracia está en la velocidad de iteración. Probar una idea en C del núcleo exige compilar, cargar el módulo y rezar ante cada pantallazo. Con Lunatik escribes un script de veinte líneas, lo cargas con su herramienta de terminal y observas qué pasa en vivo. Si algo falla, el error vuelve como mensaje en lugar de tumbar el equipo, salvo en los contextos más delicados donde la documentación pide prudencia extra.
Esta quinta versión mayor sube la apuesta con Lua en su edición 5.5.1. El lenguaje trae cadenas externas, tablas más compactas y un recolector incremental que recorta pausas. Son mejoras que importan el doble dentro del núcleo, donde cada microsegundo y cada kilobyte cuentan. El proyecto suma además una web con guía, referencia de cada módulo y API en C, algo que faltaba para tomarlo en serio fuera del laboratorio.
¿Qué trae de nuevo la versión 5.0?
El plato fuerte es la unión de eBPF con Lua. El módulo bpf abre mapas eBPF fijados con un constructor por cada tipo, y los presenta al script como tablas que se indexan, se asignan y se recorren, o como colas con operaciones de meter, sacar y ojear. En la práctica, tu script Lua comparte estado con programas eBPF a velocidad de núcleo. Es el puente que faltaba entre la comodidad del script y la potencia del verificador.
El control de tráfico abre otro frente vistoso. Con el módulo tc, un programa eBPF llama a Lua en las capas de entrada y salida de la pila de red. El ejemplo sniclassify clasifica el tráfico saliente por el nombre del servidor en el apretón de manos cifrado. Dicho en llano, tu script decide qué hacer con cada conexión según a dónde pretende ir, sin copiar paquetes al espacio de usuario.
La planificación a medida completa el trío de gala. Con el módulo scx, un programa de la extensión de planificador llama a Lua para decidir qué tarea corre en cada CPU. Cambiar el planificador era hasta hace poco territorio de parches heroicos al núcleo. Ahora se prueba con un script que se carga y se descarga en caliente.
¿Para qué sirve vigilar ficheros y red desde un script?
La vigilancia de ficheros llega con dos ejemplos que se entienden a la primera. El módulo fsnotify coloca marcas en ficheros, directorios y montajes, y entrega sus eventos a una función Lua, incluidos los eventos de permiso. El ejemplo fsmonitor registra qué cambia en un directorio, y execguard rechaza ejecutar cualquier programa cuyo nombre no figure en una lista permitida. Un guardián de ocho líneas defendiendo tu binario favorito.
La red programable desde script resuelve dolores clásicos de operadoras y laboratorios. El espacio netlink habla en Lua el protocolo genérico, las rutas con enlaces, direcciones y reglas, y el wifi con interfaces y puntos de acceso. El canal netlink emite eventos al espacio de usuario desde interrupción suave. Los ejemplos linkflap y netfailover reaccionan cuando un enlace cae y se levanta, conmutando rutas sin intervención humana.
El ejemplo dropreason responde a la pregunta que todo administrador se hizo alguna vez. ¿Por qué mueren mis paquetes? En lugar de cazar con capturas a ciegas, el script pregunta al propio núcleo el motivo de descarte de cada paquete. Para depurar redes es como pasar de adivinar a leer el informe del forense.
Eso significa que Lunatik brilla en observabilidad y reacción rápida. Detectar, clasificar y responder sin salir del núcleo recorta latencias que en espacio de usuario serían eternas. Y todo se escribe en un lenguaje que un estudiante aprende en una tarde, no en el C de núcleo que pide años de oficio.
¿Qué riesgos y límites debes conocer?
La potencia sin red de seguridad es un juguete roto. Los propios autores listan fallos conocidos que conviene leer antes de cargar nada en producción. Una función de planificador corre con el cerrojo de la cola de su CPU cogido, y allí imprimir por consola o completar ciertas operaciones puede colgar el procesador. La documentación de cada módulo marca los cinco primeros avisos, y el registro de cambios enlaza cada caso a su seguimiento público.
La compatibilidad también pide atención y una tarde de migración. Los scripts escritos para la rama 4.4 necesitan los cambios de API que detalla la versión, con decisiones de ganchos unificadas en el valor de retorno y cierres idempotentes con stop y close. Los booleanos posicionales desaparecen en favor de tablas de opciones, y varias familias del núcleo se reorganizan en tablas propias. No es un salto cosmético, porque la coherencia nueva exige retocar código viejo.
Los requisitos de plataforma cierran la puerta a equipos veteranos. Lunatik 5.0 pide Linux 6.6 o posterior y abandona la rama 5.x, deja fuera ARM de 32 bits por ayudantes de división ausentes y exige BTF del núcleo en marcha para los módulos de red. En núcleos 7.1 y posteriores, el módulo criptográfico solo carga si el núcleo compila un usuario del generador aleatorio. Y ojo con mezclar piezas, porque hay que descargar la versión anterior con su propia herramienta o reiniciar antes de instalar.
| Pieza |
Qué permite |
Precaución |
| Mapas eBPF |
Compartir estado entre eBPF y Lua |
Requiere BTF del núcleo en marcha |
| Control de tráfico |
Decidir por conexión en entrada y salida |
Un error toca todo tu tráfico |
| Planificador |
Probar políticas propias en caliente |
Puede colgar la CPU si bloquea |
| fsnotify y execguard |
Vigilar y permitir solo lo listado |
Define bien la lista antes de activar |
| Netlink en Lua |
Rutas y wifi desde script |
Cambios de red con efecto inmediato |
| Bytecode compilado |
Cargar código precompilado |
Compila con la misma configuración |
La lección es la de siempre con el núcleo, porque aquí los experimentos se hacen en máquina de pruebas. Una virtual con instantánea, un núcleo con kdump y scripts revisados línea a línea. La velocidad de iteración no exime de la disciplina, más bien la exige.
¿Cómo empezar a probarlo con cabeza?
El primer paso es comprobar el terreno antes de compilar nada. Confirma que tu núcleo es 6.6 o posterior, que tienes sus cabeceras y que el BTF está disponible si quieres jugar con red. Clona el repositorio, compila con la configuración de tu núcleo y carga el controlador con su herramienta. El fallo típico del novato es mezclar la herramienta nueva con el controlador viejo, y el sistema te lo dice con un mensaje claro de compilación distinta.
Después toca el hola mundo del núcleo con red de seguridad. Empieza por los ejemplos de solo lectura, como el que pregunta motivos de descarte o el que vigila un directorio de pruebas. Lee cada ejemplo entero antes de cargarlo, entiende qué gancho registra y cómo se detiene. Practica el ciclo completo de cargar, observar y detener hasta que salga sin mirar la chuleta.
Cuando domines el ciclo, sube un peldaño con los ejemplos activos. El guardián de ejecución sobre un directorio de juguete enseña más en diez minutos que cien páginas de teoría. El conmutador de enlaces en una máquina virtual con dos tarjetas muestra la reacción ante caídas sin romper nada real. Y la referencia del módulo netfilter explica cómo registrar ganchos de paquetes desde script cuando quieras filtrar de verdad.
Conviene matizar que este no es un juguete para servidores en producción sin red. Úsalo para aprender, para prototipar y para instrumentar, y deja que las ideas maduren en laboratorio antes de acercarse a máquinas que pagan nóminas. La comunidad del proyecto, con su seguimiento público de fallos y sus ejemplos comentados, es el mejor compañero de viaje para esa travesía.
Lo que Lunatik 5 dice del futuro del kernel
El fondo del anuncio apunta a una tendencia que va más allá de un proyecto. El núcleo Linux se vuelve programable por capas, con eBPF como autovía verificada y lenguajes de alto nivel al volante. Lunatik pone a Lua en ese volante con una propuesta radical, scripts legibles donde antes solo había C. Si la apuesta cuaja, depurar red, ensayar planificadores y vigilar sistemas se parecerá más a programar que a hacer cirugía.
Queda trabajo serio por delante, con fallos conocidos que pulir y arquitecturas por recuperar. Pero la dirección ilusiona a quienes viven entre paquetes y procesos. Este octubre de 2026, con la versión recién salida del horno, es el momento perfecto para montar un laboratorio y asomarse al núcleo sin miedo, con la prudencia que el anfitrión merece.
