A Flutter-native Wayland compositor.
Denial begins with a belief: origin does not have to dictate purpose.
Flutter was created to build application interfaces. Here, it is given a different life. It owns the desktop scene itself: the shell, its motion, and the composition of Wayland applications. Flutter is not an overlay placed on top of another compositor. It is part of the compositor's foundation.
That is the architecture. It is also the meaning of the name.
A conventional Flutter desktop application receives a window from an existing
compositor. Denial goes one layer deeper: deniald embeds the Flutter Engine
directly through its native Embedder API, and the Dart shell runs AOT-compiled
inside the compositor process. It is not a Wayland client and does not need
another compositor beneath it.
Rust and Flutter have separate responsibilities:
- Rust, built on Smithay, owns Wayland protocol state, client buffers, input devices, focus and grabs, output configuration, DRM/KMS presentation, and native resource lifetimes.
- Flutter owns the visible desktop policy: shell layout, windows, system surfaces, settings, motion, gestures, and the regions that participate in shell interaction.
Wayland client buffers remain native resources. Denial imports their contents as external textures and places them in the same Flutter scene as the shell UI. Flutter renders that scene into a desktop-wide GBM atlas; each connected display scans its own region directly through KMS, without a second compositor pass over the completed frame.
Wayland clients ──> Rust / Smithay ──> external textures ──> Flutter scene
input <──── native routing <──── shell hit regions <──────┘
│
Displays <────────────── DRM / KMS <────────────── shared GBM atlas
Denial renders with Flutter's Impeller backend by default. That sentence hides the interesting part: Impeller was designed to render an application inside a window, while Denial asks it to render the entire desktop into compositor-owned, rotating GBM framebuffers. Denial's locked Flutter fork integrates Impeller's GLES path directly with the shared KMS atlas, including exact embedder FBO presentation, no-target frame handling, preserved partial damage, native fences, and external-texture lifetime.
This is not a Flutter app using Impeller inside another compositor. Impeller
is part of the compositor's own frame path, from the Dart scene to scanout.
Skia/Ganesh remains in the same engine generation as a compatibility fallback
and can be selected explicitly with --flutter-renderer skia or the packaged
DENIA_FLUTTER_RENDERER=skia session override.
The native compositor and the Flutter shell are built as two versioned parts.
The current shell lives in dart_shell/ and is loaded with its AOT library,
assets, ICU data, and pinned engine generation as one runtime bundle. Their
platform bridge carries immutable scene state and bounded commands without
giving Dart ownership of file descriptors, Wayland objects, EGL images, or
KMS buffers.
This bundle boundary is also the path toward alternative Flutter shells. As the compatibility contract stabilizes, a compatible user-provided bundle will be able to replace Denial's reference shell without replacing the native compositor beneath it.
Denial is an English word. The name contains Denia, followed by one last letter.
It is a quiet reference to Denia from Wuthering Waves. Her story never gives a simple answer to what she originally was, and that uncertainty is important. What is clear is that others treated her as an asset: something selected, shaped, and assigned a purpose that was not her own. She was meant to remain a vessel. Instead, by observing people and learning to live among them, she grew a heart and gained the ability to choose what she would become.
Her story reflects Denial's central idea: what something was made to be does not have to determine what it can become.
Denial is a public beta in active development. The supported PC architectures are x86-64 and ARM64 (AArch64), and the native APIs, Flutter bundle contract, configuration, and wire protocol may still change before 1.0. The compositor already runs as a complete Wayland session with Xwayland, multi-output presentation, native input routing, direct screenshots, and portal-based screen sharing.
| Architecture | Working | Binaries available |
|---|---|---|
| x86-64 | ✅ | ✅ |
| ARM64 (AArch64) | ✅ | ❌ |
ARM64 is fully supported, but first-party ARM64 binaries are not published yet. Build Denial from source with an architecture-matched Flutter engine and shell bundle; see the build guide.
| Distro | Working | Binaries available |
|---|---|---|
| Arch Linux | ✅ | ✅ |
| CachyOS | ✅ | ✅ |
| Debian 13 (trixie) | ✅ | ✅ |
| Ubuntu 24.04 LTS (noble) | ✅ | ✅ |
| Fedora 44 | ✅ | ✅ |
| NixOS | ✅ | ❌ |
| Void Linux | ✅ | ❌ |
The binary column refers to the current first-party x86-64 package set. NixOS and Void Linux have been tested successfully, but do not have first-party binary packages yet.
The optional denial-ui-development binary package is currently available
only through the Pacman repository. It turns the reference shell into an
editable Flutter workspace. denialctl ui setup creates the
matching source checkout and starts a JIT shell; opening its dart_shell directory in
VSCodium enables hot reload on save and the packaged browser DevTools for
Flutter Inspector and performance profiling while Wayland applications keep
running.
Install it separately when this workflow is wanted:
sudo pacman -S denial-ui-development
denialctl ui setupThe supported editor debug-adapter connection is deliberately non-pausing. It
does not grant breakpoint, pause, stepping, or expression-evaluation control
over the desktop isolate. Browser DevTools connects through the broader VM
service and should be used carefully because pausing the root isolate pauses
the interactive desktop. A native denialctl ui restore command returns to
the packaged optimized shell even when edited Flutter code cannot present a
usable Settings window.
Denial provides signed first-party x86-64 repositories for Arch Linux and CachyOS, Debian 13, Ubuntu 24.04 LTS, and Fedora 44. Review the repository setup script, then run:
sh -c 'if ! command -v curl >/dev/null 2>&1; then echo "Error: curl is not available." >&2; exit 1; fi; curl -fsSL https://install.denialwm.org | sh'It verifies the complete release-key fingerprint, rejects conflicting package manager configuration, and adds the matching signed repository. It does not install packages. When setup completes, use only the command for the current distribution.
Arch Linux or CachyOS
sudo pacman -Syu denialDebian 13 or Ubuntu 24.04
sudo apt update && sudo apt install denialFedora 44
sudo dnf install denialThe package manager pulls in the matching denial-flutter-engine package.
The setup script shows its complete plan and asks for confirmation before using
sudo.
ARM64 is fully supported from source, but the first-party repositories do not publish ARM64 packages yet. See Build Denial.
Impeller is the default renderer. If a driver-specific issue requires the
Skia/Ganesh fallback, set DENIA_FLUTTER_RENDERER=skia in
/etc/denial/session.conf and restart the Denial session.
See the complete installation guide for per-distribution trust paths, updates, removal, and manual Pacman setup.
- Install Denial
- Arch repository details
- Build Denial
- Session startup and locking
- Control and recover Denial with
denialctl - Live Flutter UI development
- Architecture
- Screenshots and screen sharing
- Changelog
- Roadmap
- Security policy
- Beta contribution policy
- Complete documentation index
Denial was conceived, architected, directed, and tested by its human creator, Doctor Logix, and developed in continuous collaboration with OpenAI Codex. Its initial implementation was generated through that collaboration rather than written manually by its creator.
The project's purpose, architecture, design principles, and final technical decisions came from the human side. Codex investigated the codebase, proposed solutions, implemented features, analyzed failures, and refined the system through an ongoing dialogue. Every result was evaluated against real hardware and redirected whenever it failed to match the intended design or performance expectations.
This is part of Denial’s origin, not a disclaimer hidden in a footnote.
Authorship is more than typing source code. Denial exists because a person decided what should exist, defined how it should work, recognized when the implementation was wrong, and kept directing the process until the idea became a functioning system.
Denial's original source code is licensed under GPL-3.0-or-later. Bundled third-party components and media retain their own licenses and attribution notices.