My Journey Through Wayland Window Managers: From i3wm to River

My Journey Through Wayland Window Managers: From i3wm to River

The transition from X11 to Wayland has been one of the most significant changes in the Linux desktop ecosystem in recent years. As someone who values efficiency and customization, my journey through various Wayland window managers has been both challenging and enlightening. Here's how I navigated from wanting to use i3wm to finally settling on River as my daily driver.

Our configure file is on dotfiles

The Starting Point: i3wm and the X11 Reality Check

Like many Linux enthusiasts, I was drawn to i3wm for its elegant tiling window management. The idea of having windows automatically arranged in a logical, space-efficient manner was exactly what I needed for my workflow. However, there was one significant problem: i3wm is built on X11, and X11 is showing its age.

By 2025, X11 is effectively in maintenance mode with no active development. The architecture, while revolutionary in its time, lacks modern security features and performance optimizations that today's desktop environments demand. Wayland offers:

Better security: Applications can't spy on each other or capture content from other windows
Improved performance: Reduced input lag and more efficient graphics handling
Modern architecture: Designed for today's hardware and use cases
Active development: Unlike X11, Wayland continues to evolve

The writing was on the wall: if I wanted a future-proof setup, I needed to embrace Wayland and find a suitable replacement for i3wm.

First Attempt: Sway and the NVIDIA Nightmare

The logical next step was Sway, which is essentially i3wm's spiritual successor for Wayland. Sway provides nearly identical functionality to i3wm but runs natively on Wayland. It seemed like the perfect solution - until I hit the NVIDIA wall.

I have an aging but still functional RTX 1080, and Sway officially does not support proprietary NVIDIA drivers. When you try to launch Sway with NVIDIA drivers, you're greeted with the message: "Proprietary Nvidia drivers are NOT supported. Use Nouveau."

While there's a workaround using the --unsupported-gpu flag, this approach comes with caveats:

No official support for bugs or issues
Potential stability problems
Performance might be suboptimal
The flag name itself (--my-next-gpu-wont-be-nvidia) is somewhat humiliating

The --ignore-gpu startup option existed, but it felt like a band-aid solution rather than a proper fix. I needed something more reliable for daily use.

The Hyprland Experiment: Feature-Rich but Overwhelming

Frustrated with Sway's NVIDIA limitations, I decided to try Hyprland. This compositor promised to be different - it's built from the ground up for Wayland and offers better NVIDIA compatibility than Sway.

Hyprland's feature set is impressive:

Dynamic tiling with smooth animations
Rounded corners and blur effects
Extensive customization options
Active development with regular updates
Better NVIDIA support compared to Sway

Initially, Hyprland felt like the perfect solution. The animations were smooth, the configuration was flexible, and it actually worked with my RTX 1080 without requiring unsupported flags.

However, after using it for a while, I realized that Hyprland might be too much for my needs. The compositor felt heavyweight, packed with features I didn't use. The extensive animation system, while visually appealing, sometimes felt unnecessary for my productivity-focused workflow. I found myself longing for something simpler and more lightweight.

The Final Choice: River - Simple, Efficient, and Reliable

After my experience with Hyprland's feature bloat, I started looking for alternatives that would give me the simplicity I craved while still working well with my NVIDIA hardware. This search led me to River.

River is a wlroots-based dynamic tiling Wayland compositor that strikes the perfect balance:

Why River Works for Me

Lightweight Philosophy: River focuses on core functionality without unnecessary bloat. It's inspired by dwm and xmonad, emphasizing simplicity and efficiency.

NVIDIA Compatibility: Being wlroots-based, River works much better with NVIDIA GPUs than Sway. While not officially supported, the compatibility is significantly more stable.

Flexible Configuration: River uses runtime configuration through the riverctl tool, allowing for dynamic adjustments without restarts.

Tag-Based Organization: Instead of traditional workspaces, River uses tags, allowing windows to belong to multiple tags simultaneously - a more flexible approach.

Active Development: The project is actively maintained with regular updates and bug fixes.

The River Experience

Setting up River was straightforward. The configuration is done through shell scripts that call riverctl commands, making it easy to understand and modify. The performance is excellent - noticeably more responsive than Hyprland while providing all the tiling functionality I need.

Most importantly, River has been stable with my RTX 1080. While NVIDIA users still don't get official support, the wlroots foundation provides better compatibility than Sway's approach.

Lessons Learned

My journey through Wayland window managers taught me several important lessons:

1. Hardware Compatibility Matters

Don't underestimate the importance of GPU compatibility. The most elegant software is useless if it doesn't work reliably with your hardware.

2. More Features ≠ Better

Hyprland's extensive feature set was impressive but ultimately unnecessary for my workflow. Sometimes, simpler solutions are more effective.

3. The Wayland Ecosystem is Maturing

While there are still compatibility challenges, particularly with NVIDIA hardware, the Wayland ecosystem has improved dramatically. Solutions exist for most use cases.

4. Community Solutions Fill Gaps

Projects like River show that the open-source community is actively working to fill gaps in the Wayland ecosystem, often creating better solutions than official alternatives.

Looking Forward

The Linux desktop landscape continues to evolve, and Wayland is clearly the future. My journey from i3wm to River represents the broader transition the Linux community is making from X11 to Wayland.

For users considering a similar transition, I'd recommend:

Start with your hardware: Check compatibility with your GPU before committing to a solution
Consider your workflow: Match the window manager's philosophy to your actual needs
Don't be afraid to experiment: The Wayland ecosystem offers many alternatives worth exploring
Plan for NVIDIA challenges: If you have NVIDIA hardware, factor in potential compatibility issues

River has proven to be the right choice for my setup - lightweight, stable, and efficient. It demonstrates that sometimes the best solution isn't the most popular one, but the one that best fits your specific needs and constraints.

The journey from X11 to Wayland might seem daunting, but with the right approach and tools, it's not only possible but beneficial. The improved security, performance, and modern architecture of Wayland make it worth the effort, even if it means navigating some compatibility challenges along the way.