Jogos retro na nuvem: RetroArch num servidor com GPU, transmitido com Sunshine e Moonlight
A sua coleção de jogos retro num só lugar, jogável a partir do seu portátil, do seu telemóvel ou da sua televisão, com os mesmos jogos guardados em todo o lado: é isso que um pequeno servidor na nuvem com GPU lhe dá. Instalámos o RetroArch num servidor Linux com uma Intel UHD 770 e sem monitor, e transmitimo-lo com o Sunshine (no servidor) para o Moonlight (do lado do jogador). A GPU faz dois trabalhos: desenha a imagem, incluindo os shaders CRT que dão aos jogos antigos o aspeto que tinham numa televisão de tubo, e codifica o fluxo de vídeo.
Use os seus próprios jogos, obtidos legalmente. Para este teste usámos apenas jogos homebrew gratuitos, descarregados das páginas oficiais dos seus autores: Tobu Tobu Girl (Game Boy, da Tangram Games, lançado gratuitamente com o código-fonte) e µCity (Game Boy Color, código aberto). Muitos autores publicam assim jogos novos para consolas antigas, e também pode copiar os seus próprios cartuchos e discos com um dumper.
Resultados em resumo
- A emulação não é o problema: com o V-Sync desligado, o RetroArch correu um jogo de Game Boy a 1.863 fps e um de Game Boy Color a 1.807 fps em 1080p, cerca de 30 vezes a velocidade da consola.
- É nos shaders CRT que a GPU conta: com o crt-royale, um dos shaders CRT mais pesados, o RetroArch ainda desenhava cerca de 255 fps em 1080p, quatro vezes o necessário.
- Transmitir custa pouco: H.264 1080p 60 fps codificado pela GPU, 4,6 a 6,5 ms de processamento no servidor em média durante o jogo (com ou sem shader), nenhuma imagem perdida, e apenas 13 a 17% de um núcleo de CPU para o Sunshine.
- O iGPU Start chega para consolas de 8 e 16 bits; escolha o iGPU Power se também joga sistemas mais pesados ou quer mais margem quando outros servidores usam a GPU.
Configuração do teste
| Elemento | Valor |
|---|---|
| Servidor | Debian 13, Linux 7.3, Intel UHD 770 (GPU partilhada), 4 vCPU, 8 GB de RAM, sem monitor |
| Emulador | RetroArch 1.20.0 (pacotes Debian), núcleos Gambatte (Game Boy) e mGBA (Game Boy Color) |
| Shaders | coleção glsl-shaders da libretro (crt-royale, crt-lottes), controlador de vídeo OpenGL |
| Ecrã | sway headless (Wayland) em 1920×1080, desenhado pela GPU |
| Streaming | Sunshine 2026.914 no servidor, Moonlight 6.2 num cliente Linux, H.264 1080p 60 fps, descodificação por hardware |
| Rede | cliente e servidor no mesmo centro de dados: pela Internet, some a latência da sua ligação |
1. Um ecrã para um servidor que não tem nenhum
Um servidor na nuvem não tem monitor, por isso damos-lhe um virtual. Usámos o sway, um pequeno
ambiente de trabalho Wayland, em modo «headless»: cria um ecrã de 1920×1080 em memória e desenha-o com a
GPU Intel. O RetroArch corre nele em ecrã inteiro, e o Sunshine captura-o diretamente (capture = wlr)
e codifica-o na GPU (encoder = vaapi):
# ~/.config/sunshine/sunshine.conf
capture = wlr
encoder = vaapi
adapter_name = /dev/dri/renderD128O Sunshine encontra então os codificadores por hardware (h264_vaapi, hevc_vaapi). O streaming em
AV1 não está disponível nesta GPU: use H.264 ou HEVC no Moonlight. Evite o Xvfb, o «ecrã virtual»
habitual para X11: desenha tudo com o CPU, e a GPU não seria usada para os shaders.
2. A que velocidade corre a emulação?
Para medir o que o servidor consegue fazer, desligámos o V-Sync e a sincronização de áudio, e pedimos ao RetroArch que corresse um número fixo de imagens o mais depressa possível, em ecrã inteiro em 1080p. Cronometrámos 600 e 3.600 imagens e dividimos a diferença, para que o tempo de arranque (carregamento, compilação dos shaders) não conte.
| RetroArch, 1080p, V-Sync desligado | Sem shader | crt-royale | crt-lottes |
|---|---|---|---|
| Game Boy, Tobu Tobu Girl (Gambatte) | 1.863 fps | 257 fps | 80 a 116 fps |
| Game Boy Color, µCity (mGBA) | 1.807 fps | 253 fps | não medido |
A emulação em si quase não custa nada: estas consolas são minúsculas para um processador moderno. O shader CRT é trabalho para a GPU: redesenha cada píxel do ecrã 1080p com as linhas de varrimento, a máscara de sombra e o brilho de uma televisão de tubo. Mesmo com o crt-royale, o servidor fica muito acima dos 60 fps necessários. As duas passagens do crt-lottes deram resultados diferentes (80 e 116 fps): a GPU é partilhada, e outros servidores de teste estavam a usá-la nesse momento.
O V-Sync desligado serve apenas para medir. Para jogar, configure o RetroArch para seguir a taxa
própria do jogo («Sync to Exact Content Framerate», vrr_runloop_enable = "true"): o jogo corre então à
velocidade da consola (59,73 Hz numa Game Boy), e o Moonlight mostra-o de forma fluida no seu ecrã.
3. Transmitir com o Moonlight: quanto custa
Lançámos cada jogo a partir do Moonlight (cada um é uma «aplicação» do Sunshine, ver abaixo), jogámos e anotámos as estatísticas de desempenho do Moonlight e a utilização de CPU do servidor:
| Moonlight, 1080p 60 fps H.264 | Jogo, sem shader | Jogo, crt-royale | Menu do RetroArch |
|---|---|---|---|
| Processamento no servidor (captura + codificação), média | 4,6 a 6,5 ms | 5,8 a 6,4 ms | 12,2 ms |
| Processamento no servidor, mín / máx | 4,3 / 7,1 ms | 4,2 / 11,7 ms | 4,5 / 21,5 ms |
| Imagens perdidas pela rede ou por jitter | 0% | 0% | 0% |
| Tempo de descodificação no cliente | 0,20 a 0,23 ms | 0,21 a 0,24 ms | 0,29 ms |
| CPU do Sunshine (parte de um núcleo) | 14% | 17% | não medido |
| CPU do RetroArch (parte de um núcleo) | 4% | 6% | não medido |
O fluxo usava 15 Mbit/s, o valor por omissão do Sunshine em 1080p. O codificador é uma parte da GPU distinta da que desenha os shaders: é por isso que o shader CRT não abranda o fluxo. O menu do RetroArch, com o seu fundo animado, demora um pouco mais a capturar do que um jogo de Game Boy. A sua latência total vai depender sobretudo da sua ligação à Internet até ao servidor (na Alemanha): uma boa ligação de fibra na Europa acrescenta normalmente 10 a 30 ms.
4. Uma aplicação do Sunshine por jogo
O Sunshine lança um programa quando o Moonlight pede uma «aplicação». Criámos uma para o menu do
RetroArch e uma por jogo, para que um jogo possa ser lançado diretamente a partir do Moonlight
(~/.config/sunshine/apps.json):
{
"name": "Tobu Tobu Girl (CRT)",
"cmd": "retroarch --appendconfig=/root/play.cfg --set-shader /root/glsl-shaders/crt/crt-royale.glslp -L /usr/lib/x86_64-linux-gnu/libretro/gambatte_libretro.so /root/roms/tobu.gb",
"auto-detach": "true",
"wait-all": "true"
}play.cfg contém as poucas definições do RetroArch que importam para jogar através do Sunshine:
video_driver = "gl"
video_fullscreen = "true"
video_vsync = "false"
vrr_runloop_enable = "true"
video_scale_integer = "true"
video_shader_enable = "true"
pause_nonactive = "false"
audio_driver = "pulse"
config_save_on_exit = "false"pause_nonactive = "false" impede o RetroArch de entrar em pausa quando julga ter perdido o foco, e
config_save_on_exit = "false" evita que um teste ou uma alteração no menu substitua as suas
definições. O Sunshine cria um comando, um teclado e um rato virtuais no servidor para o jogador do
Moonlight, por isso o seu próprio comando funciona como se estivesse ligado ao servidor. Se preferir uma
biblioteca de jogos ao estilo de uma consola, com capas, pode acrescentar o ES-DE (EmulationStation
Desktop Edition) como outra aplicação do Sunshine por cima do RetroArch; não o incluímos neste teste.
5. iGPU Start ou iGPU Power?
Para consolas de 8 e 16 bits, o iGPU Start (2 vCPU, 8 GB de RAM, 14,99 € s/ IVA por mês) chega: o RetroArch e o Sunshine juntos usavam cerca de um quarto de um núcleo no nosso teste. O iGPU Power (4 vCPU, 14 GB de RAM, o dobro da quota de GPU do Start, 29,99 € s/ IVA por mês) é a melhor escolha se usa shaders CRT pesados, joga sistemas mais exigentes, ou quer que o fluxo se mantenha estável quando outros servidores usam a GPU ao mesmo tempo.
6. Configurar num servidor Linux GPU
Quer o servidor pronto a jogar? Peça-o por e-mail ao encomendar (contact@linuxgpu.eu): podemos entregar-lhe o servidor com tudo o que se segue já instalado e configurado (ecrã virtual, RetroArch, shaders, Sunshine). Só tem de instalar o Moonlight no seu computador, telemóvel ou box de TV, emparelhá-lo e acrescentar os seus próprios jogos.
Para fazer por si:
- Instale o RetroArch e os núcleos:
apt install retroarch libretro-gambatte libretro-mgba libretro-nestopia, e os shaders:git clone https://github.com/libretro/glsl-shaders. - Inicie uma sessão sway headless na GPU (
WLR_BACKENDS=headless WLR_RENDER_DRM_DEVICE=/dev/dri/renderD128 sway) com uma saída de 1920×1080. - Instale o Sunshine (pacote Debian 13 das releases oficiais no GitHub), com a configuração acima, e acrescente uma aplicação por jogo.
- Abra a interface web do Sunshine através de um túnel SSH
(
ssh -L 47990:localhost:47990 you@your-server), crie a conta do Sunshine e emparelhe o Moonlight (Windows, macOS, Linux, Android, iOS, boxes de TV). - Copie os seus jogos para o servidor (
scp) e jogue.
O seu servidor é acessível por IPv6 por omissão. Se a sua ligação não tiver IPv6, acrescente a opção de IPv4 dedicado, ou ligue-se através do Tailscale sem abrir nenhuma porta: veja jogar no seu servidor na nuvem a partir de qualquer lugar com o Moonlight e o Tailscale.
Para jogos de PC, leia Windows 11 na nuvem com Sunshine e Moonlight e correr jogos Windows num servidor Linux GPU com o Wine.
Sistemas prontos para jogar logo à partida. Os sistemas que instalamos por predefinição já estão otimizados para isso: Debian 13 com um kernel recente (7.3), os drivers de GPU da Intel e o Mesa (OpenGL, Vulkan, codificação de vídeo VA-API), e o Windows 11 (opção) com o driver gráfico da Intel e o Ambiente de Trabalho Remoto renderizado na GPU. Nada de procurar drivers: instale o seu jogo e o Sunshine, e jogue.
Experimentar
Ver os planos: o iGPU Start custa 14,99 € e o iGPU Power 29,99 € s/ IVA por mês.