Spectra
Un cliente de escritorio nativo para el panel Spectra en Windows y Linux, escrito en C#/.NET. Un binario real con acceso al sistema, no un Chromium empaquetado. La misma vista que en la web, pero con rendimiento nativo e integración con el escritorio.
Un cliente de administración nativo para el hosting de servidores de juego Spectra en Windows y Linux, construido en C#/.NET sobre Avalonia. La misma vista que el panel web, pero como binario real conectado directamente al núcleo de la plataforma y a su enorme API frozcore/frozmod - con acceso al sistema, velocidad nativa y lógica compartida con el resto de Spectra, no reescrita una segunda vez.
Introducción
Spectra es una marca de hosting de servidores de juego para la que construimos todo el backend del panel. Este caso de estudio trata sobre una pieza, pero crucial, de ese rompecabezas: el cliente de escritorio nativo para administradores. No es una aplicación separada que vive junto al panel - es otra carcasa sobre el mismo núcleo, que dialoga con el mismo backend que la versión web. Para entender por qué fue un reto, primero hay que ver lo grande que es el sistema por debajo.
El cliente de escritorio no dibuja pantallas bonitas sobre el vacío. Se apoya en una plataforma completa: aprovisionamiento de servidores, gestión de potencia, archivos, bases de datos, telemetría, facturación y permisos. Nuestra tarea era dar al administrador una ventana nativa sobre todo eso - sin un navegador empaquetado y sin duplicar una lógica que ya vivía en el panel web.
Un panel en el que se pasa todo el día
Un administrador de servidores de juego no consulta el panel una vez a la semana. Lo tiene abierto durante ocho horas, junto a la consola, el cliente de juego y la mensajería. En ese modo una pestaña más del navegador no es una comodidad, es una quinta rueda: se pierde entre la multitud de pestañas, no tiene icono propio en la barra de tareas, ignora los atajos del sistema y no ve los archivos locales.
Queríamos dar la misma vista que la web, pero como aplicación que se comporta como el resto de los programas del escritorio. Una condición firme: nada de Chromium empaquetado. Un cliente que añade 200 MB de memoria al arrancar solo para mostrar exactamente lo mismo falla su objetivo antes incluso de terminar de iniciarse. Si el administrador va a pasar aquí la mayor parte del día, la aplicación debe ser ligera, instantánea y "de casa" en su sistema, no otra ventana del navegador que finge ser un programa.
En cifras
| Métrica | Valor |
|---|---|
| Sistemas desde una sola base de código | Windows y Linux |
| Huella de memoria típica | ~40 MB |
| Núcleo compartido con el panel web | uno |
| Vistas conectadas a la API | decenas |
Qué es realmente Spectra por debajo
El mayor malentendido en un proyecto como este es pensar que "solo es un panel". En realidad el panel es una fina capa sobre un backend que hace el trabajo pesado: arranca y detiene servidores de juego, asigna recursos, mantiene bases de datos, transmite logs y la consola en directo, y hace cumplir límites y facturación. Ese backend es la extensa API frozcore/frozmod - decenas de endpoints, eventos en tiempo real y un modelo de permisos que decide quién ve qué y qué puede hacer.
El cliente de escritorio tiene que dialogar con exactamente la misma API que el panel web. No hay una "versión de escritorio simplificada": si el administrador cambia el límite de memoria de un servidor o reinicia una instancia, lo hace a través del mismo contrato que usa la web. Por eso, antes de que existiera una sola pantalla, había que entender y domar la escala de esa API - y esa era la parte real del reto, no el aspecto de la ventana.
La consola y el flujo de logs funcionan en directo. No es una actualización cada pocos segundos, sino un flujo continuo de eventos desde el backend - el cliente de escritorio se suscribe a él igual que la web, de modo que el administrador ve la salida de un servidor en el mismo instante en que se produce.
Un núcleo, dos carcasas
La lógica de dominio - autorización, el modelo del servidor, comandos de encendido, el flujo de logs, el mapeo de permisos sobre esa API - vive en una sola biblioteca .NET. El panel web y el cliente de escritorio son dos carcasas sobre ese único núcleo, de modo que una corrección en una regla de permisos o en cómo se maneja un endpoint aterriza en ambos sitios a la vez. Toda una clase de errores "funciona en la web, roto en el escritorio" simplemente desaparece.
Avalonia dibuja la capa de vista. No es un webview - los controles se renderizan directamente a través de Skia, por el mismo camino en Windows y Linux, de modo que la aplicación se ve idéntica en ambos. De paso obtiene acceso real al sistema de archivos, al portapapeles y a las notificaciones que una página empaquetada nunca tuvo.
Stack
| Capa | Elección | Por qué así |
|---|---|---|
| Lenguaje y runtime | C# / .NET | un solo lenguaje para lógica y UI, buenas herramientas |
| Capa de vista | Avalonia (Skia) | renderizado nativo, idéntico en Windows y Linux |
| Núcleo de dominio | biblioteca .NET compartida | la misma lógica y el mismo cliente API que el panel web |
| Capa de red | cliente frozcore/frozmod tipado | un contrato, web y escritorio hablan lo mismo |
| Distribución | self-contained publish | un binario, sin instalación de runtime en el cliente |
Integración con una API gigantesca
Esta fue la parte más pesada. El backend de Spectra expone decenas de operaciones: ciclo de vida del servidor, consola, archivos, bases de datos, planificaciones de tareas, copias de seguridad, usuarios y permisos, telemetría de recursos. Para evitar que el cliente de escritorio se convirtiera en una maraña de llamadas, envolvimos toda la API en un único cliente tipado en el núcleo - con un solo lugar para autorización, reintentos y manejo de errores.
cada endpoint frozcore/frozmod detrás de una única interfaz, con autorización y reintentos en un solo lugar, para que ni la web ni el escritorio repitan esa lógica.
consola, logs y telemetría como suscripciones a eventos, no sondeo en un bucle; el mismo mecanismo que en el panel web.
lo que un administrador puede ver y hacer se deriva de las mismas reglas que en la web, calculadas en el núcleo y no "a ojo" en la UI.
las respuestas de la API aterrizan directamente en los controles nativos de Avalonia, sin un DOM de por medio.
Envolver toda la API en un solo cliente en el núcleo compensó por partida doble: un cambio de contrato en el lado del backend es una única corrección en la biblioteca, que la web y el escritorio reciben en el mismo commit. Cero deriva de versiones, cero "en mi máquina funciona".
Rendimiento y nativez
Dado que la condición de contorno era "nada de Chromium empaquetado", el rendimiento no era un añadido sino el objetivo. Avalonia dibuja la interfaz directamente, sin motor de navegador dentro, de modo que un binario con el panel completo pesa una fracción de lo que pesaría la misma vista en Electron, y arranca en una fracción de segundo.
Huella de memoria al arranque (orientativa, MB)
A eso se suma todo lo que un navegador nunca dio: acceso real al sistema de archivos (señalas los archivos del servidor directamente desde el disco, sin subirlos primero a un navegador), atajos del sistema, notificaciones nativas y un icono en la barra de tareas. Para alguien que está en el panel todo el día, eso no es cosmética sino un ahorro de tiempo diario.
Cómo conectamos todo
Con un núcleo que contiene el cliente API y una carcasa sobre Avalonia, el conjunto se ensamblaba de forma repetible. Lo clave era que una sola fuente produjera dos binarios autónomos, realmente probados en ambos sistemas, y no solo que compilaran para ambos.
autorización, el modelo del servidor, comandos y el cliente API se separaron de la vista web y se trasladaron a una biblioteca aparte que no sabe nada de quién la dibuja.
el mismo diseño de pantallas que la web, pero en controles nativos, conectada al núcleo mediante llamadas simples, no mediante HTTP a sí misma.
publish a win-x64 y linux-x64 desde la misma fuente, cada uno como binario autónomo.
lo mismo ejecutado de verdad en Windows y en Linux, conectado al backend real, y no solo compilando para ambos.
Cuál es el resultado final de la colaboración
El administrador obtiene un programa que arranca en una fracción de segundo, se mantiene en la barra de tareas como cualquier otra aplicación y muestra exactamente los datos del panel web - porque por debajo es el mismo código y la misma API. Los atajos del sistema funcionan, los archivos del disco se pueden elegir sin subirlos primero a un navegador, la consola y los logs corren en directo, y la ventana no se pierde en una maraña de pestañas. En lugar de una "página en una ventana", el administrador obtiene una herramienta que se siente parte de su sistema.
Del lado de Spectra la ganancia es igual de concreta y duradera. Una sola lógica y un solo cliente API en lugar de dos mantenidos a mano en concordancia significan que desarrollar la plataforma no se multiplica por el número de carcasas. Una nueva regla de permisos, un nuevo endpoint en el backend o un cambio en el modelo del servidor aterriza en web y escritorio en el mismo commit. Toda una clase de errores de sincronización desaparece, y el cliente de escritorio deja de ser un proyecto aparte que mantener.
Lo más importante, sin embargo, es que el escritorio no es una "versión ligera". Dialoga con la misma API frozcore/frozmod completa que el panel web, de modo que el administrador nunca tiene que volver al navegador por una función que le faltara a la aplicación - porque no le faltaba ninguna. Esa es la diferencia entre una página empaquetada y un cliente de plataforma nativo real: este último crece con el backend en lugar de arrastrarse detrás de él.
Más proyectos
Más trabajos de la misma categoría - mira cómo abordamos retos parecidos.
¿Tiene un proyecto similar?
Escríbenos - el presupuesto es gratuito y llega en una hora.



