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 and uses Skia 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 therefore 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.

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.

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

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

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 of an other 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 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):

System config: /etc/otto/config.toml
User config: $XDG_CONFIG_HOME/otto/config.toml (defaults to ~/.config/otto/config.toml)
Local override: ./otto_config.toml (current directory, for development)
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 bar

Otto

Install / Use

README

Otto

:information_source: Testing phase

:framed_picture: What does Otto look like?

Is Otto usable?

Features and roadmap

Still to come

Experimentation

Supported Wayland Protocols

Development

How can you contribute?

Installation

Download Pre-built Packages

Debian/Ubuntu (`.deb`)

Fedora/RHEL (`.rpm`)

Arch Linux

After Installation

Building Otto

Prerequisites

Build and run

Configure Otto

Configuration Locations

Backend-specific Configuration

Otto

Install / Use

README

Otto

:information_source: Testing phase

:framed_picture: What does Otto look like?

Is Otto usable?

Features and roadmap

Still to come

Experimentation

Supported Wayland Protocols

Development

How can you contribute?

Installation

Download Pre-built Packages

Debian/Ubuntu (.deb)

Fedora/RHEL (.rpm)

Arch Linux

After Installation

Building Otto

Prerequisites

Build and run

Configure Otto

Configuration Locations

Backend-specific Configuration

Debian/Ubuntu (`.deb`)

Fedora/RHEL (`.rpm`)