World Library  
Flag as Inappropriate
Email this Article

Wayland (display server protocol)

Article Id: WHEBN0022675194
Reproduction Date:

Title: Wayland (display server protocol)  
Author: World Heritage Encyclopedia
Language: English
Subject: GTK+, GNOME, Qt (software), Window manager, KDE Software Compilation
Collection: Free Graphics Software, Free Software Programmed in C, Freedesktop.Org, Graphical User Interfaces, Wayland
Publisher: World Heritage Encyclopedia

Wayland (display server protocol)

Wayland demonstration
Original author(s) Kristian Høgsberg
Developer(s) et al.
Initial release 0.85 / 9 February 2012 (2012-02-09)[1]
Stable release 1.6.0 / 19 September 2014 (2014-09-19)[2]
Development status Active
Written in C
Operating system Linux
License HPND[3]
Website .org.freedesktopwayland

Wayland is a protocol that specifies the communication between a display server (called Wayland compositor) and its clients, as well as a reference implementation of the protocol in the C programming language.[4] Wayland is developed by a group of volunteers led by Kristian Høgsberg as a free and open-source software community-driven project with the aim of replacing the X Window System with a modern, simpler windowing system in Linux and Unix-like operating systems.[5] The source code of the project is published under the Historical Permission Notice and Disclaimer (HPND) license.[3]

As part of its efforts, the Wayland project also develops a reference implementation of a Wayland compositor called Weston.


  • Overview 1
  • Software architecture 2
    • Protocol architecture 2.1
    • Protocol overview 2.2
      • Wayland core interfaces 2.2.1
      • Wayland extension interfaces 2.2.2
    • Rendering model 2.3
  • Comparison with other window systems 3
    • Differences between Wayland and X 3.1
    • Compatibility with X 3.2
  • Wayland compositors 4
    • Weston 4.1
    • libinput 4.2
    • XDG-Shell protocol 4.3
    • Wayland Security Module 4.4
  • Adoption 5
    • Toolkit support 5.1
    • Desktop environments 5.2
    • Other software 5.3
    • Mobile and embedded hardware 5.4
  • History 6
    • Releases 6.1
  • See also 7
  • References 8
  • External links 9


① The evdev module of the Linux kernel gets an event and sends it to the Wayland compositor.
② The Wayland compositor looks through its scenegraph to determine which window should receive the event. The scenegraph corresponds to what's on screen and the Wayland compositor understands the transformations that it may have applied to the elements in the scenegraph. Thus, the Wayland compositor can pick the right window and transform the screen coordinates to window local coordinates, by applying the inverse transformations. The types of transformation that can be applied to a window is only restricted to what the compositor can do, as long as it can compute the inverse transformation for the input events.
③ As in the X case, when the client receives the event, it updates the UI in response. But in the Wayland case, the rendering happens by the client via EGL, and the client just sends a request to the compositor to indicate the region that was updated.
④ The Wayland compositor collects damage requests from its clients and then re-composites the screen. The compositor can then directly issue an ioctl to schedule a pageflip with KMS.

In recent years, Linux desktop graphics has moved from having "a pile of rendering interfaces... all talking to the X server, which is at the center of the universe" towards putting the Linux kernel and its components (i.e. DRI, DRM) "in the middle", with "window systems like X and Wayland ... off in the corner". This will be "a much-simplified graphics system offering more flexibility and better performance".[6]

Høgsberg could have added an extension to X as many recent projects have done, but preferred to "[push] X out of the hotpath between clients and the hardware" for reasons explained in the project's FAQ:[7]

Wayland consists of a protocol and a reference implementation named Weston. The project is also developing versions of GTK+ and Qt that render to Wayland instead of to X. Most applications are expected to gain support for Wayland through one of these libraries without modification to the application.

Wayland does not currently provide network transparency, but it may in the future.[8] It was attempted as a Google Summer of Code project in 2011, but was not successful.[9] Adam Jackson has envisioned providing remote access to a Wayland application by either 'pixel-scraping' (like VNC) or getting it to send a "rendering command stream" across the network (as in RDP, SPICE or X11).[10] As of early 2013, Høgsberg is experimenting with network transparency using a proxy Wayland server which sends compressed images to the real compositor.[11]

Software architecture

Protocol architecture

In Wayland protocol architecture, a client and a compositor communicate through the Wayland protocol using the reference implementation libraries.

Wayland protocol follows a client-server model in which clients are the graphical applications requesting the display of pixel buffers on the screen, and the server (compositor) is the service provider controlling the display of these buffers.

The Wayland reference implementation has been designed as a two-layer protocol:[12]

  • A low-level layer or wire protocol that handles the inter-process communication between the two involved processesclient and compositor—​and the marshalling of the data that they interchange. This layer is message-based and usually implemented using the kernel IPC services, specifically Unix domain sockets in the case of Linux and Unix-like operating systems.[13]
  • A high-level layer built upon it, that handles the information that client and compositor need to exchange to implement the basic features of a window system. This layer is implemented as "an asynchronous object oriented protocol".[14]

While the low-level layer was written manually in C language, the high-level layer is automatically generated from a description of the elements of the protocol stored in XML format.[15] Every time the protocol description of this XML file changes, the C source code that implements such protocol can be regenerated to include the new changes, allowing a very flexible, extensible and error-proof protocol.

The reference implementation of Wayland protocol is split in two libraries: a library to be used by Wayland clients called libwayland-client and a library to be used by Wayland compositors called libwayland-server.[16]

Protocol overview

The Wayland protocol is described as an "asynchronous object oriented protocol." Object oriented means that the services offered by the compositor are presented as a series of objects living on the same compositor. Each object implements an interface which has a name, a number of methods (called requests) as well as several associated events. Every request and event has zero or more arguments, each one with a name and a data type.[14] The protocol is asynchronous in the sense that requests do not have to wait for synchronized replies or ACKs, avoiding round-trip delay time and achieving improved performance.

The Wayland clients can make a request (a method invocation) on some object if the object's interface supports that request. The client must also supply the required data for the arguments of such request. This is the way the clients request services from the compositor. The compositor in turn sends information back to the client by causing the object to emit events (probably with arguments too). These events can be emitted by the compositor as a response to a certain request, or asynchronously, subject to the occurrence of internal events (such as one from an input device) or state changes. The error conditions are also signaled as events by the compositor.[14]

For a client to be able to make a request to an object, it first needs to tell the server the ID number it will use to identify that object.[14] There are two types of objects in the compositor: global objects and non-global objects. Global objects are advertised by the compositor to the clients when they are created (and also when they are destroyed), while non-global objects are usually created by other objects that already exist as part of their functionality.[17]

The interfaces and their requests and events are the core elements that define the Wayland protocol. Each version of the protocol includes a set of interfaces, along with their requests and events, which are expected to be in any Wayland compositor. Optionally, a Wayland compositor can define and implement their own interfaces with their own requests and events, in order to extend its functionality beyond the core protocol.[18] To facilitate changes between versions of the protocol, interfaces contain a "version number" attribute in addition to its name; this attribute allows an interface to be treated differently from previous versions of itself with fewer or different requests and events. Each Wayland compositor exposes not only what interfaces are available but also their supported version, and objects implement a particular version of an interface.[19]

Wayland core interfaces

The interfaces of the current version of Wayland protocol are defined in the file protocol/wayland.xml of the Wayland source code.[15] This is an XML file that lists the existing interfaces in the current version, along with their requests, events and other attributes. This set of interfaces is the minimum required to be implemented by any Wayland compositor.

Some of the most basic interfaces of the Wayland protocol are:[18]

  • wl_display – the core global object, a special object to encapsulate the Wayland protocol itself
  • wl_registry – the global registry object, in which the compositor registers all the global objects that it wants to be available to all clients
  • wl_compositor – an object that represents the compositor, and is in charge of combining the different surfaces into one output
  • wl_surface – an object representing a rectangular area on the screen, defined by a location, size and pixel content
  • wl_buffer – an object that, when attached to a wl_surface object, provides its displayable content
  • wl_output – an object representing the displayable area of a screen
  • wl_pointer, wl_keyboard, wl_touch – objects representing different input devices like pointers or keyboards
  • wl_seat – an object representing a seat (a set of input/output devices) in multiseat configurations

A typical Wayland client session starts by opening a connection to the compositor using the wl_display object. This is a special local object that represents the connection and does not live within the server. By using its interface the client can request the wl_registry global object from the compositor, where all the global object names live, and bind those that the client is interested in. Usually the client binds at least a wl_compositor object from where it will request one or more wl_surface objects to show the application output on the display.[17]

Wayland extension interfaces

A Wayland compositor can define and export its own additional interfaces.[18] This feature is used to extend the protocol beyond the basic functionality provided by the core interfaces, and has become the standard way to implement Wayland protocol extensions. Certain compositors can choose to add custom interfaces to provide specialized or unique features. The Wayland reference compositor, Weston, used them to implement new experimental interfaces as a testbed for new concepts and ideas, some of which later became part of the core protocol (such as wl_subsurface interface added in Wayland 1.4[20]).

Rendering model

XWayland and Glamor.

The Wayland protocol does not include a rendering API.[21][22][23][24] Instead, Wayland follows a direct rendering model, in which the client must render the window contents to a buffer shareable with the compositor.[22] For that purpose, the client can choose to do all the rendering by itself, use a rendering library like Cairo or OpenGL, or rely on the rendering engine of high-level widget libraries with Wayland support, such as Qt or GTK+. The client can also optionally use other specialized libraries to perform specific tasks, such as Freetype for font rendering.

Comparison with other window systems

Differences between Wayland and X

There are several differences between Wayland and X in regards to performance, code maintainability and security:[25]

  • Architecture: the composition manager is a separate, additional feature in X, while Wayland merges display server and compositor as a single function. Also, it incorporates some of the tasks of the window manager, which in X is a separate client-side process.[26]
  • Composition: compositing is optional in X, but mandatory in Wayland. Compositing in X is "active", that is, the compositor must fetch all pixel data, which introduces latency. In Wayland compositing is "passive", which means the compositor receives pixel data directly from clients.[27]
  • Rendering: the X server is able to render itself, although it can be instructed to display the rendered windows sent by clients. Wayland does not expose any API to render and delegates all the rendering responsibilities (including font rendering, widgets rendering, etc.) to the clients. Window decorations can be rendered on the client side, by the graphic toolkit, or on the server side, by the compositor.[28]
  • Security: Wayland isolates the input and output of every window, achieving confidentiality, integrity and availability in both cases; X lacks these important security features.[29] Also, with the vast majority of the code running in the client, less code needs to run with root privileges, improving security.[30]
  • Inter-process communication: the X server provides a basic communication method between X clients, later extended by ICCCM conventions. This X client-to-client communication is used by window managers and also to implement X sessions, selections and drag-and-drop, and other features. Wayland core protocol does not support communication between wayland clients at all, and the corresponding functionality (if needed) should be implemented by the desktop environments (like KDE or GNOME), or by a third party (for example, by using native IPC of the underlying operating system).
  • Networking: The X Window System is an architecture that was designed at its core to run over a network. Wayland does not offer network transparency by itself; however, a compositor can implement any remote desktop protocol to achieve remote displaying. In addition, there is research into Wayland image streaming and compression that would provide remote frame buffer access similar to that of VNC.[31]

Some of the differences can also be easily understood by comparing the architecture diagrams of both protocols.[32]

Compatibility with X

A screenshot showing xwayland

  • Official website
  • Wayland at FOSDEM 2012 by Kristian Høgsberg
  • The way to Wayland: Preparing for life After X by Joe 'Zonker' Brockmeier, LWN, 17 November 2010
  • Wayland – Beyond X by Richard Hillesley, The H, 13 February 2012
  • The Wayland Situation: Facts About X vs. Wayland by Eric Griffith, Phoronix, 7 June 2013

External links

  1. ^ a b Høgsberg, Kristian (9 February 2012). "[ANNOUNCE] Wayland and Weston 0.85.0 released". Wayland mailing list. Retrieved 8 June 2013. 
  2. ^ a b c Paalanen, Pekka (19 September 2014). "Wayland and Weston 1.6.0 released". 
  3. ^ a b "wayland/wayland: root/COPYING". 2014. Retrieved 26 November 2014. 
  4. ^ "Wayland". Wayland is a protocol for a compositor to talk to its clients as well as a C library implementation of that protocol. 
  5. ^ "Wayland". Wayland is intended as a simpler replacement for X, easier to develop and maintain. 
  6. ^ Jonathan Corbet (5 November 2010). "Linux Plumbers Conference: Life after X (reporting a talk by Keith Packard)".  
  7. ^ "Wayland FAQ". Retrieved 17 February 2011. 
  8. ^ Kristian Høgsberg (9 November 2010). "Network transparency argument". 
    "Wayland isn't a remote rendering API like X, but that doesn't exclude network transparency. Clients render into a shared buffer and then have to tell the compositor (...) what they changed. The compositor can then send the new pixels in that region out over the network. The Wayland protocol is already violently asynchronous, so it should be able to handle a bit of network lag gracefully. Remote fullscreen video viewing or gaming isn't going to work well, [but] I don't know any other display system that handles that well and transparently."
  9. ^ Michael Larabel (18 August 2011). "Remote Wayland Server Project: Does It Work Yet?". 
  10. ^ Adam Jackson (ajax) (9 November 2010). "[Re:] Ubuntu moving towards Wayland". 
  11. ^ Stone, Daniel (1 February 2013). The real story behind Wayland and X. 42:00 minutes in.  Presentation at 2013.
    "[W]e think it's going to better at remoting than X."
  12. ^ "The Hello Wayland Tutorial". Retrieved 25 July 2014. 
  13. ^ Høgsberg, Kristian. "Wayland Documentation 1.3 - Wire Format". Retrieved 25 July 2014. 
  14. ^ a b c d Høgsberg, Kristian. "Wayland Documentation 1.3 - Basic Principles". Retrieved 25 July 2014. 
  15. ^ a b Høgsberg, Kristian. "protocol/wayland.xml". Retrieved 25 July 2014. 
  16. ^ Høgsberg, Kristian. "Wayland Documentation 1.3 - Wayland Library". Retrieved 26 July 2014. 
  17. ^ a b Paalanen, Pekka. "Wayland protocol design: object lifespan". Retrieved 4 September 2014. 
  18. ^ a b c Høgsberg, Kristian. "Wayland Documentation 1.3 - Interfaces". Retrieved 31 July 2014. 
  19. ^ Høgsberg, Kristian. "Wayland Documentation 1.3 - Versioning". Retrieved 31 July 2014. 
  20. ^ a b Høgsberg, Kristian (24 January 2014). "Wayland and Weston 1.4 is out". Wayland mailing list. 
  21. ^ Høgsberg, Kristian. "Wayland". Retrieved 5 September 2014.  "No rendering API, all direct rendering"
  22. ^ a b Høgsberg, Kristian. "Wayland Documentation 1.3 - Wayland Rendering". Wayland project. Retrieved 4 September 2014. 
  23. ^ "Wayland FAQ". Wayland project. Wayland project. Retrieved 4 September 2014.  "Wayland doesn't render on behalf of the clients, it expects the clients to use whatever means they prefer to render into a shareable buffer."
  24. ^ Barnes, Jesse. "Introduction to Wayland". Intel Open Source Technology Center.  "Does not include a rendering API – Clients use what they want and send buffer handles to the server"
  25. ^ "The Wayland Situation: Facts About X vs. Wayland". 7 June 2013. p. 2. Retrieved 18 July 2013. 
  26. ^ "LFCS 2012: X and Wayland". 11 April 2012. Retrieved 19 March 2014. 
  27. ^ "Wayland/X Compositor Architecture By Example: Enlightenment DR19". Retrieved 4 July 2014. 
  28. ^ a b Gräßlin, Martin (7 February 2013). "Client Side Window Decorations and Wayland". Retrieved 26 February 2014. 
  29. ^ Peres, Martin. "Wayland Compositors - Why and How to Handle Privileged Clients!". Retrieved 26 February 2014. 
  30. ^ "XDC2012: Graphics stack security". Retrieved 18 July 2013. 
  31. ^ Stone, Daniel (28 January 2013). "The real story behind Wayland and X". 
  32. ^ "Wayland architecture".  
  33. ^ "X Clients under Wayland (XWayland)". Wayland project. Retrieved 18 July 2014. 
  34. ^ "ANNOUNCE: xorg-server 1.16.0".  
  35. ^ "Getting started with Lighthouse". Retrieved 17 December 2010. 
  36. ^ Kristian Høgsberg (25 January 2011). "Add wayland lighthouse plugin". 
  37. ^ Nokia (15 December 2011). "Qt Lighthouse git-repository". 
  38. ^  
  39. ^ Matthias Clasen (21 December 2010). "GTK+ 2.91.7 released". 
  40. ^ Kristian Høgsberg (3 January 2011). "Multiple backends for GTK+". 
  41. ^ "Jolla: Sailfish OS, Qt, and open source". LWN. 31 July 2013. 
  42. ^ e-releasemanager (18 August 2013). "A Double Dose Of The W |". Retrieved 23 August 2013. 
  43. ^ Grässlin, Martin. "The History on Wayland Support inside KWin". Martin’s Blog. Retrieved 15 July 2013. 
  44. ^ "Mutter-wayland tarballs". 
  45. ^ "README file from the Wayland source code repository".  
  46. ^  
  47. ^
  48. ^ Stone, Daniel (1 February 2013). The real story behind Wayland and X. 38:46 minutes in.  Presentation at 2013.
    "It doesn't require OpenGL. Nothing in Wayland requires OpenGL."
  49. ^ Kristian Høgsberg (9 December 2010). "Blender3D & cursor clamping.". 
  50. ^ "Maynard announcement". 16 April 2014. Retrieved 16 April 2014. 
  51. ^ a b "[RFC weston] remote access interface module".  
  52. ^ Ådahl, Jonas (12 November 2013). "[RFC] Common input device library". Wayland mailing list. 
  53. ^ "libinput". Retrieved 21 May 2014. 
  54. ^ a b Høgsberg, Kristian (20 May 2014). "Wayland and Weston 1.5.0 is released". Wayland mailing list. 
  55. ^ "xdg_shell: Adding a new shell protocol".  
  56. ^ "Security in Wayland-based desktop environments: Privileged clients, authorization, authentication and sandboxing!".  
  57. ^ "Clutter on Wayland". Retrieved 28 March 2012. 
  58. ^ "Wayland – Enlightenment". Retrieved 6 March 2013. 
  59. ^ "GTK+ 3.10 release mail". 23 September 2013. Retrieved 24 September 2013. 
  60. ^ Lantinga, Sam (8 March 2014). "SDL 2.0.2 RELEASED!". SDL Project. Retrieved 18 March 2014. 
  61. ^ Berglund, Camilla (8 April 2014). "Implementation for Wayland · Issue #106 · glfw/glfw · GitHub". Retrieved 14 August 2014. 
  62. ^ a b c "Plasma’s Road to Wayland". 25 July 2014. 
  63. ^ Grässlin, Martin (28 November 2010). "KWin runs on OpenGL ES". It does not only help, it is a must have to start working for Wayland. So to say it’s the first part of the KWin port to Wayland 
  64. ^ Grässlin, Martin (19 January 2011). "On the Road to Modern OpenGL (ES)". Retrieved 31 July 2013. 
  65. ^ Grässlin, Martin. "KWin Hacking++". Retrieved 8 April 2013. 
  66. ^ Larabel, Michael (14 June 2013). "KDE 4.11 Beta Released, Works On Wayland".  
  67. ^ "ANNOUNCE: New Wayland live CD". 21 March 2014. Retrieved 8 July 2014. 
  68. ^ "Glx-Dock/Cairo-Dock Has Been Ported To Wayland". 21 June 2014. 
  69. ^ "Enlightenment and EFL backing Wayland". 14 March 2013. Retrieved 15 July 2013. 
  70. ^ "Enlightenment as Standalone Wayland Compositor". 1 February 2014. Retrieved 16 February 2014. 
  71. ^ Larabel, Michael (13 March 2013). "GNOME Will Move Full-Speed With Wayland Support".  
  72. ^ "GNOME 3.10 Has Been Officially Released". Phoronix. 25 September 2013. Retrieved 8 October 2013. 
  73. ^ "3.10 Released!". GNOME. 25 September 2013. Retrieved 8 October 2013. 
  74. ^ "GNOME Wayland Initiative". GNOME Project. Retrieved 18 March 2014. 
  75. ^ "MATE Mythbusting | LINUX Unplugged 26". Jupiter Broadcasting. Retrieved 8 July 2014. 
  76. ^ "Split MATE 1.8 roadmap". Retrieved 8 July 2014. 
  77. ^ "Wayland in Fedora Update | Christian Schaller". 3 July 2014. Retrieved 8 July 2014. 
  78. ^ "VNC® Wayland Developer Preview". 8 July 2014. 
  79. ^ "RealVNC Wayland developer preview email".  
  80. ^ "Maliit Status Update". Posterous. 2 April 2013. Archived from the original on 17 May 2013. Retrieved 14 October 2013. 
  81. ^ "More Maliit Keyboard Improvements: QtQuick2". Murray's Blog. 2 April 2013. Retrieved 14 October 2013. 
  82. ^ "Maliit under Wayland". Retrieved 14 September 2013. 
  83. ^ "wlterm". Retrieved 8 July 2014. 
  84. ^ a b Richard Hillesley (13 February 2012). "Wayland – Beyond X". The H Open.  
  85. ^ "Mesa/Gallium3D Gets Its First ARM SoC GPU Driver". Phoronix. 12 March 2013. Retrieved 30 July 2013. 
  86. ^ Rob Clark (30 July 2013). "freedreno update: drm/kms and ifc6410". Blogspot. Retrieved 30 July 2013. 
  87. ^ "Nouveau Merged". Phoronix. 20 December 2006. Retrieved 30 July 2013. 
  88. ^ Michael Larabel (8 November 2010). "NVIDIA Says It Has No Plans To Support Wayland".  
  89. ^ "Red Hat Picks Up Another Graphics Driver Developer". Phoronix. 15 February 2013. Retrieved 30 July 2013. 
  90. ^ "Red Hat Talks About Nouveau, Open-Source Drivers". Phoronix. 11 May 2010. Retrieved 30 July 2013. 
  91. ^ "Eclipse now runs on Wayland". 18 August 2014. 
  92. ^ "Wayland Backend DRM | IVI Layer Management". GENIVI Alliance. Retrieved 15 July 2013. 
  93. ^ "IVI/IVI Setup". Tizen Wiki. Retrieved 8 April 2013. 
  94. ^ "[IVI] Tizen IVI 3.0-M1 released". Retrieved 15 July 2013. 
  95. ^ "Raspberry Pi Case Study". Collabora. Retrieved 9 August 2013. 
  96. ^ "Wayland preview". Raspberry Pi. Retrieved 9 August 2013. 
  97. ^ "The First Jolla Smartphone Runs With Wayland". 14 July 2013. Retrieved 8 October 2013. 
  98. ^ "sailfishos main components diagram". 
  99. ^ "our first Jolla will ship with wayland, yes". 
  100. ^ Høgsberg, Kristian. "Wayland – A New Display Server for Linux". Linux Plumbers Conference, 2009.  (Video available here [1])
  101. ^ Høgsberg, Kristian. "EGL and GLES1/2 on Linux". Linux Plumbers Conference, 2010. 
  102. ^ "Interview: Kristian Høgsberg".  
  103. ^ Høgsberg, Kristian (8 September 2008). "DRI2 Protocol Spec Draft". 
  104. ^ Høgsberg, Kristian (31 March 2008). "DRI2 Direct Rendering". 
  105. ^ "An Experimental GNOME Shell Running On Wayland". Retrieved 6 April 2012. Founder Kristian Høgsberg responsible for key X improvement of the past few years: DRI2.... 
  106. ^ Evan Jenkins (March 2011). "The Linux graphics stack from X to Wayland". Ars Technica. 
  107. ^ "Wayland Becomes A Project". Phoronix. 29 October 2010. Retrieved 31 July 2013. 
  108. ^ Kristian Høgsberg (29 October 2010). "Moving to". Retrieved 31 July 2013. 
  109. ^ Larabel, Michael (22 November 2010). "Wayland License Changing To LGPLv2".  
  110. ^ Larabel, Michael (20 September 2011). "Wayland Reference Code Being Re-Licensed".  
  111. ^ Carsten Munk (11 April 2013). "Wayland utilizing Android GPU drivers on glibc based systems, Part 1". Mer Project. Retrieved 3 July 2013. 
  112. ^ Munk, Carsten (8 June 2013). "Wayland utilizing Android GPU drivers on glibc based systems, Part 2". Mer Project. Retrieved 3 July 2013. 
  113. ^ "Jolla Brings Wayland Atop Android GPU Drivers". Phoronix. 11 April 2013. Retrieved 3 July 2013. 
  114. ^ "Nvidia drivers 331.13 beta". 4 October 2013. Retrieved 5 October 2013. Added support for the EGL API on 32-bit platforms. Currently, the supported client APIs are OpenGL ES 1.1, 2.0 and 3.0, and the only supported window system backend is X11. 
  115. ^ "NVIDIA Releases Major Linux Driver With New Features, EGL". Phoronix. Retrieved 5 October 2013. 
  116. ^ "Unterstützt Nvidia Wayland und Mir?". (in German) (Klass & Ihlenfeld Verlag GmbH). Retrieved 5 October 2013. 
  117. ^ James Jones (28 March 2014). "[PATCH 6/6] Xwayland DDX". we are actively working on support [for Wayland] and this certainly throws a wrench into things 
  118. ^ Daniel Stone (March 2013). "The real story behind Wayland and X". Ars Technica. 
  119. ^ "Wayland". Retrieved 15 July 2013. 
  120. ^ Høgsberg, Kristian (24 July 2012). "Wayland and Weston 0.95.0 released". Wayland mailing list. Retrieved 14 July 2013. 
  121. ^ Høgsberg, Kristian (22 October 2012). "Wayland and Weston 1.0". Wayland mailing list. Retrieved 14 July 2013. 
  122. ^ Scherschel, Fabian (23 October 2012). "Wayland's 1.0 milestone fixes graphics protocol". The H - Open.  
  123. ^  
  124. ^ Høgsberg, Kristian (15 April 2013). "1.1 Released". Wayland mailing list. Retrieved 18 July 2013. 
  125. ^  
  126. ^ Larabel, Michael (13 July 2013). "Wayland 1.2.0 Released, Joined By Weston Compositor".  
  127. ^ Høgsberg, Kristian (12 July 2013). "Wayland and Weston 1.2.0 released". Wayland mailing list. Retrieved 18 July 2013. 
  128. ^ Høgsberg, Kristian (11 October 2013). "Wayland and Weston 1.3 release notes". Wayland mailing list. 


See also

Major Wayland/Weston releases[119]
Version Date Wayland main features Weston main features
Old version, no longer supported: 0.85 9 Feb 2012[1] First release
24 Jul 2012[120] Began API stabilization
Old version, no longer supported: 1.0 22 Oct 2012[121][122] Stable wayland-client API
Old version, no longer supported: 1.1 15 Apr 2013[123][124] Software rendering.[125] FBDEV, RDP backends
Old version, no longer supported: 1.2 12 Jul 2013[126][127] Stable wayland-server API Color management. Subsurfaces. Raspberry Pi backend
Old version, no longer supported: 1.3 11 Oct 2013[128] More pixel formats. Support for language bindings Android driver support via libhybris
Old version, no longer supported: 1.4 23 Jan 2014[20] New wl_subcompositor and wl_subsurface interfaces Multiple framebuffer formats. logind support for rootless Weston
Older version, yet still supported: 1.5 20 May 2014[54] libinput. Fullscreen shell.
Current stable version: 1.6 Sep 2014[2] libinput by default
Future release: 1.7 Feb 2015 scheduled[2] xdg-shell interface


[118] The developers of Wayland are largely present

On 4 October 2013 Nvidia released a beta version of their 331.13 driver which supports the EGL API.[114] Although limited to X11, IT publications such as Phoronix and noted that EGL support in the Nvidia driver could pave the way for future Wayland support.[115][116] In March 2014, Nvidia announced a change in Wayland was "[throwing] a wrench into things" in their planned support for Wayland.[117]

The Wayland libraries (libwayland-server and libwayland-client) were released under the MIT License, with the demo compositor and clients originally under the GPLv2 license. Moving the whole project to LGPLv2 was planned[109] but did not occur and the project wanted to switch fully to the MIT License.[110] Wayland works with all Mesa-compatible drivers with DRI2 support[84] as well as Android drivers via the Hybris project.[111][112][113]

[108][107] In October 2010 Wayland became a

The name "Wayland" comes from the town of Wayland, Massachusetts. Høgsberg was driving through that town when the concepts behind Wayland "crystallized".[106]

Kristian Høgsberg (krh), a software engineer who works on the Linux graphics stack, started Wayland as a spare-time project in 2008, while working for Red Hat;[100] he is now at Intel.[101] His earlier work on X included AIGLX,[102] which enabled hardware acceleration of compositing window managers, and DRI2.[103][104][105] His stated goal was a system in which "every frame is perfect, by which I mean that applications will be able to control the rendering enough that we'll never see tearing, lag, redrawing or flicker."

Wayland uses direct rendering over EGL.


  • GENIVI Alliance: The GENIVI automotive industry consortium for in-vehicle infotainment (IVI) supports Wayland.[92]
  • Tizen: Tizen up to 2.x supports Wayland in in-vehicle infotainment (IVI) setups[93] and from 3.0 onward defaults to Wayland.[94]
  • Raspberry Pi: The Raspberry Pi Foundation in collaboration with Collabora released Maynard and work on improving performance and memory consumption, but do not expect to be able to replace X11 as the default display server until later in 2013[95][96]
  • Sailfish OS: The Jolla's company smartphones use Wayland as standard. It is also used as standard when Linux Sailfish OS is used with hardware from other vendors or when it is installed into Android devices by users.[97][98][99]

Mobile and embedded hardware

  • Intelligent Input Bus is working on Wayland support, it could be ready for Fedora 22[77]
  • RealVNC published a Wayland developer preview in July 2014[51][78][79]
  • Maliit: Maliit, an input method framework, runs under Wayland.[80][81][82]
  • kmscon supports Wayland with wlterm[83]
  • Mesa: Mesa, to which AMD and Intel directly contribute to support their graphics processors, has Wayland support integrated.[84] Within the Mesa projects, drivers for Qualcomm Snapdragon (freedreno)[85][86] and Nvidia GPUs (nouveau)[87][88] are being developed by Red Hat and community contributors.[89][90]
  • Eclipse was made to run on Wayland during a GSoC-Project in 2014.[91]

Other software

  • KDE:
    • KWin: is in the process of becoming a Wayland compositor, but support is incomplete;[62] support for OpenGL ES output was added in 2010,[63] in version 4.7.[64] In January 2013 KWin’s main developer Martin Grässlin started working for Blue Systems with one of the goals being a complete Wayland port.[65] Experimental Wayland support is now working in current KWin 4.11.[66]
    • KDE Frameworks 5: it is possible to run most applications built on top of Frameworks 5 under a Wayland compositor, without X11 as X11-dependent codepaths have become optional.[62]
    • KDE Plasma 5: is based on Frameworks 5, but as e.g. interfaces between the workspace shell, the compositor (KWin) and the display server are not yet well-defined or implemented up-stream, support is incomplete.[62]
    • Calligra Suite already has an unofficial but working port to Wayland.[67]
  • Glx-Dock has been ported to Wayland.[68]
  • Enlightenment version E19: and Enlightenment Foundation Libraries version 1.10 include full Wayland support.[69][70]
  • The Hawaii desktop environment exclusively supports Wayland.
  • GNOME: In March 2013 GNOME developers announced plans for a complete Wayland port within a year.[71] GNOME 3.10 includes initial support that "will enable the project to fully adopt the next generation display and input technology in the future".[72][73] The current roadmap targets GNOME 3.12 as the first version to be fully ported to Wayland.[74]
  • MATE: Wayland support is on Mate’s roadmap.[75] The targeted Mate version is 1.10.[76]

Desktop environments

  • Clutter has complete Wayland support.[57]
  • EFL has complete Wayland support, except for selection.[58]
  • GTK+ 3.10 has complete Wayland 1.2 support.[59]
  • Qt 5 has complete Wayland support.
  • SDL support for Wayland debuts with the 2.0.2 release, but as experimental and disabled by default.[60]
  • GLFW 3.1 will have experimental unadvertised Wayland support.[61]

Toolkit support

As explained in the "Software architecture" section above, the Wayland protocol is designed to be simple so that additional protocols and interfaces need to be defined and implemented to achieve a holistic windowing system. As of July 2014, these additional interfaces are actively being worked on. So, while the toolkits already fully support Wayland, the developers of the graphical shells are cooperating with the Wayland developers creating the necessary additional interfaces:


Wayland Security Module is a way to delegate security decisions within the compositor to a centralized security decision engine.[56]

Some applications (especially the ones related to accessibility) require privileged capabilities that should work across different Wayland compositors. Currently, applications under Wayland are generally unable to perform any sensitive tasks such as taking screenshots or injecting input events. Wayland developers are actively looking for feasible ways to handle privileged clients securely and then designing privileged interfaces for them.

Wayland Security Module is a proposition that resembles the Linux Security Module interface found in the Linux kernel.

Wayland Security Module

xdg_shell is a protocol aimed to substitute wl_shell in the long term, but will not be part of the Wayland core protocol. It starts as a non-stable API, aimed to be used as a development place at first, and once features are defined as required by several desktop shells, it can be finally made stable. It provides mainly two new interfaces: xdg_surface and xdg_popup. The xdg_surface interface implements a desktop-style window, that can be moved, resized, maximized, etc.; it provides a request for creating child/parent relationship. The xdg_popup interface implements a desktop-style popup/menu; an xdg_popup is always transient for another surface, and also has implicit grab.[55]

As of June 2014, XDG-Shell protocol was not versioned and still prone to changes.

XDG-Shell protocol (see for XDG) is an extended way to manage surfaces under Wayland compositors (not only Weston). The traditional way to manipulate (maximize, minimize, fullscreen, etc.) surfaces is to use the wl_shell_*() functions, which are part of the core Wayland protocol and live in libwayland-client. An implementation of the xdg-shell protocol, on the contrary, is supposed to be provided by the Wayland compositor. So you will find the xdg-shell-client-protocol.h header in the Weston source tree. Each Wayland compositor is supposed to provide its own implementation.

XDG-Shell protocol

[54] and it could also provide a generic [53] The goal was to provide any Wayland compositor with a common way to handle input events while minimizing the amount of custom input code compositors need to include. libinput provides device detection, device handling, input device event processing and abstraction,[52].libinput The Weston code to handle input devices (keyboards, pointers, touch screens, etc.) was split in its own separated library, called


A remote access interface for Weston was proposed in October 2013 by a RealVNC employee.[51]

Maynard is a graphical shell and has been written as a plugin for Weston, similar as the GNOME Shell has been written as a plugin to Mutter.[50]

Weston relies on GEM to share application buffers between the compositor and applications. It contains a plugin system, external "shells" for WM/dock/etc, and Weston supports X clients. Clients are responsible for the drawing of their window borders and their decorations. For rendering, Weston can use OpenGL ES or software (pixman[47]).[48] The full OpenGL implementation is not used, because on most current systems, installing the full OpenGL libraries would also install GLX and other X Window System support libraries as dependencies.[49]

Weston is written for the Linux kernel; as of February 2013, a prototype port of Wayland to FreeBSD was announced.[46]

Weston is the reference implementation of a Wayland compositor. It is written in C and was initially published under GPLv2, but is currently published under the HPND license. Weston is written for the Linux kernel API, i.e. it is only officially supported to work with the Linux kernel due to dependence on certain features, such as KMS driver, Graphics Execution Manager (GEM), and udev, which have not been implemented yet in other Unix-like operating systems.[45] When running on Linux kernel, handling of the input hardware relies on evdev, while the handling of buffers relies on Generic Buffer Management (GBM).


  • Weston – the reference implementation of a Wayland compositor; Weston implements client-side decoration
  • Lipstick – mobile graphical shell framework which implements Wayland compositor. It is used in Sailfish OS and Nemo Mobile.[41]
  • Enlightenment 0.19 (E19) is expected to have full Wayland support.[42]
  • KWin had incomplete Wayland support in April 2013.[43]
  • Mutter maintains a separate branch for the integration of Wayland for GNOME 3.9 (in September 2013).[44]
  • Clayland is a simple example Wayland compositor using Clutter.

Display servers that implement the Wayland display server protocol are also called Wayland compositors because they additionally perform the task of a compositing window manager.

Typical elements of a window. Neither Wayland nor X11 specify which software has to do the drawing of the window decoration. Weston requires that they be drawn by the client, but KWin will implement server-side decoration.[28]

Wayland compositors

In December 2010, GTK+ added preliminary support for switching back-ends at run time, saying "interesting combinations are X11+Wayland or Quartz+X11".[38][39] In January 2011, the GTK+ Wayland backend was updated to support the multiple-backends feature and moved to the gdk-wayland-backend branch of the upstream GTK+ Git repository.[40] In April 2011, the gdk-wayland-backend branch was merged in the GTK+ master branch.

Qt applications can switch between graphical back-ends like X and Wayland at load time with the -platform command-line option.[35] In January 2011, Wayland support was moved into the Lighthouse branch of the upstream Qt repository.[36] Qt Lighthouse is shipped in the Qt 4.8 release.[37]


This article was sourced from Creative Commons Attribution-ShareAlike License; additional terms may apply. World Heritage Encyclopedia content is assembled from numerous content providers, Open Access Publishing, and in compliance with The Fair Access to Science and Technology Research Act (FASTR), Wikimedia Foundation, Inc., Public Library of Science, The Encyclopedia of Life, Open Book Publishers (OBP), PubMed, U.S. National Library of Medicine, National Center for Biotechnology Information, U.S. National Library of Medicine, National Institutes of Health (NIH), U.S. Department of Health & Human Services, and, which sources content from all federal, state, local, tribal, and territorial government publication portals (.gov, .mil, .edu). Funding for and content contributors is made possible from the U.S. Congress, E-Government Act of 2002.
Crowd sourced content that is contributed to World Heritage Encyclopedia is peer reviewed and edited by our editorial staff to ensure quality scholarly research articles.
By using this site, you agree to the Terms of Use and Privacy Policy. World Heritage Encyclopedia™ is a registered trademark of the World Public Library Association, a non-profit organization.

Copyright © World Library Foundation. All rights reserved. eBooks from Hawaii eBook Library are sponsored by the World Library Foundation,
a 501c(4) Member's Support Non-Profit Organization, and is NOT affiliated with any governmental agency or department.