~3 MB. Sin daemon.
7 capas de aislamiento.

Un binario.
Sin instalador. Sin servicio.

Coloca el binario en cualquier directorio del PATH y ejecuta. Sin servicio en background, sin unit de systemd, sin grupo privilegiado para --rootless.

# 1. Descarga binario, firma, checksum, y llave publica
curl -fsSL https://hull.getmentat.run/releases/hull-x86_64 -o hull
curl -fsSL https://hull.getmentat.run/releases/hull-x86_64.minisig -o hull-x86_64.minisig
curl -fsSL https://hull.getmentat.run/releases/SHA256SUMS -o SHA256SUMS

# 2. Compara SHA256
sha256sum -c SHA256SUMS --ignore-missing
# hull-x86_64: OK

# 3. Verifica firma minisign contra la llave publica del proyecto
minisign -Vm hull -P RWQLMHs2c5iiqJf3r7KPdMKdIOgDalrXqzEKI7ijt0DROB2ywop8pbxr
# Signature and comment signature verified

# Solo despues de que ambos checks pasan:
chmod +x hull && sudo mv hull /usr/local/bin/

Apps reales, perfil por defecto.
Sin aflojar seccomp.

Cada fila se valido end-to-end en una VM GCP limpia (Ubuntu 24.04) sin Mentat, sin Docker: descargar binario, hull pull, hull run, request al servicio, respuesta recibida. Cero syscalls deshabilitadas, cero contenedor privilegiado — las 7 capas de aislamiento activas.

De cero a corriendo
en tres comandos.

curl -fsSL https://hull.getmentat.run/install.sh | sh

# o manualmente:
curl -fsSL https://hull.getmentat.run/releases/hull-x86_64 -o /usr/local/bin/hull && chmod +x /usr/local/bin/hull
hull version

{
  "name": "myapp",
  "rootfs": "/var/lib/hull/rootfs/myapp",
  "argv": ["/app/server", "--port", "8080"],
  "env": ["PORT=8080", "NODE_ENV=production"],
  "profile": "default",
  "network": "bridge",
  "hostname": "myapp",
  "limits": { "memory_mb": 256, "cpu": 1.0, "pids": 128 }
}

hull run myapp.json

hull ps
# NAME     PID       UPTIME      ARGV
# myapp    42351     12          /app/server

hull exec myapp /bin/hostname
# myapp

hull inspect myapp
# Container: myapp
#   status:    running
#   pid:       42351
#   Cgroup:    memory 48/256M, cpu 1.0, pids 3/128
#   Namespaces: pid:[4026560304] net:[4026560239] mnt:[...] ...

hull stop myapp

Ocho comandos.
Cero archivos de configuracion.

Siete capas.
Cada una independiente.

La falla de una capa no deshabilita las otras. Un workload que escape seccomp aun impacta Landlock. Un workload que evada Landlock aun ve un arbol PID aislado y un /proc vacio.

Allowlists de syscalls curadas
por tipo de workload.

Bloqueados en todos los perfiles: ptrace, process_vm_readv, bpf, add_key/keyctl, userfaultfd, kexec_load, init_module. x86_64 y aarch64 soportados.

Pull. Run.
Sin Docker.

Las imagenes de Hull son tarballs de rootfs planos almacenados en un backend compatible con S3 (OxideStore). Sin capas, sin manifest lists, sin indices de plataforma. Un tarball por imagen, un comando para pull.

# Pull una imagen del registro de hull
hull pull hull.getmentat.run/node:22-slim
hull pull hull.getmentat.run/postgres:16
hull pull hull.getmentat.run/redis:7

# Ejecutar
hull run --manifest <(cat <<EOF
{
  "name": "mydb",
  "rootfs": "/var/lib/hull/rootfs/postgres-16",
  "argv": ["postgres", "-D", "/var/lib/postgresql/data"],
  "profile": "default",
  "network": "bridge",
  "limits": { "memory_mb": 512 }
}
EOF
)

Tres modos de red.

$ nsenter -t <pid> -n ip -br addr
lo               UNKNOWN        127.0.0.1/8
eth0@if36548     UP             10.88.0.2/24

$ nsenter -t <pid> -n ping -c 3 8.8.8.8
3 packets transmitted, 3 received, 0% packet loss
rtt min/avg/max = 0.256/0.389/0.523 ms

Hull tiene dos
acepciones en ingles.

Y las dos describen lo que hace el runtime.

Hull vs Docker vs runc

Un archivo JSON.
Tres campos requeridos.