Slashdot Mirror
Remote Desktop Backend Merged into Wayland
New submitter Skrapion writes "One month ago, an independent developer submitted patches to the Wayland's Weston compositor which adds support for FreeRDP, an open-source remote desktop protocol. Now, after six revisions, the remote desktop code has been merged into the trunk. While remote desktop has been prototyped in Weston once before by Wayland developer Kristian Høgsberg, this is the first time Wayland/Weston has officially supported the feature. For a summary of why we can expect Wayland's remote desktop to surpass X.Org's network transparency, see Daniel Stone's excellent talk from Linux.conf.au."
Why show we care about freeRDP?
For the past 10 years I have been repeatedly lambasted for complaining that RDP and ICA were superior to X11 transparency and VNC with seemingly nothing being done to address the issue. Naturally, this made me a clueless troll. Blah, blah blah.
Now, with RDP copied and inserted into Wayland "we can expect Wayland's remote desktop to surpass X.Org's network transparency".
Fan boys are pathetic. LOL. I for one, welcome any improvement over X11 transparency and VNC. Anything at all.
This is excellent news and has changed my mind regarding Wayland. A successor to X11 really needs good remote control functionality, but it doesn't have to be done the way X11 did it. I now look forward to a future with Wayland.
Quantum hacker.
You would be wrong then. RDP 6.1 along with Windows Server 2008 introduced RemoteApp which allows a single application to be forwarded rather than a whole desktop.
We don't Salute You!
For the next 100 posts whining about how this isn't exactly like forwarding an Xterm over an SSH tunnel (think about how stupid that is for a second)... X IS NOT NETWORK TRANSPARENT
What? That a lie! 1985 sez X is network transparent!
Well guess what: Modern versions of X are *not* network transparent anymore because to use any of the modern features of X that make using a modern Linux desktop even remotely enjoyable, you are breaking the classic backwards server-client paradigm of X. Sure, there's still a fallback mode for transferring data over networks, but lots and lots of modern features that you expect in a modern desktop GUI break in the process, which is *not* transparency, but is instead more of a network fallback.
Frankly, having tried to use both X and RDP over real connections using the real Internet, I'd take RDP any day of the week. I still remember the finger-pointing amongst developers of different projects when I pointed out that packets were being sent over the network each and every time my cursor blinked. Get over it guys, 1985 wasn't the be-all end-all pinnacle of graphics development.
Still don't believe me? How about clicking the link to Dan's talk about X where he says the exact same thing I just said. He's only been working on X development for over 10 years though, so I'm sure that some guy who sorta got X forwarding working over a gigabit link is much much more informed that he is....
AntiFA: An abbreviation for Anti First Amendment.
Are doomed to re-implement it. Poorly.
Starting in 2008 RDP doesn't require this either, please go read all about it: http://en.wikipedia.org/wiki/Remote_Desktop_Protocol#Version_6.1
AntiFA: An abbreviation for Anti First Amendment.
Does this allow per-application forwarding? (All sorts of people blasting that Microsoft can do it, not many people speaking to whether *this* specific implementation can).
Does this allow remote applications to cleanly appear in things like notification areas? That was one problem I had with NX, even the rootless mode failed to properly incorporate that.
Does Wayland+FreeRDP provide a more unified approach to audio+video being grouped together? That's a large gap in X, where audio is consider just completely unrelated to the remoting...
XML is like violence. If it doesn't solve the problem, use more.
You're misinterpreting... I was agreeing with you about X fanboys who always cry about "network transparency" when X hasn't been network transparent for years & years. Any modern X server is just shooting bitmaps over a network link in a less efficient manner than RDP.
AntiFA: An abbreviation for Anti First Amendment.
Not if you wanted to forward the display of a single application. Your use case is not everyones use case.
I understand it now does that too, which is great.
Whatever it does RDP is far, far faster and more versatile than X forwarding. X forwarding is slow and buggy to the point that I use vnc on my unix servers and vnc is awful.
RDP is truly impressive, but not everyone wants to have a desktop on their server.
Is it capable of letting me launch graphical applications from an OS without a local graphical display? I ask because my understanding is windows 2008 has added that as an option.
Really?
Because I use X forwarding all the damn time. Mind you only on the LAN.
Newer VNC is not too bad either, but the normal ones suck. Have you tried TigerVNC?
A few things :
- Microsoft RDP clients are pre-installed on every Windows based client since Windows XP/Server 2003. This means that a majority of non-slashdot-reading admins have all the tools they need to connect to it already installed.
- Microsoft RDP is a lot faster than VNC/X11 forwarding. For one, they do smart bitmap-caching. VNC is screen-shots only (using some sensing of what has changed on the screen to send the diffs), and X11 forwarding were pretty much just UI elements, which made interacting with certain applications difficult or ackward.
- Later RDP versions allow you to forward just specific applications, in addition to the entire workspace. I don't know if FreeRDP supports this feature yet, but it is built into the protocol.
Yes, this is very common.
I have KVM installed on a server, I use virt-manager to play with it. I forward X over SSH to run virt-manager and have it display on my local machine. The server has no graphical output. You can feel free to substitute any program with a graphical output you like for virt-manager in my example.
I've used it on LANs. I've used it across my crummy IDSL link. And I've even used it on dial-up. Only when using very graphics intensive applications on dial-up did I find the performance awful (and, fortunately, I only needed to resort to dial-up during those rare times that the VPN access was down). Caveat: I'm not trying to play games via X11 connections which may be why it works well for me and so badly for the folks who are in favor of Wayland.
I find it amusing that some people are touting how wonderful the implementation of RDP is on Windows 2008 server. I need to access remote UNIX systems, not Windows servers. Those of us that use UNIX (almost exclusively or as exclusively as I can pull off) don't want something that is useful only for Win2008 Server systems. How will an RDP plug-in for Wayland accommodate UNIX/Linux desktops connecting to UNIX/Linux servers? Oh... I guess the people running UNIX servers will have to install a non-native layer to allow the Wayland folks access. That's just nuts.
(Personal opinion time: It seems there is a group of Linux developers who grew up developing for Windows and won't be happy until they've turned Linux into the Windows they would have liked to have seen. Too bad they never used UNIX/Linux as they were developing their programming skills.)
CUR ALLOC 20195.....5804M
sounds like a nice improvement. as long as:
* The interface is still the same. i.e. i ssh -X in to a machine, start a graphical program (evince or whatever), and it displays locally. I dont want to have to configure stuff, or start some additional server on the remote machine.
* It works in mixed environments. I might be running wayland on my laptop next year. but some of the machines i log into a currently on Scientific Linux 5. I guess RHEL 7 will still be X11 based and i would not make bets about RHEL8.
Also this will score double bonus points if it works with gnu screen. i.e. i ssh into a machine, start screen, start a tunnelled graphical app. drop the network connection, or suspend, or switch to a different machine, and it re-attaches the graphical app.
As long as I'm guaranteed that my local display can talk to remote applications, no matter what the flavor of the month is, I'll be happy. There needs to be a universal standard.
You do realize you probably prompted some brain-addled dev someplace to come up with the equivalent of PulseAudio for display technology, right?
All problems in computer science can be solved by another level of indirection—except for the problem of too many layers of indirection.
—David Wheeler
Non-native?
Rdesktop is a native linux app I use for when I have to deal with windows servers. The other way around I don't see why someone running wayland could not use X over SSH like the rest of us.
I cut my teeth on Solaris and my caplock key position proves it.
For one, the programming language should naturally support the notion of doing stuff in a non-blocking way (C/C++ does not naturally support this; simulating this requires working with threads or tinkering with even more low-level machinery).
You what?
Unix has offered non blocking calls more or less since forever, and C was basically invented in order to write unix.
read() can operate in non blocking mode just fine. You might want to check the man pages for read() and select().
SJW n. One who posts facts.
Aside from one major security vulnerability (Microsoft Security Bulletin MS12-020), RDP has been rock solid and secure. But perhaps most interesting is that it performs the best. I've tried just about all the major remote desktop protocols out there. VNC, LogMeIn, WebEx, GoToMyPC, TeamViewer. None of them compare to RDP in terms of responsiveness and ability to hold up under excessive gateway saturation of an ISP connection.
Life is not for the lazy.
For one, they do smart bitmap-caching. VNC is screen-shots only (using some sensing of what has changed on the screen to send the diffs)
So what's smart bitmap-caching then, if not (as I'm only naively guessing based on the name) "using some sensing of what has changed on the screen to send the diffs"?
systemd is Roko's Basilisk.
Sorry, but select() doesn't cut it. Using select, you are forced to write ugly event-driven code, with objects representing event-handlers, where all you want to do is run a bunch of snippets of code, where each of them executes as soon as the data is available.
And by the way, using select() you can't even wait for both a file descriptor and a semaphore simultaneously, but that is a different story.
If Pandora's box is destined to be opened, *I* want to be the one to open it.
My use case includes sound, printing, the clipboard and preserving state when disconnected.
VNC will preserve your state, but your performance is gone and you still haven't solved sound, printing or the clipboard.
X11 might give you the middle-button buffer, but not the clipboard.
Just guessing here, but I'd imagine 10^6 $100 bills are more convenient than 10^8 $1 bills.
I browse on +1 so AC's need not respond, I won't see it.
- Later RDP versions allow you to forward just specific applications, in addition to the entire workspace. I don't know if FreeRDP supports this feature yet, but it is built into the protocol.
Outside of Windows, this really doesn't exist. I think there is a paid-for program on Mac OS (not the MS RDP) that does this.
I'm starting to think GNU is the problem with "GNU/Linux" these days.
For one, they do smart bitmap-caching.
If you use a window manager and applications that use X primitives rather then drawing everything in bitmapped eyecandy the performance is much faster than RDP. All the anti X forwarding folks have never used the system as it was originally intended which is why we have to see it reinvented again... badly.
I am becoming gerund, destroyer of verbs.
I think what the poster was referring to is that client-side rendering is now the norm. This has brought us nice fonts and compositing, among other things. So yes, most X11 apps are just sending bitmaps to the server. No longer are modern X-based applications asking the server to render text and buttons and shapes for it. Yes this does decrease remote performance. And modern toolkits like GTK do require a lot of server round trips, which makes things hard to deal with over a high-latency link.
I remember running Xemacs over a modem and it ran great remotely, since it was mostly just asking the server to draw in its behalf. Worked very well, but compared to modern apps, was very ugly.
RDP has been able to forward the display of a single application for 5+ years.
Best guess: X is a display protocol, not audio.
I'm starting to think GNU is the problem with "GNU/Linux" these days.
Using select, you are forced to write ugly event-driven code, with objects representing event-handlers, where all you want to do is run a bunch of snippets of code, where each of them executes as soon as the data is available
How is it ugly? You can do what you want in a few lines of code with a base class, select and a std::unordered_map. With a small amount of care, you can also store a lambda in the derived class, meaning that you have a map of file descriptors to literally code snippits that get run on demand. You could use function pointers if you prefer, too.
Or, run one per thread, which C++ supports natively, including implicit stuff like futures and promises. Again, you can create threads off lambdas, so you can just run a code snipped to deal with a resource in a different thread.
And by the way, using select() you can't even wait for both a file descriptor and a semaphore simultaneously, but that is a different story.
That is true, but you can use pipes for synchronisation well enough. Also, you can (Linux extension) select on POSIX message queues.
SJW n. One who posts facts.
no, RDP forwards all the bits that have changed - now simpler versions of it will happily forward everything (eg VNC at least in early incarnations, and Microsoft's own RDP protocol) but Citrix did a load of work reducing the amount of screen that was transferred over the network. Microsoft since took that and built it into the kernel (or graphics bits that are in the kernel) so that it became even more optimised - after all, if the OS only redraws a small section, only that section needs to be transferred.
So the MS version is very well built - because it was done by someone other than MS, as usual.
I doubt the FreeRDP is more capable, but it certainly shouldn't be any less capable.
Not all that familiar with the innards of RDP myself, but the obvious difference is that a bitmap may or may not be visible on the screen, only partially visible, or repeatedly visible. This would allow parts of the bitmap that are currently not on the screen to be sent once to the client and reused over and over again, allowing smoother screen draws and less bandwidth/latency on incremental changes.
I think what the poster was referring to is that client-side rendering is now the norm.
Partly. Fonts are rendered client side, but can be composited server side just fine. Since X can cache bitmaps, a well written client will send the glyphs to the server as bitmaps, then send a list of bitmap IDs to composite. After the initial data dump it can go very fast.
And modern toolkits like GTK do require a lot of server round trips, which makes things hard to deal with over a high-latency link.
Frequently things like GTK do very strange, inexplicable things requiring far more round trips than necessary.
SJW n. One who posts facts.
So the cure to remote performance is to rewrite modern applications to 80 era style, because writing a display server that handles modern apps is doomed to be implemented badly...
Dude, just listen to yourself.
Sorry, but I want expressiveness without seeing all the ugly low-level stuff.
To go back to the original topic, Wayland needs to remove round-trip times to make the system faster and more responsive.
How can a compiler decide to move code from the client to the server or vice versa if all the plumb-work gets in the way?
If Pandora's box is destined to be opened, *I* want to be the one to open it.
You must be joking.
I've seen what VNC is capable of going from any combination of Unix, Windows, or MacOS.
VNC is just sad when compared to X.
Don't try to confuse RDP with VNC.
A Pirate and a Puritan look the same on a balance sheet.
- Later RDP versions allow you to forward just specific applications, in addition to the entire workspace. I don't know if FreeRDP supports this feature yet, but it is built into the protocol.
It does a lot more that just that...
$ xfreerdp --help
FreeRDP - A Free Remote Desktop Protocol Client
See http://www.freerdp.com/ for more information
Usage: xfreerdp [options] server:port
-0: connect to console session
-a: set color depth in bit, default is 16
-c: initial working directory
-D: hide window decorations
-T: window title
-d: domain
-f: fullscreen mode
-g: set geometry, using format WxH or X% or 'workarea', default is 1024x768
-h: print this help
-k: set keyboard layout ID
-K: do not interfere with window manager bindings
-m: don't send mouse motion events
-n: hostname
-o: console audio
-p: password
-s: set startup-shell
-t: alternative port number, default is 3389
-u: username
-x: performance flags (m[odem], b[roadband] or l[an])
-X: embed into another window with a given XID.
-z: enable compression
--app: RemoteApp connection. This implies -g workarea
--ext: load an extension
--no-auth: disable authentication
--no-fastpath: disable fast-path
--gdi: graphics rendering (hw, sw)
--no-osb: disable offscreen bitmaps
--no-bmp-cache: disable bitmap cache
--plugin: load a virtual channel plugin
--rfx: enable RemoteFX
--rfx-mode: RemoteFX operational flags (v[ideo], i[mage]), default is video
--nsc: enable NSCodec (experimental)
--disable-wallpaper: disables wallpaper
--composition: enable desktop composition
--disable-full-window-drag: disables full window drag
--disable-menu-animations: disables menu animations
--disable-theming: disables theming
--no-rdp: disable Standard RDP encryption
--no-tls: disable TLS encryption
--no-nla: disable network level authentication
--ntlm: force NTLM authentication protocol version (1 or 2)
--ignore-certificate: ignore verification of logon certificate
--sec: force protocol security (rdp, tls or nla)
--secure-checksum: use salted checksums with Standard RDP encryption
--version: print version information
Sendmail is like emacs: A nice operating system, but missing an editor and a MTA.
X with compression and caching can work very well actually.
Across the Internet, it runs circles around what VNC can do locally on a gigabit network.
VNC is nothing to hold up as a solution for not having the networking features of X anymore.
A Pirate and a Puritan look the same on a balance sheet.
Sounds like a conventional Windows application installer, doesn't it?
Never wanted to install software from some 3rd party proprietary vendor? It's not like Free Software where you can just integrated it into some yum or apt repository.
Plus you're basically stuck dealing with whatever the vendor wants to give you.
A Pirate and a Puritan look the same on a balance sheet.
So what you're saying is that X11 isn't network transparent, at least from the perspective of developers. And the example of inefficiency that you provided (drawing bitmaps) is something that all modern GUIs do extensively today. Your defense of X11 seems to be out of touch with the reality of modern GUI development. This is precisely why the people that actually do development on X11 or using X11 want a new graphics stack while the people that don't do any X11 development say that X is good enough.
> I never understood why sound on Linux was kept separate from X
X is older than gaming PCs.
There are still a lot of remote desktop use cases where lack of sound support is pretty much irrelevant. Actually, I would go further and say that sound on a remote desktop is more likely than not COMPLETELY IRRELEVANT.
Most use cases that call for sound support stretch the abilities of ANY remote desktop implementation.
A Pirate and a Puritan look the same on a balance sheet.
Exactly - xedit, xclac, xvim, all work great over the slowest link you will find in use anywhere. The trouble is the world has moved on. I am not sure sending bit-maps ( regardless of how clever your scheme of sending just the changed parts, compress etc is ), is the right way to go but the fact is the X11 programs most people are using most of the time these days don't get the benefits of X11 server side rendering features.
Sending bit-maps be it X11 doing it, RDP, or VNC is certainly the simplest thing to do and it lets you display anything you want. Having clients send compressed postscript diffs possibly with some compositing, cursor, and clipboard extensions might be an interesting model; but how you go about dealing unpredictable motion like video playback would be real challenge.
Repeal the 17th Amendment TODAY! Also Please Read http://www.gnu.org/philosophy/right-to-read.html
Sorry, but I want expressiveness without seeing all the ugly low-level stuff.
Even versus callback driven is a matter of taste. I strongly suspect there will soon be some good C++11 libraries for callback driven I/O since the language can do it very prettily.
SJW n. One who posts facts.
Hi, I am Marc-Andre Moreau, founder and leader of the FreeRDP project. I was not directly involved with the FreeRDP Wayland backend. First, definitely take this backend as a first step. There is a *lot* more than can be done in the future, and I can tell you it has the potential to make your best dreams come true in terms of remote desktop. Here is a screencast I took about a month ago showing FreeRDP on Linux connecting to Windows 8 with RemoteFX, playing videos with sound smoothly: http://www.youtube.com/watch?v=JUF8xPKBQJM Even if this is impressive at this point, it is just a fraction of what we're going after in the future. RemoteFX was introduced in RDP 7.1, and is what FreeRDP implements. It basically encodes everything on-the-fly for fast encoding on the server and fast decoding on the client. This means the videos played in that remote desktop session I've recorded are re-encoded to RemoteFX, they are not sent as H264. RDP also provides a functionality allowing the redirection of the compressed video stream for local decoding and playback, but from experience RemoteFX provides a better user experience. RDP may be a protocol designed by Microsoft, it is part of the Microsoft Open Specifications. The long term goal of the project is not to make it a "FreeRDP to Microsoft" technology, but really to make it a "FreeRDP to FreeRDP" technology, where high quality clients and servers will be available for all platforms in existence. Like it or not, RDP is an extremely powerful protocol that has all the potential necessary to compete with leading commercially-supported alternatives, except that this one is open specification and open source with FreeRDP. We are also considering the possibility of defining our own community extensions to the RDP protocol to fill in the gaps left by Microsoft. We currently have clients on Linux, Windows, Mac OS X, Android and iOS. We have servers (still in their early stage) on Linux, Windows, Mac OS X and now Wayland. All of this is available under the Apache license. One common mistake about RDP is to compare only in terms of the core feature set, which is graphics remoting and input. RDP provides support for disk redirection, audio input and output redirection, multimedia redirection, smartcard redirection, printer redirection, usb device redirection, multitouch input, serial & parallel device redirection, etc. It has a very rich set of security features which we work very hard on supporting well (Network Level Authentication, TS Gateway, etc). As for graphics remoting, it is very elaborate in the RDP protocol, and it just keeps getting better with newer versions of the protocol. The next step for us is to jump on RDP8 support, which will bring many new features such as a progressive graphics codec, dynamic adaptation based on changing network conditions, a high performance codec for anti-aliased fonts, support for multitransport (TCP + UDP), enhanced support for WAN and higher-latency/low bandwith environments, etc. All of this can be brought to all platforms with the FreeRDP project, for the benefit of all. Brace yourselves, FreeRDP is coming.
Any word on when it will be able to delete files that are open?
I suppose it already can, otherwise the SUA subsystem would be unimplementable.
Ezekiel 23:20
Ah yes, the ever intelligent commentary on Slashdot.
What video did you watch? Was it made within the last few months? You do realize (if the video is covering Weston) that Weston is not only new but also a reference implementation and not intended for production use, right?
This has not a goddamn thing to do with why "Linux on the desktop has failed."
Most users and developers really do use (and like) their modern toolkits and desktop environments. In those cases what CajunArson says is entirely correct. X is already just sending frames one by one, and does it horribly inefficently because it was designed for a very different use case.
Your claim is only correct if you only run motif-era apps. And that is just not relevant. Sorry.
I think you have misunderstood the intent of the original post. The poster was not saying that X doesn't work over a network - as you have pointed out, anyone can easily prove that X technically works over a network. The point was that the efficiency of "network transparency" in X is no longer a reality. That is because the intent of X was that a request could be made to render a primitive, such as text, by providing a few parameters over X (networked or local) about the text that should be rendered and the result can be displayed with minimal protocol chatter. However, since many elements of modern GUIs use bitmaps for display elements, many of the transmissions over X are simply bitmap requests instead of requests to render X primitives. At that point, X is basically behaving like a glorified rootless VNC server - just sending a series of bitmap updates that can be costly over slow or high-latency networks. Perhaps the original poster should have said the "efficiency of network transparency" is no longer a reality to make the point a little clearer.
1. As I told another poster, Network Forwarding != Network Transparency. You know how modern X servers operate over a network? By pushing a bunch of bitmaps in a less-efficient manner than RDP. I really don't care if some dusty design document from 1985 says otherwise, you're irrational wishes don't create a new reality. Unless you are a real fossil, I was probably doing X forwarding before you even new what Linux was, and I know much much more about its limitations than you do.
2. If you're calling me a liar, you're also calling the main developers of the X server and Wayland liars because they agree with me and not with you.
If arrogance, ignorance, and disrespect for people who do hard work could be trasmuted into display server code, you would control the market!
AntiFA: An abbreviation for Anti First Amendment.
I've used it on LANs. I've used it across my crummy IDSL link. And I've even used it on dial-up
Try it on a satellite connection with 700ms+ ping times. Usable, but significant delay even when trying to do a simple tab completion when changing directories ... 1 second delay between each directory change. Not bad by itself, but extremely annoying in total delay when working long periods.
I have a Windows box at work which I RDP into and then daisy-chain from the Windows box to X or VNC into other *Nix machines at work because RDP is that much better over my satellite link. If I had to pick a good second behind RDP, I'd go with NX.
"Oh... I guess the people running UNIX servers will have to install a non-native layer to allow the Wayland folks access. That's just nuts. ?
That's a pretty flimsy straw-man. Of course you'd install an X Server on Windows.
What settings are you using for X over dialup?
As I told another poster, Network Forwarding != Network Transparency.
OK, you're not a liar, you're just redefining commonly understood terms to confuse people. Fair play.
ou know how modern X servers operate over a network? By pushing a bunch of bitmaps
First yo umean xclients. And no, the cliend can still upload nice glyph bitmaps and then composite them using the bitmap IDs instead of using the old font mechanism, meaning the expensive bitmaps are sent once, not once per use.
Unless you are a real fossil, I was probably doing X forwarding before you even new what Linux was, and I know much much more about its limitations than you do.
Possibly, but the window is not enormous. I started with X in 94, and it debuted in 87. So I've been using it for 19 of it's 25 years in service.
2. If you're calling me a liar, you're also calling the main developers of the X server and Wayland liars because they agree with me and not with you.
Keith Packard is a bit of a FUD machine and seems to enjoyu setting up straw men along with making some very odd claims which are demonstrably false (a I've covered repeatedly). The fact that he's an X developer only means that his acts must be intentional, rather than through a lack of knowledge.
SJW n. One who posts facts.
While Wayland may solve some mundane issues with the client-server nature of remote desktops, I think in general a completely different programming model is needed for client-server applications. For one, the programming language should naturally support the notion of doing stuff in a non-blocking way (C/C++ does not naturally support this; simulating this requires working with threads or tinkering with even more low-level machinery).
I expect we'll see more posts like this now that so many states have decriminalized weed.
No. What he's saying is that X11 is still perfectly network transparent, but that the clients are using the protocol in a manner that only works well over very high bandwidth, very low latency links, like a local socket. The only time network transparency goes away is when you're using extensions like SHM or DRM, which typically means you're doing things like video playback, games, or other intensive rendering; tasks which will never function well over slow, laggy links.
This depends on your method of X forwarding. NX does a pretty good job and isn't slow and is less "buggy" (well, you can't do GLX, but trying to do that via a VPN would be...evil...)- along with handling pretty low bandwidth links well.
Having said this, if RDP does a good enough job and Wayland untangles the whole POSIX desktop world, I'd say it's pretty much a win- esp. if I can do the RDP remoting over moderately low bandwidth links.
I am not merely a "consumer" or a "taxpayer". I am a Citizen of the State of Texas
Essentially, the client can request a bitmap representation of an element, or the native UI component. For example, common UI components are sent as UIElements and SkinParts. SkinParts can be sent as vector items (like gradients, lines, etc), or bitmaps themselves. So, for example if you run calc.exe, the client can request the app as a stack of UI elements (essentially, how the GDI plans on drawing the components to the screen). All the buttons, etc. are sent as a component package which describes how the element should look. If it uses a bitmap as a part of its chrome, it is sent as a separate SkinPart.
You can also get bitmap representations of components if the OS thinks it is too difficult to draw them (or the developer just threw a bunch of bitmaps together to represent common UI components). When this happens, calls into the GDI update the RDP server to let it know that a component of size X/Y at X/Y has updated. It's a lot smarter than VNC which has to watch the screen and updates the screen in a 1/x method.
X11 is a bit more primitive... It expects the UI components to be created and skinned by the client. This is really only useful/consistent if both the client and the server are running the same WM. Users of RDP get the same experience regardless of their client.
Caching the way a button looks, the way your titlebar looks, possibly down to each letter on the screen.,All these are stored Client-side by the Server's request, so instead of sending a 24bpp bitmap of the word "cat" (a few kb), it references a previous: "c.jpg, a.jpg, t.jpg" (which is only a few bytes). It also caches whole windows so a window move isn't expensive.
Science & open-source build trust from peer review. Learn systems you can trust.
Does Wayland include support for sound in the overall protocol, or is that still separate?
Drawing bitmaps is a broad statement - that's what every graphical application does and has always done since we started using raster displays instead of oscilloscopes for UIs - and it hides a lot of details. There are two important steps: rasterisation and compositing.
The first used to be done entirely on the server and is now done in the client. This hasn't changed from the perspective of an application developer, who says 'draw a line from x,y to x1,y1', but the library he calls now does this locally rather than calling xlib. This change largely happened for two reasons. The first is that X11 never got sensible antialised drawing primitives (e.g. a PS rendering model with antialiased bezier paths). Wayland doesn't have this either. The other is that CPUs became fast. One of the main reasons for wanting to do line drawing on the server was that rasterisation took up a huge amount of the CPU time if you did it purely in software and 2D accelerators (often sold as Windows accelerators, because they sped up typical GUIs) could do line drawing much faster.
The second, compositing, is what happens when you take a bunch of source images (text glyphs, controls, and so on) and combine them into a single image for display. This can be done entirely server-side on X11 and doing so over the network means that you keep the individual button images as textures on the GPU and do the compositing there. This is what most modern X11 toolkits do. I'm not 100% sure what Wayland exposes here, but I believe it only exposes this compositing at the window layer, whereas X lets you use it within the window. If you want to do hardware-accelerated composting in Wayland, you ask for a GLES context and do all of your rendering there (which, actually, isn't a bad idea these days, but is going to be horribly slow if you don't have GPU drivers).
I am TheRaven on Soylent News
So if you want your app to be reasonably usable over connections slower than LANs, you need to design your app in a very specific manner. That doesn't sound unreasonable, but it also doesn't sound transparent, which was my original point.
From your statement, you obviously haven't used NX/X2Go. Very fast even over slow connections.
God is imaginary
I have 3 clients for OSX, including the Microsoft Remote Desktop Client. They all support it. Only one of them (Jump Desktop) cost money.
It is not a feature of the client, but of the server. Any client is capable of doing it, some just actually offer a way for the client to request do it without the server forcing it on you.
Persistent Volume manager for Kubernetes - https://github.com/dwimsey/openshift-pvmanager
I don't care about RDP either, but have you ever used NX/X2Go instead of straight X forwarding? I find it is much faster and usable even over slow(ish) connections.
God is imaginary
Doesn't RDP forward an entire desktop? If so, that's no replacement for X forwarding. But maybe FreeRDP is more capable than Microsoft's version. What the hell are we using
I used to run RDP over dialup modems and it was usable to get work done. RDP is insanely good. It blew alternatives such as VNC and PCA out of the water in quality and performance. X11 over broadband is completely unusable today while RDP over broadband is often indisingushable from sitting in front of the computer.
Microsoft technology anyway?
What about technical merit? This is all really shit citrix did eons ago.
RDP also deals with drawing primatives. I worked pretty extensively with the FreeRdp code for a project. RDP is a pretty nice protocol, and FreeRdp is an excellent implementation of it.
I use vnc on my unix servers and vnc is awful.
Yeah? I do my daily work via a VNC connection to localhost (I run a headless VNC instance for my main work desktop, 1920x1200x32 so it's portable). I usually forget and only notice when the videos don't have sound. I often do work from home to it on a 7Mbps DSL connection and only see lag on full-screen re-draws). Both ends are tigervnc.
Oh, and pointers to a working PulseAudio HOWTO on doing multi-user sound are welcome.
My God, it's Full of Source!
OUTSIDE_IP=$(dig +short my.ip @outsideip.net)
Sadly, no. The closest it can get is delete on close. There are many such infelicities in Windows, even very simple concepts like atomic file rename, fork, and exec are absent.
I haven't tried this, but jack is a networked sound protocol... it should be possible to export that to your end of a remote session.
Need a Linux consultant in New Orleans?
It's dependent on the version of the protocol supported by the client as well. Just like MS RDP on Mac does not support remote gateways. RDC 2.0 doesn't support RemoteApp - it supports opening a desktop session with the shell changed to whatever program you want, but it does not support RemoteApp.
I'm starting to think GNU is the problem with "GNU/Linux" these days.
This is great news and solves the long-standing question about how Wayland was going to handle remote clients in an acceptable manner.
But... the grandparent poster DIDN'T put a windowing system on the server!
virt-manager is a pretty simple X client, and the GUI is solely on your workstation. No GUI on the server at all. And, if that's what YOU do, you also don't have a GUI on the server:
[myworkstation] $ ssh -X myname@myserver ... and virt-manager appears in a window on your workstation.
[myserver] $ virt-manager
clicky, clicky, happy.
Folks - that's ALL there is to it. Except... myserver can be something completely different - A Solaris box, AIX, HP-UX, IRIX.
But, we get farther away... The Solaris application that has it's display on my workstation cannot use notifications (which should have been designed as an X extension, but the kids didn't know...). XBell seems to be deprecated. Without hackery, the xterm (that may be running on that AIX box) can't make a sound on my workstation (using that newfangled "pulse" thing). It can be hacked to work, though.
RDP? Will that help me? Probably not -- I don't log in to a single system that supports RDP.
Local X clients on my workstation can do fancier stuff, off course. But all the applications render to my X server, and the compositing happens locally, anyway. My Solaris and AIX X applications can push bitmaps, but they generally don't. Those applications really don't care.
The biggest problems with X today? Notifications. Other crap that uses other inter-application communications (like DBUS) instead of X. Deprecation of XBell. Network sound that is far too complicated.
If it takes "Wayland" to solve this, make sure that there is a simple proxy that can easily be deployed that lets me use those X applications. However, that doesn't fix my X issues, and just adds an additional layer.
How does this stack up? About the same as if I run an X Server (say Hummingbird, or Cygwin) on a Windows workstation. Interesting, that...the PRIMARY reason I (personally) run Linux as a workstation OS is to allow me to use an X Server as my primary display.
If that were not the case, I would just leave Windows (whatever version) on my workstation, and start from there.
Well... that and being able to simply recompile my code to run on the workstation or the servers as appropriate. I generally use Tk as a GUI for applications anyway (at least for one-off apps).
Just another "Cubible(sic) Joe" 2 17 3061
Sorry, this will NOT directly replace all you can do with X11. Not by a long shot.
Sadly, no. The closest it can get is delete on close. There are many such infelicities in Windows, even very simple concepts like atomic file rename, fork, and exec are absent.
Does this mean that the Unix subsystem for Windows doesn't actually implement the Unix behavior? I imagine that this would have to break many applications.
Ezekiel 23:20
Posix applications are very much second class citizens in Windows. If your app uses the posix subsystem, it loses a lot of other functionality. Only some editions of the various Windows versions have the support at all. It was only added in the first place to technically meet U.S. federal purchasing requirements but never really sufficed for any practical use..
And practically none of the elegance of Unix is evident in the standard Windows API.
I liked Daniel's video. It provided more detail about X than I've seen from any Wayland link so far and cleared up a lot about Wayland to finally get me interested in it's development. Daniel in particular is the first person I've seen talking about Wayland that I'm interested in listening to since he actually knows facts and can communicate them well as well as have a great attitude about what he's doing
That said, and I know I'm biased in favor of X, I'm very disappointed in the solution to all the problems in X11 that he detailed. Due to issues with how X handles it's job, the solution has been for years to let the client fix it at their end and use very little of X. Avoid fixing X. The Wayland solution sounds like take that work around and build a new display around it. Not encouraging.
From his description I agree: the X11 code cannot be fixed. But, my impression is that as coders/developers they applied a coders take to the problem and came up with a coders solution: Take the code written app-side as a work around and build a design on it. Reverse engineer a design based on code that exists. That sounds really negative and I know that will raise some bile, especially since the standard answer is "if you think they are wrong, code it yourself". Based on that video, there's no way I could code at his level so there's no ground for me to stand on there.
What makes me comment on this topic is that I like the X11 design/architecture and feel strongly it is more useful now than the alternatives (RDP/VNC/etc.) and will be more useful as time goes on. I would like a designers solution in that fix the design, then work towards getting that design coded. From the sound of things, that would mean dumping backwards compatibility with X11 protocol, but I would still rather loose X to a better design than loose it to what I see in the Wayland design. Unfortunately those who would be able to handle that kind of development look to be focused elsewhere...
AB HOC POSSUM VIDERE DOMUM TUUM
VNC sucks. RDP sucks a little less.
That said, I've shunted entire X sessions - the whole GNOME/KDE desktop - over the Internet. Performance was pretty decent - all using X11 forwarding over SSH. (Yeah, I basically logged in via SSH with X forwarding enabled and ran "startx". Overlayed my own desktop.)
Truth is like the sun. You can shut it out for a time, but it ain't goin' away. - Elvis Presley (source: imdb.com)
yum and apt aren't restricted to Free software; there's proprietary software that uses these (at least apt, not sure about yum) to maintain themselves too. A couple of examples are Opera and Google Talk.