A visually-focused desktop system designed around smooth animations, thoughtful gestures and careful attention to detail, inspired by familiar macOS interactions.

This system aims to be visually refined and pleasant to use, while at the same time, serving as an experimental platform to push the Linux desktop environment forward.

Otto is a Wayland compositor and stacking window manager, built in Rust on top of LayersEngine and uses Skia for rendering.

While many features are ready for daily use, there is still some work required for full stability. Testing is valuable therefore you are invited to play around with Otto.

Dock task manager showing running applications.

Minimising windows with animated genie effect to the Dock.

Moving windows between workspaces with drag and drop.

Navigating between applications from the Dock.

Workspace selector with visual previews.

Exposé view showing all open windows with smooth animations.

Application switcher with icons, names and background blur.

Otto is in an early but functional state and can be tested by building it from source. Many features are still missing, and the project is not yet packaged for any distribution.

Testing and issue reports are welcome. Development follows a draft roadmap of planned features and improvements.

• Window management: move/resize, fullscreen/maximize (animated), minimise to the Dock (animated).
• Workspaces: multiple workspaces, animated switching, drag windows between workspaces, configurable background.
• Dock (task manager): shows running apps, minimised windows and pinned/bookmarked apps.
• App switcher (default: Ctrl+Tab): searches app metadata/icons (XDG), can close apps, cycles between windows of the same app.
• Exposé / overview (default: PageDown, gesture: three-finger swipe up): shows all windows, shows window previews with names, includes “show desktop”.
• Input: natural scrolling, two-finger scrolling, keyboard remapping.
• Theming: dark/light.
• Screen sharing: works through an XDG Desktop Portal backend + PipeWire (full-screen capture via GPU blit + dmabuf).

• Multi-monitor: multiple screens.
• Screen capture: per-window capture, screenshots, and a permission dialog UI.
• Session management: lockscreen / login with libseat integration.
• Topbar: application menus and system integration.
• Dock improvements: favorite locations; move Dock code out of compositor core.
• System UI: brightness, volume, keyboard backlight widgets; notifications.
• Input polish: scroll acceleration.

• Scene graph protocol: WIP protocol (sc-layer-v1) to expose the scene graph and animations to external clients for advanced UI customisation and effects.
• Ideas: remote "virtual screens" (VNC/RDP).

Otto implements a comprehensive set of Wayland protocols, including:

• Core: wl_compositor, wl_shm, wl_seat, wl_data_device_manager
• Shells: xdg_wm_base (XDG shell), wlr_layer_shell_v1 (Layer shell 1.0)
• Output management: wl_output, xdg_output, wp_presentation
• Rendering: zwp_linux_dmabuf_v1, wp_viewporter
• Input: pointer gestures, relative pointer, keyboard shortcuts inhibit, text input, input method
• Selection: primary selection, data control (wlr-data-control)
• XDG foreign: cross-client surface identification

For a complete and up-to-date list, see docs/developer/wayland.md.

Otto consists of the main compositor and additional components:

The portal backend is located in components/xdg-desktop-portal-otto/.

Both this project and the LayersEngine are open to contributions. Contribute by testing the compositor, reporting bugs, by implementing new features or by bringing new ideas. If you have any questions, open an issue on the repository.

The repository provides AGENTS.md, automated code review instructions and developer documentation to support both human contributors and coding agents.

You'll need to install the following dependencies (note, that those package names may vary depending on your OS and linux distribution):

• libwayland
• libxkbcommon
• libudev
• libinput
• libgbm
• libseat

If you want to enable X11 support (to run X11 applications within Otto), then you'll need to install the following packages as well: - xwayland

You can run Otto with cargo after having cloned this repository:

cd otto;

cargo run -- --{backend}

Current available backends:

• --tty-udev: start Otto in a tty with udev support. This is the "traditional" launch of a Wayland compositor. Note that this might require you to start Otto as root if your system does not have logind available.
• --winit: start Otto as a Winit application. This allows you to run it inside of an other X11 or Wayland session, useful for developemnt.
• --x11: start Otto as an X11 client. This allows you to run the compositor inside an X11 session or any compositor supporting XWayland. This implementation is quite basic and not really maintaned.

Otto uses TOML configuration files. A complete example configuration is provided in otto_config.example.toml which you can copy and modify:

cp otto_config.example.toml otto_config.toml

You can create backend-specific configuration files using the naming convention otto_config.{backend}.toml. For example:

• otto_config.winit.toml - Configuration for the winit backend
• otto_config.udev.toml - Configuration for the tty-udev/DRM backend

When running with a specific backend, Otto will automatically load the corresponding configuration file if it exists, falling back to otto_config.toml otherwise.

This allows you to maintain different display settings, keyboard shortcuts or other preferences for each backend. For instance, you might want different screen_scale values or display resolutions when running in a window (winit/X11) versus on bare metal (tty-udev).

For detailed configuration options, see the configuration documentation.

Hotkeys are now fully configurable via the otto_config.toml file. See the [keyboard_shortcuts] section to customize keybindings for your setup. Example:

[keyboard_shortcuts]
"Ctrl+Alt+BackSpace" = "Quit"
"Ctrl+Shift+Q" = "Quit"
"Ctrl+Return" = { run = { cmd = "terminator", args = [] } }
"Logo+Space" = { open_default = "file_manager" }
"Logo+B" = { open_default = "browser" }
"Ctrl+1" = { builtin = "Workspace", index = 0 }

Otto includes built-in support for profiling using puffin. The profiler is enabled by default through the profile feature.

1. Run the compositor - The puffin HTTP server starts automatically on port 8585:

   cargo run -- --winit

2. Install puffin_viewer (if you haven't already):

   cargo install puffin_viewer

3. Connect to the profiler:

   • Launch puffin_viewer
   • Connect to 127.0.0.1:8585

The profiler will show frame timing, render performance and other metrics to help identify performance bottlenecks.

Note: Make sure your puffin_viewer version matches the puffin version used by Otto (0.19.x requires puffin_viewer 0.22.0 or later).

• Icons used: Fluent Icon Theme
• Font used: Inter Font
• Background used: Zach Lieberman Soft Circle Study #6 2024 zach.li