Los vecinos de campo: Wails y Neutralino

Lo que comparten, y no es poco

Antes de las diferencias conviene fijar lo común, porque es la mayor parte:

• El motor lo pone la máquina. Instaladores de megabytes, actualizaciones de seguridad del motor a cargo del sistema, y tres motores distintos que hay que probar. Los tres tienen exactamente el mismo problema del nivel 3.3.
• El frontend es web. Cualquier framework que compile a ficheros estáticos, y la posibilidad de servir la misma interfaz en un navegador.
• La arquitectura es la misma. Un proceso con autoridad, una webview sin llaves, un canal de mensajes tipado por convención en medio.
• La accesibilidad se hereda del motor, que es una ventaja compartida y silenciosa.

Elegir dentro del campo, por tanto, no es elegir arquitectura. Es elegir con qué vas a escribir la mitad que no es interfaz, y qué te dan alrededor.

Las tres respuestas

Go frente a Rust, en la práctica

La comparación se suele plantear como una guerra de lenguajes y es más concreta que eso. En el contexto de un core de escritorio, las diferencias que se notan son cuatro:

El recolector de basura. Go lo tiene y Rust no. Para una aplicación de escritorio corriente esto casi nunca importa —las pausas del recolector de Go son de menos de un milisegundo desde hace años— pero importa en dos sitios: cuando el core procesa datos muy grandes de forma sostenida, y cuando el binario tiene que ser lo más pequeño posible.

El sistema de tipos en la frontera. Aquí Rust gana con claridad, y es el argumento serio. Un enum con variantes que llevan datos, un Result que obliga a tratar el error, un tipo que no se puede construir en un estado inválido: eso permite que la frontera con la webview esté modelada en tipos y no en documentación. El nivel 18 y el 19 viven enteros en esa ventaja.

El tiempo de compilación. Go compila muy rápido y Rust no. En un proyecto de escritorio de tamaño medio, esa diferencia se nota todos los días. Es un coste real y no conviene despreciarlo.

El ecosistema. Depende del dominio. Para red, servicios y herramientas de sistema, Go tiene una biblioteca estándar excepcional. Para procesamiento intensivo, criptografía, interoperabilidad con C y todo lo que roce el sistema a bajo nivel, el ecosistema de Rust es más profundo.

Neutralino, y por qué es coherente

Neutralino renuncia al core. En vez de un lenguaje al otro lado, ofrece un binario muy pequeño que expone un conjunto fijo de APIs —ficheros, procesos, ventana, sistema— por un WebSocket local protegido con un token. Tu aplicación es la web, y lo demás son llamadas.

Eso hace dos cosas interesantes. La primera, que el instalador es minúsculo de verdad, porque no hay un core que compilar. La segunda, que puedes poner lo que quieras al otro lado: si necesitas lógica pesada, lanzas un proceso escrito en el lenguaje que te dé la gana y hablas con él. Es una arquitectura honesta para herramientas pequeñas.

El precio es simétrico: sin core no hay tipos compartidos, no hay un modelo de permisos que declare nada, y el conjunto de APIs es el que es. Cuando lo que necesitas cae fuera, no hay extensión: hay otro proceso y otro protocolo que mantener.