Polo 1.0 Brings MATE's Classic Linux Desktop Experience Into the Wayland Era
The MATE desktop environment has taken an important step toward native Wayland compatibility with the release of Polo 1.0, a new compositor designed to preserve MATE's traditional desktop behavior while replacing its dependence on the X11 display system. Released on November 12, 2026, the project introduces a Wayland-native window manager, compositor, and session-management framework built specifically around MATE's existing architecture.
Developed independently by Kerem Söke, Polo uses libweston 16 as its Wayland foundation while retaining the window-management policies, keyboard shortcuts, themes, and configuration settings associated with Marco, MATE's long-standing X11 window manager. Rather than requiring users to adapt to a completely different desktop workflow, Polo attempts to recreate the familiar MATE experience using modern Linux display technology.
The initial release already supports window tiling, virtual workspaces, XWayland applications, multiple monitors, display scaling, screenshots, screen sharing, and session management. It also includes classic desktop effects such as wobbly windows, animated minimization, and the three-dimensional desktop cube.
Although Polo 1.0 represents substantial progress, it remains an independent project under active development rather than an officially adopted replacement for Marco. Its developer is seeking testers, particularly users with complex hardware configurations, as the broader MATE ecosystem continues preparing its components for Wayland.
Why MATE Needs a Native Wayland Compositor
MATE originated as a continuation of the GNOME 2 desktop experience, preserving the traditional Linux interface built around panels, application menus, desktop icons, and conventional window management. Its design has remained popular among users who prefer a familiar, configurable desktop without adopting the workflows introduced by newer desktop environments.
For much of its history, MATE has relied on X11, the display system that supported Linux graphical desktops for decades. Its Marco window manager handles window placement, decorations, workspaces, keyboard shortcuts, and other fundamental desktop interactions.
However, Linux desktop development has increasingly shifted toward Wayland. Major environments such as GNOME and KDE Plasma have invested heavily in native Wayland sessions, while graphics drivers, screen-sharing tools, and desktop applications continue expanding their Wayland capabilities.
Wayland changes the relationship between applications, compositors, and input devices. Instead of depending on a separate X server and window manager, a Wayland compositor generally coordinates display output, input handling, window management, and graphical composition.
For MATE, this transition creates a difficult engineering challenge. The desktop contains years of assumptions about X11 behavior, and replacing its display infrastructure without changing the user experience requires careful integration.
Polo addresses that problem by recreating Marco's behavior within a Wayland-native compositor rather than introducing an entirely new desktop design.
Polo Recreates Marco Instead of Replacing MATE's Workflow
The central design principle behind Polo is compatibility with MATE's established desktop behavior. Its developer wants users to recognize the same window-management experience they already know from Marco, including familiar shortcuts, themes, menus, and workspace interactions.
This approach differs from simply launching MATE applications under an unrelated Wayland compositor. A general-purpose compositor may provide window management and display output, but it does not necessarily understand MATE's existing configuration conventions or session-management expectations.
Polo incorporates Marco's window-management policies directly into its implementation. It continues recognizing settings stored under the org.mate.Marco.* GSettings hierarchy, allowing existing preferences to remain relevant in the new environment.
For example, users can inspect Marco's configured keyboard shortcuts with:
gsettings list-recursively org.mate.Marco.global-keybindings
The command displays the current shortcut configuration associated with Marco's global keybindings. These settings can include operations such as switching windows, moving between workspaces, and invoking window-management actions.
Users can also inspect available Marco-related configuration schemas with:
gsettings list-schemas | grep org.mate.Marco
The significance of preserving these interfaces extends beyond convenience. Existing configuration tools and user preferences can continue interacting with familiar settings rather than requiring an entirely new configuration system.
Polo also introduces its own settings under org.mate.polo, separating compositor-specific functionality from the established Marco configuration.
libweston 16 Provides the Wayland Foundation
Polo is built using libweston 16, the compositor library associated with the Weston reference implementation of Wayland.
Weston provides an established collection of components for implementing Wayland compositors, including output management, rendering infrastructure, input handling, and communication with graphical clients. Developers can use these components instead of implementing every part of the Wayland protocol stack independently.
Polo combines this foundation with code written in C and Vala. C is widely used for low-level Linux systems programming, while Vala provides a higher-level development language that integrates closely with GLib and the GNOME technology ecosystem.
This combination allows Polo to reuse established Wayland infrastructure while concentrating development effort on MATE-specific behavior.
The project currently installs its own patched version of libweston 16.0.1 within a private Polo library directory. This helps isolate its compositor dependencies from other software that may use different Weston versions or configurations.
Maintaining a private library build introduces additional packaging responsibilities, but it also allows Polo to incorporate the adjustments required by its current implementation.
The architectural goal is to preserve MATE's familiar interface while replacing the underlying X11-dependent components with Wayland-compatible alternatives.
Window Management Supports Tiling and Traditional Controls
Polo 1.0 already implements a substantial collection of window-management features.
Users can switch between applications with Alt+Tab, access traditional window menus, work with multiple virtual desktops, and arrange windows using keyboard shortcuts or mouse-driven tiling.
Window tiling allows applications to occupy defined portions of the screen without requiring users to resize each window manually. Polo supports tiling through keyboard commands and by dragging windows into appropriate positions, including visual previews of the resulting layout.
These features are important because MATE users expect more than basic application rendering. A desktop environment must coordinate window placement, focus changes, keyboard interactions, and workspace behavior consistently.
Polo also provides dialogs and on-screen displays through its polo-shell-ui component. These interface elements communicate information about window operations and other desktop activities.
The implementation includes accessibility announcements for supported interface elements, helping screen readers recognize relevant desktop notifications.
Although the underlying display protocol changes, the intention is for users to retain the conventional window-management behavior associated with MATE.
XWayland Keeps Older Linux Applications Running
One of the challenges of transitioning a desktop environment to Wayland is maintaining compatibility with applications that still depend on X11.
Polo addresses this through XWayland, a compatibility server that allows X11 applications to operate within a Wayland session.
XWayland translates the necessary communication between legacy X11 clients and the Wayland environment. This allows users to continue running applications that have not yet adopted native Wayland support.
Polo includes its own XWayland window manager, applying Marco-style window-management behavior to these applications.
This is particularly important for MATE because some of its existing components and third-party applications still contain X11-specific functionality.
Users can inspect the display protocol used by their current desktop session with:
echo "$XDG_SESSION_TYPE"
On a native Wayland session, the output normally reports:
wayland
On a traditional X11 session, it typically reports:
x11
This identifies the session type rather than the protocol used by every individual application. An X11 application running through XWayland can still operate inside a session identified as Wayland.
The compatibility layer makes a gradual migration possible, allowing native Wayland components and legacy X11 applications to coexist.
Polo Includes Its Own MATE Session Manager
One of Polo's most significant architectural features is that it handles more than graphical composition and window management.
The project also implements MATE session-management functionality, allowing it to take over responsibilities traditionally associated with mate-session-manager.
A desktop session manager coordinates application startup, user sessions, logout procedures, shutdown requests, and interactions with system power-management services.
Polo provides a session mode through:
polo --session
This mode implements interfaces compatible with mate-session-manager 1.28, including the D-Bus interfaces used by existing MATE components.
The implementation supports application autostart, session inhibitors, user presence information, saved sessions, and shutdown dialogs. It also integrates with logind for operations such as suspend, hibernate, reboot, power off, and user switching.
Session inhibitors are particularly important because applications sometimes need to delay shutdown or suspend operations. A document editor, for example, may need an opportunity to save unsaved work before the desktop closes.
By implementing these mechanisms directly, Polo reduces the need to maintain separate X11-dependent session infrastructure alongside its Wayland compositor.
Saved Sessions and Autostart Behavior Remain Familiar
MATE users often configure applications to launch automatically when they log in. Some also rely on saved sessions to restore previously running applications.
Polo 1.0 supports these workflows through a session-management implementation designed around MATE's existing conventions.
Application startup follows recognizable phases, including initialization, window management, panel startup, desktop initialization, and ordinary application launching.
This ordering matters because some desktop components depend on others being available first. A panel may need a functioning compositor, while desktop applications may expect session services and configuration interfaces to be initialized.
Polo also supports conditional startup, delays, and application restarts, allowing the session to coordinate more complex initialization requirements.
Saved sessions continue using the familiar location:
~/.config/mate-session/saved-session
Users can inspect whether this directory exists with:
ls -la ~/.config/mate-session/saved-session
The directory may not exist on systems that have never saved a session.
Polo also provides compatibility with the X Session Management Protocol through XSMP, allowing supported legacy X11 applications to participate in session management.
These features help make Polo a complete desktop-session implementation rather than simply a Wayland compositor capable of launching applications.
Multi-Monitor Support Includes Scaling and Hotplugging
Modern Linux desktops must support a wide variety of display configurations, including laptops with external monitors, workstations with several displays, and systems using different resolutions or scaling factors.
Polo 1.0 includes a DRM-based display backend with support for multiple monitors, display hotplugging, saved layouts, gamma adjustment, and output zoom.
Hotplugging allows the compositor to respond when displays are connected or disconnected while the desktop is running. This is particularly important for laptop users who frequently move between standalone operation and external-monitor setups.
Display scaling allows interface elements to remain usable on high-resolution monitors. Without appropriate scaling, text and controls may appear too small on dense displays.
Polo stores monitor configuration information in:
~/.config/mate/polo/monitors.xml
This allows the compositor to preserve supported display arrangements across sessions.
Users can inspect the configuration file with:
cat ~/.config/mate/polo/monitors.xml
The file is available only after the relevant configuration has been created.
Multi-monitor behavior remains an important testing priority. Although the basic functionality is implemented, unusual display arrangements, mixed scaling factors, and hardware-specific driver behavior may reveal problems that have not yet been encountered during development.
Classic Desktop Effects Return With Wayland
Polo 1.0 includes an extensive collection of visual effects inspired by the desktop environments that helped define earlier generations of Linux graphical interfaces.
Among the supported effects are the desktop cube, wobbly windows, fade animations, zoom transitions, spin effects, and the Magic Lamp minimization animation.
The desktop cube transforms virtual workspaces into faces of a three-dimensional cube, allowing users to visualize workspace transitions. Wobbly windows add elastic movement when windows are dragged, while the Magic Lamp effect animates windows as they minimize.
These effects were popular during the Compiz era, when Linux desktops became known for advanced graphical customization.
Polo also includes effects described as zap, squeemize, and expo, expanding the available animation and workspace-presentation options.
Effect configuration is organized under:
org.mate.polo.effects
On an installed Polo system, users can inspect the available settings with:
gsettings list-recursively org.mate.polo.effects
The exact settings depend on the installed version and available schemas.
Although these effects are primarily cosmetic, they reinforce Polo's objective of preserving the visual character of traditional Linux desktops.
They also demonstrate that a Wayland compositor designed for MATE can provide more than basic window rendering.
Screenshots and Screen Sharing Use Wayland Portals
Screen capture is another area where Wayland differs substantially from X11.
Under X11, applications could often inspect or capture desktop content through interfaces exposed by the display server. Wayland uses a more restrictive model in which applications generally cannot access arbitrary screen content without cooperation from the compositor and related services.
Polo supports screenshots and screen sharing through the XDG Desktop Portal infrastructure.
Desktop portals provide standardized interfaces that applications can use to request access to system resources, including screen capture, file selection, and other operations that require coordination with the desktop environment.
Polo includes a screenshot component named polo-screenshot and a screen-sharing selection interface.
The compositor also supports layer-shell functionality, allowing desktop components such as mate-panel to occupy special regions of the screen.
These capabilities are essential for a functional Wayland desktop. Without them, applications such as screen recorders, video-conferencing tools, and remote collaboration software may be unable to capture the desktop correctly.
The availability of portal support does not guarantee compatibility with every recording or conferencing application, but it provides the infrastructure needed for supported Wayland capture workflows.
Polo Takes a Different Approach From Wayfire
MATE has already experimented with Wayland through a session based on Wayfire, an extensible compositor that supports plugins and configurable desktop effects.
Wayfire provides a general-purpose Wayland environment, but it was not originally designed specifically around MATE's internal architecture.
Integrating MATE with Wayfire therefore requires configuration files, plugins, compatibility adjustments, and supporting scripts.
Polo approaches the problem differently by making MATE compatibility a central design requirement.
Instead of adapting MATE's behavior to match an external compositor, Polo implements the window-management policies and session interfaces that MATE already expects.
This can reduce certain integration differences, particularly around keyboard shortcuts, window rules, session behavior, and existing GSettings configuration.
However, the approach also creates a substantial maintenance responsibility. Polo must continue implementing and maintaining the functionality required by the desktop as MATE and Wayland evolve.
The two approaches are not necessarily mutually exclusive. Wayfire remains part of MATE's experimental Wayland work, while Polo provides another implementation that may help identify which architectural choices best preserve the traditional desktop experience.
MATE Settings Daemon Still Depends on XWayland
Despite the progress in Polo 1.0, not every MATE component has completed the transition to native Wayland.
One important example is mate-settings-daemon, which continues running through XWayland in the current Polo session.
The settings daemon traditionally manages several desktop behaviors, including keyboard configuration, mouse settings, display management, multimedia keys, and background handling.
Some of these functions depend on X11 interfaces that do not translate directly into Wayland.
Polo disables incompatible settings-daemon plugins within its own session to prevent conflicts or unsupported operations.
The affected areas include XRandR display configuration, certain keyboard and mouse functions, multimedia keys, accessibility keyboard handling, and background management.
Disabling these plugins does not mean the entire desktop loses the corresponding capabilities. In some cases, Polo provides the necessary functionality directly through its compositor and session-management infrastructure.
However, it does mean that some traditional MATE configuration components may not yet operate exactly as they do under X11.
Completing this integration will require continued development across Polo and the broader MATE software stack.
Distribution Packages Need Wayland-Enabled Builds
Another challenge concerns how Linux distributions package MATE components.
Some distributions currently build packages such as mate-panel with X11-oriented configurations. Even when upstream MATE code contains Wayland support, users may not receive that functionality if their distribution packages were compiled without the appropriate options.
Polo's developer specifically identifies this as a limitation affecting Fedora and other distributions.
The project recommends using recent MATE components compiled with Wayland support to obtain the most complete experience.
This distinction is important because software support exists at several levels. A feature may be implemented upstream but remain unavailable in a distribution until maintainers enable the relevant build options and publish updated packages.
MATE's ongoing 1.29 development series includes additional Wayland-related work, particularly in panel integration and other desktop components.
As these changes reach distribution repositories, testing Polo should become easier.
For now, users may need to build more than just the compositor to obtain a complete Wayland-compatible MATE environment.
Building Polo 1.0 From Source on Linux
Polo 1.0 is distributed primarily as source code, with build instructions covering Fedora 44 and 45, Debian 14, Ubuntu 26.04, and Ubuntu 26.10.
The project uses Meson and Ninja for compilation and requires development dependencies associated with Wayland, GLib, GTK, Vala, graphics libraries, and system integration.
Its documented minimum build requirements include Vala 0.56, GLib 2.80, Meson 1.4, and Wayland Protocols 1.46.
After installing the appropriate development dependencies and obtaining the Polo 1.0 source archive, users can extract it with:
tar xf polo-1.0.0.tar.xz
cd polo-1.0.0
The build can then be configured with:
meson setup build --buildtype=release --prefix=/usr
Compilation and installation follow:
ninja -C build
sudo ninja -C build install
These commands follow the project's published build procedure, but they assume the required dependencies are already installed.
Because this is an early compositor release, users should test it on a noncritical system or separate installation before replacing their primary desktop workflow.
Installing development software directly under /usr can also complicate package management because files installed manually may not be tracked by the distribution's package manager.
Experienced users may prefer to build distribution packages or test Polo in a dedicated development environment.
Testing Polo Without Replacing the Current Desktop
Developers who want to investigate Polo do not necessarily need to begin by replacing their existing graphical session.
The project supports running the compositor in nested or headless configurations, allowing selected functionality to be tested independently.
After configuring and compiling the source tree, a nested development session can be started from an existing Wayland desktop with:
meson devenv -C build polo --exec gtk3-demo
This launches Polo within the development environment and starts a GTK demonstration application.
For automated testing or debugging, Polo also supports a headless backend:
meson devenv -C build polo --backend=headless --renderer=pixman
Headless mode can be useful when testing compositor behavior without requiring a physical display.
Developers can also run the project's automated tests with:
meson test -C build
These commands assume they are executed from the Polo source directory after a successful build.
Nested and headless testing cannot reproduce every issue that occurs on real graphics hardware, but they provide a useful starting point for investigating application compatibility and compositor behavior.
Selecting the MATE Polo Session Through LightDM
After installing Polo and the required Wayland-enabled MATE components, users can select MATE (Polo) from the LightDM login screen.
LightDM is a display manager commonly used by lightweight Linux desktop environments. It handles graphical login and allows users to choose between installed desktop sessions.
The Polo session starts the compositor and associated MATE components using the project's Wayland configuration.
Users can also launch the complete development session from a text console through the included startup script:
./start-polo.sh
The script is intended to initialize the session and collect diagnostic information. Development-session logs are stored under:
~/polo-logs/
These logs can help identify problems involving application startup, compositor initialization, or desktop integration.
For more targeted debugging, Polo provides logging options such as:
polo --debug-scopes=polo-policy,drm-backend
Users can also write diagnostic output to a file:
polo --log=/tmp/polo.log
These facilities are especially valuable while the project is collecting feedback from early testers.
Known Limitations Make Polo 1.0 an Experimental Release
Although the version number has reached 1.0, Polo is not yet a fully polished replacement for every MATE installation.
The developer acknowledges that testing remains incomplete across different graphics hardware, applications, and multi-monitor configurations.
Several MATE components still require Wayland-enabled builds, and some desktop settings continue relying on XWayland compatibility.
The release also documents a GTK 3.24 memory leak associated with closing windows under Wayland. Polo includes a workaround for its own shell interface, but the underlying issue remains relevant to affected GTK applications.
Another important limitation concerns the magnifier. The Polo 1.0 release notes explicitly warn users not to start it because of a known issue. A correction has been prepared for a subsequent version, but it is not included in the original 1.0 release.
These limitations matter because compositor stability affects the entire graphical session. A crash or serious display problem can interrupt all applications running under the affected desktop.
Users interested in testing Polo should preserve access to their existing X11 session and avoid relying on the new compositor for critical work until its compatibility has been evaluated.
What Polo Means for the Future of MATE
Polo's arrival demonstrates that MATE's traditional desktop model can be adapted to Wayland without abandoning the design principles that made the environment popular.
The project does not attempt to transform MATE into GNOME, KDE Plasma, or another modern desktop environment. Instead, it treats the existing desktop behavior as something worth preserving.
This approach could be particularly valuable for users who prefer conventional panels, application menus, familiar window controls, and stable keyboard shortcuts.
It also offers an opportunity for the MATE development community to evaluate a compositor built around its own interfaces rather than depending entirely on a general-purpose alternative.
However, Polo's long-term role remains uncertain. It is independently developed, and the MATE project has not officially adopted it as the replacement for Marco.
For Polo to become a widely available option, several additional steps would be necessary. These include broader hardware testing, continued Wayland integration across MATE components, distribution packaging, accessibility improvements, and sustained maintenance.
The release provides a working foundation for that effort, but it does not establish that the transition is complete.
Why the Release Matters for Linux Desktop Diversity
The broader significance of Polo extends beyond MATE itself.
As Linux desktops move toward Wayland, smaller environments face the challenge of modernizing their graphics infrastructure without the development resources available to larger projects.
Implementing a Wayland compositor requires substantial work involving graphics rendering, input devices, session management, application compatibility, screen capture, and desktop integration.
For a traditional desktop environment, the challenge is even greater because users expect established behavior to remain consistent throughout the transition.
Polo demonstrates one possible solution: build on an existing compositor library while preserving the desktop's original policies and configuration interfaces.
This approach may help smaller desktop projects modernize without abandoning their identity.
It also reinforces the importance of reusable open-source infrastructure. Libraries such as libweston, protocols maintained by the Wayland ecosystem, and standardized desktop portals make it possible for independent developers to create functional compositor implementations without starting from nothing.
Whether Polo becomes an official MATE component or remains an alternative implementation, its development contributes to the broader effort to maintain diversity across Linux desktop environments.
Conclusion
Polo 1.0 represents an important milestone in bringing MATE's traditional desktop experience to Wayland. Released on November 12, 2026, the independent compositor combines modern display infrastructure with the familiar window-management behavior, settings, themes, and session functionality associated with Marco.
Built on libweston 16, Polo supports window tiling, virtual workspaces, XWayland applications, multiple monitors, display scaling, screenshots, screen sharing, and integrated session management. It also restores classic Linux desktop effects such as wobbly windows, animated minimization, and the desktop cube.
Its most important architectural decision is preserving MATE's existing interfaces. By maintaining compatibility with Marco's GSettings configuration and implementing familiar session-management APIs, Polo aims to make the transition to Wayland less disruptive for users and desktop applications.
The project still faces significant challenges. Some MATE components require Wayland-enabled builds, parts of the settings infrastructure remain dependent on XWayland, and broader hardware testing is necessary before the compositor can be considered production-ready.
Nevertheless, Polo 1.0 provides a working demonstration of how MATE can move beyond X11 while retaining its established desktop identity. For Linux users who value the traditional MATE experience, the release offers an encouraging foundation for a future native Wayland session.
