Otto

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, with Skia used for rendering.

:information_source: Testing phase

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

Feedback and questions are welcome in the Matrix chat: #otto-compositor:matrix.org.

:framed_picture: What does Otto look like?

Dock task manager showing running applications.

Minimizing windows to the Dock with an animated genie effect.

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.

Is Otto usable?

Otto is in an early but functional state. You can install it from pre-built packages or build it from source. Many features are still missing.

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

Features and roadmap

• Window management: move/resize, fullscreen/maximize (animated), minimize to the Dock (animated).
• Workspaces: multiple workspaces, animated switching, drag windows between workspaces, configurable background.
• Dock (task manager): shows running apps, minimized 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).
• System UI: brightness, volume, keyboard backlight

Still to come

• 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.

Experimentation

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

Supported Wayland Protocols

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
• Display control: wlr_gamma_control_v1 (color temperature/night shift with hardware gamma tables)

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

Development

Otto consists of the main compositor and additional components:

Component	Description
otto	Main compositor binary
xdg-desktop-portal-otto	XDG Desktop Portal backend for screen sharing

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

How can you contribute?

Both this project and the LayersEngine are open to contributions. Contribute by testing the compositor, reporting bugs, implementing new features, or 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.

Installation

Download Pre-built Packages

Pre-built packages are available from the GitHub Releases page.

Debian/Ubuntu (.deb)

# Download the .deb package from releases, then:
sudo dpkg -i otto_*.deb
sudo apt-get install -f  # Install dependencies if needed

Fedora/RHEL (.rpm)

# Download the .rpm package from releases, then:
sudo dnf install otto-*.rpm
# or
sudo rpm -i otto-*.rpm

Arch Linux

# Download PKGBUILD and let makepkg fetch the tarball automatically:
curl -O https://raw.githubusercontent.com/nongio/otto/main/PKGBUILD
makepkg -si

If you already downloaded the tarball from GitHub Releases, put the PKGBUILD in the same directory — makepkg will use it without re-downloading:

cd ~/Downloads  # wherever your otto-*-x86_64.tar.gz is
curl -O https://raw.githubusercontent.com/nongio/otto/main/PKGBUILD
makepkg -si

After Installation

Once installed, Otto will appear in your login manager (GDM, SDDM, LightDM, etc.) as "Otto" in the session selection menu. Simply select it and log in.

Note: Screen sharing functionality requires xdg-desktop-portal to be installed on your system.

Building Otto

Prerequisites

You'll need to install the following dependencies (note that these 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), you'll need to install the xwayland package as well.

Build and run

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

cd otto

# Run Otto (auto-detects backend)
cargo run

# Run with development features (debugger, profiler)
cargo run --features "dev"

# Release build
cargo build --release
cargo run --release

Otto automatically detects the best backend for your environment:

• If running inside a Wayland session, it uses --winit (runs as a window)
• If running in a TTY, it uses --tty-udev (bare metal display)

You can force a specific backend by passing it as an argument:

• --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 another X11 or Wayland session — useful for development.
• --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 is not really maintained.

Configure Otto

Otto uses TOML configuration files and follows standard Linux configuration paths.

Configuration Locations

Otto searches for configuration files in the following order (later files override earlier ones):

1. System config: /etc/otto/config.toml
2. User config: $XDG_CONFIG_HOME/otto/config.toml (defaults to ~/.config/otto/config.toml)
3. Local override: ./otto_config.toml (current directory, for development)
4. Backend-specific: ./otto_config.{backend}.toml (highest priority)

A complete example configuration is provided in otto_config.example.toml. To get started:

# Create user config directory
mkdir -p ~/.config/otto

# Copy example config
cp otto_config.example.toml ~/.config/otto/config.toml

# Edit as needed
$EDITOR ~/.config/otto/config.toml

Backend-specific Configuration

You can create backend-specific configuration files for development using the naming convention otto_config.{backend}.toml in the current directory:

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

Backend-specific configs have the highest priority and override all other configuration files. 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 when running in a window (winit/X11) versus on bare metal (tty-udev).

For detailed configuration options, see the configuration documentation.

Keyboard Shortcuts

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 }

Profiling

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

Using the Profiler

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).

Credits

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