Pixelising on transition

.local/share/kaomoji

@@ -1,3 +1,7 @@
+ᵔᴗᵔ	                 smile
+ᐢᗜᐢ	                 :D
+˘ᗜ˘	                 :D
+˃ᗜ˂	                 smile
 ʕ•ₒ•ʔ				Bear Shocked
 ʕ•ᴥ•ʔ				Bear
 ʕ　·ᴥ·ʔ				RBear
@@ -451,4 +455,4 @@ o(>< )o⌒*			Mad (3)
 (；^＿^)ッ☆(　゜o゜) 		Slapping
 ＼（～Ｏ～）／ 			Good Morning
 \＿(´▽｀)♪＿/ 			Bathtub
-( • )( • )ԅ(≖‿≖ԅ)       BOOB
+( • )( • )ԅ(≖‿≖ԅ)	   BOOB

Xdefaults

@@ -10,6 +10,7 @@
 #define font2 xft:MesloLGM Nerd Font Mono:minispace=False:size=10
 #define font3 xft:Noto Sans Mono CJK TC:minispace=False:size=10
 #define font4 xft:Noto Color Emoji:style=regular:size=10
+
 URxvt.letterSpace: spacing
 URxvt.lineSpace: 0
 
@@ -55,13 +56,15 @@ dzen2.font: mononoki
 ! Set depth to make transparency work.
 URxvt*depth: 32
 
-*.font: mononoki:minispace=False:size=10:antialias=true
+! *.font: mononoki:minispace=False:size=10:antialias=true
+*.font: FiraMono Nerd Font:size=10:antialias=true
+
 URxvt.font: font1,font2,font3,font4
 URxvt.boldFont: font1:style=bold,font2:style=bold,font3:style=bold,font4
 URxvt.italicFont:font1:style=italic,font2:style=italic,font3:style=italic,font4
 URxvt.boldItalicfont: font1:style=bolditalic,font2:style=bolditalic,font3:style=bolditalic,font4
 
-*.borderpx: 20
+*.borderpx: 32
 URxvt.internalBorder: 20
 *.cursorBlink: true
 URxvt.cursorUnderline: true

bspwm/01-fix-polybar-rounding.patch

@@ -0,0 +1,97 @@
+diff --git a/src/tree.c b/src/tree.c
+index 9e0a6dd..49c46bc 100644
+--- a/src/tree.c
++++ b/src/tree.c
+@@ -82,6 +82,7 @@ void apply_layout(monitor_t *m, desktop_t *d, node_t *n, xcb_rectangle_t rect, x
+ 		draw_presel_feedback(m, d, n);
+ 	}
+ 
++
+ 	if (is_leaf(n)) {
+ 		unsigned int br = 0;
+ 
+@@ -136,7 +137,7 @@ void apply_layout(monitor_t *m, desktop_t *d, node_t *n, xcb_rectangle_t rect, x
+ 
+ 		if (!rect_eq(r, cr)) {
+ 			window_move_resize(n->id, r.x, r.y, r.width, r.height);
+-			window_rounded_border(n);
++			window_rounded_border(n, br);
+ 			if (!grabbing) {
+ 				put_status(SBSC_MASK_NODE_GEOMETRY, "node_geometry 0x%08X 0x%08X 0x%08X %ux%u+%i+%i\n", m->id, d->id, n->id, r.width, r.height, r.x, r.y);
+ 			}
+@@ -145,7 +146,7 @@ void apply_layout(monitor_t *m, desktop_t *d, node_t *n, xcb_rectangle_t rect, x
+ 		window_border_width(n->id, bw);
+ 
+ 		n->client->drawn_border_radius = br;
+-		window_rounded_border(n);
++		window_rounded_border(n, br);
+ 
+ 	} else {
+ 		xcb_rectangle_t first_rect;
+diff --git a/src/window.c b/src/window.c
+index 8058fa5..1931352 100644
+--- a/src/window.c
++++ b/src/window.c
+@@ -91,6 +91,8 @@ bool manage_window(xcb_window_t win, rule_consequence_t *csq, int fd)
+ 		free(csq->layer);
+ 		free(csq->state);
+ 		window_show(win);
++		node_t *n = make_node(win);
++        window_rounded_border(n, d->border_radius);
+ 		return false;
+ 	}
+ 
+@@ -229,7 +231,7 @@ bool manage_window(xcb_window_t win, rule_consequence_t *csq, int fd)
+ 		draw_border(n, false, (m == mon));
+ 	}
+ 
+-	window_rounded_border(n);
++	window_rounded_border(n, n->client->drawn_border_radius);
+ 	free(csq->layer);
+ 	free(csq->state);
+ 
+@@ -335,7 +337,7 @@ void draw_presel_feedback(monitor_t *m, desktop_t *d, node_t *n)
+ 
+ 	window_move_resize(p->feedback, n->rectangle.x + presel_rect.x, n->rectangle.y + presel_rect.y,
+ 	                   presel_rect.width, presel_rect.height);
+-	window_rounded_border(n);
++	window_rounded_border(n, n->client->drawn_border_radius);
+ 
+ 	if (!exists && m->desk == d) {
+ 		window_show(p->feedback);
+@@ -429,12 +431,9 @@ void draw_border(node_t *n, bool focused_node, bool focused_monitor)
+ 	}
+ }
+ 
+-void window_rounded_border(node_t *n)
++void window_rounded_border(node_t *n, unsigned int radius)
+ {
+ 	xcb_window_t win = n->id;
+-	unsigned int radius = n->client->drawn_border_radius;
+-
+-	if (n->client->sets_own_shape) return;
+ 
+ 	// get geometry
+ 	xcb_get_geometry_reply_t *geo = xcb_get_geometry_reply(dpy, xcb_get_geometry(dpy, win), NULL);
+@@ -720,7 +719,7 @@ bool resize_client(coordinates_t *loc, resize_handle_t rh, int dx, int dy, bool
+ 		n->client->floating_rectangle = (xcb_rectangle_t) {x, y, width, height};
+ 		if (n->client->state == STATE_FLOATING) {
+ 			window_move_resize(n->id, x, y, width, height);
+-			window_rounded_border(n);
++			window_rounded_border(n, n->client->drawn_border_radius);
+ 
+ 			if (!grabbing) {
+ 				put_status(SBSC_MASK_NODE_GEOMETRY, "node_geometry 0x%08X 0x%08X 0x%08X %ux%u+%i+%i\n", loc->monitor->id, loc->desktop->id, loc->node->id, width, height, x, y);
+diff --git a/src/window.h b/src/window.h
+index 79805cb..77da863 100644
+--- a/src/window.h
++++ b/src/window.h
+@@ -44,7 +44,7 @@ void hide_presel_feedbacks(monitor_t *m, desktop_t *d, node_t *n);
+ void update_colors(void);
+ void update_colors_in(node_t *n, desktop_t *d, monitor_t *m);
+ void draw_border(node_t *n, bool focused_node, bool focused_monitor);
+-void window_rounded_border(node_t *n);
++void window_rounded_border(node_t *n, unsigned int radius);
+ void window_draw_border(xcb_window_t win, uint32_t border_color_pxl);
+ void adopt_orphans(void);
+ uint32_t get_border_color(bool focused_node, bool focused_monitor);

bspwm/deploy.sh

@@ -5,9 +5,10 @@ wd="$HOME/.local/src/bspwm"
 [ ! -d "$HOME/.local/src" ] && mkdir -p "$wd"
 
 rm -rf "$wd"
-git clone https://github.com/baskerville/bspwm "$wd"
+git clone https://github.com/phuhl/bspwm-rounded "$wd"
+git -C "$wd" checkout 8b6e8f065d5667728f4f58c06f4f65f790c04a66
 
-patch -d "$wd" -p1 -i $(realpath change_update_order.patch)
+patch -d "$wd" -p1 -i $(realpath 01-fix-polybar-rounding.patch)
 
 make -C "$wd" 
 doas make -C "$wd" install PREFIX=/usr

config/bspwm/bspwmrc

@@ -11,11 +11,17 @@ xsetroot -cursor_name left_ptr &
 xrdb ~/.config/Xdefaults
 
 pgrep -x sxhkd > /dev/null || sxhkd &
-pgrep -x picom > /dev/null || picom &
+pgrep -x picom > /dev/null || picom --root-pixmap-shader "/home/x/.config/picom/shaders/glitch.glsl" &
 pgrep -x xss-lock > /dev/null || xss-lock slock &
 pgrep -x bg.sh > /dev/null || $HOME/.scripts/bg.sh > /dev/null &
 
-[ -f "$HOME/.config/xrandr.sh" ] && . $HOME/.config/xrandr.sh
+if [ -f "$HOME/.config/xrandr.sh" ] ; then
+    . $HOME/.config/xrandr.sh
+else
+    if [ -f "$HOME/.scripts/xrandr.sh" ] ; then
+        . $HOME/.scripts/xrandr.sh
+    fi
+fi
 
 primary=$(bspc query --monitors -m primary)
 set -- a b c d e f g h i j k l m n o 
@@ -29,6 +35,8 @@ for m in $(bspc query -M --names); do
     bspc monitor $m -d ${m}1 ${m}2 ${m}3 ${m}4 ${m}5 ${m}6 ${m}7 ${m}8 ${m}9
 done
 
+bspc config border_radius 16
+
 $HOME/.config/polybar/launch.sh &
 
 bspc config border_width	$BORDER
@@ -47,11 +55,10 @@ bspc config focused_border_color "$COLOR_PRIMARY"
 
 # fix java programs that get confused on a missing name property
 wmname LG3D
+while ! pgrep dbus-daemon > /dev/null; do sleep 1; done
 
-sleep 1
-
-#pgrep -x pipewire > /dev/null || pipewire &
-#pgrep -x pipewire-pulse > /dev/null || pipewire-pulse &
-#pgrep -x wireplumber > /dev/null || wireplumber &
+pgrep -x pipewire > /dev/null || pipewire &
+pgrep -x pipewire-pulse > /dev/null || pipewire-pulse &
+pgrep -x wireplumber > /dev/null || wireplumber &
 
 $HOME/.scripts/start-mpd

config/gtk-3.0/bookmarks

@@ -1,3 +1,4 @@
+file:///home/david/docs/astronovus
 file:///home/david/docs/lmms
 file:///home/david/docs docs
 file:///home/david/pics pics

config/gtk-3.0/settings.ini

@@ -6,7 +6,7 @@ gtk-cursor-theme-size=24
 gtk-decoration-layout=icon:minimize,maximize,close
 gtk-enable-animations=true
 gtk-fallback-icon-theme=gnome
-gtk-font-name=mononoki 10
+gtk-font-name=FiraMono Nerd Font 10
 gtk-icon-theme-name=Vimix-dark
 gtk-menu-images=1
 gtk-primary-button-warps-slider=false

config/mimeapps.list

@@ -13,6 +13,8 @@ application/x-extension-shtml=userapp-Firefox-PCQJ91.desktop
 application/xhtml+xml=userapp-Firefox-PCQJ91.desktop
 application/x-extension-xhtml=userapp-Firefox-PCQJ91.desktop
 application/x-extension-xht=userapp-Firefox-PCQJ91.desktop
+x-scheme-handler/discord-1216669957799018608=discord-1216669957799018608.desktop
+application/octet-stream=lmms.desktop
 
 [Added Associations]
 x-scheme-handler/http=userapp-Firefox-AK3I01.desktop;userapp-Firefox-PCQJ91.desktop;
@@ -28,3 +30,5 @@ application/x-extension-xht=userapp-Firefox-AK3I01.desktop;userapp-Firefox-PCQJ9
 image/gif=nsxiv.desktop;
 image/png=gimp.desktop;
 image/jpeg=gimp.desktop;
+application/octet-stream=lmms.desktop;
+audio/x-vorbis+ogg=audacity.desktop;

config/picom/picom.conf

@@ -1,121 +1,67 @@
-#################################
-#             Corners           #
-#################################
-# requires: https://github.com/sdhand/compton
-corner-radius = 4;
-round-borders = 0;
-
-# Specify a list of border width rules, in the format `PIXELS:PATTERN`, 
-# Note we don't make any guarantee about possible conflicts with the
-# border_width set by the window manager.
-#
-# example:
-#    round-borders-rule = [ "2:class_g = 'URxvt'" ];
-#
-round-borders-rule = [
-];
-
 #################################
 #             Shadows           #
 #################################
 
-
-# Enabled client-side shadows on windows. Note desktop windows 
-# (windows with '_NET_WM_WINDOW_TYPE_DESKTOP') never get shadow, 
+# Enabled client-side shadows on windows. Note desktop windows
+# (windows with '_NET_WM_WINDOW_TYPE_DESKTOP') never get shadow,
 # unless explicitly requested using the wintypes option.
 #
-#shadow = false
+# Can be set per-window using rules.
+#
+# Default: false
 shadow = true;
 
-# The blur radius for shadows, in pixels. (defaults to 12)
-# shadow-radius = 12
-shadow-radius = 20;
-
-# The opacity of shadows. (1.0 - 1.0, defaults to 0.75)
-shadow-opacity = 0.7; 
-
-# The left offset for shadows, in pixels. (defaults to -15)
-# shadow-offset-x = -15
-shadow-offset-x = -20;
-
-# The top offset for shadows, in pixels. (defaults to -15)
-# shadow-offset-y = -15
-shadow-offset-y = -20;
-
-# Don't draw shadows on drag-and-drop windows. This option is deprecated, 
-# you should use the *wintypes* option in your config file instead.
+# The blur radius for shadows, in pixels.
 #
-#no-dnd-shadow = true
-#no-dock-shadow = false
+# Default: 12
+shadow-radius = 12;
 
-# Red color value of shadow (0.0 - 1.0, defaults to 0).
-#shadow-red = 0.86328125
-
-# Green color value of shadow (0.0 - 1.0, defaults to 0).
-#shadow-green = 0.2109375
-
-# Blue color value of shadow (0.0 - 1.0, defaults to 0).
-#shadow-blue = 0.015625
-
-# Do not paint shadows on shaped windows. Note shaped windows 
-# here means windows setting its shape through X Shape extension. 
-# Those using ARGB background is beyond our control. 
-# Deprecated, use 
-#   shadow-exclude = 'bounding_shaped'
-# or 
-#   shadow-exclude = 'bounding_shaped && !rounded_corners'
-# instead.
+# The opacity of shadows.
 #
-# shadow-ignore-shaped = ''
+# Range: 0.0 - 1.0
+# Default: 0.75
+# shadow-opacity = .75
 
-# Specify a list of conditions of windows that should have no shadow.
+# The left offset for shadows, in pixels.
 #
-# examples:
-#   shadow-exclude = "n:e:Notification";
-#
-# shadow-exclude = []
-shadow-exclude = [
-  "_GTK_FRAME_EXTENTS@:c",
-  #"_NET_WM_STATE@:32a"
-];
+# Default: -15
+shadow-offset-x = -7;
 
-# Specify a X geometry that describes the region in which shadow should not
-# be painted in, such as a dock window region. Use 
-#    shadow-exclude-reg = "x10+0+0"
-# for example, if the 10 pixels on the bottom of the screen should not have shadows painted on.
+# The top offset for shadows, in pixels.
 #
-# shadow-exclude-reg = "" 
+# Default: -15
+shadow-offset-y = -7;
 
-# Crop shadow of a window fully on a particular Xinerama screen to the screen.
-# xinerama-shadow-crop = false
+# Hex string color value of shadow. Formatted like "#RRGGBB", e.g. "#C0FFEE".
+#
+# Default: #000000
+# shadow-color = "#000000"
+
+# Crop shadow of a window fully on a particular monitor to that monitor. This is
+# currently implemented using the X RandR extension.
+#
+# Default: false
+# crop-shadow-to-monitor = false
 
 
 #################################
 #           Fading              #
 #################################
 
-
 # Fade windows in/out when opening/closing and when opacity changes,
-#  unless no-fading-openclose is used.
-# fading = false
-fading = false;
+# unless no-fading-openclose is used. Can be set per-window using rules.
+#
+# Default: false
+fading = true;
 
 # Opacity change between steps while fading in. (0.01 - 1.0, defaults to 0.028)
-# fade-in-step = 0.028
-fade-in-step = 0.03;
+fade-in-step = 0.012;
 
 # Opacity change between steps while fading out. (0.01 - 1.0, defaults to 0.03)
-# fade-out-step = 0.03
-fade-out-step = 0.03;
+fade-out-step = 0.012;
 
 # The time between steps in fade step, in milliseconds. (> 0, defaults to 10)
-fade-delta = 4
-
-# Specify a list of conditions of windows that should not be faded.
-# don't need this, we disable fading for all normal windows with wintypes: {}
-fade-exclude = [
-  "class_g = 'slop'"   # maim
-]
+fade-delta = 2
 
 # Do not fade on window open/close.
 # no-fading-openclose = false
@@ -128,321 +74,252 @@ fade-exclude = [
 #   Transparency / Opacity      #
 #################################
 
-
-# Opacity of inactive windows. (0.1 - 1.0, defaults to 1.0)
-# inactive-opacity = 1
-
-# Opacity of window titlebars and borders. (0.1 - 1.0, disabled by default)
-# frame-opacity = 1.0
-
-# Default opacity for dropdown menus and popup menus. (0.0 - 1.0, defaults to 1.0)
-# menu-opacity = 1.0
-
-# Let inactive opacity set by -i override the '_NET_WM_OPACITY' values of windows.
-# inactive-opacity-override = true
-inactive-opacity-override = true;
-
-# Default opacity for active windows. (0.0 - 1.0, defaults to 1.0)
-active-opacity = 1.0;
-
-# Dim inactive windows. (0.0 - 1.0, defaults to 0.0)
-inactive-dim = 0.0
-
-# Specify a list of conditions of windows that should always be considered focused.
-# focus-exclude = []
-focus-exclude = [
-  "class_g = 'slop'"                    # maim
-];
+# Opacity of window titlebars and borders.
+#
+# Range: 0.1 - 1.0
+# Default: 1.0 (disabled)
+frame-opacity = 0.7;
 
 # Use fixed inactive dim value, instead of adjusting according to window opacity.
-# inactive-dim-fixed = 1.0
-
-# Specify a list of opacity rules, in the format `PERCENT:PATTERN`, 
-# like `50:name *= "Firefox"`. picom-trans is recommended over this. 
-# Note we don't make any guarantee about possible conflicts with other 
-# programs that set '_NET_WM_WINDOW_OPACITY' on frame or client windows.
-# example:
-#    opacity-rule = [ "80:class_g = 'URxvt'" ];
 #
-# opacity-rule = []
-opacity-rule = [
-  "100:class_g    = 'slop'",            # maim
-];
-
+# Default: false
+# inactive-dim-fixed = true
 
 #################################
-#     Background-Blurring       #
+#           Corners             #
 #################################
 
+# Sets the radius of rounded window corners. When > 0, the compositor will
+# round the corners of windows. Does not interact well with
+# `transparent-clipping`.
+#
+# Default: 0 (disabled)
+corner-radius = 0
 
-# Parameters for background blurring, see the *BLUR* section for more information.
-# blur-method = gaussian
+#################################
+#            Blur               #
+#################################
+
+# Parameters for background blurring, see BLUR section in the man page for more information.
+# blur-method =
 # blur-size = 12
 #
 # blur-deviation = false
-
-# Blur background of semi-transparent / ARGB windows. 
-# Bad in performance, with driver-dependent behavior. 
-# The name of the switch may change without prior notifications.
 #
-blur-background = true;
+# blur-strength = 5
 
-# Blur background of windows when the window frame is not opaque. 
+# Blur background of semi-transparent / ARGB windows.
+# Can be set per-window using rules.
+#
+# Default: false
+# blur-background = false
+
+# Blur background of windows when the window frame is not opaque.
 # Implies:
-#    blur-background 
-# Bad in performance, with driver-dependent behavior. The name may change.
+#    blur-background
 #
-# blur-background-frame = false;
-
+# Default: false
+# blur-background-frame = false
 
 # Use fixed blur strength rather than adjusting according to window opacity.
-# blur-background-fixed = false;
+#
+# Default: false
+# blur-background-fixed = false
 
 
 # Specify the blur convolution kernel, with the following format:
 # example:
 #   blur-kern = "5,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1";
+# Can also be a pre-defined kernel, see the man page.
 #
-# blur-kern = ''
-# blur-kern = "3x3box";
-
-blur: {
-  # requires: https://github.com/ibhagwan/picom
-  #method = "none";
-  method = "kawase";
-  strength = 3;
-  deviation = 1.0;
-  background = true;
-  background-frame = false;
-  background-fixed = false;
-  kern = "3x3box";
-}
-
-# Exclude conditions for background blur.
-blur-background-exclude = [
-  "class_g != 'St'",
-  "_GTK_FRAME_EXTENTS@:c"
-];
-
+# Default: ""
+blur-kern = "3x3box";
 
 #################################
 #       General Settings        #
 #################################
 
+# Enable remote control via D-Bus. See the man page for more details.
+#
+# Default: false
+# dbus = true
+
 # Daemonize process. Fork to background after initialization. Causes issues with certain (badly-written) drivers.
-daemon = true
+# daemon = false
 
-# Specify the backend to use: `xrender`, `glx`, or `xr_glx_hybrid`.
-# `xrender` is the default one.
+# Specify the backend to use: `xrender`, `glx`, or `egl`.
 #
-experimental-backends = true;
-backend = "glx";
+# Default: "xrender"
+backend = "glx"
 
-vsync = false
+# Use higher precision during rendering, and apply dither when presenting the
+# rendered screen. Reduces banding artifacts, but may cause performance
+# degradation. Only works with OpenGL.
+dithered-present = false;
 
-# Enable remote control via D-Bus. See the *D-BUS API* section below for more details.
-# dbus = false
-
-# Try to detect WM windows (a non-override-redirect window with no 
-# child that has 'WM_STATE') and mark them as active.
+# Enable/disable VSync.
 #
-# mark-wmwin-focused = false
-mark-wmwin-focused = true;
+# Default: false
+vsync = true;
 
-# Mark override-redirect windows that doesn't have a child window with 'WM_STATE' focused.
-# mark-ovredir-focused = false
-mark-ovredir-focused = true;
-
-# Try to detect windows with rounded corners and don't consider them 
+# Try to detect windows with rounded corners and don't consider them
 # shaped windows. The accuracy is not very high, unfortunately.
 #
+# Has nothing to do with `corner-radius`.
+#
+# Default: false
 detect-rounded-corners = true;
 
-# Detect '_NET_WM_OPACITY' on client windows, useful for window managers
-# not passing '_NET_WM_OPACITY' of client windows to frame windows.
+# Detect '_NET_WM_WINDOW_OPACITY' on client windows, useful for window managers
+# not passing '_NET_WM_WINDOW_OPACITY' of client windows to frame windows.
 #
-#detect-client-opacity = false
+# Default: false
 detect-client-opacity = true;
 
-# Specify refresh rate of the screen. If not specified or 0, picom will 
-# try detecting this with X RandR extension.
-#
-# refresh-rate = 60
-refresh-rate = 0
-
-# Limit picom to repaint at most once every 1 / 'refresh_rate' second to 
-# boost performance. This should not be used with 
-#   vsync drm/opengl/opengl-oml
-# as they essentially does sw-opti's job already, 
-# unless you wish to specify a lower refresh rate than the actual value.
-#
-# sw-opti = 
-
-# Use EWMH '_NET_ACTIVE_WINDOW' to determine currently focused window, 
-# rather than listening to 'FocusIn'/'FocusOut' event. Might have more accuracy, 
+# Use EWMH '_NET_ACTIVE_WINDOW' to determine currently focused window,
+# rather than listening to 'FocusIn'/'FocusOut' event. May be more accurate,
 # provided that the WM supports it.
 #
+# Default: false
 # use-ewmh-active-win = false
 
-# Unredirect all windows if a full-screen opaque window is detected, 
-# to maximize performance for full-screen windows. Known to cause flickering 
-# when redirecting/unredirecting windows. paint-on-overlay may make the flickering less obvious.
+# Unredirect all windows if a full-screen opaque window is detected,
+# to maximize performance for full-screen windows. Known to cause flickering
+# when redirecting/unredirecting windows.
 #
-# unredir-if-possible = true
+# Default: false
+# unredir-if-possible = false
 
-# Delay before unredirecting the window, in milliseconds. Defaults to 0.
+# Delay before unredirecting the window, in milliseconds.
+#
+# Default: 0.
 # unredir-if-possible-delay = 0
 
-# Conditions of windows that shouldn't be considered full-screen for unredirecting screen.
-# unredir-if-possible-exclude = []
-
-# Use 'WM_TRANSIENT_FOR' to group windows, and consider windows 
+# Use 'WM_TRANSIENT_FOR' to group windows, and consider windows
 # in the same group focused at the same time.
 #
-# detect-transient = false
-detect-transient = true
+# Default: false
+detect-transient = true;
 
-# Use 'WM_CLIENT_LEADER' to group windows, and consider windows in the same 
-# group focused at the same time. 'WM_TRANSIENT_FOR' has higher priority if 
-# detect-transient is enabled, too.
+# Use 'WM_CLIENT_LEADER' to group windows, and consider windows in the same
+# group focused at the same time. This usually means windows from the same application
+# will be considered focused or unfocused at the same time.
+# 'WM_TRANSIENT_FOR' has higher priority if detect-transient is enabled, too.
 #
+# Default: false
 # detect-client-leader = false
-detect-client-leader = true
 
-# Resize damaged region by a specific number of pixels. 
-# A positive value enlarges it while a negative one shrinks it. 
-# If the value is positive, those additional pixels will not be actually painted 
-# to screen, only used in blur calculation, and such. (Due to technical limitations, 
-# with use-damage, those pixels will still be incorrectly painted to screen.) 
-# Primarily used to fix the line corruption issues of blur, 
-# in which case you should use the blur radius value here 
-# (e.g. with a 3x3 kernel, you should use `--resize-damage 1`, 
-# with a 5x5 one you use `--resize-damage 2`, and so on). 
-# May or may not work with *--glx-no-stencil*. Shrinking doesn't function correctly.
+# Use of damage information for rendering. This cause the only the part of the
+# screen that has actually changed to be redrawn, instead of the whole screen
+# every time. Should improve performance.
 #
-# resize-damage = 1
+# Default: false
+use-damage = false;
 
-# Specify a list of conditions of windows that should be painted with inverted color. 
-# Resource-hogging, and is not well tested.
+# Use X Sync fence to wait for the completion of rendering of other windows,
+# before using their content to render the current screen.
 #
-# invert-color-include = []
+# Required for explicit sync drivers, such as nvidia.
+#
+# Default: false
+# xrender-sync-fence = false
 
-# GLX backend: Avoid using stencil buffer, useful if you don't have a stencil buffer. 
-# Might cause incorrect opacity when rendering transparent content (but never 
-# practically happened) and may not work with blur-background. 
-# My tests show a 15% performance boost. Recommended.
+# GLX backend: Use specified GLSL fragment shader for rendering window
+# contents. Read the man page for a detailed explanation of the interface.
 #
-# glx-no-stencil = false
+# Can be set per-window using rules.
+#
+#window-shader-fg = "~/.config/picom/shaders/glitch_animation.glsl"
 
-# GLX backend: Avoid rebinding pixmap on window damage. 
-# Probably could improve performance on rapid window content changes, 
-# but is known to break things on some drivers (LLVMpipe, xf86-video-intel, etc.).
-# Recommended if it works.
-#
-# glx-no-rebind-pixmap = false
-
-# Disable the use of damage information. 
-# This cause the whole screen to be redrawn everytime, instead of the part of the screen
-# has actually changed. Potentially degrades the performance, but might fix some artifacts.
-# The opposing option is use-damage
-#
-# no-use-damage = false
-use-damage = true
-
-# Use X Sync fence to sync clients' draw calls, to make sure all draw 
-# calls are finished before picom starts drawing. Needed on nvidia-drivers 
-# with GLX backend for some users.
-#
-xrender-sync-fence = true
-
-# GLX backend: Use specified GLSL fragment shader for rendering window contents. 
-# See `compton-default-fshader-win.glsl` and `compton-fake-transparency-fshader-win.glsl` 
-# in the source tree for examples.
-#
-# glx-fshader-win = ''
-
-# Force all windows to be painted with blending. Useful if you 
-# have a glx-fshader-win that could turn opaque pixels transparent.
+# Force all windows to be painted with blending. Useful if you
+# have a `window-shader-fg` that could turn opaque pixels transparent.
 #
+# Default: false
 # force-win-blend = false
 
-# Do not use EWMH to detect fullscreen windows. 
+# Do not use EWMH to detect fullscreen windows.
 # Reverts to checking if a window is fullscreen based only on its size and coordinates.
 #
+# Default: false
 # no-ewmh-fullscreen = false
 
-# Dimming bright windows so their brightness doesn't exceed this set value. 
-# Brightness of a window is estimated by averaging all pixels in the window, 
-# so this could comes with a performance hit. 
-# Setting this to 1.0 disables this behaviour. Requires --use-damage to be disabled. (default: 1.0)
+# Dimming bright windows so their brightness doesn't exceed this set value.
+# Brightness of a window is estimated by averaging all pixels in the window,
+# so this could comes with a performance hit.
+# Setting this to 1.0 disables this behaviour. Requires --use-damage to be disabled.
 #
+# Default: 1.0 (disabled)
 # max-brightness = 1.0
 
 # Make transparent windows clip other windows like non-transparent windows do,
-# instead of blending on top of them.
+# instead of blending on top of them. e.g. placing a transparent window on top
+# of another window will cut a "hole" in that window, and show the desktop background
+# underneath.
 #
+# Default: false
 # transparent-clipping = false
 
 # Set the log level. Possible values are:
 #  "trace", "debug", "info", "warn", "error"
-# in increasing level of importance. Case doesn't matter. 
-# If using the "TRACE" log level, it's better to log into a file 
+# in increasing level of importance. Case insensitive.
+# If using the "TRACE" log level, it's better to log into a file
 # using *--log-file*, since it can generate a huge stream of logs.
 #
-# log-level = "debug"
-log-level = "info";
+# Default: "warn"
+# log-level = "warn";
 
 # Set the log file.
-# If *--log-file* is never specified, logs will be written to stderr. 
-# Otherwise, logs will to written to the given file, though some of the early 
-# logs might still be written to the stderr. 
+# If *--log-file* is never specified, logs will be written to stderr.
+# Otherwise, logs will to written to the given file, though some of the early
+# logs might still be written to the stderr.
 # When setting this option from the config file, it is recommended to use an absolute path.
 #
-# log-file = '/path/to/your/log/file'
-
-# Show all X errors (for debugging)
-# show-all-xerrors = false
+# log-file = "/path/to/your/log/file"
 
 # Write process ID to a file.
-# write-pid-path = '/path/to/your/log/file'
+# write-pid-path = "/path/to/your/log/file"
 
-# Window type settings
-# 
-# 'WINDOW_TYPE' is one of the 15 window types defined in EWMH standard: 
-#     "unknown", "desktop", "dock", "toolbar", "menu", "utility", 
-#     "splash", "dialog", "normal", "dropdown_menu", "popup_menu", 
-#     "tooltip", "notification", "combo", and "dnd".
-# 
-# Following per window-type options are available: ::
-# 
-#   fade, shadow:::
-#     Controls window-type-specific shadow and fade settings.
-# 
-#   opacity:::
-#     Controls default opacity of the window type.
-# 
-#   focus:::
-#     Controls whether the window of this type is to be always considered focused. 
-#     (By default, all window types except "normal" and "dialog" has this on.)
-# 
-#   full-shadow:::
-#     Controls whether shadow is drawn under the parts of the window that you 
-#     normally won't be able to see. Useful when the window has parts of it 
-#     transparent, and you want shadows in those areas.
-# 
-#   redir-ignore:::
-#     Controls whether this type of windows should cause screen to become 
-#     redirected again after been unredirected. If you have unredir-if-possible
-#     set, and doesn't want certain window to cause unnecessary screen redirection, 
-#     you can set this to `true`.
+# Rule-based per-window options.
 #
-wintypes:
+# See WINDOW RULES section in the man page for how these work.
+rules: ({
+  match = "window_type = 'tooltip'";
+  fade = false;
+  shadow = true;
+  opacity = 0.9;
+  full-shadow = false;
+}, {
+  match = "window_type = 'dock'    || "
+          "window_type = 'desktop' || "
+          "_GTK_FRAME_EXTENTS@";
+  blur-background = false;
+}, {
+  match = "window_type != 'dock'";
+}, {
+  match = "window_type = 'dock' || "
+          "window_type = 'desktop'";
+  corner-radius = 0;
+}, {
+  match = "name = 'Notification'   || "
+          "class_g = 'Conky'       || "
+          "class_g ?= 'Notify-osd' || "
+          "class_g = 'Cairo-clock' || "
+          "_GTK_FRAME_EXTENTS@";
+  shadow = false;
+},
 {
-  normal = { fade = true; shadow = true;}
-  tooltip = { fade = true; shadow = true; opacity = 0.75; focus = true; full-shadow = false; };
-  dock = { full-shadow = true; }
-  dnd = { shadow = true; }
-  popup_menu = { shadow = true; }
-  dropdown_menu = { shadow = true; }
-};
-unredir-if-possible = false 
+  match = "window_type = 'desktop'";
+  shader = "/home/x/.config/picom/shaders/glitch.glsl";
+},
+{
+  match = "window_type != 'desktop'";
+  shader = "/home/x/.config/picom/shaders/glitch_animation.glsl";
+});
+
+# `@include` directive can be used to include additional configuration files.
+# Relative paths are search either in the parent of this configuration file
+# (when the configuration is loaded through a symlink, the symlink will be
+# resolved first). Or in `$XDG_CONFIG_HOME/picom/include`.
+#
+# @include "extra.conf"
+

config/picom/shaders/OldCRT.glsl

@@ -0,0 +1,190 @@
+#version 430
+#define PI 3.1415926538
+uniform float opacity;
+uniform float time;
+
+// Works best with fullscreen windows
+// Made this to play retro games the way god intended
+
+uniform float sc_freq = 0.2; // Frequency for the scanlines
+
+uniform float sc_intensity = 0.6; // Intensity of the scanline effect
+
+uniform bool grid = false; // Whether to also apply scanlines to x axis or not
+
+uniform int distortion_offset = 2; // Pixel offset for red/blue distortion
+
+uniform int downscale_factor = 2; // How many pixels of the window
+                                  // make an actual "pixel" (or block)
+
+uniform float sph_distance = 500; // Distance from the theoretical sphere 
+                                  // we use for our curvature transform
+
+uniform float curvature = 1.5; // How much the window should "curve" 
+
+uniform float shadow_cutoff = 1; // How "early" the shadow starts affecting 
+                                 // pixels close to the edges
+                                 // I'd keep this value very close to 1
+
+uniform int shadow_intensity = 1; // Intensity level of the shadow effect (from 1 to 5)
+
+vec4 outside_color = vec4(0 ,0 ,0, opacity); // Color for the outside of the window
+
+float flash_speed = 0; // Speed of flashing effect, set to 0 to deactivate
+                         
+float flash_intensity = 0.8; // Intensity of flashing effect
+
+
+// You can play with different values for all the variables above
+
+in vec2 texcoord;             // texture coordinate of the fragment
+
+uniform sampler2D tex;        // texture of the window
+
+ivec2 window_size = textureSize(tex, 0);
+ivec2 window_center = ivec2(window_size.x/2, window_size.y/2);
+float radius = (window_size.x/curvature);
+int flash = int(round(flash_speed*time/(10000/window_size.y))) % window_size.y;
+
+// Default window post-processing:
+// 1) invert color
+// 2) opacity / transparency
+// 3) max-brightness clamping
+// 4) rounded corners
+vec4 default_post_processing(vec4 c);
+
+// Darkens a pixels near the edges
+vec4 darken_color(vec4 color, vec2 coords)
+{
+    // If shadow intensity is 0, change nothing
+    if (shadow_intensity == 0)
+    {
+        return color;
+    }
+
+    // Get how far the coords are from the center
+    vec2 distances_from_center = abs(window_center - coords);
+
+    // Darken pixels close to the edges of the screen in a polynomial fashion
+    float brightness = 1;
+    brightness *= -pow((distances_from_center.y/window_center.y)*shadow_cutoff, 
+                       (5/shadow_intensity)*2)+1;
+    brightness *= -pow((distances_from_center.x/window_center.x)*shadow_cutoff, 
+                       (5/shadow_intensity)*2)+1;
+    color.xyz *= brightness;
+
+    return color;
+}
+
+// Applies a transformation to our window pixels to simulate
+// a curved screen
+ivec2 curve_coords_spheric(vec2 coords)
+{
+    // Offset coords
+    coords -= window_center;
+    vec2 curved_coords; 
+
+    // For this transform imagine a sphere in a 3d space with the 
+    // window as a 2d plane tangent to that sphere
+    // For simplicity, we center the sphere at 0,0,0
+    // The coordinates of the projection share x and y with our window pixel 
+    // We find Z using the formula for a sphere
+    vec3 projection_coords3d = vec3(coords.x, coords.y, 
+                                    sqrt(pow(radius+sph_distance,2)-
+                                         pow(coords.x,2)-
+                                         pow(coords.y,2)));
+
+    // That vector goes from the center of the sphere to the projection of a pixel
+    // of our window onto the sphere's surface
+    // Let's scale it until it hits our window plane
+    projection_coords3d *= ((radius+sph_distance)/projection_coords3d.z);
+    curved_coords = projection_coords3d.xy;
+
+    // Compensate for starting coords offset
+    curved_coords += window_center;
+
+    return ivec2(curved_coords);
+}
+
+
+// Gets a color for a pixel with all the coordinate and
+// downscale changes
+vec4 get_pixel(vec2 coords)
+{
+    // If pixel is at the edge of the window, return a completely black color
+    if (coords.x >=window_size.x-1 || coords.y >=window_size.y-1 || 
+        coords.x <=0 || coords.y <=0)
+    {
+        return outside_color;
+    }
+    vec4 color = texelFetch(tex, ivec2(coords), 0);
+    return default_post_processing(color);
+}
+
+// Gets the color from a downscaled block
+vec4 get_block_color(vec2 coords)
+{
+    // If downscale is set to 1, just return a pixel
+    if (downscale_factor < 2)
+    {
+        return get_pixel(coords);
+    }
+
+    // Relative position of pixel inside the block
+    ivec2 relative_position;
+    relative_position.xy = ivec2(coords).xy % downscale_factor;
+
+    // Average all colors from pixels inside the block
+    vec4 average = vec4(0, 0 , 0, 0);
+    for (int i = 0; i < downscale_factor; i++)
+    {
+       for (int j = 0; j < downscale_factor; j++)
+       {
+           average.xyzw += get_pixel(vec2(coords.x + i - relative_position.x,
+                                          coords.y + j - relative_position.y));
+       }
+    }
+    average /= pow(downscale_factor, 2);
+
+    return average;
+}
+
+
+// Main shader function
+vec4 window_shader() {
+    
+    // Apply curvature transform to coords
+    vec2 curved_coords = curve_coords_spheric(texcoord);
+
+    // Fetch the color
+    vec4 c = get_block_color(curved_coords);
+    
+    // Fetch colors from close pixels to apply color distortion
+    vec4 c_right = get_block_color(vec2(curved_coords.x+2, curved_coords.y));
+    vec4 c_left = get_block_color(vec2(curved_coords.x-2, curved_coords.y));
+
+    // Mix red and blue colors
+    c = vec4(c_left.x, c.y, c_right.z, c.w);
+
+    // Apply scanlines
+    c.xyz *= sin(2*PI*sc_freq*(texcoord).y)/(2/sc_intensity) +
+             1 - sc_intensity/2;
+
+    // Also apply scanlines to x axis if grid is enabled
+    if (grid == true)
+    {
+        c.xyz *= sin(2*PI*sc_freq*(texcoord).x)/(2/sc_intensity) +
+                 1 - sc_intensity/2;
+    }
+    
+    // Apply flash
+    if (curved_coords.y >=flash-(window_size.y/10) && curved_coords.y <=flash)
+    {
+       c.xyz *= flash_intensity*(pow(((flash-curved_coords.y)/(window_size.y/10))-1,2)
+                                                  + 1/flash_intensity); 
+    }
+
+    // Darken pixel
+    c = darken_color(c, curved_coords);
+    return (c);
+}

config/picom/shaders/bg.glsl

@@ -0,0 +1,138 @@
+#version 330
+
+int delta = 20;
+float barh = 0.05;
+float barw = 0.6;
+int nbar = 8;
+
+float maxoff = 32;
+float minoff = 2;
+float hue = 0.3;
+
+// blinds
+int blinds_spacing = 4;
+int blinds_width = 1;
+float blinds_intensity = 1.2;
+
+in vec2 texcoord;             // texture coordinate of the fragment
+
+uniform sampler2D tex;        // texture of the window
+ivec2 window_size = textureSize(tex, 0);
+ivec2 window_center = ivec2(window_size.x/2, window_size.y/2);
+
+// Default window post-processing:
+// 1) invert color
+// 2) opacity / transparency
+// 3) max-brightness clamping
+// 4) rounded corners
+vec4 default_post_processing(vec4 c);
+
+uniform float time; // Time in miliseconds.
+
+float alpha = round(time/delta); // Like time, but in seconds and resets to 
+
+vec4 blinds(vec4 c, vec2 coords) {
+    if (mod(coords.y, blinds_spacing)  < blinds_width) {
+        return c * blinds_intensity;
+    }
+
+    return c;
+}
+
+vec3 hueShift( vec3 color, float hueAdjust ){
+
+    const vec3  kRGBToYPrime = vec3 (0.299, 0.587, 0.114);
+    const vec3  kRGBToI      = vec3 (0.596, -0.275, -0.321);
+    const vec3  kRGBToQ      = vec3 (0.212, -0.523, 0.311);
+
+    const vec3  kYIQToR     = vec3 (1.0, 0.956, 0.621);
+    const vec3  kYIQToG     = vec3 (1.0, -0.272, -0.647);
+    const vec3  kYIQToB     = vec3 (1.0, -1.107, 1.704);
+
+    float   YPrime  = dot (color, kRGBToYPrime);
+    float   I       = dot (color, kRGBToI);
+    float   Q       = dot (color, kRGBToQ);
+    float   hue     = atan (Q, I);
+    float   chroma  = sqrt (I * I + Q * Q);
+
+    hue += hueAdjust;
+
+    Q = chroma * sin (hue);
+    I = chroma * cos (hue);
+
+    vec3    yIQ   = vec3 (YPrime, I, Q);
+
+    return vec3( dot (yIQ, kYIQToR), dot (yIQ, kYIQToG), dot (yIQ, kYIQToB) );
+
+}
+
+// Pseudo-random function (from original shader)
+float random(float n) {
+    return fract(sin(n) * 43758.5453f);
+}
+
+float get_box() {
+    float n = random(alpha)*(nbar);
+
+    for(int i=0;i<n;i++){
+        float y = random(mod(alpha, 2048)+i) * window_size.y;
+        float x = random(mod(alpha+128, 2048)+i) * window_size.x;
+        float w = random(mod(alpha+64, 2048)+i) * barw*window_size.x;
+        float h = random(mod(alpha+32, 2048)+i) * barh*window_size.y;
+        if (texcoord.y > y && texcoord.y < y + h
+         && texcoord.x > x && texcoord.x < x + w) {
+            return i*w*h*y*x*n;
+        }
+    }
+    return -1.0f;
+}
+
+float rand_offset(float b) {
+    return (random(b*64) - 0.5) * (maxoff*2);
+}
+
+vec4 window_color(vec2 uv) {
+    return blinds(texelFetch(tex, ivec2(uv), 0), uv);
+}
+
+vec4 window_shader() {
+    float b = get_box();
+
+    if (b == -1.0) {
+        vec4 c = window_color(ivec2(texcoord));
+        return default_post_processing(c);
+    }
+    //b = random(mod(alpha, 2000));
+
+    // Offsets in pixels for each color
+    vec2 uvr = vec2(rand_offset(b*1), rand_offset(b*6));
+    vec2 uvg = vec2(rand_offset(b*2),rand_offset(b*7));
+    vec2 uvb = vec2(rand_offset(b*3),rand_offset(b*8));
+
+
+    // Calculate offset coords
+    uvr += texcoord;
+    uvg += texcoord;
+    uvb += texcoord;
+
+    // Fetch colors using offset coords
+    vec3 offset_color;
+    offset_color.x = window_color(uvr).x;
+    offset_color.y = window_color(uvg).y;
+    offset_color.z = window_color(uvb).z;
+
+    offset_color.x = hueShift(window_color(uvr).xyz, hue).x;
+    offset_color.y = hueShift(window_color(uvg).xyz, hue).y;
+    offset_color.z = hueShift(window_color(uvb).xyz, hue).z;
+
+    offset_color.xyz = hueShift(offset_color.xyz, -hue);
+    // Set the new color
+    vec4 c;
+    c.w = texelFetch(tex, ivec2(uvr), 0).w;
+    c.xyz = offset_color;
+
+    c.xyz = hueShift(c.xyz, random(mod(b, 2000)));
+
+    return default_post_processing(c);
+}
+

config/picom/shaders/cross.glsl

@@ -0,0 +1,335 @@
+#version 430
+#define PI 3.14159265
+
+// These shaders work by using a pinhole camera and raycasting
+// The window 3d objects will always be (somewhat) centered at (0, 0, 0)
+struct pinhole_camera
+{
+    float focal_offset; // Distance along the Z axis between the camera 
+                        // center and the focal point. Use negative values
+                        // so the image doesn't flip
+                        // This kinda works like FOV in games
+
+    // Transformations 
+    // Use these to modify the coordinate system of the camera plane
+    vec3 rotations; // Rotations in radians around each axis 
+                    // The camera plane rotates around 
+                    // its center point, not the origin
+
+    vec3 translations; // Translations in pixels along each axis
+
+    vec3 deformations; // Deforms the camera. Higher values on each axis
+                       // means the window will be squashed in that axis
+
+    // ---------------------------------------------------------------// 
+    
+    // "Aftervalues" 
+    // These will be set later with setup_camera(), leave them as 0
+    vec3 base_x;
+    vec3 base_y;
+    vec3 base_z;
+    vec3 center_point;
+    vec3 focal_point;
+};
+
+in vec2 texcoord;             // texture coordinate of the fragment
+
+uniform sampler2D tex;        // texture of the window
+
+
+uniform float time; // Time in miliseconds.
+      
+float time_cyclic = mod(time/10000,2); // Like time, but in seconds and resets to 
+                                       // 0 when it hits 2. Useful for using it in 
+                                       // periodic functions like cos and sine
+// Time variables can be used to change transformations over time
+
+
+ivec2 window_size = textureSize(tex, 0); // Size of the window
+
+float window_diagonal = length(window_size); // Diagonal of the window
+// Try to keep focal offset and translations proportional to window_size components 
+// or window_diagonal as you see fit
+
+pinhole_camera camera = 
+pinhole_camera(-window_size.y/2,   // Focal offset
+               vec3(0,0,0), // Rotations
+               vec3(0,0,0), // Translations
+               vec3(1,1,1), // Deformations
+               // Leave the rest as 0
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0));
+
+// Here are some presets you can use
+
+// Moves the camera up and down
+pinhole_camera bobbing = 
+pinhole_camera(-window_size.y/2,
+               vec3(0,0,0),
+               vec3(0,cos(time_cyclic*PI)*window_size.y/16,-window_size.y/4),
+               vec3(1,1,1),
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0));
+
+// Rotates camera around the origin
+// Makes the window rotate around the Y axis from the camera's POV
+// (if the window is centered)
+pinhole_camera rotate_around_origin = 
+pinhole_camera(-window_diagonal,
+               vec3(0,-time_cyclic*PI-PI/2,0),
+               vec3(cos(time_cyclic*PI)*window_diagonal,
+                   0,
+                   sin(time_cyclic*PI)*window_diagonal),
+               vec3(1,1,1),
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0));
+
+// Rotate camera around its center
+pinhole_camera rotate_around_itself = 
+pinhole_camera(-window_diagonal,
+               vec3(0,-time_cyclic*PI-PI/2,0),
+               vec3(0,0,-window_diagonal),
+               vec3(1,1,1),
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0));
+
+// Here you can select the preset to use
+pinhole_camera window_cam = rotate_around_origin;
+
+
+
+ivec2 window_center = ivec2(window_size.x/2, window_size.y/2); 
+
+// Default window post-processing:
+// 1) invert color
+// 2) opacity / transparency
+// 3) max-brightness clamping
+// 4) rounded corners
+vec4 default_post_processing(vec4 c);
+
+// Sets up a camera by applying transformations and 
+// calculating xyz vector basis 
+pinhole_camera setup_camera(pinhole_camera camera)
+{
+    // Apply translations
+    camera.center_point += camera.translations;
+
+    // Apply rotations 
+    // We initialize our vector basis as normalized vectors
+    // in each axis * our deformations vector
+    camera.base_x = vec3(camera.deformations.x, 0, 0);
+    camera.base_y = vec3(0, camera.deformations.y, 0);
+    camera.base_z = vec3(0, 0, camera.deformations.z);
+
+
+    // Then we rotate them around following our rotations vector:
+    // First save these values to avoid redundancy
+    float cosx = cos(camera.rotations.x);
+    float cosy = cos(camera.rotations.y);
+    float cosz = cos(camera.rotations.z);
+    float sinx = sin(camera.rotations.x);
+    float siny = sin(camera.rotations.y);
+    float sinz = sin(camera.rotations.z);
+    
+    // Declare a buffer vector we will use to apply multiple changes at once
+    vec3 tmp = vec3(0);
+
+    // Rotations for base_x:
+    tmp = camera.base_x;
+    // X axis:
+    tmp.y =  camera.base_x.y * cosx - camera.base_x.z * sinx;
+    tmp.z =  camera.base_x.y * sinx + camera.base_x.z * cosx;
+    camera.base_x = tmp;
+    // Y axis:
+    tmp.x =  camera.base_x.x * cosy + camera.base_x.z * siny;
+    tmp.z = -camera.base_x.x * siny + camera.base_x.z * cosy;
+    camera.base_x = tmp;
+    // Z axis:
+    tmp.x =  camera.base_x.x * cosz - camera.base_x.y * sinz;
+    tmp.y =  camera.base_x.x * sinz + camera.base_x.y * cosz;
+    camera.base_x = tmp;
+
+    // Rotations for base_y:
+    tmp = camera.base_y;
+    // X axis:
+    tmp.y =  camera.base_y.y * cosx - camera.base_y.z * sinx;
+    tmp.z =  camera.base_y.y * sinx + camera.base_y.z * cosx;
+    camera.base_y = tmp;
+    // Y axis:
+    tmp.x =  camera.base_y.x * cosy + camera.base_y.z * siny;
+    tmp.z = -camera.base_y.x * siny + camera.base_y.z * cosy;
+    camera.base_y = tmp;
+    // Z axis:
+    tmp.x =  camera.base_y.x * cosz - camera.base_y.y * sinz;
+    tmp.y =  camera.base_y.x * sinz + camera.base_y.y * cosz;
+    camera.base_y = tmp;
+
+    // Rotations for base_z: 
+    tmp = camera.base_z;
+    // X axis:
+    tmp.y =  camera.base_z.y * cosx - camera.base_z.z * sinx;
+    tmp.z =  camera.base_z.y * sinx + camera.base_z.z * cosx;
+    camera.base_z = tmp;
+    // Y axis:
+    tmp.x =  camera.base_z.x * cosy + camera.base_z.z * siny;
+    tmp.z = -camera.base_z.x * siny + camera.base_z.z * cosy;
+    camera.base_z = tmp;
+    // Z axis:
+    tmp.x =  camera.base_z.x * cosz - camera.base_z.y * sinz;
+    tmp.y =  camera.base_z.x * sinz + camera.base_z.y * cosz;
+    camera.base_z = tmp;
+
+    // Now that we have our transformed 3d orthonormal base 
+    // we can calculate our focal point 
+    camera.focal_point = camera.center_point + camera.base_z * camera.focal_offset;
+
+    // Return our set up camera
+    return camera;
+}
+
+// Gets a pixel from the end of a ray projected to an axis
+vec4 get_pixel_from_projection(float t, int face, pinhole_camera camera, vec3 focal_vector)
+{
+    // If the point we end up in is behind our camera, don't "render" it
+    if (t < 1)
+    {
+        return vec4(0);
+    }
+
+    // Then we multiply our focal vector by t and add our focal point to it
+    // to end up in a point inside the window plane 
+    vec3 intersection = focal_vector * t + camera.focal_point;
+    
+
+    // Save a the necessary coordinates and add back offset
+    vec2 cam_coords;
+    switch (face) 
+    {
+        case 0:
+            cam_coords = intersection.xy + window_center;
+            break;
+        case 1:
+            cam_coords = intersection.zy + window_center;
+            break;
+    }
+    
+    // If pixel is outside of our window region
+    // return a completely transparent color
+    if (cam_coords.x >=window_size.x-1 || 
+        cam_coords.y >=window_size.y-1 ||
+        cam_coords.x <=0 || cam_coords.y <=0)
+    {
+        return vec4(0);
+    }
+    
+    // Fetch the pixel
+    vec4 pixel = texelFetch(tex, ivec2(cam_coords), 0);
+    return pixel;
+}
+
+// Combines colors using alpha
+// Got this from https://stackoverflow.com/questions/64701745/how-to-blend-colours-with-transparency
+// Not sure how it works honestly lol
+vec4 alpha_composite(vec4 color1, vec4 color2)
+{
+
+    float ar = color1.w + color2.w - (color1.w * color2.w);
+    float asr = color2.w / ar;
+    float a1 = 1 - asr;
+    float a2 = asr * (1 - color1.w);
+    float ab = asr * color1.w;
+    vec4 outcolor;
+    outcolor.xyz = color1.xyz * a1 + color2.xyz * a2 + color2.xyz * ab;
+    outcolor.w = ar;
+    return outcolor;
+
+}
+
+// Gets a pixel through the camera using coords as coordinates in
+// the camera plane
+vec4 get_pixel_through_camera(vec2 coords, pinhole_camera camera)
+{
+    // Offset coords
+    coords -= window_center;
+
+    // Find the pixel 3d position using the camera vector basis
+    vec3 pixel_3dposition =   camera.center_point 
+                            + coords.x * camera.base_x 
+                            + coords.y * camera.base_y;
+
+    // Get the vector going from the focal point to the pixel in 3d sapace
+    vec3 focal_vector = pixel_3dposition - camera.focal_point;
+
+    // We need 2 planes, one for each axis of the cross, they all follow the plane EQ
+    // ax + by + cz + d
+    float a[] = {0,1};
+    float b[] = {0,0};
+    float c[] = {1,0};
+    float d[] = {0,0};
+    // Then there's a line going from our focal point to each of the planes 
+    // which we can describe as:
+    // x(t) = focal_point.x + focal_vector.x * t
+    // y(t) = focal_point.y + focal_vector.y * t
+    // z(t) = focal_point.z + focal_vector.z * t
+    // We substitute x, y and z with x(t), y(t) and z(t) in the plane EQ
+    // Solving for t we get:
+    vec2 t[2]; // we use a vec2 to also store the plane that was hit
+    for (int i = 0; i < 2; i++)
+    {
+        t[i].x = (d[i] 
+                - a[i]*camera.focal_point.x 
+                - b[i]*camera.focal_point.y 
+                - c[i]*camera.focal_point.z)
+            / (a[i]*focal_vector.x 
+                    + b[i]*focal_vector.y 
+                    + c[i]*focal_vector.z);
+        t[i].y = i;
+    }
+    
+    // Bubble sort to know which intersections happen first
+    for (int i = 0; i < t.length(); i++)
+    {
+        for (int j = 0; j < t.length(); j++)
+        {
+            if (t [j].x > t[j+1].x)
+            {
+                vec2 tmp = t[j];
+                t[j] = t[j+1];
+                t[j+1] = tmp;
+            }
+        }
+    }
+
+    // Then we go through each one of the intersections in order 
+    // and mix pixels together using alpha
+    vec4 blended_pixels = vec4(0);
+    for (int i = 0; i < 2; i++)
+    {
+        // We get the pixel through projection
+        vec4 projection_pixel = get_pixel_from_projection(t[i].x, 
+                                                          int(t[i].y),
+                                                          camera,
+                                                          focal_vector);
+        // Blend the pixel using alpha
+        blended_pixels = alpha_composite(projection_pixel, blended_pixels);
+    }
+    return blended_pixels;
+}
+
+// Main function
+vec4 window_shader() {
+    pinhole_camera transformed_cam = setup_camera(window_cam);
+    return(get_pixel_through_camera(texcoord, transformed_cam));
+}

config/picom/shaders/cube.glsl

@@ -0,0 +1,373 @@
+#version 430
+#define PI 3.14159265
+
+// These shaders work by using a pinhole camera and raycasting
+// The window 3d objects will always be (somewhat) centered at (0, 0, 0)
+struct pinhole_camera
+{
+    float focal_offset; // Distance along the Z axis between the camera 
+                        // center and the focal point. Use negative values
+                        // so the image doesn't flip
+                        // This kinda works like FOV in games
+
+    // Transformations 
+    // Use these to modify the coordinate system of the camera plane
+    vec3 rotations; // Rotations in radians around each axis 
+                    // The camera plane rotates around 
+                    // its center point, not the origin
+
+    vec3 translations; // Translations in pixels along each axis
+
+    vec3 deformations; // Deforms the camera. Higher values on each axis
+                       // means the window will be squashed in that axis
+
+    // ---------------------------------------------------------------// 
+    
+    // "Aftervalues" 
+    // These will be set later with setup_camera(), leave them as 0
+    vec3 base_x;
+    vec3 base_y;
+    vec3 base_z;
+    vec3 center_point;
+    vec3 focal_point;
+};
+
+in vec2 texcoord;             // texture coordinate of the fragment
+
+uniform sampler2D tex;        // texture of the window
+
+
+uniform float time; // Time in miliseconds.
+      
+float time_cyclic = mod(time/10000,2); // Like time, but in seconds and resets to 
+                                       // 0 when it hits 2. Useful for using it in 
+                                       // periodic functions like cos and sine
+
+// Time variables can be used to change transformations over time
+
+
+ivec2 window_size = textureSize(tex, 0); // Size of the window
+
+float window_diagonal = length(window_size); // Diagonal of the window
+                                             
+int wss = min(window_size.x, window_size.y); // Window smallest side, useful when squaring windows
+// Try to keep focal offset and translations proportional to window_size components 
+// or window_diagonal as you see fit
+
+pinhole_camera camera = 
+pinhole_camera(-window_size.y/2,   // Focal offset
+               vec3(0,0,0), // Rotations
+               vec3(0,0,0), // Translations
+               vec3(1,1,1), // Deformations
+               // Leave the rest as 0
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0));
+
+// Here are some presets you can use
+
+// Moves the camera up and down
+pinhole_camera bobbing = 
+pinhole_camera(-window_size.y/2,
+               vec3(0,0,0),
+               vec3(0,cos(time_cyclic*PI)*window_size.y/16,-window_size.y/4),
+               vec3(1,1,1),
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0));
+
+// Rotates camera around the origin
+// Makes the window rotate around the Y axis from the camera's POV
+// (if the window is centered)
+pinhole_camera rotate_around_origin = 
+pinhole_camera(-wss,
+               vec3(PI/6*sin(2*time_cyclic*PI),-time_cyclic*PI-PI/2,0),
+               vec3(cos(time_cyclic*PI)*wss,
+                    wss/2*sin(2*time_cyclic*PI),
+                    sin(time_cyclic*PI)*wss),
+               vec3(1,1,1),
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0));
+
+// Rotate camera around its center
+pinhole_camera rotate_around_itself = 
+pinhole_camera(-wss,
+               vec3(0,-time_cyclic*PI-PI/2,0),
+               vec3(0,0,-wss),
+               vec3(1,1,1),
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0));
+
+// Here you can select the preset to use
+pinhole_camera window_cam = rotate_around_origin;
+
+
+
+ivec2 window_center = ivec2(window_size.x/2, window_size.y/2); 
+
+// Default window post-processing:
+// 1) invert color
+// 2) opacity / transparency
+// 3) max-brightness clamping
+// 4) rounded corners
+vec4 default_post_processing(vec4 c);
+
+// Sets up a camera by applying transformations and 
+// calculating xyz vector basis 
+pinhole_camera setup_camera(pinhole_camera camera)
+{
+    // Apply translations
+    camera.center_point += camera.translations;
+
+    // Apply rotations 
+    // We initialize our vector basis as normalized vectors
+    // in each axis * our deformations vector
+    camera.base_x = vec3(camera.deformations.x, 0, 0);
+    camera.base_y = vec3(0, camera.deformations.y, 0);
+    camera.base_z = vec3(0, 0, camera.deformations.z);
+
+
+    // Then we rotate them around following our rotations vector:
+    // First save these values to avoid redundancy
+    float cosx = cos(camera.rotations.x);
+    float cosy = cos(camera.rotations.y);
+    float cosz = cos(camera.rotations.z);
+    float sinx = sin(camera.rotations.x);
+    float siny = sin(camera.rotations.y);
+    float sinz = sin(camera.rotations.z);
+    
+    // Declare a buffer vector we will use to apply multiple changes at once
+    vec3 tmp = vec3(0);
+
+    // Rotations for base_x:
+    tmp = camera.base_x;
+    // X axis:
+    tmp.y =  camera.base_x.y * cosx - camera.base_x.z * sinx;
+    tmp.z =  camera.base_x.y * sinx + camera.base_x.z * cosx;
+    camera.base_x = tmp;
+    // Y axis:
+    tmp.x =  camera.base_x.x * cosy + camera.base_x.z * siny;
+    tmp.z = -camera.base_x.x * siny + camera.base_x.z * cosy;
+    camera.base_x = tmp;
+    // Z axis:
+    tmp.x =  camera.base_x.x * cosz - camera.base_x.y * sinz;
+    tmp.y =  camera.base_x.x * sinz + camera.base_x.y * cosz;
+    camera.base_x = tmp;
+
+    // Rotations for base_y:
+    tmp = camera.base_y;
+    // X axis:
+    tmp.y =  camera.base_y.y * cosx - camera.base_y.z * sinx;
+    tmp.z =  camera.base_y.y * sinx + camera.base_y.z * cosx;
+    camera.base_y = tmp;
+    // Y axis:
+    tmp.x =  camera.base_y.x * cosy + camera.base_y.z * siny;
+    tmp.z = -camera.base_y.x * siny + camera.base_y.z * cosy;
+    camera.base_y = tmp;
+    // Z axis:
+    tmp.x =  camera.base_y.x * cosz - camera.base_y.y * sinz;
+    tmp.y =  camera.base_y.x * sinz + camera.base_y.y * cosz;
+    camera.base_y = tmp;
+
+    // Rotations for base_z: 
+    tmp = camera.base_z;
+    // X axis:
+    tmp.y =  camera.base_z.y * cosx - camera.base_z.z * sinx;
+    tmp.z =  camera.base_z.y * sinx + camera.base_z.z * cosx;
+    camera.base_z = tmp;
+    // Y axis:
+    tmp.x =  camera.base_z.x * cosy + camera.base_z.z * siny;
+    tmp.z = -camera.base_z.x * siny + camera.base_z.z * cosy;
+    camera.base_z = tmp;
+    // Z axis:
+    tmp.x =  camera.base_z.x * cosz - camera.base_z.y * sinz;
+    tmp.y =  camera.base_z.x * sinz + camera.base_z.y * cosz;
+    camera.base_z = tmp;
+
+    // Now that we have our transformed 3d orthonormal base 
+    // we can calculate our focal point 
+    camera.focal_point = camera.center_point + camera.base_z * camera.focal_offset;
+
+    // Return our set up camera
+    return camera;
+}
+
+// Gets a pixel from the end of a ray projected to an axis
+vec4 get_pixel_from_projection(float t, int face, pinhole_camera camera, vec3 focal_vector)
+{
+    // If the point we end up in is behind our camera, don't "render" it
+    if (t < 1)
+    {
+        return vec4(0);
+    }
+
+    // Then we multiply our focal vector by t and add our focal point to it
+    // to end up in a point inside the window plane 
+    vec3 intersection = focal_vector * t + camera.focal_point;
+    
+
+    // Save necessary coordinates
+    // (different cube faces need different coords)
+    vec2 cam_coords;
+    switch (face) 
+    {
+        case 0:
+            cam_coords = intersection.xy;
+            break;
+        case 1:
+            cam_coords = intersection.xy;
+            break;
+        case 2:
+            cam_coords = intersection.zy;
+            break;
+        case 3:
+            cam_coords = intersection.zy;
+            break;
+        case 4:
+            cam_coords = intersection.zx;
+            break;
+        case 5:
+            cam_coords = intersection.zx;
+            break;
+    }
+    
+    if (window_size.x > window_size.y)
+    {
+        cam_coords.x /= window_size.y/float(window_size.x);
+        cam_coords.xy += window_center.xy;
+    }
+    else if (window_size.x < window_size.y)
+    {
+        cam_coords.y /= window_size.x/float(window_size.y);
+        cam_coords.xy += window_center.xy;
+    }
+    // If pixel is outside of our window region
+    // return a completely transparent color
+    if (cam_coords.x >=window_size.x-1 || 
+        cam_coords.y >=window_size.y-1 ||
+        cam_coords.x <=0 || cam_coords.y <=0)
+    {
+        return vec4(0);
+    }
+
+    // Fetch the pixel
+    vec4 pixel = texelFetch(tex, ivec2(cam_coords), 0);
+
+    return pixel;
+}
+
+// Combines colors using alpha
+// Got this from https://stackoverflow.com/questions/64701745/how-to-blend-colours-with-transparency
+// Not sure how it works honestly lol
+vec4 alpha_composite(vec4 color1, vec4 color2)
+{
+    float ar = color1.w + color2.w - (color1.w * color2.w);
+    float asr = color2.w / ar;
+    float a1 = 1 - asr;
+    float a2 = asr * (1 - color1.w);
+    float ab = asr * color1.w;
+    vec4 outcolor;
+    outcolor.xyz = color1.xyz * a1 + color2.xyz * a2 + color2.xyz * ab;
+    outcolor.w = ar;
+    return outcolor;
+}
+
+// Gets a pixel through the camera using coords as coordinates in
+// the camera plane
+vec4 get_pixel_through_camera(vec2 coords, pinhole_camera camera)
+{
+    // Offset coords
+    coords -= window_center;
+
+    // Find the pixel 3d position using the camera vector basis
+    vec3 pixel_3dposition =   camera.center_point 
+                            + coords.x * camera.base_x 
+                            + coords.y * camera.base_y;
+
+    // Get the vector going from the focal point to the pixel in 3d sapace
+    vec3 focal_vector = pixel_3dposition - camera.focal_point;
+
+    // We need 6 planes, one for each face of the cube, they all follow the plane EQ
+    // ax + by + cz + d
+    float a[] = {0,0,
+                 1,1,
+                 0,0};
+    float b[] = {0,0,
+                 0,0,
+                 1,1};
+    float c[] = {1,1,
+                 0,0,
+                 0,0};
+    float d[] = {-wss/2.0,wss/2.0,
+                 -wss/2.0,wss/2.0,
+                 -wss/2.0,wss/2.0};
+
+    // Then there's a line going from our focal point to each of the planes 
+    // which we can describe as:
+    // x(t) = focal_point.x + focal_vector.x * t
+    // y(t) = focal_point.y + focal_vector.y * t
+    // z(t) = focal_point.z + focal_vector.z * t
+    // We substitute x, y and z with x(t), y(t) and z(t) in the plane EQ
+    // Solving for t we get:
+    vec2 t[6]; // we use a vec2 to also store the plane that was hit
+    for (int i = 0; i < t.length(); i++)
+    {
+        t[i].x = (d[i] 
+                - a[i]*camera.focal_point.x 
+                - b[i]*camera.focal_point.y 
+                - c[i]*camera.focal_point.z)
+            / (a[i]*focal_vector.x 
+                    + b[i]*focal_vector.y 
+                    + c[i]*focal_vector.z);
+        t[i].y = i;
+    }
+    
+    // Bubble sort to know which intersections happen first
+    for (int i = 0; i < t.length(); i++)
+    {
+        for (int j = 0; j < t.length(); j++)
+        {
+            if (t [j].x > t[j+1].x)
+            {
+                vec2 tmp = t[j];
+                t[j] = t[j+1];
+                t[j+1] = tmp;
+            }
+        }
+    }
+
+    // Then we go through each one of the intersections in order 
+    // and mix pixels together using alpha
+    vec4 blended_pixels = vec4(0);
+    for (int i = 0; i < t.length(); i++)
+    {
+        // We get the pixel through projection
+        vec4 projection_pixel = get_pixel_from_projection(t[i].x, 
+                                                          int(t[i].y),
+                                                          camera,
+                                                          focal_vector);
+        // Only blend non fully transparent pixels
+        if (projection_pixel.w > 0.0)
+        {
+            // Blend the pixel using alpha
+            blended_pixels = alpha_composite(projection_pixel, blended_pixels);
+        }
+    }
+    return blended_pixels;
+}
+
+// Main function
+vec4 window_shader() {
+    pinhole_camera transformed_cam = setup_camera(window_cam);
+    return(get_pixel_through_camera(texcoord, transformed_cam));
+}

config/picom/shaders/default_anim.glsl

@@ -0,0 +1,70 @@
+#version 330
+
+in vec2 texcoord;             // texture coordinate of the fragment
+
+uniform sampler2D tex;        // texture of the window
+
+
+ivec2 window_size = textureSize(tex, 0); // Size of the window
+ivec2 window_center = ivec2(window_size.x/2, window_size.y/2);
+
+/*
+These shaders use a sorta hacky way to use the changing
+window opacity you might set on picom.conf animation rules
+to perform animations.
+
+Basically, when a window get's mapped, we make it's alpha 
+go from 0 to 1, so, using the default_post_processing to get that alpha
+we can get a variable going from 0 (start of mapping animation)
+to 1 (end of mapping animation)
+
+You can also set up your alpha value to go from 1 to 0 in picom when
+a window is closed, effectively reversing the animations described here
+*/
+
+// Default window post-processing:
+// 1) invert color
+// 2) opacity / transparency
+// 3) max-brightness clamping
+// 4) rounded corners
+vec4 default_post_processing(vec4 c);
+
+//  If you have semitransparent windows (like a terminal)
+// You can use the below function to add an opacity threshold where the
+// animation won't apply. For example, if you had your terminal
+// configured to have 0.8 opacity, you'd set the below variable to 0.8
+float max_opacity = 1;
+float opacity_threshold(float opacity)
+{
+  // if statement jic?
+  if (opacity >= max_opacity)
+  {
+    return 1.0;
+  }
+  else 
+  {
+    return min(1, opacity/max_opacity);
+  }
+
+}
+
+vec4 anim(float time) {
+  vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+  return c;
+}
+
+// Default window shader:
+// 1) fetch the specified pixel
+// 2) apply default post-processing
+vec4 window_shader() {
+  vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+  c = default_post_processing(c);
+  float opacity = opacity_threshold(c.w);
+  if (opacity == 0.0)
+  {
+    return c;
+  }
+  vec4 anim_c = anim(opacity);
+  return default_post_processing(anim_c);
+}
+

config/picom/shaders/dither.glsl

@@ -0,0 +1,127 @@
+#version 430
+
+bool monochrome = false; // Whether to apply a black & white filter to the window
+
+// You can modify the list of patterns to whatever you like, the code will
+// adapt to it as long as it is a list of equally sized 2D arrays 
+// This example shows a dither pattern list that uses numbers other than
+// 0 and 1 for more color variation
+// Dither patterns
+float dither [][][] = { {{0  , 0  },
+                         {0  , 0  }},
+
+                        {{0.5, 0  },
+                         {0  , 0  }},
+
+                        {{0.5, 0  },
+                         {0  , 0.5}},
+
+                        {{0.5, 0.5},
+                         {0  , 0.5}},
+
+                        {{0.5, 0.5},
+                         {0.5, 0.5}},
+
+                        {{1  , 0.5},
+                         {0.5,0.5}},
+
+                        {{1  , 0.5},
+                         {0.5, 1  }},
+
+                        {{1  , 1  },
+                         {0.5, 1  }},
+
+                        {{1  , 1  },
+                         {1  , 1  }} };
+
+// Some more props that depend on the dither patterns
+float bit_depth = dither.length() - 1.0;
+int block_size = dither[0].length();
+
+in vec2 texcoord;       // texture coordinate of the fragment
+
+uniform sampler2D tex;  // texture of the window
+                    
+// Default window post-processing:
+// 1) invert color
+// 2) opacity / transparency
+// 3) max-brightness clamping
+// 4) rounded corners
+vec4 default_post_processing(vec4 c);
+
+// Returns a monochromatic pixel
+vec4 to_monochrome (vec4 pixel)
+{
+    float brightness = (pixel.x + pixel.y + pixel.z)/3;
+    return vec4(vec3(brightness), pixel.w);
+}
+
+vec4 window_shader() {
+    // Alpha for the current pixel
+    float alpha;
+
+    // Relative block position
+    ivec2 block_pos;
+    block_pos.x = int(texcoord.x) % block_size;
+    block_pos.y = int(texcoord.y) % block_size;
+    
+    // Current block total color
+    vec3 block_color = vec3(0,0,0);
+    
+    // We will iterate over all the pixels in the block 
+    // and save it to this variable
+    vec4 pixel;
+    for (int y = 0; y < block_size; y += 1)
+    {
+        for (int x = 0; x < block_size; x += 1)
+        {
+            // Apply default post processing picom things and
+            // add color values after.
+            pixel = texelFetch(tex, ivec2(texcoord.x+x-block_pos.x,texcoord.y+y-block_pos.y), 0);
+            pixel = default_post_processing(pixel);
+            if (monochrome)
+            {
+                pixel = to_monochrome(pixel);
+                block_color.x += pixel.x;
+            }
+            else
+            {
+                block_color.x += pixel.x;
+                block_color.y += pixel.y;
+                block_color.z += pixel.z;
+            }
+
+            // If we are on the current pixel, save the alpha value
+            if (x == 0 && y == 0)
+            {
+                alpha = pixel.w;
+            }
+        }
+    }
+    // Normalize block colors and quantify them
+    block_color.x = block_color.x/float(block_size*block_size);
+    block_color.x = round(block_color.x*bit_depth);
+
+    // Get the pixel colors using our dither pattern
+    block_color.x = dither[int(block_color.x)][block_pos.y][block_pos.x];
+
+    if (monochrome)
+    {
+        block_color.yz = block_color.xx;
+    }
+    else
+    {
+        block_color.y = block_color.y/float(block_size*block_size);
+        block_color.y = round(block_color.y*bit_depth);
+
+        block_color.z = block_color.z/float(block_size*block_size);
+        block_color.z = round(block_color.z*bit_depth);
+    
+        block_color.y = dither[int(block_color.y)][block_pos.y][block_pos.x];
+        block_color.z = dither[int(block_color.z)][block_pos.y][block_pos.x];
+    }
+
+    // Set the final value for our pixel
+    pixel = vec4(block_color.x, block_color.y, block_color.z, alpha);
+    return pixel;
+}

config/picom/shaders/glass.glsl

@@ -0,0 +1,165 @@
+#version 330
+
+in vec2 texcoord;             // texture coordinate of the fragment
+
+uniform sampler2D tex;        // texture of the window
+
+
+ivec2 window_size = textureSize(tex, 0); // Size of the window
+ivec2 window_center = ivec2(window_size.x/2, window_size.y/2);
+
+/*
+These shaders use a sorta hacky way to use the changing
+window opacity you might set on picom.conf animation rules
+to perform animations.
+
+Basically, when a window get's mapped, we make it's alpha 
+go from 0 to 1, so, using the default_post_processing to get that alpha
+we can get a variable going from 0 (start of mapping animation)
+to 1 (end of mapping animation)
+
+You can also set up your alpha value to go from 1 to 0 in picom when
+a window is closed, effectively reversing the animations described here
+*/
+
+// Default window post-processing:
+// 1) invert color
+// 2) opacity / transparency
+// 3) max-brightness clamping
+// 4) rounded corners
+vec4 default_post_processing(vec4 c);
+
+//  If you have semitransparent windows (like a terminal)
+// You can use the below function to add an opacity threshold where the
+// animation won't apply. For example, if you had your terminal
+// configured to have 0.8 opacity, you'd set the below variable to 0.8
+float max_opacity = 0.8;
+float opacity_threshold(float opacity)
+{
+  // if statement jic?
+  if (opacity >= max_opacity)
+  {
+    return 1.0;
+  }
+  else 
+  {
+    return min(1, opacity/max_opacity);
+  }
+
+}
+
+// Pseudo-random function (from original shader)
+float random(vec2 st) {
+    return fract(sin(dot(st.xy, vec2(12.9898,78.233))) * 43758.5453123);
+}
+
+float PI = 3.1415926535;
+float TWO_PI = 2.0 * PI;
+
+// NEW anim function: Glass-Shard Shatter
+vec4 anim(float animation_progress) {
+    vec4 out_color = vec4(0.0); // Default to transparent
+
+    // --- Shard Parameters ---
+    float num_shards = 20.0; // Number of angular shards
+    vec2 impact_point = window_center;
+
+    // --- Fragment's Relation to Impact Point & Shard ID ---
+    vec2 vec_frag_to_impact = texcoord - impact_point;
+    float dist_frag_to_impact = length(vec_frag_to_impact);
+    float angle_frag = atan(vec_frag_to_impact.y, vec_frag_to_impact.x); // Range: -PI to PI
+    if (angle_frag < 0.0) {
+        angle_frag += TWO_PI; // Normalize to 0 to 2*PI
+    }
+    float shard_id = floor(angle_frag / (TWO_PI / num_shards));
+
+    // --- Staggered Animation Timing for each Shard ---
+    // Use random for a less ordered shatter
+    float shard_delay_normalized = random(vec2(shard_id, shard_id * 0.31)); 
+    // float shard_delay_normalized = shard_id / num_shards; // For a sweep
+
+    float individual_shard_anim_duration = 0.7; // How long each shard takes to animate
+    float ripple_spread_factor = 1.0 - individual_shard_anim_duration;
+    
+    float stagger_start_progress = shard_delay_normalized * ripple_spread_factor;
+    float stagger_end_progress = stagger_start_progress + individual_shard_anim_duration;
+
+    // shard_anim_progress: 0.0 (shard starts moving in) -> 1.0 (shard is in place)
+    float shard_anim_progress = smoothstep(stagger_start_progress, stagger_end_progress, animation_progress);
+
+    if (shard_anim_progress < 0.001) { // Shard is not yet visible or fully shattered away
+        return vec4(0.0); // Fully transparent
+    }
+
+    // --- Shard Transformation Parameters ---
+    // current_displacement_factor: 1.0 (max shatter) -> 0.0 (assembled)
+    float current_displacement_factor = 1.0 - shard_anim_progress;
+
+    // Max translation (e.g., 30% of half window width)
+    float max_translation_dist = length(vec2(window_size) * 0.5) * 0.3; 
+    // Max rotation (e.g., 25 degrees)
+    float max_rotation_angle_rad = (PI / 180.0) * 25.0 * random(vec2(shard_id * 0.7, shard_id)); // Add some randomness to rotation
+
+    // Direction for this shard (center angle of the shard sector)
+    float shard_center_angle = (shard_id + 0.5) * (TWO_PI / num_shards);
+    vec2 shard_radial_dir = vec2(cos(shard_center_angle), sin(shard_center_angle));
+
+    vec2 translation_offset = shard_radial_dir * max_translation_dist * current_displacement_factor;
+    float current_rotation = max_rotation_angle_rad * current_displacement_factor;
+
+    // --- Inverse Transformation for Sampling ---
+    // We are at `texcoord` on screen. Find where this point came from on the original texture.
+    // 1. Undo translation
+    vec2 p1_translated_back = texcoord - translation_offset;
+
+    // 2. Undo rotation around impact_point
+    vec2 p1_rel_to_impact = p1_translated_back - impact_point;
+    float cos_rot = cos(current_rotation); // Rotate by +angle to undo shatter rotation by -angle
+    float sin_rot = sin(current_rotation); // (or vice-versa, depends on convention)
+                                           // Let's assume shatter rotates by -current_rotation
+                                           // So to undo, rotate by +current_rotation
+    mat2 rot_matrix = mat2(cos_rot, -sin_rot, sin_rot, cos_rot);
+    vec2 p2_rotated_back = rot_matrix * p1_rel_to_impact;
+    vec2 sample_coord = p2_rotated_back + impact_point;
+
+    // --- Boundary Check & Texture Fetch ---
+    if (sample_coord.x >= 0.0 && sample_coord.x < float(window_size.x) &&
+        sample_coord.y >= 0.0 && sample_coord.y < float(window_size.y)) {
+        
+        // --- Chromatic Aberration ---
+        float ca_strength = 0.008 * current_displacement_factor; // Stronger when more shattered
+        vec2 ca_offset_dir = shard_radial_dir; // Radial aberration
+        // vec2 ca_offset_dir = vec2(-shard_radial_dir.y, shard_radial_dir.x); // Tangential
+
+        vec2 r_sample = sample_coord + ca_offset_dir * ca_strength * float(window_size.x);
+        vec2 b_sample = sample_coord - ca_offset_dir * ca_strength * float(window_size.x);
+
+        out_color.r = texelFetch(tex, ivec2(r_sample), 0).r;
+        out_color.g = texelFetch(tex, ivec2(sample_coord), 0).g; // Green channel from center
+        out_color.b = texelFetch(tex, ivec2(b_sample), 0).b;
+        out_color.a = texelFetch(tex, ivec2(sample_coord), 0).a; // Base alpha from original texture
+
+    } else {
+        out_color.a = 0.0; // Sampled point is outside original texture
+    }
+
+    // Modulate final alpha by shard's animation progress
+    out_color.a *= shard_anim_progress;
+    return out_color;
+}
+
+
+// Default window shader:
+// 1) fetch the specified pixel
+// 2) apply default post-processing
+vec4 window_shader() {
+  vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+  c = default_post_processing(c);
+  float opacity = opacity_threshold(c.w);
+  if (opacity == 0.0)
+  {
+    return c;
+  }
+  vec4 anim_c = anim(opacity);
+  return default_post_processing(anim_c);
+}

config/picom/shaders/glitch.glsl

@@ -0,0 +1,85 @@
+#version 330
+
+int delta = 20;
+float barh = 0.05;
+float barw = 0.6;
+int nbar = 8;
+
+float maxoff = 32;
+float minoff = 2;
+
+in vec2 texcoord;             // texture coordinate of the fragment
+
+uniform sampler2D tex;        // texture of the window
+ivec2 window_size = textureSize(tex, 0);
+ivec2 window_center = ivec2(window_size.x/2, window_size.y/2);
+
+// Default window post-processing:
+// 1) invert color
+// 2) opacity / transparency
+// 3) max-brightness clamping
+// 4) rounded corners
+vec4 default_post_processing(vec4 c);
+
+uniform float time; // Time in miliseconds.
+
+float alpha = round(time/delta); // Like time, but in seconds and resets to 
+
+// Pseudo-random function (from original shader)
+float random(float n) {
+    return fract(sin(n) * 43758.5453f);
+}
+
+float get_box() {
+    float n = random(alpha)*(nbar);
+
+    for(int i=0;i<n;i++){
+        float y = random(mod(alpha, 2048)+i) * window_size.y;
+        float x = random(mod(alpha+128, 2048)+i) * window_size.x;
+        float w = random(mod(alpha+64, 2048)+i) * barw*window_size.x;
+        float h = random(mod(alpha+32, 2048)+i) * barh*window_size.y;
+        if (texcoord.y > y && texcoord.y < y + h
+         && texcoord.x > x && texcoord.x < x + w) {
+            return i*w*h*y*x*n;
+        }
+    }
+    return -1.0f;
+}
+
+float rand_offset(float b) {
+    return (random(b*64) - 0.5) * (maxoff*2);
+}
+
+vec4 window_shader() {
+    float b = get_box();
+
+    if (b == -1.0) {
+        vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+        return default_post_processing(c);
+    }
+    //b = random(mod(alpha, 2000));
+
+    // Offsets in pixels for each color
+    vec2 uvr = vec2(rand_offset(b*1), rand_offset(b*6));
+    vec2 uvg = vec2(rand_offset(b*2),rand_offset(b*7));
+    vec2 uvb = vec2(rand_offset(b*3),rand_offset(b*8));
+
+    // Calculate offset coords
+    uvr += texcoord;
+    uvg += texcoord;
+    uvb += texcoord;
+
+    // Fetch colors using offset coords
+    vec3 offset_color;
+    offset_color.x = texelFetch(tex, ivec2(uvr), 0).x;
+    offset_color.y = texelFetch(tex, ivec2(uvg), 0).y;
+    offset_color.z = texelFetch(tex, ivec2(uvb), 0).z;
+    
+    // Set the new color
+    vec4 c;
+    c.w = texelFetch(tex, ivec2(uvr), 0).w;
+    c.xyz = offset_color;
+
+    return default_post_processing(c);
+}
+

config/picom/shaders/glitch_animation.glsl

@@ -0,0 +1,126 @@
+#version 330
+
+float maxoff = 10;
+float minoff = 0;
+float hue = 0.3;
+
+float block_max = 500;
+float block_min = 200;
+
+float pixelate_size = 3;
+
+in vec2 texcoord;             // texture coordinate of the fragment
+uniform sampler2D tex;        // texture of the window
+
+vec4 default_post_processing(vec4 c);
+
+uniform float time; // Time in miliseconds.
+
+float max_opacity = 0.9;
+float opacity_threshold(float opacity)
+{
+  // if statement jic?
+  if (opacity >= max_opacity) {
+    return 1.0;
+  } else {
+    return min(1, opacity/max_opacity);
+  }
+
+}
+
+// Pseudo-random function (from original shader)
+float random(float n) {
+    return fract(sin(n) * 43758.5453f);
+}
+
+float rand_offset(float b, float off) {
+    return (random(b*64) - 0.5) * (off*2);
+}
+
+vec4 alpha_effect(vec4 pix, vec2 coord) {
+    if (random(coord.x * random(coord.y / 100)) < pix.w) {
+        pix.w = 1;
+        return pix;
+    }
+    return vec4(0, 0, 0, 0);
+
+}
+
+vec3 hueShift( vec3 color, float hueAdjust ){
+
+    const vec3  kRGBToYPrime = vec3 (0.299, 0.587, 0.114);
+    const vec3  kRGBToI      = vec3 (0.596, -0.275, -0.321);
+    const vec3  kRGBToQ      = vec3 (0.212, -0.523, 0.311);
+
+    const vec3  kYIQToR     = vec3 (1.0, 0.956, 0.621);
+    const vec3  kYIQToG     = vec3 (1.0, -0.272, -0.647);
+    const vec3  kYIQToB     = vec3 (1.0, -1.107, 1.704);
+
+    float   YPrime  = dot (color, kRGBToYPrime);
+    float   I       = dot (color, kRGBToI);
+    float   Q       = dot (color, kRGBToQ);
+    float   hue     = atan (Q, I);
+    float   chroma  = sqrt (I * I + Q * Q);
+
+    hue += hueAdjust;
+
+    Q = chroma * sin (hue);
+    I = chroma * cos (hue);
+
+    vec3    yIQ   = vec3 (YPrime, I, Q);
+
+    return vec3( dot (yIQ, kYIQToR), dot (yIQ, kYIQToG), dot (yIQ, kYIQToB) );
+
+}
+
+vec4 anim(float alpha) {
+    float block = mix(block_max, block_min, alpha);
+    vec2 bs = floor(texcoord / block) * block + block/2;
+
+    float b = random(bs.y) * random(mod(time/10000,2));
+
+    float off = mix(maxoff, minoff, alpha);
+    if (b > alpha) {
+        off = 0;
+    }
+
+    // Offsets in pixels for each color
+    vec2 uvr = vec2(rand_offset(b*1, off), rand_offset(b*6, off));
+    vec2 uvg = vec2(rand_offset(b*2, off), rand_offset(b*7, off));
+    vec2 uvb = vec2(rand_offset(b*3, off), rand_offset(b*8, off));
+
+    // Calculate offset coords
+    uvr += texcoord;
+    uvg += texcoord;
+    uvb += texcoord;
+
+    // Fetch colors using offset coords
+    vec3 offset_color;
+    offset_color.x = texelFetch(tex, ivec2(uvr), 0).x;
+    offset_color.y = texelFetch(tex, ivec2(uvg), 0).y;
+
+    offset_color.x = hueShift(texelFetch(tex, ivec2(uvr), 0).xyz, hue).x;
+    offset_color.y = hueShift(texelFetch(tex, ivec2(uvg), 0).xyz, hue).y;
+    offset_color.z = hueShift(texelFetch(tex, ivec2(uvb), 0).xyz, hue).z;
+
+    offset_color.xyz = hueShift(offset_color.xyz, -hue);
+
+    // Set the new color
+    vec4 c;
+
+    c.xyz = offset_color;
+
+    return c;
+}
+
+vec4 window_shader() {
+    vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+    c = default_post_processing(c);
+    float opacity = opacity_threshold(c.w);
+    c = anim(opacity);
+    c.w = opacity;
+    c = alpha_effect(c, ceil(texcoord / pixelate_size) * pixelate_size);
+    //c = default_post_processing(c);
+    return c;
+}
+

config/picom/shaders/matrix_dissolve.glsl

@@ -0,0 +1,78 @@
+#version 330
+
+in vec2 texcoord;             // texture coordinate of the fragment
+
+uniform sampler2D tex;        // texture of the window
+
+
+ivec2 window_size = textureSize(tex, 0); // Size of the window
+ivec2 window_center = ivec2(window_size.x/2, window_size.y/2);
+
+/*
+These shaders use a sorta hacky way to use the changing
+window opacity you might set on picom.conf animation rules
+to perform animations.
+
+Basically, when a window get's mapped, we make it's alpha 
+go from 0 to 1, so, using the default_post_processing to get that alpha
+we can get a variable going from 0 (start of mapping animation)
+to 1 (end of mapping animation)
+
+You can also set up your alpha value to go from 1 to 0 in picom when
+a window is closed, effectively reversing the animations described here
+*/
+
+// Default window post-processing:
+// 1) invert color
+// 2) opacity / transparency
+// 3) max-brightness clamping
+// 4) rounded corners
+vec4 default_post_processing(vec4 c);
+// Pseudo-random function
+float random(vec2 st) {
+    return fract(sin(dot(st.xy, vec2(12.9898,78.233))) * 43758.5453123);
+}
+
+// Creates vertical scanlines
+float scanline(vec2 uv, float time) {
+    return sin(uv.y * 200.0 + time * 10.0) * 0.5 + 0.5;
+}
+
+vec4 anim(float time) {
+    vec2 uv = texcoord / vec2(window_size);
+    
+    // Adjust square size (smaller number = more squares)
+    float square_size = 4.0;
+    
+    // Calculate grid position
+    vec2 square_pos = floor(texcoord / square_size);
+    
+    // Generate random value for this square
+    float index = random(square_pos);
+    
+    // Get original color
+    vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+    
+    // Create threshold for dissolve
+    float threshold = (1.0 - time) * 1.2; // The 1.2 creates a slight overlap
+    
+    // If the random index is greater than our threshold, make pixel transparent
+    if (index > threshold) {
+        c.a = 0.0;
+    }
+    
+    return c;
+}
+
+// Default window shader:
+// 1) fetch the specified pixel
+// 2) apply default post-processing
+vec4 window_shader() {
+    vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+    c = default_post_processing(c);
+    if (c.w != 1.0)
+    {
+        c = anim(1.0-c.w);
+    }
+    return default_post_processing(c);
+}

config/picom/shaders/pixelize.glsl

@@ -0,0 +1,72 @@
+#version 330
+
+in vec2 texcoord;             // texture coordinate of the fragment
+
+uniform sampler2D tex;        // texture of the window
+
+
+ivec2 window_size = textureSize(tex, 0); // Size of the window
+ivec2 window_center = ivec2(window_size.x/2, window_size.y/2);
+
+/*
+These shaders use a sorta hacky way to use the changing
+window opacity you might set on picom.conf animation rules
+to perform animations.
+
+Basically, when a window get's mapped, we make it's alpha 
+go from 0 to 1, so, using the default_post_processing to get that alpha
+we can get a variable going from 0 (start of mapping animation)
+to 1 (end of mapping animation)
+
+You can also set up your alpha value to go from 1 to 0 in picom when
+a window is closed, effectively reversing the animations described here
+*/
+
+// Default window post-processing:
+// 1) invert color
+// 2) opacity / transparency
+// 3) max-brightness clamping
+// 4) rounded corners
+vec4 default_post_processing(vec4 c);
+
+//  If you have semitransparent windows (like a terminal)
+// You can use the below function to add an opacity threshold where the
+// animation won't apply. For example, if you had your terminal
+// configured to have 0.8 opacity, you'd set the below variable to 0.8
+float max_opacity = 0.9;
+float opacity_threshold(float opacity)
+{
+  // if statement jic?
+  if (opacity >= max_opacity)
+  {
+    return 1.0;
+  }
+  else 
+  {
+    return min(1, opacity/max_opacity);
+  }
+
+}
+
+vec4 anim(float time) {
+// block size shrinks from 40→1
+  float block = mix(40.0, 1.0, time);
+  vec2 uvb = floor(texcoord / block) * block + block/2;
+  vec4 c = texelFetch(tex, ivec2(uvb), 0);
+  return c;
+}
+
+// Default window shader:
+// 1) fetch the specified pixel
+// 2) apply default post-processing
+vec4 window_shader() {
+    vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+    c = default_post_processing(c);
+    float opacity = opacity_threshold(c.w);
+    if (opacity != 1.0)
+    {
+        c = anim(opacity);
+    }
+    return default_post_processing(c);
+}
+

config/picom/shaders/pixelize_median.glsl

@@ -0,0 +1,85 @@
+#version 330
+
+#define vec vec3
+#define toVec(x) x.rgb
+
+#define s2(a, b)				temp = a; a = min(a, b); b = max(temp, b);
+#define mn3(a, b, c)			s2(a, b); s2(a, c);
+#define mx3(a, b, c)			s2(b, c); s2(a, c);
+
+#define mnmx3(a, b, c)			mx3(a, b, c); s2(a, b);                                   // 3 exchanges
+#define mnmx4(a, b, c, d)		s2(a, b); s2(c, d); s2(a, c); s2(b, d);                   // 4 exchanges
+#define mnmx5(a, b, c, d, e)	s2(a, b); s2(c, d); mn3(a, c, e); mx3(b, d, e);           // 6 exchanges
+#define mnmx6(a, b, c, d, e, f) s2(a, d); s2(b, e); s2(c, f); mn3(a, b, c); mx3(d, e, f); // 7 exchanges
+
+
+in vec2 texcoord;             // texture coordinate of the fragment
+
+uniform sampler2D tex;        // texture of the window
+
+
+ivec2 window_size = textureSize(tex, 0); // Size of the window
+ivec2 window_center = ivec2(window_size.x/2, window_size.y/2);
+
+/*
+These shaders use a sorta hacky way to use the changing
+window opacity you might set on picom.conf animation rules
+to perform animations.
+
+Basically, when a window get's mapped, we make it's alpha 
+go from 0 to 1, so, using the default_post_processing to get that alpha
+we can get a variable going from 0 (start of mapping animation)
+to 1 (end of mapping animation)
+
+You can also set up your alpha value to go from 1 to 0 in picom when
+a window is closed, effectively reversing the animations described here
+*/
+
+// Default window post-processing:
+// 1) invert color
+// 2) opacity / transparency
+// 3) max-brightness clamping
+// 4) rounded corners
+vec4 default_post_processing(vec4 c);
+
+//  If you have semitransparent windows (like a terminal)
+// You can use the below function to add an opacity threshold where the
+// animation won't apply. For example, if you had your terminal
+// configured to have 0.8 opacity, you'd set the below variable to 0.8
+float max_opacity = 0.9;
+float opacity_threshold(float opacity)
+{
+  // if statement jic?
+  if (opacity >= max_opacity)
+  {
+    return 1.0;
+  }
+  else 
+  {
+    return min(1, opacity/max_opacity);
+  }
+
+}
+
+vec4 anim(float time) {
+// block size shrinks from 40→1
+  float block = mix(40.0, 1.0, time);
+  vec2 uvb = floor(texcoord / block) * block + block/2;
+  vec4 c = texelFetch(tex, ivec2(uvb), 0);
+  return c;
+}
+
+// Default window shader:
+// 1) fetch the specified pixel
+// 2) apply default post-processing
+vec4 window_shader() {
+    vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+    c = default_post_processing(c);
+    float opacity = opacity_threshold(c.w);
+    if (opacity != 1.0)
+    {
+        c = anim(opacity);
+    }
+    return default_post_processing(c);
+}
+

config/picom/shaders/plane.glsl

@@ -0,0 +1,266 @@
+#version 330
+#define PI 3.14159265
+
+// These shaders work by using a pinhole camera and raycasting
+// The window 3d objects will always be (somewhat) centered at (0, 0, 0)
+struct pinhole_camera
+{
+    float focal_offset; // Distance along the Z axis between the camera 
+                        // center and the focal point. Use negative values
+                        // so the image doesn't flip
+                        // This kinda works like FOV in games
+
+    // Transformations 
+    // Use these to modify the coordinate system of the camera plane
+    vec3 rotations; // Rotations in radians around each axis 
+                    // The camera plane rotates around 
+                    // its center point, not the origin
+
+    vec3 translations; // Translations in pixels along each axis
+
+    vec3 deformations; // Deforms the camera. Higher values on each axis
+                       // means the window will be squashed in that axis
+
+    // ---------------------------------------------------------------// 
+    
+    // "Aftervalues" 
+    // These will be set later with setup_camera(), leave them as 0
+    vec3 base_x;
+    vec3 base_y;
+    vec3 base_z;
+    vec3 center_point;
+    vec3 focal_point;
+};
+
+in vec2 texcoord;             // texture coordinate of the fragment
+
+uniform sampler2D tex;        // texture of the window
+
+
+uniform float time; // Time in miliseconds.
+      
+float time_cyclic = mod(time/10000,2); // Like time, but in seconds and resets to 
+                                       // 0 when it hits 2. Useful for using it in 
+                                       // periodic functions like cos and sine
+// Time variables can be used to change transformations over time
+
+
+ivec2 window_size = textureSize(tex, 0); // Size of the window
+
+float window_diagonal = length(window_size); // Diagonal of the window
+// Try to keep focal offset and translations proportional to window_size components 
+// or window_diagonal as you see fit
+
+pinhole_camera camera = 
+pinhole_camera(-window_size.y/2,   // Focal offset
+               vec3(0,0,0), // Rotations
+               vec3(0), // Translations
+               vec3(1,1,1), // Deformations
+               // Leave the rest as 0
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0));
+
+// Here are some presets you can use
+
+// Moves the camera up and down
+pinhole_camera bobbing = 
+pinhole_camera(-window_size.y/2,
+               vec3(0,0,0),
+               vec3(0,cos(time_cyclic*PI)*window_size.y/16,-window_size.y/4),
+               vec3(1,1,1),
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0));
+
+// Rotates camera around the origin
+// Makes the window rotate around the Y axis from the camera's POV
+// (if the window is centered)
+pinhole_camera rotate_around_origin = 
+pinhole_camera(-window_diagonal,
+               vec3(0,-time_cyclic*PI-PI/2,0),
+               vec3(cos(time_cyclic*PI)*window_diagonal,
+                   0,
+                   sin(time_cyclic*PI)*window_diagonal),
+               vec3(1,1,1),
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0));
+
+// Rotate camera around its center
+pinhole_camera rotate_around_itself = 
+pinhole_camera(-window_diagonal,
+               vec3(0,-time_cyclic*PI-PI/2,0),
+               vec3(0,0,-window_diagonal),
+               vec3(1,1,1),
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0),
+               vec3(0));
+
+// Here you can select the preset to use
+pinhole_camera window_cam = rotate_around_origin;
+
+
+
+ivec2 window_center = ivec2(window_size.x/2, window_size.y/2); 
+
+// Default window post-processing:
+// 1) invert color
+// 2) opacity / transparency
+// 3) max-brightness clamping
+// 4) rounded corners
+vec4 default_post_processing(vec4 c);
+
+// Sets up a camera by applying transformations and 
+// calculating xyz vector basis 
+pinhole_camera setup_camera(pinhole_camera camera)
+{
+    // Apply translations
+    camera.center_point += camera.translations;
+
+    // Apply rotations 
+    // We initialize our vector basis as normalized vectors
+    // in each axis * our deformations vector
+    camera.base_x = vec3(camera.deformations.x, 0, 0);
+    camera.base_y = vec3(0, camera.deformations.y, 0);
+    camera.base_z = vec3(0, 0, camera.deformations.z);
+
+
+    // Then we rotate them around following our rotations vector:
+    // First save these values to avoid redundancy
+    float cosx = cos(camera.rotations.x);
+    float cosy = cos(camera.rotations.y);
+    float cosz = cos(camera.rotations.z);
+    float sinx = sin(camera.rotations.x);
+    float siny = sin(camera.rotations.y);
+    float sinz = sin(camera.rotations.z);
+    
+    // Declare a buffer vector we will use to apply multiple changes at once
+    vec3 tmp = vec3(0);
+
+    // Rotations for base_x:
+    tmp = camera.base_x;
+    // X axis:
+    tmp.y =  camera.base_x.y * cosx - camera.base_x.z * sinx;
+    tmp.z =  camera.base_x.y * sinx + camera.base_x.z * cosx;
+    camera.base_x = tmp;
+    // Y axis:
+    tmp.x =  camera.base_x.x * cosy + camera.base_x.z * siny;
+    tmp.z = -camera.base_x.x * siny + camera.base_x.z * cosy;
+    camera.base_x = tmp;
+    // Z axis:
+    tmp.x =  camera.base_x.x * cosz - camera.base_x.y * sinz;
+    tmp.y =  camera.base_x.x * sinz + camera.base_x.y * cosz;
+    camera.base_x = tmp;
+
+    // Rotations for base_y:
+    tmp = camera.base_y;
+    // X axis:
+    tmp.y =  camera.base_y.y * cosx - camera.base_y.z * sinx;
+    tmp.z =  camera.base_y.y * sinx + camera.base_y.z * cosx;
+    camera.base_y = tmp;
+    // Y axis:
+    tmp.x =  camera.base_y.x * cosy + camera.base_y.z * siny;
+    tmp.z = -camera.base_y.x * siny + camera.base_y.z * cosy;
+    camera.base_y = tmp;
+    // Z axis:
+    tmp.x =  camera.base_y.x * cosz - camera.base_y.y * sinz;
+    tmp.y =  camera.base_y.x * sinz + camera.base_y.y * cosz;
+    camera.base_y = tmp;
+
+    // Rotations for base_z: 
+    tmp = camera.base_z;
+    // X axis:
+    tmp.y =  camera.base_z.y * cosx - camera.base_z.z * sinx;
+    tmp.z =  camera.base_z.y * sinx + camera.base_z.z * cosx;
+    camera.base_z = tmp;
+    // Y axis:
+    tmp.x =  camera.base_z.x * cosy + camera.base_z.z * siny;
+    tmp.z = -camera.base_z.x * siny + camera.base_z.z * cosy;
+    camera.base_z = tmp;
+    // Z axis:
+    tmp.x =  camera.base_z.x * cosz - camera.base_z.y * sinz;
+    tmp.y =  camera.base_z.x * sinz + camera.base_z.y * cosz;
+    camera.base_z = tmp;
+
+    // Now that we have our transformed 3d orthonormal base 
+    // we can calculate our focal point 
+    camera.focal_point = camera.center_point + camera.base_z * camera.focal_offset;
+
+    // Return our set up camera
+    return camera;
+}
+
+vec4 get_pixel_through_camera(vec2 coords, pinhole_camera camera)
+{
+    // Offset coords
+    coords -= window_center;
+
+    // Find the pixel 3d position using the camera vector basis
+    vec3 pixel_3dposition =   camera.center_point 
+                            + coords.x * camera.base_x 
+                            + coords.y * camera.base_y;
+
+    // Get the vector going from the focal point to the pixel in 3d sapace
+    vec3 focal_vector = pixel_3dposition - camera.focal_point;
+
+    // Let's say we have a plane for our window following the plane equation
+    // ax + by + cz = d
+    float a = 0;
+    float b = 0;
+    float c = 1;
+    float d = 0;
+    // Then there's a line going from our focal point to the plane 
+    // which we can describe as:
+    // x(t) = focal_point.x + focal_vector.x * t
+    // y(t) = focal_point.y + focal_vector.y * t
+    // z(t) = focal_point.z + focal_vector.z * t
+    // We substitute x, y and z with x(t), y(t) and z(t) in our plane EQ 
+    // Solving for t we get:
+    float t = (d 
+               - a*camera.focal_point.x 
+               - b*camera.focal_point.y 
+               - c*camera.focal_point.z)
+               / (a*focal_vector.x 
+                  + b*focal_vector.y 
+                  + c*focal_vector.z);
+
+    // If the point we end up in is behind our camera, don't "render" it
+    if (t < 1)
+    {
+        return vec4(0);
+    }
+
+    // Then we multiply our focal vector by t and add our focal point to it
+    // to end up in a point inside the window plane 
+    vec3 intersection = focal_vector * t + camera.focal_point;
+
+    // Save x and y coordinates and add back our initial offset 
+    vec2 cam_coords = intersection.xy + window_center;
+    
+    // If pixel is outside of our window region
+    // return a completely transparent color
+    if (cam_coords.x >=window_size.x-1 || 
+        cam_coords.y >=window_size.y-1 ||
+        cam_coords.x <=0 || cam_coords.y <=0)
+    {
+        return vec4(0);
+    }
+
+    // Fetch the pixel
+    vec4 pixel = texelFetch(tex, ivec2(cam_coords), 0);
+    return pixel;
+}
+
+vec4 window_shader() {
+    pinhole_camera transformed_cam = setup_camera(window_cam);
+    return(get_pixel_through_camera(texcoord, transformed_cam));
+}

config/picom/shaders/sdf_mask.glsl

@@ -0,0 +1,131 @@
+#version 330
+
+in vec2 texcoord;             // texture coordinate of the fragment
+
+uniform sampler2D tex;        // texture of the window
+
+
+ivec2 window_size = textureSize(tex, 0); // Size of the window
+ivec2 window_center = ivec2(window_size.x/2, window_size.y/2);
+
+/*
+These shaders use a sorta hacky way to use the changing
+window opacity you might set on picom.conf animation rules
+to perform animations.
+
+Basically, when a window get's mapped, we make it's alpha 
+go from 0 to 1, so, using the default_post_processing to get that alpha
+we can get a variable going from 0 (start of mapping animation)
+to 1 (end of mapping animation)
+
+You can also set up your alpha value to go from 1 to 0 in picom when
+a window is closed, effectively reversing the animations described here
+*/
+
+// Default window post-processing:
+// 1) invert color
+// 2) opacity / transparency
+// 3) max-brightness clamping
+// 4) rounded corners
+vec4 default_post_processing(vec4 c);
+
+//  If you have semitransparent windows (like a terminal)
+// You can use the below function to add an opacity threshold where the
+// animation won't apply. For example, if you had your terminal
+// configured to have 0.8 opacity, you'd set the below variable to 0.8
+float max_opacity = 0.8;
+float opacity_threshold(float opacity)
+{
+  // if statement jic?
+  if (opacity >= max_opacity)
+  {
+    return 1.0;
+  }
+  else 
+  {
+    return min(1, opacity/max_opacity);
+  }
+
+}
+
+// NEW anim function: Morphing Distance-Field Mask (Wobbly Circle)
+vec4 anim(float progress) {
+
+    vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+
+    // Early exit for fully transparent or fully opaque states
+    if (progress <= 0.001) { // Beginning of reveal / End of conceal
+        c.a = 0.0;
+        return c;
+    }
+    if (progress >= 0.999) { // End of reveal / Beginning of conceal
+        return c; // Original alpha, effect is complete
+    }
+
+    vec2 p_centered = texcoord - vec2(window_center); // Pixel coords relative to center
+
+    // --- SDF Parameters ---
+    // Max radius needed to cover the window from the center to a corner
+    float max_coverage_radius = length(vec2(window_size) * 0.5) * 1.05; // 5% margin
+
+    // Easing for progress (e.g., ease-in: starts slow, speeds up)
+    float eased_progress = progress * progress;
+    // float eased_progress = sqrt(progress); // Alternative: ease-out
+    // float eased_progress = progress; // Alternative: linear
+
+    float base_radius = eased_progress * max_coverage_radius;
+
+    // --- Wobble Parameters ---
+    float angle = atan(p_centered.y, p_centered.x); // Angle of pixel from center
+
+    float spatial_freq = 7.0; // Number of wobbles around circumference
+    float wobble_anim_speed = 10.0; // How fast wobbles change with progress
+    // Wobble amplitude (as a factor of base_radius), decreases as reveal completes
+    float wobble_amplitude_factor = 0.15 * (1.0 - eased_progress * 0.7);
+
+    // Wobble animation phase based on progress
+    float wobble_phase = progress * wobble_anim_speed;
+    
+    float radius_offset = sin(angle * spatial_freq + wobble_phase) *
+                          base_radius * wobble_amplitude_factor;
+    
+    float effective_radius = base_radius + radius_offset;
+
+    // --- SDF Calculation (Circle) ---
+    // Distance from current pixel to the center of the coordinate system (p_centered)
+    float dist_from_center = length(p_centered);
+    // SDF value: negative inside the shape, positive outside
+    float sdf_value = dist_from_center - effective_radius;
+
+    // --- Alpha Masking ---
+    float edge_softness = 15.0; // Softness of the mask edge in pixels
+
+    // Create mask: 1.0 inside (visible), 0.0 outside (transparent)
+    // smoothstep transitions from 0 to 1 as sdf_value goes from 0 to edge_softness
+    // So, for sdf_value < 0 (inside), mask is 1.0.
+    // For sdf_value > edge_softness (far outside), mask is 0.0.
+    float mask = 1.0 - smoothstep(0.0, edge_softness, sdf_value);
+
+    c.a *= mask; // Apply the mask to the original alpha
+
+    return c;
+}
+
+// Default window shader:
+// 1) fetch the specified pixel
+// 2) apply default post-processing
+vec4 window_shader() {
+  vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+  c = default_post_processing(c);
+  float opacity = opacity_threshold(c.w);
+  if (opacity == 0.0)
+  {
+    return c;
+  }
+  vec4 anim_c = anim(opacity);
+  if (anim_c.w < max_opacity)
+  {
+    return vec4(0);
+  }
+  return default_post_processing(anim_c);
+}

config/picom/shaders/shiny.glsl

@@ -0,0 +1,33 @@
+#version 430
+
+// Source: https://github.com/yshui/picom/issues/295#issuecomment-592077997
+
+in vec2 texcoord;
+
+uniform float opacity;
+uniform bool invert_color;
+uniform sampler2D tex;
+uniform float time;
+
+ivec2 window_size = textureSize(tex, 0);
+
+float amt = 10000.0;
+
+vec4 default_post_processing(vec4 c);
+
+vec4 window_shader() {
+    float pct = mod(time, amt) / amt * 1000;
+    float factor = float(max(window_size.x, window_size.y));
+    pct *= factor / 150.0;
+    vec2 pos = texcoord;
+	vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+
+    if (pos.x + pos.y < pct * 4.0 && pos.x + pos.y > pct * 4.0 - .5 * pct
+        || pos.x + pos.y < pct * 4.0 - .8 * pct && pos.x + pos.y > pct * 3.0)
+       c *= vec4(2, 2, 2, 1);
+    if (invert_color)
+    	c = vec4(vec3(c.a, c.a, c.a) - vec3(c), c.a);
+
+	c *= opacity;
+	return default_post_processing(c);
+}

config/picom/shaders/terminal_vignette.glsl

@@ -0,0 +1,58 @@
+#version 330
+in vec2 texcoord;             // texture coordinate of the fragment
+
+uniform sampler2D tex;        // texture of the window
+
+ivec2 window_size = textureSize(tex, 0); // Size of the window
+ivec2 window_center = ivec2(window_size.x/2, window_size.y/2);
+uniform float shadow_cutoff = 1; // How "early" the shadow starts affecting 
+                                 // pixels close to the edges
+                                 // I'd keep this value very close to 1
+uniform int shadow_intensity = 3; // Intensity level of the shadow effect (from 1 to 5)
+
+
+// Default window post-processing:
+// 1) invert color
+// 2) opacity / transparency
+// 3) max-brightness clamping
+// 4) rounded corners
+vec4 default_post_processing(vec4 c);
+
+// Darkens a pixels near the edges
+vec4 calc_opacity(vec4 color, vec2 coords)
+{
+    // If shadow intensity is 0, change nothing
+    if (shadow_intensity == 0)
+    {
+        return color;
+    }
+
+    // Get how far the coords are from the center
+    vec2 distances_from_center = abs(window_center - coords);
+
+    // Darken pixels close to the edges of the screen in a polynomial fashion
+    float opacity = 1;
+    opacity *= -pow((distances_from_center.y/window_center.y)*shadow_cutoff, 
+                       (5/shadow_intensity)*2)+1;
+    opacity *= -pow((distances_from_center.x/window_center.x)*shadow_cutoff, 
+                       (5/shadow_intensity)*2)+1;
+    color.w *= opacity;
+    color.w = max(1 - color.w, 0.8);
+
+    return color;
+}
+
+
+// Default window shader:
+// 1) fetch the specified pixel
+// 2) apply default post-processing
+vec4 window_shader() {
+    vec4 c = texelFetch(tex, ivec2(texcoord), 0);
+    if (c.x +c.y + c.z < 0.6)
+    {
+        c.w = 1;
+        c = calc_opacity(c,texcoord);
+    }
+
+    return default_post_processing(c);
+}

config/polybar/config

@@ -4,7 +4,6 @@ offsety = 24
 
 [color]
 bg = #191919
-bga = #C0191919
 fg4= #f58d44
 fg2 = #5f819d
 fg3 = #707880
@@ -15,52 +14,78 @@ fg1 = #fefefe
 monitor = ${env:MONITOR}
 
 enable-ipc                = true
-font-0                    = mononoki:style=Regular:pixelsize=11;3
-font-1                    = mononoki:style=Regular:pixelsize=15;4
-font-2                    = mononoki:style=Regular:pixelsize=19;5
-font-3                    = mononoki:style=Regular:pixelsize=11;3
-font-4                    = MesloLGM Nerd Font Mono:style=Regular:pixelsize=14;2
-font-5                    = Noto Sans Mono CJK TC:style=Medium,Regular;pixelsize=10;2
+font-0                    = FiraMono Nerd Font:style=Regular,size=10;3
+font-1                    = MesloLGM Nerd Font Mono:style=Regular:pixelsize=14;3
+font-2                    = Noto Sans Mono CJK TC:style=Medium,Regular;pixelsize=10;3
 
-height                    = 25
-background                = ${color.bga}
+height                    = 32
 
 module-margin		      = 1
 wm-restack                = bspwm
 radius                    = 0
-foreground                = ${color.fg1}
-
-padding-right		      = 1
-
-[bar/wsonly]
-inherit			          = bar/base
-width			          = 100%
-modules-left	          = workspaces
-modules-right		      = time
-
-[bar/ws]
-inherit                   = bar/base
-width                     = 2510
-offset-x                  = 25
-offset-y                  = 10
-modules-left              = workspaces xwindow
-modules-right		      = mpd temperature memory network battery pulseaudio microphone time
-tray-position		      = right
-background		          = ${color.bga}
+background		          = ${color.bg}
 border-size		          = 0
 border-color              = ${color.fg3}
 fg			              = ${color.fg1}
+offset-y                  = 16
+
+padding-right		      = 1
+
+[bar/time]
+inherit			          = bar/base
+modules-center		      = time
+width                     = 86
+
+[bar/time1920]
+inherit                   = bar/time
+offset-x                  = 1792
+
+[bar/time1080]
+inherit                   = bar/time
+offset-x                  = 952
+
+[bar/time2560]
+inherit                   = bar/time
+offset-x                  = 2432
+
+[bar/ws]
+inherit                   = bar/base
+width                     = 248
+offset-x                  = 32
+modules-left              = workspaces 
+tray-position		      = right
+
+[bar/right]
+inherit                   = bar/base
+width                     = 420
+modules-center		      = temperature memory network battery pulseaudio vpn microphone
+tray-position		      = right
+padding                   = 1
+
+[bar/right2560]
+inherit                   = bar/right
+offset-x                  = 1980
+
+[bar/right1920]
+inherit                   = bar/right
+offset-x                  = 1340
 
 
-[module/wsnumber]
-type                      = custom/scrip80
-exec                      = bspc query -D -d focused --names
-tail                      = true
-interval                  = 0
-format                    = "<label>"
-format-foreground         = ${color.background}
-format-background         = ${color.colorlb}
-format-padding            = 0
+[bar/mpd]
+inherit                   = bar/base
+width                     = 250
+fixed-center              = true
+modules-right		      = mpdctrls
+modules-left		      = mpdsong
+padding		              = 1
+
+[bar/mpd2560]
+inherit                   = bar/mpd
+offset-x                  = 1698
+
+[bar/mpd1920]
+inherit                   = bar/mpd
+offset-x                  = 1058
 
 [module/xwindow]
 type                      = internal/xwindow
@@ -75,16 +100,15 @@ enable-click = true
 enable-scroll = true
 
 format = <label-state>
-format-padding = 0
-label-monitor = %name%
-label-active             = %{T2}雷%{T-}
-label-active-padding     = 1
-label-occupied            = %{T2}ﲭ%{T-}
+label-monitor             = %name%
+label-active              = %{T2}%{T-}
+label-active-padding      = 1
+label-occupied            = %{T2}%{T-}
 label-occupied-padding    = 1
-label-empty               = %{T2}ﱤ%{T-}
+label-empty               = %{T2}%{T-}
 label-empty-padding       = 1
-label-urgent            = %{T2}ﲭ%{T-}
-label-urgent-padding    = 1
+label-urgent              = %{T2}%{T-}
+label-urgent-padding      = 1
 
 
 [module/time]
@@ -92,18 +116,28 @@ type                      = internal/date
 interval                  = 10
 time                      = "%H:%M"
 date                      = "%d %b"
-label                     = %{T2}◷%{T-} %time%
+label                     = %{T2}%{T-} %time%
 label-padding             = 0
 
-[module/mpd]
+[module/mpdctrls]
+type                      = internal/mpd
+host                      = 127.0.0.1
+port                      = 6600
+format-online 		      = <icon-prev> <toggle> <icon-next> 
+
+icon-play		  = 
+icon-pause 		  = 
+icon-prev		  = 
+icon-next		  = 
+
+[module/mpdprogress]
 type                      = internal/mpd
 host                      = 127.0.0.1
 port                      = 6600
 
-format-online 		       = <label-song> <icon-prev> <toggle> <icon-next> <bar-progress> 
-label-song 		           = %title%
+format-online 		      = <bar-progress>
 
-bar-progress-width = 12 
+bar-progress-width = 13
 bar-progress-indicator = |
 bar-progress-fill = ─
 bar-progress-empty = ─
@@ -112,14 +146,13 @@ format-online-padding     = 0
 
 format-offline-padding    = 0
 
-label-song-maxlen         = 80
-label-song-ellipsis       = true
-
-icon-play		  =  
 bar-empty         = ─
-icon-pause 		  = 
-icon-prev		  = 
-icon-next		  = 
+
+[module/mpdsong]
+type                      = custom/script
+exec                      = ~/.scripts/mpd-zscroll
+tail                      = true
+interval                  = 0.3
 
 
 [module/pulseaudio]
@@ -130,15 +163,15 @@ label-volume              = %percentage:3:3%%
 use-ui-max                = false
 interval                  = 3
 
-ramp-volume-0             = ""
-ramp-volume-1             = ""
-ramp-volume-2             = ""
+ramp-volume-0             = "󰕿"
+ramp-volume-1             = "󰖀"
+ramp-volume-2             = "󰕾"
 
-label-muted               = "%{T3} %{T-}--%"
+label-muted               = "%{T3}󰝟 %{T-}--%"
 
 [module/microphone]
 type = custom/script
-exec = amixer get Capture | tail -2 | grep -q off && echo "" || echo ""
+exec = amixer get Capture | tail -2 | grep -q off && echo " " || echo " "
 interval = 1
 click-left = $HOME/.scripts/toggle-mute.sh
 
@@ -198,10 +231,16 @@ interface = wlan0
 udspeed-minwidth = 5
 accumulate-stats = true
 unknown-as-up = true
-format-connected = <label-connected>
+format-connected = <ramp-signal>
 format-disconnected = <label-disconnected>
 
-format-packetloss = <label-connected>
+format-packetloss = 󰤫
 
-label-connected =  
+ramp-signal-0 = 󰤯
+ramp-signal-1 = 󰤟
+ramp-signal-2 = 󰤢
+ramp-signal-3 = 󰤥
+ramp-signal-4 = 󰤨
+
+label-disconnected = 󰤯
 

config/polybar/launch.sh

@@ -13,9 +13,26 @@ while pgrep -u $UID -x polybar >/dev/null; do sleep 0.1; done
 
 polybar -m | while read -r mon; do
     export MONITOR=$(echo $mon | cut -d: -f1)
+    width="$(echo $mon | cut -d' ' -f2 | cut -dx -f1)"
+    w=1920
+    case "$width" in
+        1920) w=1920
+            ;;
+        1080) w=1080
+            ;;
+        2560) w=2560
+            ;;
+        *) w=1920
+    esac
+
     echo $mon | grep -q "(primary)" && {
         polybar ws &
+
+        polybar time$w &
+        polybar right$w &
+        polybar mpd$w &
     } || {
-        polybar wsonly &
+        polybar ws &
+        polybar time$w &
     }
 done

config/rofi/colors.rasi

@@ -13,24 +13,26 @@
     alternate-urgent-background: @background2;
     alternate-urgent-foreground: @foreground;
 
-    selected-active-background: @foreground2;
+    selected-active-background: @foreground3;
     selected-active-foreground: @background;
-    selected-normal-background: @foreground2;
+    selected-normal-background: @foreground3;
     selected-normal-foreground: @background;
-    selected-urgent-background: @foreground2;
+    selected-urgent-background: @foreground3;
     selected-urgent-foreground: @background;
 
     text-color:			@foreground;
     border-color:       @foreground;
 
     background-color: #00000000;
-    background: #191919e0;
-    background2: #19191900;
+    background: #191919;
+    background2: #191919;
+    background3: #282a2e;
     foreground: #fefefe;
     foreground2: #c5c8c6;
-    spacing: 2;
+    foreground3: #373b41;
+    spacing: 4;
 
-    font: "mononoki 12";
+    font: "FiraMono Nerd Font 12";
 }
 
 #window {
@@ -61,7 +63,7 @@
 
 #textbox-prompt-colon {
     expand: false;
-    str: ":";
+    str: "";
     margin: 0px 0.3em 0em 0em;
     text-color: @normal-foreground;
 }
@@ -75,9 +77,14 @@
     padding: 2px 0px 0px;
 }
 
+element-text, element-icon {
+    background-color: inherit;
+    text-color:       inherit;
+}
+
 #element {
     border: 0;
-    padding: 1px;
+    padding: 6px;
 }
 
 #element.normal.normal {

config/rofi/config.rasi

@@ -149,5 +149,5 @@ configuration {
 /*	me-accept-entry: "MouseDPrimary";*/
 /*	me-accept-custom: "Control+MouseDPrimary";*/
 }
-@theme "colors-rofi-dark"
+@theme "colors"
 

config/rofi/launcher.rasi

@@ -0,0 +1,174 @@
+/**
+ *
+ * Author : Aditya Shakya (adi1090x)
+ * Github : @adi1090x
+ * 
+ * Rofi Theme File
+ * Rofi Version: 1.7.3
+ **/
+
+/*****----- Configuration -----*****/
+configuration {
+	modi:                       "drun";
+    show-icons:                 true;
+    display-drun:               "";
+	drun-display-format:        "{name}";
+}
+
+/*****----- Global Properties -----*****/
+@import                          "colors.rasi"
+
+/*****----- Main Window -----*****/
+window {
+    transparency:                "real";
+    location:                    center;
+    anchor:                      center;
+    fullscreen:                  false;
+    width:                       1000px;
+    x-offset:                    0px;
+    y-offset:                    0px;
+
+    enabled:                     true;
+    margin:                      0px;
+    padding:                     0px;
+    border:                      0px solid;
+    border-radius:               0px;
+    border-color:                @selected;
+    background-color:            @background;
+    cursor:                      "default";
+}
+
+/*****----- Main Box -----*****/
+mainbox {
+    enabled:                     true;
+    spacing:                     20px;
+    margin:                      0px;
+    padding:                     40px;
+    border:                      0px solid;
+    border-radius:               0px 0px 0px 0px;
+    border-color:                @selected;
+    background-color:            transparent;
+    children:                    [ "inputbar", "listview" ];
+}
+
+/*****----- Inputbar -----*****/
+inputbar {
+    enabled:                     true;
+    spacing:                     10px;
+    margin:                      0px 500px 0px 0px;
+    padding:                     12px;
+    border:                      0px 0px 0px 4px;
+    border-radius:               0px 100% 100% 0px;
+    border-color:                @selected;
+    background-color:            @background-alt;
+    text-color:                  @foreground;
+    children:                    [ "prompt", "entry" ];
+}
+
+prompt {
+    enabled:                     true;
+    background-color:            inherit;
+    text-color:                  inherit;
+}
+textbox-prompt-colon {
+    enabled:                     true;
+    expand:                      false;
+    str:                         "::";
+    background-color:            inherit;
+    text-color:                  inherit;
+}
+entry {
+    enabled:                     true;
+    background-color:            inherit;
+    text-color:                  inherit;
+    cursor:                      text;
+    placeholder:                 "Search";
+    placeholder-color:           inherit;
+}
+
+/*****----- Listview -----*****/
+listview {
+    enabled:                     true;
+    columns:                     7;
+    lines:                       3;
+    cycle:                       true;
+    dynamic:                     true;
+    scrollbar:                   false;
+    layout:                      vertical;
+    reverse:                     false;
+    fixed-height:                true;
+    fixed-columns:               true;
+    
+    spacing:                     10px;
+    margin:                      0px;
+    padding:                     0px;
+    border:                      0px solid;
+    border-radius:               0px;
+    border-color:                @selected;
+    background-color:            transparent;
+    text-color:                  @foreground;
+    cursor:                      "default";
+}
+scrollbar {
+    handle-width:                5px ;
+    handle-color:                @selected;
+    border-radius:               0px;
+    background-color:            @background-alt;
+}
+
+/*****----- Elements -----*****/
+element {
+    enabled:                     true;
+    spacing:                     10px;
+    margin:                      0px;
+    padding:                     15px 10px;
+    border:                      0px solid;
+    border-radius:               0px;
+    border-color:                @selected;
+    background-color:            transparent;
+    text-color:                  @foreground;
+    orientation:                 vertical;
+    cursor:                      pointer;
+}
+element normal.normal {
+    background-color:            transparent;
+    text-color:                  @foreground;
+}
+element selected.normal {
+    border:                      0px 0px 0px 4px;
+    border-radius:               0px;
+    border-color:                @selected;
+    background-color:            @background-alt;
+    text-color:                  @foreground;
+}
+element-icon {
+    background-color:            transparent;
+    text-color:                  inherit;
+    size:                        64px;
+    cursor:                      inherit;
+}
+element-text {
+    background-color:            transparent;
+    text-color:                  inherit;
+    highlight:                   inherit;
+    cursor:                      inherit;
+    vertical-align:              0.5;
+    horizontal-align:            0.5;
+}
+
+/*****----- Message -----*****/
+error-message {
+    padding:                     40px;
+    border:                      0px solid;
+    border-radius:               0px;
+    border-color:                @selected;
+    background-color:            black / 10%;
+    text-color:                  @foreground;
+}
+textbox {
+    background-color:            transparent;
+    text-color:                  @foreground;
+    vertical-align:              0.5;
+    horizontal-align:            0.0;
+    highlight:                   none;
+}

config/sx/sxrc

@@ -1,4 +1,5 @@
 setxkbmap -option caps:backspace
 xmodmap -e "clear Lock"
+xterm -e "xinput list" &
 exec bspwm
 

config/sxhkd/sxhkdrc

@@ -11,11 +11,14 @@ super + ctrl + alt + f
 
 #Volume Control
 {XF86AudioLowerVolume,super + Next}
-	amixer -D pulse sset Master 5%-
+    pactl set-sink-volume @DEFAULT_SINK@ -5%
 {XF86AudioRaiseVolume,super + Prior}
-	amixer -D pulse sset Master 5%+
+    pactl set-sink-volume @DEFAULT_SINK@ +5%
 {XF86AudioMute}
-	amixer -D pulse set Master 1+ toggle
+	pactl set-sink-mute @DEFAULT_SINK@ toggle
+
+super + alt + ctrl + button{4,5}
+    pactl set-sink-volume @DEFAULT_SINK@ {+,-}1%
 
 {_, super} + XF86MonBrightnessDown
     light -U {10,1}
@@ -25,12 +28,12 @@ super + ctrl + alt + f
 
 
 super + r
-	rofi -show drun -show-icons
+    $HOME/.scripts/launcher
 
 super + shift + r
 	rofi -show ssh -show-icons
 
-super + ctrl + Tab
+super + alt + Tab
 	rofi -show window
 
 super + g
@@ -75,6 +78,10 @@ super + i
 super + semicolon
 	bspc rule -a \* -o state=floating && $TERMINAL -e pulsemixer 
 
+# xrandr switcher
+super + apostrophe
+	$HOME/.scripts/xrandr.sh
+
 # xkill
 ctrl + alt + Escape
 	xkill
@@ -109,18 +116,16 @@ super + ctrl + c
 
 # stuff
 super + ctrl + m
-	dmenu -p "i am stuff" | xargs /usr/bin/stuff 
+	dmenu -p "i am stuff" | xargs /usr/local/bin/stuff 
 
 super + ctrl + n
-	dmenu -p "i am big chungus" | xargs /usr/bin/chungus
+	dmenu -p "i am big chungus" | xargs /usr/local/bin/chungus
+
+super + ctrl + b
+	dmenu -p "eminem says" | xargs /usr/bin/local/eminem
 
 super + ctrl + t
 	dmenu -p "toilet" | toilet --font mono12 | sed 's/ /_  _ /g' | xclip -selection clipboard
-super + ctrl + b
-	dmenu -p "eminem says" | xargs /usr/bin/eminem
-# memes
-super + ctrl + alt + c
-	$HOME/.scripts/memeselector
 
 # iocane
 super + shift + Return 

config/vim/vimrc

@@ -1,4 +1,4 @@
-set viminfo+=n~/.config/vim/viminfo
+"set viminfo+=~/.config/vim/viminfo
 set runtimepath+=~/.config/vim,~/.config/vim/after
 set autoindent
 set wrap
@@ -41,6 +41,10 @@ call plug#begin()
 
 Plug 'preservim/nerdtree'
 nnoremap <F5> :NERDTree<CR>
+let NERDTreeMinimalUI=1
+
+Plug 'ryanoasis/vim-devicons'
+set encoding=UTF-8
 
 Plug 'preservim/vim-markdown'
 "let g:vim_markdown_math = 1
@@ -107,19 +111,138 @@ endfunction
 
 autocmd FileType python let b:coc_root_patterns = ['.git', '.env', '.']
 
+Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' }
 Plug 'junegunn/fzf.vim'
 
+
+let g:fzf_cache_dir = '$HOME/.cache'
+
+Plug 'yuki-yano/fzf-preview.vim'
+Plug 'BurntSushi/ripgrep'
+
 nnoremap <F6> :Files<CR>
 nnoremap <F7> :Rg<CR>
 
+nnoremap <F8> :Tags<CR>
+
+nnoremap g] :call fzf#vim#tags(expand('<cword>'))<CR>
+nnoremap <silent> <Leader>ag :Ag <C-R><C-W><CR>
 
 Plug 'heavenshell/vim-pydocstring', { 'do': 'make install', 'for': 'python' }
 
 Plug 'tpope/vim-fugitive'
 
+Plug 'yggdroot/indentline'
+
+"Plug 'yuttie/comfortable-motion.vim'
+"noremap <silent> <ScrollWheelDown> :call comfortable_motion#flick(40)<CR>
+"noremap <silent> <ScrollWheelUp>   :call comfortable_motion#flick(-40)<CR>
+
+let g:comfortable_motion_interval = 2000.0/60
+let g:comfortable_motion_friction = 80.0
+let g:comfortable_motion_air_drag = 2.0
+
+Plug 'myusuf3/numbers.vim'
+
+let g:numbers_exclude = ['tagbar', 'gundo', 'minibufexpl', 'nerdtree']
+
 call plug#end()
 
 highlight Pmenu ctermbg=black guibg=black ctermfg=white
 
 hi TrailingWhitespace ctermbg=red guibg=red
 call matchadd("TrailingWhitespace", '\v\s+$')
+
+" ex command for toggling hex mode - define mapping if desired
+command -bar Hexmode call ToggleHex()
+
+" helper function to toggle hex mode
+function ToggleHex()
+  " hex mode should be considered a read-only operation
+  " save values for modified and read-only for restoration later,
+  " and clear the read-only flag for now
+  let l:modified=&mod
+  let l:oldreadonly=&readonly
+  let &readonly=0
+  let l:oldmodifiable=&modifiable
+  let &modifiable=1
+  if !exists("b:editHex") || !b:editHex
+    " save old options
+    let b:oldft=&ft
+    let b:oldbin=&bin
+    " set new options
+    setlocal binary " make sure it overrides any textwidth, etc.
+    silent :e " this will reload the file without trickeries 
+              "(DOS line endings will be shown entirely )
+    let &ft="xxd"
+    " set status
+    let b:editHex=1
+    " switch to hex editor
+    %!xxd
+  else
+    " restore old options
+    let &ft=b:oldft
+    if !b:oldbin
+      setlocal nobinary
+    endif
+    " set status
+    let b:editHex=0
+    " return to normal editing
+    %!xxd -r
+  endif
+  " restore values for modified and read only state
+  let &mod=l:modified
+  let &readonly=l:oldreadonly
+  let &modifiable=l:oldmodifiable
+endfunction
+
+" autocmds to automatically enter hex mode and handle file writes properly
+if has("autocmd")
+  " vim -b : edit binary using xxd-format!
+  augroup Binary
+    au!
+
+    " set binary option for all binary files before reading them
+    au BufReadPre *.bin,*.hex setlocal binary
+
+    " if on a fresh read the buffer variable is already set, it's wrong
+    au BufReadPost *
+          \ if exists('b:editHex') && b:editHex |
+          \   let b:editHex = 0 |
+          \ endif
+
+    " convert to hex on startup for binary files automatically
+    au BufReadPost *
+          \ if &binary | Hexmode | endif
+
+    " When the text is freed, the next time the buffer is made active it will
+    " re-read the text and thus not match the correct mode, we will need to
+    " convert it again if the buffer is again loaded.
+    au BufUnload *
+          \ if getbufvar(expand("<afile>"), 'editHex') == 1 |
+          \   call setbufvar(expand("<afile>"), 'editHex', 0) |
+          \ endif
+
+    " before writing a file when editing in hex mode, convert back to non-hex
+    au BufWritePre *
+          \ if exists("b:editHex") && b:editHex && &binary |
+          \  let oldro=&ro | let &ro=0 |
+          \  let oldma=&ma | let &ma=1 |
+          \  silent exe "%!xxd -r" |
+          \  let &ma=oldma | let &ro=oldro |
+          \  unlet oldma | unlet oldro |
+          \ endif
+
+    " after writing a binary file, if we're in hex mode, restore hex mode
+    au BufWritePost *
+          \ if exists("b:editHex") && b:editHex && &binary |
+          \  let oldro=&ro | let &ro=0 |
+          \  let oldma=&ma | let &ma=1 |
+          \  silent exe "%!xxd" |
+          \  exe "set nomod" |
+          \  let &ma=oldma | let &ro=oldro |
+          \  unlet oldma | unlet oldro |
+          \ endif
+  augroup END
+endif
+

deploy.sh

@@ -1,6 +1,6 @@
 #!/bin/sh
 
-configurations="iocane bg bg.gif bspwm cava neofetch mpd mpv ncmpcpp vim sxhkd polybar compfy rofi user-dirs.dirs gtk-3.0 zathura sx mimeapps.list"
+configurations="iocane bg bg.gif bspwm cava neofetch mpd mpv ncmpcpp vim sxhkd polybar compfy rofi user-dirs.dirs gtk-3.0 zathura sx mimeapps.list picom"
 
 
 save () {

gtkrc-2.0

@@ -1,6 +1,6 @@
 gtk-theme-name="vimix-vski"
 gtk-icon-theme-name="Vimix-dark"
-gtk-font-name="mononoki 10"
+gtk-font-name="FiraMono Nerd Font 10"
 gtk-cursor-theme-name="pixelfun3"
 gtk-cursor-theme-size=24
 gtk-toolbar-style=GTK_TOOLBAR_ICONS

misc/init.d/tunnel

@@ -0,0 +1,13 @@
+#!/sbin/openrc-run
+
+: ${user:="tor"}
+
+name="tunnel"
+
+command="/home/david/tunnel.sh"
+command_background="true"
+pidfile="/run/tunnel.pid"
+
+depend() {
+	need sshd
+}

misc/tunnel.sh

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+while true; do
+    echo "digging a tunnel..."
+    /usr/bin/ssh -NT -i /home/david/.ssh/ovski_rsa -p 4522 \
+        -R 5069:localhost:5069 \
+        -R 6680:localhost:6680 \
+        -R 2022:localhost:22 \
+        vski@86.10.87.187
+done

mkshrc

@@ -7,7 +7,7 @@ esac
 export VIMINIT="source ~/.config/vim/vimrc"
 export NVIMINIT="source ~/.config/vim/vimrc"
 
-HISTFILE="$HOME/.mksh_history"
+HISTFILE="/tmp/.mksh_history$$"
 HISTSIZE=5000
 
 if [ -x /usr/bin/dircolors ]; then
@@ -55,4 +55,4 @@ parse_git_dirty() {
 
 bind '^L=clear-screen'
 
-export PS1="\${PWD/#\$HOME/\~}\`parse_git_branch\` > "
+export PS1="\${PWD/#\$HOME/\~}\`parse_git_branch\` > [3 q"

profile

@@ -1,4 +1,4 @@
-
+export $(dbus-launch)
 [ -n "$BASH_VERSION" ] && [ -f "$HOME/.bashrc" ] && . "$HOME/.bashrc"
 
 [ -d "$HOME/bin" ] && PATH="$HOME/bin:$PATH"
@@ -11,7 +11,7 @@ alias editor=vim
 export TERMINAL="st"
 export BROWSER="/usr/bin/firefox"
 export FILE_MANAGER="/usr/bin/thunar"
-export EMAIL_CLIENT="/usr/bin/claws-mail"
+export EMAIL_CLIENT="/usr/bin/thunderbird"
 export EDITOR="/usr/bin/vim"
 
 export JAVA_HOME=/usr/lib/jvm/java-19-openjdk/

scripts/a

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+printf "
+ ╱|、
+(˚ˎ。7
+|、˜〵
+じしˍ,)ノ
+
+"
+

scripts/aa

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+printf "
+     へ   ♡   ╱|、
+   ૮ - ՛)    (\` - 7
+   /  ៸|     |、⁻〵
+乀(ˍ,ل ل     じしˍ,)ノ
+
+"
+

scripts/color-test.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+#
+# This file echoes a bunch of color codes to the terminal to demonstrate
+# what's available. Each line is the color code of one forground color,
+# out of 17 (default + 16 escapes), followed by a test use of that color
+# on all nine background colors (default + 8 escapes).
+#
+T='gYw'   # The test text
+echo -e "\n                 40m     41m     42m     43m     44m     45m     46m     47m";
+for FGs in '    m' '   1m' '  30m' '1;30m' '  31m' '1;31m' '  32m' '1;32m' '  33m' '1;33m' '  34m' '1;34m' '  35m' '1;35m' '  36m' '1;36m' '  37m' '1;37m';
+  do FG=${FGs// /}
+  echo -en " $FGs \033[$FG  $T  "
+  for BG in 40m 41m 42m 43m 44m 45m 46m 47m;
+    do echo -en "$EINS \033[$FG\033[$BG  $T \033[0m\033[$BG \033[0m";
+  done
+  echo;
+done
+echo
+

scripts/dmenukaomoji

@@ -12,13 +12,14 @@ if [ -n "$1" ]; then
 	if [[ "$WINDOW" =~ .*"$SUB".* ]]; then
 		xdotool key "ctrl+v" 
 	else
-		xdotool key Shift+Insert
+		xdotool key "ctrl+v" 
+		#xdotool key Shift+Insert
 	fi
-#	xdotool type --delay 1 $chosen
+#xdotool type --delay 1 $chosen
 
 #	VAR=$(xclip -o)
 
-#	xdotool type $chosen
+	#xdotool type $chosen
 else
 	notify-send "'$chosen' copied to clipboard." &
 fi

scripts/launcher

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+rasi="$HOME/.config/rofi/launcher.rasi"
+
+## Run
+rofi \
+    -show drun \
+    -theme $rasi

scripts/memeselector

@@ -1,6 +0,0 @@
-#!/bin/sh
-
-FOLDER=/home/david/docs/proj/davidovski.xyz/f/meme
-cd $FOLDER
-xdotool type "https://davidovski.xyz/f/meme/$(ls -1 | dmenu)"
-

scripts/mpc_picker

@@ -1,6 +1,29 @@
-#!/bin/sh
-selected=$(mpc -f "%title%[\t\t%artist%][\t\t%album%]\t\t%file%" listall | dmenu -i -p mpd)
-[ "$selected" == "" ] && exit
-file=$(printf "%s\n" "$selected" | rev | cut -f1 -d'	' | rev)
-echo "$file"
-mpc insert "$file"
+#!/usr/bin/dash
+format="<b>%title%</b>\t%artist%\t%album%\t%file%"
+
+columns="$(mpc -f "$format" listall \
+    | column -t -s'	' \
+        -C title,width=10,trunc \
+        -C artist,width=10,trunc \
+        -C album,width=10,trunc \
+        -C file \
+    | sed 's/&/&amp;/g'
+)"
+
+np=$(printf "%s" "$columns" | grep "$(mpc -f '%title%' current)" | head -1)
+echo "$np"
+selected=$(
+        printf "%s" "$columns" | rofi -dmenu -i \
+                -multi-select \
+                -markup-rows \
+                -p " " \
+                -ballot-selected-str " " \
+                -ballot-unselected-str "  " \
+                -select "$np"
+    )
+[ -z "$selected" ] && exit
+echo "$selected" | while read -r option; do 
+    file=$(printf "%s\n" "$option" | awk -F'  ' '{print $NF}' | sed 's/^\s*//g')
+    echo ${file}
+    mpc insert "$file"
+done

scripts/mpd-zscroll

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+if [ ! -z "$@" ]; then
+    mpc -f "%title%" current
+else
+    zscroll -l 14 --before-text "󰎇 " --delay 0.2 \
+		--update-check true "$0 current" -p "     " &
+fi
+
+wait

scripts/record_window_hd.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+info=/tmp/wminfo
+
+xwininfo > /tmp/wminfo
+
+geom=$(cat $info | grep "geometry" | cut -d' ' -f4) 
+
+width=$(cat $info | grep Width | cut -d' ' -f4)
+height=$(cat $info | grep Height | cut -d' ' -f4)
+
+size="${width}x${height}"
+position=+$(echo $geom | cut -d'+' -f2- | sed "s/+/,/g")
+
+filename=$(date +"$HOME/pics/screenshot/%F_%T.mp4")
+
+echo $size and $position
+ffmpeg -y -f x11grab -video_size $size -i $position -f pulse -i default $filename
+
+rm $info

scripts/toggle-gap.sh

@@ -1,3 +1,3 @@
 #!/bin/sh
-GAP=25; bspc config window_gap | grep -q $GAP && bspc config window_gap 0 || bspc config window_gap $GAP
+GAP=32; bspc config window_gap | grep -q $GAP && bspc config window_gap 0 || bspc config window_gap $GAP
 

scripts/toggle-mic.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+SOURCE=1
+pactl list sources | grep -qi 'Mute: yes' && pactl set-source-mute $SOURCE false || pactl set-source-mute $SOURCE true
+

scripts/xrandr.sh

@@ -0,0 +1,35 @@
+#!/bin/sh
+all=$(xrandr | grep "connected" | cut -d' ' -f1 | paste -s -d' ')
+available=$(xrandr | grep " connected" | cut -d' ' -f1 | paste -s -d' ')
+set -- $available
+
+printf "connected: "
+printf "%s " $available
+printf "\n"
+
+printf "all: "
+printf "%s " $all
+printf "\n"
+
+if [ "$1" == "eDP1" ]; then
+    # this is a laptop so awesome!
+
+    if [ "$#" != "1" ]; then
+        # ensure the main one is turned on yeah
+        xrandr --output eDP1 --mode 1920x1080 --pos 0x0 --rotate normal
+
+        # put the non main one to the left (assume its +1920 because im lazy)
+        xrandr --output "$2" --primary --mode 2560x1440 --pos 1920x0 --rotate normal
+    else
+        # ensure the main one is turned on yeah
+        xrandr --output eDP1 --primary --mode 1920x1080 --pos 0x0 --rotate normal
+    fi
+    #disconnect all the rest i think
+    for x in $all; do
+        echo disconnecting $x
+        case $available in
+            *"$x"*) ;;
+            *) xrandr --output "$x" --off
+        esac
+    done
+fi

scripts/z

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+printf "
+\e[1;36mZzzzz \e[0;33m|\       _,,,--,,_
+      /\e[1;37m,\e[0;33m \`.-'\`'    ._ \-;;,
+     |\e[1;37m,3\e[0;33m-  \e[0;33m) )_    .;.(  \e[0;33m\`'-'
+   \e[0;33m '---''(_/._)-'(_\_)    \e[0;m
+
+"
+

sh_aliases

@@ -73,3 +73,7 @@ passthrough_enable () {
 }
 alias links="links -g -html-g-text-color 0xfefefe -html-g-background-color 0x191919 -font /home/david/.fonts/ttf-mononoki/mononoki-Regular.ttf"
 alias weechat="weechat -d ~/.weechat"
+
+alias glibc="LANG=en_US.UTF-8 bwrap --bind /var/chroots/debian / --dev-bind /dev /dev --proc /proc --bind /sys /sys --bind /run /run --bind /home /home --ro-bind /etc/resolv.conf /etc/resolv.conf --ro-bind /etc/passwd /etc/passwd --ro-bind /etc/group /etc/group"
+
+alias glibcX11="xhost + local: ; LANG=en_US.UTF-8 bwrap --bind /var/chroots/debian / --dev-bind /dev /dev --proc /proc --bind /sys /sys --bind /run /run --bind /home /home --ro-bind /etc/resolv.conf /etc/resolv.conf --ro-bind /etc/passwd /etc/passwd --ro-bind /etc/group /etc/group --bind /tmp/.X11-unix/X1 /tmp/.X11-unix/X1 --setenv DISPLAY $DISPLAY --ro-bind \"${XDG_RUNTIME_DIR}/pulse\" \"${XDG_RUNTIME_DIR}/pulse\" "

st/deploy.sh

@@ -6,6 +6,7 @@ wd="$HOME/.local/src/st"
 
 rm -rf "$wd"
 git clone https://git.suckless.org/st "$wd"
+git -C "$wd" checkout 9846a56bd7fdc86bf788db04bbbcbde7b7eb9952
 
 patch -d "$wd" -p1 -i $(realpath davidovski.patch)