بو النوافذ is a personal Window manager

Related tags

GUI bunnuafeth
Overview

عربي؟ كمل قراءة بالعربي (لهجة سعودية).

Bunnuafeth | بو النوافذ

Bunnuafeth is a personal Window manager written in Rust

General philosophy

This window manager is specifically made for me, so features are mostly gonna be focused on my own workflow, but if you have good suggestions, or would just like to contribute, you can open an issue or a PR.

however it could be a not too bad base for a patched window manager like dwm

Build

to build the window manager you can just build it with cargo

# debug build
cargo build

# release build (when you want to actually use it)
cargo build --release

Run

the compiled binary name is bunnu

so you can add the following entry to your display manager/login manager

[Desktop Entry]
Name=Bunnuafeth
Comment=Bunnuafeth
Exec=path/to/bunnuafeth/bunnu
TryExec=path/to/bunnuafeth/bunnu
Type=Application

then open your display manager and run Bunnuafeth

You might also like...
Experimental package manager/system configurator for system hoppers

mascara An experimental package manager/config initializer tool for system hoppers. mascara.toml [mascara] feature = "Debian" logs = { stdout = "blue"

A Modern, Open Source GTK4 ebook manager powered by Rust.
A Modern, Open Source GTK4 ebook manager powered by Rust.

Bookx An MVP in progress: An ebook reader with .epub support Context menu for each book (delete, rename book, info) On click switch the carousal to th

An easy to use command line project manager for projects using the ReCT programming language
An easy to use command line project manager for projects using the ReCT programming language

☢️ A powerful project manager for the ReCT programming language! ☢️ ReCTx makes your projects easier to manage by allowing you to configure everything

♾️ Fast & Simple AppImage manager
♾️ Fast & Simple AppImage manager

⚠️ Heavily in development (Not working) Leap Fast & Simple AppImage manager What's working Installation (github only, info about app not stored yet) R

Let Tauri's transparent background rendering window be stacked on Bevy's rendering window in real time to run the game with native-level performance!

Native Bevy with Tauri HUD DEMO 将 Tauri 的透明背景渲染窗口实时叠在 Bevy 的渲染窗口上,以使用原生级别性能运行游戏! Let Tauri's transparent background rendering window be stacked on Bev

A tiling window manager for Windows 10 based on binary space partitioning
A tiling window manager for Windows 10 based on binary space partitioning

yatta BSP Tiling Window Manager for Windows 10 Getting Started This project is still heavily under development and there are no prebuilt binaries avai

StarWM is an extensible window manager written in Rust.
StarWM is an extensible window manager written in Rust.

StarWM is an extensible, floating and tiling, X window manager for Linux-based operating systems written in Rust.

A tiling window manager for Windows
A tiling window manager for Windows

komorebi Tiling Window Management for Windows. About komorebi is a tiling window manager that works as an extension to Microsoft's Desktop Window Mana

A floating, tag-based window manager written in Rust
A floating, tag-based window manager written in Rust

worm worm is a floating, tag-based window manager for X11. It is written in the Rust programming language, using the X11RB library. Install cargo buil

Generic tiling window manager library in Rust

Pop Tiler Generic tiling window manager library for Rust, using an architecture based on GhostCell. License Licensed under the GNU Lesser General Publ

A window manager coded in rust

Tailwin A window manager coded in rust Thanks Victoruler for making the logo under a cc-by licence.

My Window Manager
My Window Manager

mwm My window manager that is a work in progress. Currently hacky Installation Clone this repo then: cargo build --release Put the binary in your pat

skyWM is an extensible tiling window manager written in Rust. skyWM has a clear and distinct focus adhering to the KISS and Unix philosophy.
skyWM is an extensible tiling window manager written in Rust. skyWM has a clear and distinct focus adhering to the KISS and Unix philosophy.

Please note: skyWM is currently in heavy development and is not usable as of yet. Documentation and versions will change quickly. skyWM skyWM is an ex

A fully modular window manager, extremely extensibile and easily approachable.

AquariWM is a fully modular window manager, allowing extreme extensibility while remaining easily approachable. Installation AquariWM is currently in

skyWM is an extensible tiling window manager written in Rust
skyWM is an extensible tiling window manager written in Rust

skyWM is an extensible tiling window manager written in Rust. skyWM has a clear and distinct focus adhering to the KISS and Unix philosophy.

skyWM is an extensible tiling window manager written in Rust
skyWM is an extensible tiling window manager written in Rust

skyWM is an extensible tiling window manager written in Rust. skyWM has a clear and distinct focus adhering to the KISS and Unix philosophy.

Minimal, flexible & user-friendly X and Wayland tiling window manager with rust
Minimal, flexible & user-friendly X and Wayland tiling window manager with rust

SSWM Minimal, flexible & user-friendly X and Wayland tiling window manager but with rust. Feel free to open issues and make pull requests. [Overview]

POC for a Roguelike UI/Window Manager

Minimal POC for a Roguelike UI Manager This repo is a proof of concept for a roguelike UI and a generally expandable template for a rogue/df-like. Use

Simple and lightweight tray icon that shows the current workspace for the Komorebi window manager.
Simple and lightweight tray icon that shows the current workspace for the Komorebi window manager.

komotray Simple and lightweight tray icon that shows the current workspace for the Komorebi window manager. This is a Rust rewrite of the original Aut

Comments
  • refactor window manager structures

    refactor window manager structures

    The focus tracking method currently used is something like this:

    struct WM {
        windows: Vec<WindowState>,
        focused_window: Option<WindowState>,
    }
    

    and then to set the focused window we do this:

    fn set_focus(&mut self, window: Window) {
        if let Some(win_state) = self.windows.iter().find(|w| w.window == window) {
            self.focused_window = win_state.clone();
        }
    }
    

    but cloning it means that it's not gonna be up to date with the windows vector, so it requires additional bookkeeping or having to get it from the windows vector every time

    one solution to this problem could be by using a different data structure like the Zipper.

    I found out about it from the penrose from scratch series ep09 (thank you @sminez !)

    the basic idea is to have this kind of structure:

    struct Windows {
        left: Vec<WindowState>,
        focus: Option<WindowState>,
        right: Vec<WindowState>,
    }
    

    and that allows for direct access to the focused windows and no need to keep a separate manually updated focused_window field

    also this can make it much easier for nesting the same structure for workspaces/tags like this:

    struct Screens {
        left: Vec<Screen>,
        focus: Option<Screen>, // arguably should not be an option
        right: Vec<Screen>,
    }
    
    struct Screen {
        tags: Tags
    }
    
    struct Tags {
        left: Vec<Tag>,
        focus: Option<Tag>,
        right: Vec<Tag>,
    }
    
    struct Tag {
        windows: Windows,
    }
    
    struct Windows {
        left: Vec<WindowState>,
        focus: Option<WindowState>,
        right: Vec<WindowState>,
    }
    
    struct WindowState {
        // window data
    }
    

    then add methods to make accessing nested stuff easier

    it's relatively more complicated than the current method, but I think it's worth adding.

    it's better than just having a Option<usize> because the index is not guaranteed to be there, and even if it exists it could be pointing to another element, so it needs to be manually managed, also it might introduce lifetime issues when using the windows vector, not sure tho, so before doing that, experimenting with something like focus: Option<usize> on another branch could be worth doing

    also could check out something like indexmap

    UPDATE: after thinking about it for a bit I think using indexmap could be better than using a zipper, because zippers are better for relative movement, so if I want to have directional focus with MOD + k for example I would need to use the index or something like that, but if I use an indexmap I can get the handle to the window (which will be the window id from the x session) and then access it like that, while also being able to iterate through the windows since it preserves the insertion order (but still need to make sure it actually does, because the docs mentions it's ordered until you remove an element (?))

    opened by BKSalman 1
  • add tags/workspaces

    add tags/workspaces

    every monitor will have their separate tags/workspaces.

    could look like this:

    struct WM {
        tags: Vec<Tag>,
    }
    
    struct Tag {
        id: u32,
        name: String,
        layout_manager: LayoutManager,
        // other fields
    }
    

    or like this:

    struct WM {
        tags: Vec<Tag>,
        layout_manager: LayoutManager,
    }
    
    struct Tag {
        id: u32,
        name: String,
        // other fields
    }
    

    maybe I would like to pin one of the tags to a specific monitor, but that's for later

    TODOs:

    • [ ] add tags
    • [ ] change the _NET_NUMBER_OF_DESKTOPS property
    • [ ] track the _NET_CURRENT_DESKTOP property
    • [ ] unmap windows that are on other tags ( not sure if that's how you hide the windows from other tags )
    • [ ] map windows on the current tag
    opened by BKSalman 0
  • add state to the layouts

    add state to the layouts

    layouts could have extra state.

    for example the MainStack layout could hold a ratio field that specifies the width ratio between the main window and the sub windows

    could look like this:

    pub enum TiledLayout {
        MainStack {
            ratio: f32,
        },
    }
    
    opened by BKSalman 0
  • TODOs

    TODOs

    usable if done means I could personally use the window manager if the features mentioned are there.

    useful if done means the window manager is more useful, but not workflow impairing if not done.

    usable if done:

    • [ ] add EWMH to window manager
    • [x] add keybinds ( like closing a window with the keyboard )
    • [x] add buttonbinds ( like resizing a window with the mouse )
    • [x] add base for layouts
    • [x] add MainStack layout
    • [x] tile windows
    • [x] add floating windows and treat them different from tiled windows
    • [ ] #4
    • [ ] #2
    • [ ] add SwapWithMain to WMCommand
    • [ ] custom EWMH compliant status bar

    useful if done:

    • [x] #3
    • [ ] scratch pads
    • [ ] Add the ability to rotate layouts, or maybe only flip
    • [ ] config file (could just make it without a separate config file, like dwm)
    opened by BKSalman 0
Owner
Salman Abuhaimed
Salman Abuhaimed
A floating, tag-based window manager written in Rust

worm worm is a floating, tag-based window manager for X11. It is written in the Rust programming language, using the X11RB library. Install cargo buil

null 627 Jan 4, 2023
Generic tiling window manager library in Rust

Pop Tiler Generic tiling window manager library for Rust, using an architecture based on GhostCell. License Licensed under the GNU Lesser General Publ

Pop!_OS 65 Dec 29, 2022
A window manager coded in rust

Tailwin A window manager coded in rust Thanks Victoruler for making the logo under a cc-by licence.

Arthur Melton 3 Jul 27, 2022
skyWM is an extensible tiling window manager written in Rust

skyWM is an extensible tiling window manager written in Rust. skyWM has a clear and distinct focus adhering to the KISS and Unix philosophy.

Chadano 74 Dec 28, 2022
skyWM is an extensible tiling window manager written in Rust

skyWM is an extensible tiling window manager written in Rust. skyWM has a clear and distinct focus adhering to the KISS and Unix philosophy.

Orbital 76 Apr 22, 2023
A window swallower for swaywm

swayhide - A window swallower for sway Description swayhide hides the currently active terminal (by moving it to the scratchpad), then it executes the

NomisIV 47 Dec 14, 2022
D3D9 Window overlay written in Rust

win-overlay (-rs) DirectX overlay written in Rust for various projects, wanted to easily create overlays across projects so decided to write my own im

Zor 18 Dec 28, 2022
Provides event handling for egui in SDL2 window applications.

egui-sdl2-event Provides event handling for egui when SDL2 is used as the windowing system. This crate does not perform any rendering, but it can be c

Valtteri Vallius 8 Feb 15, 2023
A straightforward stateful input manager for the Bevy game engine.

About A simple but robust input-action manager for Bevy: intended to be useful both as a plugin and a helpful library. Inputs from various input sourc

null 212 Jan 6, 2023
A cross-platform Mod Manager for RimWorld intended to work with macOS, linux and Windows

TODOs are available here. Discussions, PRs and Issues are open for anyone who is willing to contribute. rrm Inspired by Spoons rmm. This is a cross-pl

Alejandro Osornio 7 Sep 5, 2022