Vermell: framework C++ minimalista con epoll y cero deps

Vermell: un framework web C++ que cabe en un único header

Vermell es un framework web para C++ moderno que se instala con un único header y una biblioteca estática, sin dependencias externas. Su motor está construido sobre epoll, la interfaz de multiplexación de E/S de Linux, lo que le permite manejar miles de conexiones concurrentes con un footprint mínimo. En palabras de su documentación: «one header to include, one static library to link, and nothing else».

La propuesta contrasta con frameworks C++ más pesados como Crow, Drogon o Pistache, que suelen requerir dependencias adicionales (Boost, OpenSSL, JSON libraries externas) y ofrecen más abstracciones a costa de binarios más grandes. Vermell va en la dirección opuesta: cero dependencias, solo APIs nativas de Linux.

¿Qué problema resuelve para founders y equipos backend?

La mayoría de backends modernos se construyen en Node.js, Python (FastAPI), Go o Rust. C++ queda reservado para casos donde el rendimiento o el control de recursos son críticos: trading de alta frecuencia, infraestructura de juegos, gateways IoT o servicios de baja latencia. Vermell apunta exactamente a ese nicho:提供了一个 servicio HTTP de alto rendimiento con la simplicidad de un script.

👥 ¿Quieres ir más allá de la noticia?

En nuestra comunidad discutimos las tendencias, compartimos oportunidades y nos ayudamos entre emprendedores. Sin humo, solo acción.

👥 Unirme a la comunidad

Para un founder, las implicancias concretas son:

Costos de infraestructura más bajos: un binario C++ con epoll consume menos memoria y CPU que un servidor Node.js equivalente, lo que permite mover más tráfico por instancia.
Latencia predecible: sin garbage collector ni runtime intermedio, los tiempos de respuesta son consistentes — crítico para APIs en tiempo real.
Despliegue simple: un solo ejecutable estático que corre en cualquier Linux, desde una Raspberry Pi hasta un contenedor en la nube.

Características técnicas clave

Arquitectura event-driven con epoll

El motor de Vermell es un event loop no bloqueante basado en epoll que lee peticiones y delega el trabajo a un pool de worker threads. Esta separación entre el loop de E/S y los hilos de trabajo es lo que permite que el framework aguante cargas altas sin degradarse ante clientes lentos.

La protección contra Slowloris (ataque que envía bytes muy lentamente para agotar recursos) está integrada por defecto: los bytes se leen en el event loop no bloqueante, un cliente que envía 1 byte cada pocos segundos ocupa un fd de epoll — nunca un worker thread — y se descarta con 408 cuando supera el request_timeout.

Cero dependencias

Vermell solo usa APIs base de Linux: sockets, epoll, pthreads y fork/exec. Esto significa que el binario compilado no requiere DLLs compartidas ni librerías del sistema para funcionar más allá del estándar. En la práctica, el mismo binario corre en:

x86_64 (servidores, laptops)
ARM (aarch64, armv7)
Android vía Termux
WSL (Windows Subsystem for Linux)
Raspberry Pi
Contenedores Docker

macOS y Windows no son plataformas soportadas porque usan kqueue e IOCP en lugar de epoll.

Hardening por defecto

A diferencia de muchos frameworks donde la seguridad es opt-in, Vermell trae protecciones activas de fábrica:

Timeouts para lectura, escritura y petición completa
Caps en tamaño máximo de request y conexiones simultáneas
Render jail que impide servir archivos fuera del directorio configurado
Validación de Host header según RFC 9112 §3.2 para evitar request smuggling
ETag fuerte y conditional GET para caché eficiente

La configuración por defecto limita max_connections a 1024 para que un connection flood no agote la memoria.

API minimalista

Un servidor Vermell completo cabe en pocas líneas:

#include <vermell/vermell.h>
int main() {
    Router router;
    router.setPort(8080);
    router.get("/", { [](Query &http) {
        http.send("Hello from Vermell");
    }});
    router.listen();
}

La compilación es una sola línea: g++ -std=c++20 server.cpp -o exe -lvermell. No hay orden de linkado que recordar, ni flags adicionales.

Capacidades que importan para productizar

Routing HTTP completo

Vermell expone métodos de registro para cada verbo HTTP: get, post, put, deleteX (el X evita el conflicto con la keyword delete de C++), patch, head, options, link, unlink y purge. Las rutas estáticas se despachan en O(1) mediante un hash map, y las rutas con parámetros (:id) funcionan out-of-the-box.

Servidor de archivos estáticos con soporte SPA

El método staticX() monta un directorio del disco en un prefijo URL, equivalente al express.static de Node.js pero en C++. Soporta:

Fallback SPA para que Vue, React o Angular funcionen con deep links y refresh
Cache-Control configurable (default 30 días)
ETag fuerte con soporte para 304 Not Modified
Jail de directorio que rechaza escapes con .., symlinks y NUL bytes
GET/HEAD únicamente (otros métodos devuelven 404 genérico)

JSON nativo con tipado estricto

El módulo JSON incluido implementa un parser y serializer conforme a RFC 8259, con soporte para parámetros tipados, raw bodies y uploads multipart. No requiere librerías externas como nlohmann/json o RapidJSON.

Templates HTML con compose() y render()

Vermell incluye dos motores de templates integrados:

compose() ensambla páginas HTML a partir de módulos referenciados como #[header]; dentro del template
render() rellena placeholders [[variable]] mediante una callback dataRender

Ambos están endurecidos contra includes circulares (una página que se incluye a sí misma devuelve 413 en lugar de agotar memoria).

Configuración fluida

Toda la configuración vive en vermell::Config y se aplica con una sola llamada:

router.configure({
    .threads = 4,
    .read_timeout = std::chrono::seconds{30},
    .max_request_size = 16UL * 1024UL * 1024UL,
});

Los cambios de configuración (timeouts, límites, número de threads) se aplican en caliente sin reiniciar el servidor. Solo los parámetros de red (puerto, backlog, reuse_port) requieren restart.

Comparación con el ecosistema C++ actual

El estándar C++26, ratificado en marzo de 2026 según la cobertura de Herb Sutter recogida en Wikipedia, trajo mejoras importantes de memory safety que se obtienen simplemente recompilando código existente. Esa evolución del lenguaje refuerza el atractivo de frameworks C++ modernos como Vermell: ahora es posible escribir servidores de alto rendimiento con menos riesgos de seguridad.

Sin embargo, Vermell no compite con frameworks enterprise como Boost.Beast (que requiere Boost completo) ni con Drogon (que soporta HTTP/2 y WebSockets pero pesa más). Su sweet spot es el servicio HTTP minimalista donde cada megabyte de binario y cada milisegundo de latencia cuentan.

¿Qué significa esto para tu startup?

Si tu stack actual depende de Node.js, Python o Go para APIs internas, Vermell probablemente no sea para ti — esos lenguajes ofrecen productividad y ecosistema que C++ no iguala. Pero si estás en alguno de estos escenarios, vale la pena evaluarlo:

Acción 1: Identifica cuellos de botella de latencia o memoria

Revisa tus métricas de infraestructura. Si tienes microservicios que:

Procesan >10K requests/segundo por nodo
Consumen >500MB de RAM solo para servir HTTP
Necesitan p99 <10ms consistente

…entonces un rewrite en C++ con Vermell podría reducir tus costos de cloud entre 3x y 10x. Haz un benchmark con un endpoint representativo antes de comprometerte.

Acción 2: Evalúa si tu equipo tiene el perfil técnico

Vermell asume que tu equipo sabe C++ moderno (C++20 mínimo), entiende memory management y puede debuggear segfaults. Si vienes de un equipo full-stack JavaScript, la curva de aprendizaje es empinada. Considera Vermell solo si ya tienes al menos un ingeniero C++ senior en el equipo, o si el ahorro de infraestructura justifica una contratación.

Acción 3: Prototipa un servicio no crítico primero

Antes de poner Vermell en producción con tráfico real, levanta un servicio interno (panel admin, health check, webhook receiver) y mide:

Tiempo de build (debería ser segundos, no minutos)
Footprint de memoria bajo carga
Comportamiento ante clientes lentos y ataques Slowloris
Facilidad de debugging con gdb o valgrind

Si los números son buenos y el equipo se siente cómodo, escala a servicios más críticos.

Instalación y primeros pasos

Vermell ofrece tres vías de instalación:

Desde código fuente (recomendado para desarrollo):

git clone https://github.com/vermellcc/vermell.git
cd Vermell
cmake .
cmake --build .
sudo make install

Paquetes APT firmados (para producción en Debian/Ubuntu):

sudo install -d -m 0755 /etc/apt/keyrings
curl -fsSL https://vermellcc.github.io/vermell/vermell-apt-key.asc | sudo gpg --dearmor --yes -o /etc/apt/keyrings/vermell.gpg
echo "deb [signed-by=/etc/apt/keyrings/vermell.gpg] https://vermellcc.github.io/vermell stable main" | sudo tee /etc/apt/sources.list.d/vermell.list
sudo apt-get update
sudo apt-get install -y libvermell

Imagen Docker (para CI/CD y deployments):

docker pull vermellcc/vermell

La documentación completa en inglés y español está disponible en vermell.cc, con ejemplos para cada caso de uso (básicos, requests, responses, configuración, middlewares, graceful shutdown).