Delonix vs Docker vs Podman
Comparação honesta, para decidir com que motor construir — não um argumento de venda.
O Delonix Engine é um motor de containers e microVMs daemonless, rootless-first, em Rust, com Kubernetes de raiz (CRI próprio). Em vários pontos concretos já vai mais longe que o Docker e o Podman rootless. Noutros, fica muito atrás. Esta página diz exactamente onde é onde — para uma pessoa a decidir o que instalar hoje, ou uma empresa a avaliar para produção.
Estado actual (2026-07): beta público, em hardening activo. Várias rondas de auditoria
ofensiva já correram sobre o núcleo de syscalls do motor (clone/mount/
namespaces, ~104 blocos unsafe), a fronteira rootless→root, o socket de controlo, e o
código mais recente (rede/cluster/manifesto) — todos os achados CRÍTICOS e ALTOS encontrados
já estão corrigidos, e os de maior severidade (os 6 HIGH originais + os
CRITICAL/HIGH de rondas seguintes) foram re-confirmados por uma auditoria adversarial
INDEPENDENTE genuína (2026-07-26) — um TOCTOU adicional real foi encontrado nessa ronda
(kubeconfig com uma janela de permissões antes do chmod) e já está corrigido também.
Continuam por fechar ~27 achados de severidade MÉDIA/BAIXA (documentados, sem exploit conhecido).
Não há indícios de execução remota de código a partir da rede — a fronteira rootless→root está
sólida e já foi testada por um 2.º par de olhos — mas por prudência, um projecto sem anos
de produção continua a merecer cautela em produção multi-tenant com dados sensíveis.
Detalhe completo, com ficheiro e linha de cada achado e o estado da correcção:
relatório
da auditoria original e
análise
de gaps com o histórico completo das rondas seguintes.
Decisão rápida
| Se precisas de… | Usa |
|---|---|
Correr um docker-compose.yml já existente |
Delonix — delonix compose up, suporte nativo (Compose Spec v2.x),
sem Docker instalado |
| Um pipeline de build com BuildKit completo (SSH forwarding, cross-compile paralelo) | Docker ou Podman — o Delonix faz multi-stage, --mount=type=secret/
type=cache e cache de camadas (rootless), mas não type=ssh nem
paralelismo de estágios |
| Cargas GPU/CUDA | Delonix via CDI funciona (mesma fonte que Docker/Podman) mas nunca foi validado num host GPU real — para produção GPU hoje, prefere Docker/Podman |
docker version/ps/images/info e o
ciclo de vida completo de um container via DOCKER_HOST |
Delonix — delonix serve docker-api, validado contra um
docker CLI real, incl. docker compose up apontado ao socket |
docker exec/attach interactivo via a API |
Docker ou Podman — deliberadamente fora de escopo (hijacking HTTP) |
| Bootstrap de um cluster Kubernetes real sem instalar Docker/containerd | Delonix — CRI próprio, já validado com um control-plane v1.34 Ready |
| Um só motor para containers e microVMs e Kubernetes | Delonix — ninguém no espaço Docker/Podman cobre isto junto |
| Trocar portas/volumes/redes de um container a quente, sem o recriar | Delonix — o Docker obriga a recriar |
Versionar a infra em git e ter um plan antes de aplicar, sem Terraform |
Delonix — stack plan/apply/destroy
convergem, com diff de 3 vias e sem ficheiro de estado. Nem o Docker nem o
Podman têm equivalente: o compose up dos dois recria o container para mudar um
campo, e nenhum dos dois te diz o que ia mudar antes de mudar |
| Um gate de deriva em CI (falhar o build se a máquina saiu do que o git declara) | Delonix — stack plan --detailed-exitcode, o contrato 0/2/1 do
terraform plan, num comando |
| Rede rootless avançada (overlay cifrado entre nós, firewall dirigido por container) | Delonix — acima do Podman rootless nestes pontos |
| Um motor com anos de produção, comunidade enorme, máxima compatibilidade de ferramentas | Docker ou Podman — ainda sem substituto à vista |
Comparação por área
forte · parcial ou com limitações · ausente
| Área | Docker | Podman | Delonix |
|---|---|---|---|
| Correr/parar/inspeccionar containers | forte | forte | forte — mais reconfiguração a quente e diagnóstico automático de crash (razão + snapshot do log, não só "Exited") |
| Rootless por omissão | não é o modo por omissão | forte, é a proposta do Podman | forte — e falha de propósito se o isolamento não ficar activo |
Build de imagens (Dockerfile) |
forte — multi-stage, BuildKit, cache | forte — via buildah | multi-stage + ARG/USER/ENTRYPOINT + --mount=type=secret/
type=cache + cache de camadas (rootless) já funcionam; sem type=ssh nem
paralelismo de estágios do BuildKit real |
docker compose / orquestração local |
nativo | podman-compose | nativo (delonix compose), sem Docker — depends_on
com healthcheck real |
IaC declarativo com plan antes do apply |
ausente | ausente | stack plan/apply/destroy: diff de
3 vias, convergência a quente sem mudar o PID, recusa fail-closed do que obriga a recriar, posse
por label, sem ficheiro de estado, e --detailed-exitcode como gate
de deriva. Schema gerado do código e estável |
API compatível com DOCKER_HOST |
é a própria | compatível | ciclo de vida completo do container (create/start/stop/kill/wait/
restart/rename/rm); sem exec/attach interactivo nem --restart |
| Rede rootless avançada (overlay inter-nó, firewall por-container) | overlay exige swarm | sem overlay rootless nativo | VXLAN+WireGuard rootless, firewall dirigido por container |
| Bootstrap de Kubernetes sem Docker/containerd | não é o papel do Docker | não tem CRI próprio | CRI próprio + cluster kubeadm, validado com cluster real |
| MicroVMs no mesmo motor | ausente | ausente | Cloud Hypervisor / libvirt, declarativo |
| GPU/CUDA | nvidia-container-toolkit maduro | idem | via CDI (a mesma fonte que Docker/Podman consomem), mas nunca validado num host GPU real |
| Assinatura de imagens + scan de CVE embutidos | precisa de cosign/trivy à parte | idem | cosign/sigstore + scan de CVE no próprio motor |
| Maturidade de segurança EM PRODUÇÃO (anos de uso adversarial real) | muito madura | muito madura | projecto novo — auditoria própria já encontrou e corrigiu falhas altas, ainda sem confirmação independente, ver aviso acima |
| Ecossistema (docs, fóruns, integrações de terceiros) | enorme | grande | início — este site + o repositório é tudo o que há por agora |
Onde o Delonix já vai mais longe
- Um motor só, três problemas — containers, microVMs e Kubernetes (via CRI
próprio) na mesma ferramenta. Já correu um control-plane Kubernetes v1.34 completo
Ready, com o própriokube-proxya programar netfilter dentro do modelo rootless. - Reconfiguração a quente — mudar portas, volumes, redes ou limite de banda de um container sem o recriar e com o mesmo PID. No Docker, mudar uma porta obriga a apagar e recriar o container.
- Diagnóstico automático de crash — quando um container morre inesperadamente, o Delonix regista a razão (processo desapareceu vs PID reciclado) e guarda um excerto do log automaticamente. Docker e Podman só dizem "Exited"/"Dead".
- Segurança rootless mais rígida por desenho — no-new-privs sempre activo, e o arranque de um container falha se seccomp/capabilities não ficarem mesmo a valer, em vez de seguir em frente a fingir que está protegido.
- Storage de rede estilo Kubernetes — uma pasta NFS/CIFS/WebDAV vira um volume
nomeado montável por qualquer container, como um
PersistentVolume. docker-compose.ymlnativo, sem Docker —delonix compose up/down/ps/logs, comdepends_ona esperar por um healthcheck real, não só por ordem declarada.
Onde ainda não chega
- Build de imagens ainda não tem BuildKit real — multi-stage,
ARG/--build-arg,USER/ENTRYPOINT,--mount=type=secret/type=cachee cache de camadas (rootless) já funcionam, mas semtype=sshnem paralelismo de estágios. - GPU nunca validado num host real — o caminho CDI existe e usa a mesma fonte que Docker/Podman consomem, mas sem um host com GPU não há confirmação ao vivo.
docker exec/attach interactivo via a API — deliberadamente fora de escopo (hijacking HTTP).compose: cobertura da spec ainda parcial — semprofiles/extends/configs/secretstop-level, multi-ficheiro,build.target,deploy.replicas != 1, IP fixo por rede, ou volumes anónimos.- Projecto novo — sem o histórico de produção que o Docker e o Podman têm; ver o aviso de segurança no topo desta página antes de decidir.
Recomendação por perfil
| Quem és | Sugestão |
|---|---|
| Programador(a) a experimentar em local/homelab, ou a fazer bootstrap de um cluster Kubernetes pequeno sem instalar Docker | Experimenta o Delonix hoje — é exactamente o caso em que já está forte. |
Equipa com um pipeline de build maduro que precisa de --mount=type=ssh ou
paralelismo de estágios |
Fica no Docker/Podman para esse build específico; podes correr as imagens resultantes no
Delonix se quiseres testar a operação — docker-compose.yml, multi-stage e
--mount=type=secret/type=cache já funcionam (rootless). |
| Empresa a avaliar para produção multi-tenant ou com dados sensíveis | Os achados de severidade CRÍTICA/ALTA já estão corrigidos e re-confirmados por uma auditoria independente (aviso acima); ainda faltam ~27 achados MÉDIO/BAIXO documentados (sem exploit conhecido) e o histórico de produção que só o tempo dá — acompanha o changelog. |
| Quer avaliar tecnicamente ao detalhe (gap-a-gap, com ficheiro e linha) | Lê a análise de gaps completa no repositório. |
Delonix vs Docker vs Podman
An honest comparison, to help you decide which engine to build on — not a sales pitch.
Delonix Engine is a daemonless, rootless-first container and microVM engine, in Rust, with Kubernetes built in from the ground up (its own CRI). On several concrete points it already goes further than Docker and rootless Podman. On others, it lags well behind. This page says exactly where is where — for someone deciding what to install today, or a company evaluating it for production.
Current status (2026-07): public beta, under active hardening. Several rounds of
offensive audit have already run over the engine's syscall core (clone/mount/
namespaces, ~104 unsafe blocks), the rootless→root boundary, the control socket, and the
most recent code (networking/cluster/manifest) — every CRITICAL and HIGH finding
is already fixed, and the highest-severity ones (the original 6 HIGH findings plus
the CRITICAL/HIGH ones from later rounds) were re-confirmed by a genuinely INDEPENDENT
adversarial audit (2026-07-26) — one additional real TOCTOU was found in that round
(a kubeconfig permissions window before chmod) and is already fixed too.
About 27 MEDIUM/LOW findings remain open (documented, no known exploit).
There's no sign of remote code execution from the network — the rootless→root boundary is
solid and has already been tested by a second pair of eyes — but out of caution, a project
without years of production history still deserves care in multi-tenant production with
sensitive data. Full detail, with the file and line of every finding and its fix status:
original audit
report and
gap
analysis with the full history of later rounds.
Quick decision
| If you need… | Use |
|---|---|
To run an existing docker-compose.yml |
Delonix — delonix compose up, native support (Compose Spec v2.x),
no Docker installed |
| A build pipeline with full BuildKit (SSH forwarding, parallel cross-compile) | Docker or Podman — Delonix does multi-stage, --mount=type=secret/
type=cache and layer caching (rootless), but not type=ssh or stage
parallelism |
| GPU/CUDA workloads | Delonix works via CDI (the same source as Docker/Podman) but has never been validated on a real GPU host — for GPU production today, prefer Docker/Podman |
docker version/ps/images/info and the
full lifecycle of a container via DOCKER_HOST |
Delonix — delonix serve docker-api, validated against a real
docker CLI, including docker compose up pointed at the socket |
Interactive docker exec/attach via the API |
Docker or Podman — deliberately out of scope (HTTP hijacking) |
| Bootstrapping a real Kubernetes cluster with no Docker/containerd installed | Delonix — own CRI, already validated with a Ready v1.34
control-plane |
| One engine for containers and microVMs and Kubernetes | Delonix — nobody in the Docker/Podman space covers this together |
| Swapping a container's ports/volumes/networks on the fly, with no recreate | Delonix — Docker forces a recreate |
Versioning infrastructure in git with a plan before you apply, without
Terraform |
Delonix — stack plan/apply/destroy
converge, with a three-way diff and no state file. Neither Docker nor Podman has
an equivalent: compose up recreates the container to change a field, and neither
tells you what would change before it changes |
| A drift gate in CI (fail the build when the machine left what git declares) | Delonix — stack plan --detailed-exitcode, the 0/2/1 contract of
terraform plan, in one command |
| Advanced rootless networking (encrypted inter-node overlay, per-container directed firewall) | Delonix — ahead of rootless Podman on these points |
| An engine with years of production use, a huge community, maximum tooling compatibility | Docker or Podman — still no substitute in sight |
Comparison by area
strong · partial or limited · absent
| Area | Docker | Podman | Delonix |
|---|---|---|---|
| Run/stop/inspect containers | strong | strong | strong — plus hot reconfiguration and automatic crash diagnosis (reason + log snapshot, not just "Exited") |
| Rootless by default | not the default mode | strong, it's Podman's whole pitch | strong — and fails on purpose if isolation doesn't actually come up |
Image builds (Dockerfile) |
strong — multi-stage, BuildKit, cache | strong — via buildah | multi-stage + ARG/USER/ENTRYPOINT + --mount=type=secret/
type=cache + layer cache (rootless) already work; no real BuildKit
type=ssh or stage parallelism |
docker compose / local orchestration |
native | podman-compose | native (delonix compose), no Docker — depends_on
with a real healthcheck |
Declarative IaC with a plan before the apply |
absent | absent | stack plan/apply/destroy:
three-way diff, hot convergence with the PID unchanged, a fail-closed refusal for anything needing
a recreate, ownership by label, no state file, and
--detailed-exitcode as a drift gate. Schema generated from the code, and
stable |
DOCKER_HOST-compatible API |
is the real thing | compatible | full container lifecycle (create/start/stop/kill/wait/
restart/rename/rm); no interactive exec/attach or --restart |
| Advanced rootless networking (inter-node overlay, per-container firewall) | overlay needs swarm | no native rootless overlay | rootless VXLAN+WireGuard, per-container directed firewall |
| Kubernetes bootstrap with no Docker/containerd | not Docker's job | no own CRI | own CRI + cluster kubeadm, validated with a real cluster |
| MicroVMs in the same engine | absent | absent | Cloud Hypervisor / libvirt, declarative |
| GPU/CUDA | mature nvidia-container-toolkit | same | via CDI (the same source Docker/Podman consume), but never validated on a real GPU host |
| Built-in image signing + CVE scan | needs separate cosign/trivy | same | cosign/sigstore + CVE scan in the engine itself |
| Security maturity IN PRODUCTION (years of real adversarial use) | very mature | very mature | new project — its own audit already found and fixed high-severity flaws, still no independent confirmation beyond what's noted above |
| Ecosystem (docs, forums, third-party integrations) | huge | large | early days — this site plus the repository is all there is for now |
Where Delonix already goes further
- One engine, three problems — containers, microVMs and Kubernetes (via its own
CRI) in the same tool. A full Kubernetes v1.34 control-plane has already run
Ready, withkube-proxyitself programming netfilter inside the rootless model. - Hot reconfiguration — changing a container's ports, volumes, networks or bandwidth limit without recreating it, same PID. On Docker, changing a port means deleting and recreating the container.
- Automatic crash diagnosis — when a container dies unexpectedly, Delonix records the reason (process disappeared vs. recycled PID) and automatically saves a log excerpt. Docker and Podman just say "Exited"/"Dead".
- Stricter rootless security by design — no-new-privs always on, and a container's start fails if seccomp/capabilities don't actually take effect, instead of proceeding while pretending to be protected.
- Kubernetes-style network storage — an NFS/CIFS/WebDAV folder becomes a named
volume any container can mount, like a
PersistentVolume. - Native
docker-compose.yml, no Docker —delonix compose up/down/ps/logs, withdepends_onwaiting for a real healthcheck, not just declared order.
Where it still falls short
- Image builds still have no real BuildKit — multi-stage,
ARG/--build-arg,USER/ENTRYPOINT,--mount=type=secret/type=cacheand layer caching (rootless) already work, but notype=sshor stage parallelism. - GPU never validated on a real host — the CDI path exists and uses the same source Docker/Podman consume, but with no GPU host there's no live confirmation.
- Interactive
docker exec/attach via the API — deliberately out of scope (HTTP hijacking). compose: spec coverage still partial — no top-levelprofiles/extends/configs/secrets, multi-file,build.target,deploy.replicas != 1, fixed per-network IP, or anonymous volumes.- New project — without the production track record Docker and Podman have; see the security notice at the top of this page before deciding.
Recommendation by profile
| Who you are | Suggestion |
|---|---|
| Developer experimenting locally/homelab, or bootstrapping a small Kubernetes cluster with no Docker install | Try Delonix today — it's exactly the case where it's already strong. |
Team with a mature build pipeline that needs --mount=type=ssh or stage
parallelism |
Stay on Docker/Podman for that specific build; you can run the resulting images on Delonix if
you want to test operations — docker-compose.yml, multi-stage and
--mount=type=secret/type=cache already work (rootless). |
| Company evaluating for multi-tenant production or with sensitive data | CRITICAL/HIGH severity findings are already fixed and re-confirmed by an independent audit (notice above); about 27 documented MEDIUM/LOW findings remain (no known exploit), plus the production track record only time can give — follow the changelog. |
| Wants to evaluate it technically in detail (gap by gap, with file and line) | Read the full gap analysis in the repository. |