uhm, did you know that waypipe with ssh is fast enough to use blender remotely over wi-fi?

@mntmn@mastodon.social

this works much better/faster than x11 forwarding ever did

i think this is cause waypipe uses h264 whereas x11 forwarding forwards the draw instructions which in the modern day is just "draw this 4k 32-bit colour pixmap" which isn't very efficient over the network

@tauon @mntmn It could be though, if toolkits cared enough to use it efficiently, otherwise you could use something such as xpra which I guess is similar to waypipe. But that we are back to such solutions instead of having a proper remote protocol is a bit sad.

@mntmn@mastodon.social If one is stuck on X11, one can still do 3D forwarding with VirtualGL. Still maintained today. It replaces the GL libraries with a shim to send pixmaps over the network. The window activities and mouse clicks are still in X11.

@mntmn Waypipe is such a cool tool. I use it to forward windows from a VM to my host and it's genuinely indistinguishable from a native app ...

@mntmn Can it work with a whole desktop, like how Windows RDP works? I'm still using Xorgrdp for remote sessions, so I have both plasma-x11 and regular plasma

@mntmn dumb question because i hardly use gui forwarding: why is this a benchmark? dont x11 forwarding and wayland equivalent not just simply render the gui as images? so like if you were watching an video or a very heavy application is basically the same because it is just colored pixels?

@woltiv yes, i tried running sway and weston over it

@mntmn Well damn, now you have my attention.

@mntmn Waypipe is awesome, been using it to run stuff on my desktop from my #postmarketOS phone and it's the most seamless and frustration-free remote GUI system I've ever used.

@mntmn I did _not_ know this and now I need to play around with it. Thanks for the encouragement!

@mntmn@mastodon.social I tried using it to run Blender remotely over Wireguard from my home computer once. However, the lag was a bit too much to use. Tried experimenting with compression but that didn't seem to change anything, so maybe the problem wasn't bandwidth?

@uecker @tauon @mntmn for applications like blender there's neither a toolkit, nor any good way to handle forwarding that isn't streaming.

@dotstdy@mastodon.social @uecker@mastodon.social @mntmn@mastodon.social can't you just forward the opengl instructions? presumably the computer has a gpu too

@dotstdy@mastodon.social @uecker@mastodon.social @mntmn@mastodon.social actually then you'd run into the same problem sending the textures over the network too wouldn't you

@tauon @mntmn @dotstdy Both could work just fine with X in theory. The GLX extension - a long time in the past - could do remote 3D rendering, but pixel shuffling over X could also work fine. X is a very generic and flexible remote buffer handling protocol. The issues with ssh -X are mostly latency related because toolkits (and blender if not using a standard one then has one builtin) use it synchronously instead of asynchronously.

@uecker @tauon @mntmn remote rendering for a program which is heavily reliant on the GPU like blender is the exact opposite of why you'd want remoting though. (Plus none of those virtualization things really work so well in the modern day, it's not gl1.1 anymore, the model just doesn't fit)

@uecker @tauon @mntmn it's not really obvious with the default scene, but a 3d program like blender requires a pretty hefty GPU to run the UI (see also any CAD tool, or a game)

@dotstdy @tauon @mntmn This depends on where the strong GPU is, but as I said, pixel pushing should work also with X. I use medical image viewer over X, the image content updated very quickly. What is slow is the GTK part because it is implemented badly.

@dotstdy @tauon @mntmn But I think even for many 3D applications that render locally, a remote rendering protocol is actually the right thing, because for all intents and purposes a discrete GPU is *not* local to the CPU and whether you stream the commands via PCI or the network is not so different. In fact, Wayland is also a designed for remote rendering in this sense just in a much more limited way.

@uecker @tauon @mntmn Unfortunately that's really not how the GPU works at all in the present day, it made more sense back in OpenGL 1.1 when there were pretty straightforward sets of "commands" and limited amounts of data passing between the GPU and the CPU. Nowadays with things like bindless textures and gpu-driven rendering, and compute, practically every draw call can access practically all the data on the GPU, and the CPU can write arbitrary data directly to GPU VRAM at any time.