Pake frente a Electron: cuánta app necesita tu web
Hay un momento muy concreto en el que nace esta historia: usas una web a diario —un panel interno, Excalidraw, el chat de turno— y quieres tenerla en el dock como una app de verdad. Con su icono, su ventana propia, su Alt+Tab. Sin que viva perdida entre cuarenta pestañas del navegador.
La respuesta clásica a ese deseo es Electron. La respuesta que llevo un tiempo mirando con simpatía es Pake, una herramienta escrita en Rust sobre Tauri que convierte cualquier URL en una app de escritorio en un comando. Antes de seguir, el aviso de honestidad de rigor: esto es análisis y unas cuantas pruebas ligeras, no meses de uso en producción. Las cifras que doy son las que anuncian los propios proyectos, no benchmarks míos.
La diferencia de fondo: llevar tu navegador o usar el que ya hay
Todo lo demás se deriva de una única decisión de diseño.
Electron empaqueta un Chromium completo y un runtime de Node.js dentro de cada aplicación. Cada app Electron que instalas es, literalmente, otro navegador más en tu disco, aunque ya tengas tres. Eso explica por qué un instalador de Electron arranca en decenas de megas antes de que hayas escrito una sola línea de tu aplicación: el peso base es el peso de un navegador moderno.
Pake (vía Tauri) no lleva navegador: usa el webview que el sistema operativo ya trae. WebView2 en Windows, WKWebView en macOS, WebKitGTK en Linux. El binario resultante solo contiene una capa fina en Rust que abre una ventana, carga tu web y añade detalles de app nativa. El README de Pake lo resume así: instalador «casi 20 veces menor que los paquetes de Electron, típicamente por debajo de 10 MB en disco», y menor consumo de memoria que los frameworks basados en JS (la versión actual del README, prudente, ya no fija cifras concretas de memoria). Tauri, por su parte, presume de que una app puede quedarse en unos 600 KB usando el renderer nativo del SO.
La contrapartida es igual de directa: si usas el webview del sistema, heredas el webview del sistema. Tres motores distintos, tres versiones distintas según lo actualizado que esté cada máquina, tres colecciones de peculiaridades de CSS y de APIs. Electron paga 100+ MB precisamente para no tener esta conversación: tu app corre sobre tu Chromium, con la versión exacta que tú probaste, en todas partes.
Qué es Pake exactamente
Pake es un proyecto de tw93 con más de 60.000 estrellas en GitHub. La experiencia de uso es deliberadamente mínima. Se instala el CLI (necesita Rust ≥ 1.85 y Node ≥ 22):
pnpm install -g pake-cli
# Y una web cualquiera pasa a ser una app:
pake https://github.com --name GitHub
Hay flags para lo esperable —icono, dimensiones, barra de título oculta— y algún detalle más fino:
pake https://weekly.tw93.fun --name Weekly \
--icon https://ejemplo.com/icono.icns \
--width 1200 --height 800 \
--hide-title-bar
También empaqueta un directorio local (pake ./dist --name MiHerramienta) y genera instaladores para macOS, Windows y Linux, añadiendo atajos de teclado, ventanas inmersivas, inyección de estilos y hasta eliminación de anuncios. En su galería hay decenas de webs ya empaquetadas: ChatGPT, YouTube Music, Excalidraw, Notion...
En mis pruebas —una tarde, no un despliegue— el flujo cumple: un comando, unos minutos de compilación de Rust la primera vez, y una app pequeña con la web dentro.
La tabla, con trampa incluida
| Pake | Electron | |
|---|---|---|
| Motor de render | Webview del sistema | Chromium embebido |
| Instalador | < 10 MB (según el proyecto) | Decenas o cientos de MB |
| Qué haces realmente | Envolver una web existente | Construir una app completa |
| Acceso al sistema | El que expone la capa Tauri/config | Node completo + módulos nativos |
| Comportamiento entre SO | Depende del webview de cada máquina | Idéntico: llevas tu propio motor |
| Curva de entrada | Un comando | Un proyecto |
La trampa está en la tercera fila, y llegaremos a ella.
Cuándo Pake es la respuesta obvia
- Ya existe la web y solo quieres la ventana. El caso fundacional: «quiero esta web como app en el dock sin gastar 200 MB». Pake resuelve exactamente eso y nada más.
- Herramientas internas. Ese panel que el equipo abre veinte veces al día gana mucho con icono y ventana propios, y empaquetarlo cuesta un comando, no un sprint.
- Distribuir un front estático como utilidad de escritorio. Un
./distde cualquier SPA se convierte en instalador multiplataforma sin montar un proyecto Electron con sumain.jsy su pipeline. - Cuando el disco y la RAM importan. Diez apps envueltas con Pake pesan menos que una app Electron mediana.
Cuándo Electron sigue ganando
Sería deshonesto vender que Electron está obsoleto. No lo está, y hay razones por las que VS Code, Slack u Obsidian siguen construidos sobre él.
- Acceso nativo profundo. Si tu app necesita hardware, módulos nativos de Node, procesos hijos o integración fina con el sistema, Electron te da un Node.js completo en el proceso principal. La capa de Pake, por diseño, expone muchísimo menos.
- Comportamiento idéntico en todas partes. Llevar tu propio Chromium significa que el bug que no reprodujiste en macOS tampoco aparecerá en el Windows del cliente. Con webviews del sistema, WKWebView y WebKitGTK van por detrás de Chromium en algunas APIs, y tu superficie de pruebas se multiplica.
- Ecosistema maduro. Auto-updates, firmado, crash reporting, tooling de empaquetado, años de respuestas en Stack Overflow. Cuando algo se rompe en Electron, alguien lo rompió antes que tú y lo documentó.
- La app es el producto. Si construyes un editor o algo que vive ocho horas al día en la pantalla del usuario, los megas del instalador son el precio menos importante de la lista.
Peras, manzanas y el término medio
Y aquí la trampa prometida: comparar Pake con Electron es comparar un envoltorio con un framework. Pake envuelve una web que ya existe; Electron (y Tauri) construyen aplicaciones. Poner sus tamaños de instalador en la misma frase es útil como titular y tramposo como análisis.
La matriz honesta tiene tres casillas. Con una web hecha y ganas de ventana, Pake. Si vas a construir una app nueva y quieres que sea ligera, el término medio es Tauri a secas: tu frontend, un backend en Rust, el webview del sistema y binarios diminutos, pero con un modelo de aplicación completo debajo. Y si necesitas profundidad nativa máxima y comportamiento clavado en todas las plataformas, Electron sigue siendo la respuesta aburrida y correcta.
La rima con este blog
Confesaré por qué Pake me cae bien antes incluso de entrar en méritos técnicos: su filosofía rima con la de esta casa. Este blog es Go, stdlib y ficheros Markdown, sin base de datos: usar lo que el sistema ya ofrece y añadir la capa mínima que falta. Pake aplica el mismo instinto al escritorio: el sistema operativo ya tiene un motor de render excelente, ¿por qué distribuir otro?
Y las servidumbres también riman. Yo renuncio a queries SQL a cambio de simplicidad; Pake renuncia al control total del motor a cambio de ligereza. Ninguna de las dos renuncias es gratis, y ambas son buenos tratos si tu problema es del tamaño adecuado.
Conclusión
La pregunta no es «¿Pake o Electron?» sino cuánta app necesita tu web. Mi respuesta corta tras estas pruebas: la mayoría de las webs que quiero en el dock necesitan muchísima menos app de la que Electron trae puesta. Para envolver, Pake; para construir ligero, Tauri; para construir grande y clavado en todas partes, Electron. Elegir el martillo pequeño cuando el clavo es pequeño no es una limitación: es criterio.