Kubernetes-Native Retro Game Streaming Written in Go
github.com
github.com
Readme is incomprehensible. What's the use case? Is this a web client I self host tp connect to a remote Retroarch instance? Fully remote or local? What kind of inputs work?
From the headline it's impossible to distinguish between this idea or maybe some bundle of Javascript emulators I'd self host or run on a box.
Seems cool but please think about the Readme!
Interesting question here would be the performance - is this efficient enough to get low latency and high framerates? if yes, this could be useful for a bunch of stuff, where you want to spin up a heavyweight GUI app on some kubernetes cluster quickly (think remote dev setup) and stream it to your laptop/tablet.
Edit: Looks like a Desktop client application, also written in Go. But the streaming is implemented with WebRTC and some custom signalling for keyboard/mouse/gamepad feedback, so this could theoretically also be adopted for a Webbrowser I guess?
For this project specifically, it seems they have done some interesting work to make things run in containers, like udev input and streaming wayland sessions to a web browser.
Overall, it looks pretty interesting.
Let me preface that I wrote a whole thesis on Kubernetes, and the sentence "Kubernetes-Native" makes no sense to me. It's just a container.
My buzzword-meter is beeping pretty hard right now.
Their sunlight alternative https://github.com/games-on-whales/wolf adding multiple tenants is neat as well. Definitely going to give it a spin on some intel iGpu nodes.
Because we haven't really advertised the project anywhere, I was a little surprised to wake up and see the 86 stars we have now. This project is still very much in its infancy. While we have a working setup internally, I wouldn't say it's quite ready for external use.
Getting docs and a (comprehensible and non-ChatGPT written) readme is on our list of things to do. We're still in the process of some major refactors right now, and are mostly focused on improving the reliability of the streaming from ffmpeg/gstreamer to our application. We're dropping far more packets over UDP on loopback than I would have thought, so we're rethinking how we get the frames.
We also haven't actually had any kind of official release or anything and only shared the repository with a handful of people in the Games on Whales community (including WanjohiRyan), but that was only to share some implementation details around the udev stuff with them for their own projects.
The basic premise of the Pod-Arcade is this:
You load up a webpage, and can share that URL with a bunch of your friends. It's like Steam's Remote Play together, but using web-browsers instead.
There's a "Server" application that runs an MQTT server and hosts a web frontend. "Desktops" are basically just docker containers hosting Wayland desktops that run applications and can be streamed over WebRTC to the web frontend. Both the client's web browser, and the desktop connect to the server application and use MQTT to exchange SDPs and liveness information. From there, most of the communication between the desktop and the web client (for things like mouse and gamepad) happens over WebRTC Data Channels.
The "Kubernetes-Native" is part of our roadmap. We want to have an operator that dynamically spins up pods as you need them. You and three of your friends all want to play separate instances of retro-arch at the same time? The operator can handle spinning up and managing those pods. Ideally there will eventually be some catalog of applications that you can one-click deploy through the web frontend.
If you need any help/advice with the WebRTC stuff I am always available :)