leftwm VS yatta

(Also I wouldn't mind if you want to contribute to leftwm ;))

I've looked at these: - DWM: A popular, compact WM written in C - LeftWM: A popular, configurable WM written in Rust - GabelstaplerWM: An obscure, compact WM written in Rust - XCB DWM: An abandoned rewrite of DWM using XCB

Been using and liking LeftWM: https://github.com/leftwm/leftwm

In particular, I think that "ultrawide-vertical-stack" (based on "CenterMain" from LeftWM) is quite close to what you are looking for. Give it a try with komorebic change-layout ultrawide-vertical-stack!

Right now there are only a fixed number of layouts because there is a bunch of stuff that needs to be implemented for navigating in different layouts, but in general it should not be too difficult to port any of the layouts used by LeftWM, especially now that there is the optional to make some layouts navigable via cycling only. Please do open an issue for more ultrawide-friendly layouts as I imagine that this is an issue that is stopping other ultrawide users from making the jump to using a TWM like komorebi.

Once again I'm happy to answer any questions, and I want to give a special thanks to nog, leftwm and umberwm, whose work this project borrows from and builds upon.

might as well use amp (vim in rust), leftwm (wm in rust), and nushell (shell in rust), just because

If something should be added to the documentation/made more clear in the documentation feel free to open a PR on the GitHub, DM me, or peruse https://github.com/leftwm/leftwm/wiki .

I used Rust to prototype a new window manager in public and I found it very productive, easy to iterate on and make large changes without worrying about breaking anything.

Thanks! I had a look through the latest commit that you pushed to grist, and I noticed you handling errors from windows-rs in a similar way as I was doing in a previous project (yatta.

In general, I feel a lot better about this code base, the choice of data structures, and particularly the added safety around how I am calling unsafe Windows APIs in cleaner ways that allow me to propagate and handle errors when responding to WinEvents or socket commands (compare this mishmash to this much cleaner module!)

I wrote my very first window manager for Windows 10 in Rust earlier this here, I built it from the ground up using the new windows-rs crate. It was my first time developing anything for Windows and I was pleasantly surprised with the quality of the MS documentation ecosystem, and I also had a lot of great example code to learn from thanks to other projects like nog.

https://github.com/LGUG2Z/yatta/commit/87bc73eaa4f6ba7d00dbab2a6fb100f060b88ed8 Creating window floating rules based on partial title matching is added with this commit

I thought you might be interested to know that I have now implemented floating rules across all workspaces for applications both by class and process name! Example is on the README: https://github.com/LGUG2Z/yatta#keybindings

I started working on yatta for Windows 10 because I was missing yabai and bspwm after I started working from a Windows 10 desktop last year.

I made a post about it on the Rust subreddit yesterday looking for more contributors: https://old.reddit.com/r/rust/comments/lh4uyq/yatta_bsp_tili...

It's still early days, but it has automatic tiling, gap control, focus switching, directional moving and tree orientation toggling and you can use AHK or any other hotkey daemon to manage your keybindings.

You still have to build it from source at the moment, but I'm hoping to have it installable via the Scoop package manager in a month or two.

https://github.com/LGUG2Z/yatta

I spent a couple of days hacking away to get something that works on Windows 10 with the bare minimum TWM functionality that my hands are used to, and I've managed to throw together Yatta: https://github.com/LGUG2Z/yatta (there is a demo gif on the readme).