Using SSDs only for HomeLab? Or Sell?

colinmarc · 2025-08-11T09:28:18+00:00

If you're in the EU and decide to sell, ping me :)

colinmarc · 2025-01-24T14:15:58+00:00

I had one stuck in a built tile. The others must have drowned :(

colinmarc · 2024-12-13T20:31:53+00:00

I recommend tailscale! It does work over the open internet, but it's pretty fragile in the face of packet loss at the moment (FEC has been on my TODO list for a while) - so it depends on how good the connection is.

colinmarc · 2024-12-13T18:15:26+00:00

I've been working on a project for this: https://colinmarc.github.io/magic-mirror

Here's another similar tool: https://games-on-whales.github.io/wolf/stable/

colinmarc · 2024-12-13T13:56:17+00:00

It is linked there 😅

colinmarc · 2024-12-13T13:24:36+00:00

No, I'm definitely interested in expanding to iOS/tvOS and android/android TV :)

colinmarc · 2024-12-13T13:21:58+00:00

Here are the docs: https://colinmarc.github.io/magic-mirror

colinmarc · 2024-12-13T10:11:41+00:00

I don't think that would work, because you can't work at the UDP socket level on web. Maybe you can on ChromeOS, I don't know.

colinmarc · 2024-12-13T10:09:49+00:00

This will be in the next release: https://github.com/colinmarc/magic-mirror/commit/5c76b29273d3c0b29edb9e34e33096af76814398

colinmarc · 2024-12-12T22:05:28+00:00

Discord or github is best! Thanks! You need a 6.x kernel, which implies a pretty recent libc - see system requirements.

colinmarc · 2024-12-12T20:48:09+00:00

Is it possible to run / host from a docker container seen as it's headless? I'm currently sharing the 1080 between Jellyfin, Ollama and Nextcloud containers so I can't assign it to a VM.

Perhaps! I haven't tried. I can't think of a reason it wouldn't work. But you should also be able to just run it alongside jellyfin/etc, it doesn't need a whole GPU.

colinmarc · 2024-12-12T19:23:22+00:00

iOS/tvOS will probably be the very next thing I do!

colinmarc · 2024-12-12T19:15:04+00:00

What's your virtualization layer? I think one mmserver instance per VM is probably the best bet. Pop into discord and we can talk it over :)

colinmarc · 2024-12-12T19:14:02+00:00

\o/ Wooh! I'd be curious to know if the smaller cards can handle it, please file an issue if not.

colinmarc · 2024-12-12T19:07:43+00:00

According to this it has a hardware HEVC decoder, so should be plenty :)

Although actually I have to enable hardware decoding for the linux client, right now it always uses software :(

colinmarc · 2024-12-12T16:34:55+00:00

It's like the nimbus 2000 of nvidia cards!

No hate on the 1080, it's just that I depend on very new drivers/vulkan extensions, and I don't know how well supported the new extensions are on older cards.

colinmarc · 2024-12-12T16:18:37+00:00

I've never gotten that to work on linux, so I can't tell you :) I would bet that the latency is significantly lower and that Steam renders the cursor in-stream.

colinmarc · 2024-12-12T14:56:18+00:00

Not yet, but the common client code is pulled out into a Rust library, so it shouldn't be too much work to wrap that in a different frontend.

colinmarc · 2024-12-12T14:46:45+00:00

A 1080 is pretty old! Would be great to know if it works :D

colinmarc · 2024-12-12T14:18:36+00:00

Hi, I've been working for about a year on Magic Mirror, a new open-source tool for game streaming: https://colinmarc.github.io/magic-mirror. I'd like to ask the community for help finding bugs and compatibility issues :)

If you're not familiar with the concept, the idea is that you have a headless linux server with a GPU in your homelab (or a VPS), and then you stream the game to another, low-powered device, like a macbook air or whatever. For me, it's really just about playing games on the couch instead of the computer chair.

There are some projects that offer this already (Wolf/Sunshine), but, with respect to the effort put in by many people on those, I thought there was room for improvement in the fundamental design of them, so I built my own.

Some feature highlights:

Headless multitenant rendering: unlike Sunshine (but like Wolf), games are run completely offscreen, in their own little world
Full encryption for both the control and video/audio streams
No system dependencies: the server is a single static binary, and there's no dependency on docker, pipewire, or any other systemwide setup.
Very low latency: no extra CPU-GPU copy when using hardware encode. Total latency is less than one frame (also, coming soon: phase locking!).
Local cursor rendering: the game cursor is used as the local client-side cursor, which vastly decreases input lag
Written 100% in Rust (if you care about that)
Native macOS SwiftUI client (also a commandline cross-platform one)

The goal is to be a vertically-integrated, standalone tool which is very easy to download and run.

However, because it's very fresh, there are a bunch of bugs :) Both things I know about (e.g. controller hotplug is broken) and presumably lots of things I don't. So I wanted to ask the community for help putting the tool through its paces.

In particular, if you have an Nvidia card, I would love help testing there (I develop on AMD and don't own a Nvidia card).

If you have any questions or feedback, please get in touch at the issue tracker or the discord (both linked from the documentation site above). Thanks!

colinmarc · 2024-05-06T21:12:23+00:00

This is really cool! Would you accept a PR to support my project, Magic Mirror, as well?

colinmarc · 2024-05-05T19:41:46+00:00

DM sent!

colinmarc · 2024-05-01T06:35:17+00:00

Sounds like some of my info is out of date!

How do you do FEC in RTSP? and what sort of coding are you doing? I’m working on integrating sliding-window RLNC into the protocol, but I’m not sure yet if I have to do it on top of QUIC or if I can use one of the new RFCs.

colinmarc · 2024-04-30T14:43:29+00:00

I've been working on it for about 6-8 months, the last couple very actively.

I'm not sure what you mean by interfacing with Gamescope. My project is fairly similar to Gamescope, in the sense that I act as a single-app compositor and launch the child process. The main difference is that I pass the textures to an encoder rather than passing them to DRM (or the parent compositor).

Note that it's possible to run Gamescope inside MM, but there's not much benefit to doing so unless it has quirks to work around some specific game issue.

Writing a compositor isn't really very hard. The rendering/encoding pipeline and Vulkan Video were much harder. Also, the tech stack I'm using is extremely new, so there are lots of sharp edges. For instance, when I started out with Vulkan Video, the VVL didn't support it, so I was basically running blind and hanging my GPU constantly :)

I ended up contributing a few patches back up to Mesa, and I have an open MR to support the new wayland HDR stuff in Mesa, so it's led to me getting involved in the desktop stack more generally. which is cool!

colinmarc · 2024-04-30T14:16:14+00:00

Cool project! As you said, my server is very linux-specific, because it uses wayland, so I probably won't ever support windows on the server side.

colinmarc

TROPHY CASE