Rinux es un kernel nuevo, escrito en Rust y pensado para servidores, que ejecuta binarios de Linux ya compilados, tal cual, dentro de dominios: cada uno con su memoria, su CPU, su raíz y sus fallos. Cuando algo cae dentro de un dominio, el resto de la máquina no se entera.
Pulsa un dominio para provocarle un fallo: el kernel lo reinicia con la generación siguiente y los demás siguen. La sesión es real, copiada del puerto serial de la VM y de SSH.
transacciones confirmadas que siguen ahí después de cortar la energía con carga en curso
desde que entra el kernel hasta que está listo para trabajar
llamadas al sistema implementadas, cada una con su estado escrito
Rinux es el sistema operativo, no algo que corre encima de uno. Arranca directo en el servidor o en la VM de la nube, en lugar de Linux.
Debian 13, desde una imagen OCI verificada capa por capa con SHA-256, arranca con systemd en un dominio de Rinux. Por SSH, apt instala paquetes y curl habla HTTPS. Todo lo que hacen por debajo lo resuelve Rinux.
Un dominio no es un truco de espacios de nombres sobre un kernel compartido. Es un objeto del propio kernel, que posee sus recursos y responde por sus fallos.
Docker necesita un Linux debajo y sus contenedores comparten ese kernel. Aquí no hay Linux: Rinux toma imágenes de Docker tal cual y corre cada una en un dominio aislado por el propio kernel.
No hay un Linux invitado por cada carga. Un solo kernel aísla a todos los dominios, y arranca en 129 ms.
Debian, systemd, apt y sshd no saben que no están sobre Linux, porque Rinux habla su mismo idioma de llamadas al sistema.
Esta página y otros sitios propios corren en un nodo Rinux en Google Cloud. En la misma máquina corren el plano de control de Mentat, que decide qué carga va dónde, y Cóndor, el proxy que termina TLS y obtiene los certificados de Let's Encrypt. Cada sitio vive en su propio dominio.
Reset duro de la VM desde Google Cloud, con un sondeo cada medio segundo a cada dominio: seis volvieron a los 15 s y el más pesado, de 60 MB, a los 21 s. Los 463 ms son la mediana de 20 conexiones nuevas, con 148 ms de ida y vuelta hasta la nube.
Un kernel nuevo arranca una vez a prueba y, si el nodo no lo confirma, el cargador vuelve al anterior. Solo acepta imágenes firmadas.
Cada dominio abre solo los puertos y la salida que se le conceden. Una carga con salida a internet no alcanza el servidor de metadatos.
Una carga sale solo a los destinos que se le nombran; el kernel filtra también sus consultas DNS. Cada intento hacia otro lado se niega y llega como aviso al teléfono en segundos. En producción, una carga de prueba insistió seis veces en un minuto: quedó sin salida y siguió atendiendo. Ninguna carga del nodo tiene salida abierta a internet.
Tres fallas, cada una con su prueba: un segmento TCP retenido, un lock que hacía girar un hilo y un plano de control lento al reponer cargas.
Desplegamos nosotros una carga de prueba en el nodo de producción y la pusimos a actuar como un atacante que ya hubiera tomado una aplicación. Nadie entró de afuera: la carga es nuestra, y el punto era ver qué puede hacer desde su dominio. Intentó salir a internet, llegar al servidor de metadatos —donde están las llaves del nodo—, saltar a las otras cargas y hasta verlas. No pudo nada de eso.
La carga solo tenía permiso de salir a un destino. Intentó internet por IP y por nombre, el servidor de metadatos, la puerta de enlace, los puertos de las otras cargas y del plano de control, y leer sus datos: el kernel lo negó todo y contó cada intento; al sexto en un minuto, Mentat le quitó la salida mientras seguía atendiendo. Lo que probamos es que una carga ya tomada no se puede mover ni sacar nada. Cómo se toma una aplicación en primer lugar depende de cada aplicación, no del kernel: eso es otra prueba, no esta.
OxideStore, nuestro almacén compatible con S3, corre aquí como tres dominios con Raft entre ellos. Le copiamos 1.147 objetos desde tres máquinas virtuales con Linux. La copia encontró lo que las pruebas no habían encontrado: límites del kernel que solo aparecen con datos de verdad, cada uno arreglado y con su prueba.
para copiar los 7,8 GB con cuatro subidas en paralelo, con los mismos objetos y tamaños en los tres nodos
para escribir, releer y juntar 100 MiB en un disco de red, antes y después del arreglo
el límite de memoria de un nodo del almacén, subido y devuelto por Mentat sin reiniciarlo
El sistema de archivos pedía al disco 4 KiB por petición, y en un disco de red cada petición cuesta medio milisegundo. Ahora lee en una sola petición los bloques vecinos de un archivo. Cerrar una subida de 92 MiB pasó de 13 s a 3 s.
Reservar memoria ya no cuesta: cada página se cobra al dominio cuando se toca, y lo que un programa devuelve deja de contar. En reposo, cada nodo del almacén figura con 43 MB en vez de 92.
El kernel deja cambiar el límite de un dominio en marcha y cuenta cada vez que le niega memoria. Mentat lo mira cada 5 segundos: sube el límite de la carga que se acerca a él y lo devuelve cuando baja el uso.
Al detenerse suelta todo: su sistema de archivos en memoria y, desde este kernel, también la memoria compartida y los semáforos System V que nadie borró. Después del fuzzer, uno sin procesos seguía cobrando 55 MiB; ahora todos los dominios detenidos juntos suman menos de medio MiB.
Los procesos terminados quedaban anotados hasta que alguien listaba su dominio, y esa limpieza detenía al resto del nodo. Ahora cada proceso sale de la tabla al terminar: tras 2.000 que nacen y mueren quedan 2 entradas, no 2.002.
Cada arreglo pasó por las 40 pruebas en aarch64 y por un nodo Rinux x86_64 en Google Cloud antes de llegar aquí; los del disco, medidos con discos iguales a los de este nodo.
Una base de datos es la prueba más dura para un kernel: cada transacción confirmada espera un fsync, y ese dato tiene que estar ahí después de cualquier apagón. PostgreSQL 17 de Debian corre sin modificar en un dominio de Rinux, y le cortamos la energía en plena carga.
transacciones confirmadas que sobreviven al corte con carga en curso
transacciones por segundo con 50 clientes en Google Cloud, sin una sola fallida
por transacción con un cliente: casi todo es el fsync del disco
Con pgbench escribiendo, se confirman 200 transacciones marcadas y se apaga la VM sin aviso. Al volver, las 200 marcas están, los saldos cuadran y pg_amcheck no encuentra corrupción. En x86_64 y aarch64.
Se congela el proceso principal: el puerto sigue abierto pero nadie responde. La prueba de vida del kernel lo detecta y reinicia el dominio; vuelve con las 200 marcas en menos de un minuto.
Reset duro de la VM desde la consola de Google Cloud: 200 de 200 marcas, saldos cuadrados sobre casi 80.000 transacciones y pg_amcheck limpio.
Siete fallas del kernel, cada una con su prueba: memoria compartida System V, E/S vectorial, montajes apilados, red local por dominio y una lectura del disco que fallaba bajo carga.
n2-standard-2 con disco pd-balanced, pgbench escala 10: 133 tps con 1 cliente, unas 314 con 8 y 368 con 50.
Oracle es de lo más exigente que se le puede pedir a un kernel que no es Linux: un ejecutable de 434 MB, decenas de procesos que comparten memoria, hilos que se avisan con señales y un listener que revisa la red del nodo antes de aceptar a nadie. Oracle Free 26ai corre en un dominio de Rinux desde su imagen de contenedor, con su propio usuario, y abre la base.
filas escritas y leídas de vuelta por el listener, por TCP
desde que arranca el dominio hasta la base abierta, usada y cerrada en orden
de memoria en el momento de mayor uso, con un límite de 6,5
Arranca la máquina, espera a que Oracle abra la base, crea una tabla, inserta 1.000 filas a través del listener y las lee. Si el arranque falla, deja en la consola el registro de alertas de Oracle. Hoy corre en aarch64.
Cada proceso tenía su copia privada del programa, y uno de más de 256 MiB no arrancaba. Ahora sus páginas se toman de la caché del sistema de archivos y solo se copian las que el proceso escribe, como hace Linux.
Cada hilo nuevo de Oracle lee su propia entrada en /proc. Rinux respondía por procesos, no por hilos: el hilo se rendía y Oracle informaba que no podía crearlo. Fue la falla más difícil de ver.
El usuario de la imagen para el primer proceso, /dev/shm donde cualquiera puede escribir, señales que llevan un valor, las direcciones del nodo por netlink y por ioctl, y enviar varios mensajes en una sola llamada.
En la prueba, no en producción. De los 5,5 GiB, 2,9 son las capas de la imagen, que todavía se guardan en memoria: llevarlas a disco es lo que sigue.
Al terminar cada prueba, el kernel comprueba sus propias cuentas. Si una no cierra, la prueba falla aunque el programa de adentro haya terminado bien. Así cada carga real que corre sobre Rinux prueba también al kernel.
pruebas de arranque en aarch64 que terminan con el veredicto del kernel limpio
que un dominio detenido seguía cobrando: lo primero que encontró
corridas idénticas de un clúster de tres nodos en el kernel determinista
Recorre cada volumen entero y lo compara con su mapa de bloques: ninguno perdido, ninguno usado dos veces, cada nombre con su archivo. Que lo cobrado a los dominios no supere la memoria del nodo. Que cada proceso esté en el dominio al que pertenece.
Después del fuzzer, un dominio sin procesos conservaba la memoria compartida System V que nadie había borrado. Ahora la devuelve al terminar. El arreglo ya corre en el nodo que sirve esta página.
En el kernel determinista, la misma semilla tiene que dar la misma ejecución. Un clúster con systemd daba una traza antes de la hora en punto y otra después: el primer proceso de cada dominio leía el reloj de la máquina sin pasar por el kernel.
Con eso cerrado, 100 corridas con una semilla dieron la misma traza de 844.211 eventos. La mitad se hizo con el reloj de la máquina en fechas entre 2024 y 2032. Desde entonces cada prueba determinista se repite con otro reloj.
Antes de producción, siete pruebas y el fuzzer determinista corrieron en un nodo Rinux de Google Cloud: todas con el veredicto limpio, y dos arranques del mismo disco con la misma traza.
Rinux apunta a nodos a los que no se puede ir: la red parte cerrada y todo pasa por el plano de control. Un nodo así tiene que volver solo de lo que lo deje sin servicio.
desde que entra el kernel hasta que está listo para trabajar
hasta SSH en Debian, con PostgreSQL y el disco cifrado
de una falla a SSH otra vez: el dominio de Debian se reinicia entero, solo
Copy-on-write y registro de intención: un corte deja el último estado confirmado, nunca una mezcla.
Cada volumen con su propia llave, sellada en el TPM. Borrar un dominio destruye su llave.
Si el kernel nuevo no arranca bien dos veces, o se cae tres veces en 10 minutos, el cargador vuelve solo al anterior.
Una CPU 20 segundos atrapada en el kernel se detecta, deja el motivo en el log y reinicia el nodo.
Cada 10 segundos el kernel verifica que el servicio acepte conexiones. Uno colgado se reinicia; uno detenido a propósito, no.
El de hardware reinicia la VM si el kernel se congela; cada dominio tiene su propio /dev/watchdog para systemd.
Un segundo SSH en un dominio independiente responde cuando Debian no. fail2ban bloquea en el propio kernel.
Miles de conexiones a medias no dejan sin SSH al nodo: vencen, y la más vieja cede su lugar.
Cada dominio paga la memoria que usa, no la que reserva. Si se pasa de su límite muere solo el proceso que tocó la página de más; el resto del nodo no se entera.
Nada cuenta como hecho hasta que una prueba arranca Rinux en QEMU, en x86_64 y en aarch64, corre programas Linux reales dentro de un dominio y verifica el resultado desde adentro.
llamadas al sistema de Linux 6.12 en x86_64, cada una con su estado escrito
en aarch64, con la tabla de números propia de esa arquitectura
pruebas de arranque completo, en las dos arquitecturas
| Prueba | Qué verifica | Checks | x86_64 | aarch64 |
|---|---|---|---|---|
| boot | UEFI, sobre firmado, rinuxd en modo usuario, apagado | 1 | pasa | pasa |
| mm | frames, heap, paginación, fallos, scheduler, timer | 8 | pasa | pasa |
| elf-static | 64 procesos estáticos en 4 CPUs | 1 | pasa | pasa |
| domains | aislamiento de fallos, capabilities, límites de memoria y CPU | 8 | pasa | pasa |
| vfs | tmpfs, devfs, procfs, syscalls de archivos | 10 | pasa | pasa |
| proc | fork, execve, wait4, pipes, posix_spawn, /proc/self/exe | 17 | pasa | pasa |
| signals | manejadores, máscaras, marcos de señal de Linux | 11 | pasa | pasa |
| tty | terminales, pseudoterminales, control de trabajos | 11 | pasa | pasa |
| dynamic | BusyBox dinámico de Alpine como init | 15 | pasa | pasa |
| alpine | imagen OCI desde un disco virtio, digest alterado rechazado | 21 | pasa | pasa |
| threads | pthread, futex, copy-on-write, páginas perezosas, TLB, mremap, stack que crece | 15 | pasa | pasa |
| ipc | mmap compartido, FIFOs, permisos, memoria compartida y semáforos System V, E/S vectorial, AIO nativo | 18 | pasa | pasa |
| events | epoll, eventfd, timerfd, signalfd, temporizadores POSIX | 15 | pasa | pasa |
| sockets | AF_UNIX, paso de descriptores, credenciales, netlink | 12 | pasa | pasa |
| system | montajes apilados, opciones de tmpfs, sysfs, cgroup2, inotify | 15 | pasa | pasa |
| systemd | Debian 13 con systemd como init, journal, login, nombre del nodo, SSH solo con llave, memoria según el nodo, hora de inicio de los procesos, watchdog, avisos de licencia | 15 | pasa | pasa |
| net | virtio-net, DHCP, ARP, ICMP, TCP | 3 | pasa | pasa |
| inet | sockets TCP y UDP, red cerrada por defecto, DNS, netlink, entrantes, red local propia de cada dominio, salida solo a metadatos | 17 | pasa | pasa |
| gce | imagen de Google Cloud: PCI sin MCFG, virtio legacy, login, SSH y actualización real | 4 | pasa | no aplica |
| blkw | escritura en disco por virtio-blk, virtio-scsi y NVMe, verificada desde el host | 3 | pasa | pasa |
| rfs | sistema de archivos propio en disco, revisado desde el host al apagar | 9 | pasa | pasa |
| crypt-persist | volúmenes cifrados que sobreviven reinicios y se destruyen con su llave | 13 | pasa | pasa |
| tpm | llaves selladas en el TPM, en tres arranques | 11 | pasa | pasa |
| loader | cargador propio con ranuras A/B | 1 | pasa | pasa |
| update | actualización en caliente, firma, kernel que no arranca y vuelta atrás sola | 18 | pasa | pasa |
| load | 128 procesos escribiendo a la vez en un volumen cifrado | 2 | pasa | pasa |
| persist | Debian instalado en disco: lo cambiado sobrevive al reinicio | 27 | pasa | pasa |
| pg | PostgreSQL 17 con corte de energía en plena carga, y colgado a propósito | 15 | pasa | pasa |
| lockup | una CPU atrapada se detecta y el nodo se reinicia solo | 2 | pasa | pasa |
| unstable | un kernel que se cae tres veces vuelve solo al anterior | 13 | pasa | pasa |
| health | un servicio colgado se reinicia; uno sano o detenido no; watchdog de cada dominio | 6 | pasa | pasa |
| watchdog | el kernel entero congelado: el watchdog de hardware reinicia la máquina | 1 | pasa | pasa |
| syn | un escaneo de conexiones a medias no deja el puerto sin atender | 1 | pasa | pasa |
| keys | llaves SSH desde el servidor de metadatos, usuarios, cambios en caliente | 12 | pasa | pasa |
| hv | imagen para Proxmox y KVM: sin TPM lo explica; con TPM instala cifrado y vuelve a arrancar | 3 | pasa | pasa |
| sysfuzz | 144.000 llamadas al sistema con número y argumentos al azar desde una semilla: el kernel no entra en pánico ni se bloquea, y sigue atendiendo | 4 | pasa | pasa |
| sysfuzz-det | el mismo fuzzer en el kernel determinista: la misma semilla da la misma traza del kernel, llamada por llamada | 2 | pasa | pasa |
| oracle | Oracle Free 26ai desde su imagen de contenedor: abre la base, y 1.000 filas escritas y leídas por el listener | 1 | sin probar | pasa |
| cluster-det | tres nodos con systemd y un generador de carga en el kernel determinista: la misma semilla da la misma traza, con el reloj de la máquina en otra fecha | 2 | sin probar | pasa |
Rust no impide tocar el hardware; lo obliga a declararlo. En Rinux, todo lo que necesita unsafe (tablas de páginas, registros de dispositivos, DMA, cambio de contexto) está en un único crate con sus invariantes escritas. El resto del kernel tiene prohibido usarlo.
unsafe33.149 líneas en el kernel, con #![forbid(unsafe_code)]Programas Linux sin modificar, con musl o glibc, y rinuxd, el controlador del nodo. Corren en modo usuario.
ring 3 en x86_64, EL0 en aarch64Memoria virtual, scheduler multiprocesador, dominios y capabilities, sistema de archivos, sockets, red TCP/IP, señales y la personalidad Linux que traduce cada syscall.
ring 0 / EL1, sin unsafePaginación, interrupciones, contexto de CPU, MMIO y DMA, expuestos al kernel como tipos seguros.
el único crate con unsafeUEFI arranca una sola imagen, RINUX.EFI. El kernel descubre la máquina por ACPI y verifica la firma Ed25519 del sobre de arranque antes de ejecutar nada.
x86_64 y aarch64 desde la misma fuenteCuando un dominio se reinicia, su generación avanza y todo permiso viejo deja de servir.
Cuotas de CPU y memoria. Pasarse es un error del dominio, nunca del nodo.
Lo que no está permitido se niega con el error que Linux daría y queda en la traza.
Cada dominio tiene su localhost; ninguno alcanza la red local de otro.
Rinux arranca como el sistema operativo de la máquina virtual. Todavía no está publicado: el código y las imágenes salen con la primera versión, bajo licencia MPL-2.0.
Hoy en VMs n2-standard-2, con disco de arranque firmado y actualizaciones con vuelta atrás. C3, C4 y N4 necesitan el driver gVNIC, que viene.
Imagen lista: tres discos qcow2 y un TPM virtual, probada en x86_64 y aarch64.
En camino. AWS necesita el driver ENA; Azure, los dispositivos de Hyper-V.
La imagen no trae llaves ni contraseñas: las toma del servidor de metadatos.
Cada pieza corre en su propio dominio, con su propia autoridad, en el mismo nodo.