Add Glitch shade

16 files changed, 2375 insertions, 317 deletions

diff --git a/config/picom/picom.conf b/config/picom/picom.conf
index 1179a80..d30d4eb 100644
--- a/config/picom/picom.conf
+++ b/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
-
-# 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
+# Default: 12
+shadow-radius = 12;
 
-# 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";
+# Default: -15
+shadow-offset-x = -7;
+
+# The top offset for shadows, in pixels.
 #
-# shadow-exclude = []
-shadow-exclude = [
-  "_GTK_FRAME_EXTENTS@:c",
-  #"_NET_WM_STATE@:32a"
-];
+# Default: -15
+shadow-offset-y = -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.
+# Hex string color value of shadow. Formatted like "#RRGGBB", e.g. "#C0FFEE".
 #
-# shadow-exclude-reg = "" 
+# Default: #000000
+# shadow-color = "#000000"
 
-# Crop shadow of a window fully on a particular Xinerama screen to the screen.
-# xinerama-shadow-crop = false
+# 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.01;
 
 # 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.01;
 
 # 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,245 @@ 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
+
+#################################
+#            Blur               #
+#################################
 
-# Parameters for background blurring, see the *BLUR* section for more information.
-# blur-method = gaussian
+# Parameters for background blurring, see BLUR section in the man page for more information.
+# blur-method =
 # blur-size = 12
 #
 # blur-deviation = false
+#
+# blur-strength = 5
 
-# 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 of semi-transparent / ARGB windows.
+# Can be set per-window using rules.
 #
-blur-background = true;
+# Default: false
+# blur-background = false
 
-# Blur background of windows when the window frame is not opaque. 
+# 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";
-
-vsync = false
+# Default: "xrender"
+backend = "glx"
 
-# Enable remote control via D-Bus. See the *D-BUS API* section below for more details.
-# dbus = 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;
 
-# 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;
-
-# Mark override-redirect windows that doesn't have a child window with 'WM_STATE' focused.
-# mark-ovredir-focused = false
-mark-ovredir-focused = true;
+# Default: false
+vsync = 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 = []
-
-# 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.
+# Required for explicit sync drivers, such as nvidia.
 #
-# glx-no-stencil = false
+# Default: false
+# xrender-sync-fence = false
 
-# 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 backend: Use specified GLSL fragment shader for rendering window
+# contents. Read the man page for a detailed explanation of the interface.
 #
-# 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.
+# Can be set per-window using rules.
 #
-xrender-sync-fence = true
+window-shader-fg = "~/.config/picom/shaders/glitch_animation.glsl"
 
-# 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'
-
-# 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`.
-#
-wintypes:
-{
-  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 
+# write-pid-path = "/path/to/your/log/file"
+
+# Rule-based per-window options.
+#
+# 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'";
+  # shader = "my_shader.frag";
+}, {
+  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;
+})
+
+# `@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"
+
diff --git a/config/picom/shaders/OldCRT.glsl b/config/picom/shaders/OldCRT.glsl
new file mode 100644
index 0000000..6e02812
--- /dev/null
+++ b/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);
+}
diff --git a/config/picom/shaders/cross.glsl b/config/picom/shaders/cross.glsl
new file mode 100644
index 0000000..2241508
--- /dev/null
+++ b/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));
+}
diff --git a/config/picom/shaders/cube.glsl b/config/picom/shaders/cube.glsl
new file mode 100644
index 0000000..8988a7d
--- /dev/null
+++ b/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));
+}
diff --git a/config/picom/shaders/default_anim.glsl b/config/picom/shaders/default_anim.glsl
new file mode 100644
index 0000000..e4f43ed
--- /dev/null
+++ b/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);
+}
+
diff --git a/config/picom/shaders/dither.glsl b/config/picom/shaders/dither.glsl
new file mode 100644
index 0000000..6a2a285
--- /dev/null
+++ b/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;
+}
diff --git a/config/picom/shaders/glass.glsl b/config/picom/shaders/glass.glsl
new file mode 100644
index 0000000..a37972e
--- /dev/null
+++ b/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);
+}
diff --git a/config/picom/shaders/glitch.glsl b/config/picom/shaders/glitch.glsl
new file mode 100644
index 0000000..be28f78
--- /dev/null
+++ b/config/picom/shaders/glitch.glsl
@@ -0,0 +1,86 @@
+#version 330
+
+
+int delta = 20;
+float barh = 0.02;
+float barw = 0.4;
+int nbar = 16;
+
+float maxoff = 5;
+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);
+}
+
diff --git a/config/picom/shaders/glitch_animation.glsl b/config/picom/shaders/glitch_animation.glsl
new file mode 100644
index 0000000..be1e16c
--- /dev/null
+++ b/config/picom/shaders/glitch_animation.glsl
@@ -0,0 +1,119 @@
+#version 330
+
+float maxoff = 10;
+float minoff = 2;
+float hue = 0.3;
+
+float block_max = 500;
+float block_min = 200;
+
+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);
+}
+
+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.w = texelFetch(tex, ivec2(uvr), 0).w;
+    c.xyz = offset_color;
+
+    return default_post_processing(c);
+}
+
+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);
+    }
+    //c = anim(opacity);
+    return default_post_processing(c);
+}
+
diff --git a/config/picom/shaders/matrix_dissolve.glsl b/config/picom/shaders/matrix_dissolve.glsl
new file mode 100644
index 0000000..aaa6c4b
--- /dev/null
+++ b/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);
+}
diff --git a/config/picom/shaders/pixelize.glsl b/config/picom/shaders/pixelize.glsl
new file mode 100644
index 0000000..8a9c72e
--- /dev/null
+++ b/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);
+}
+
diff --git a/config/picom/shaders/pixelize_median.glsl b/config/picom/shaders/pixelize_median.glsl
new file mode 100755
index 0000000..9d695aa
--- /dev/null
+++ b/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);
+}
+
diff --git a/config/picom/shaders/plane.glsl b/config/picom/shaders/plane.glsl
new file mode 100644
index 0000000..b1c6885
--- /dev/null
+++ b/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));
+}
diff --git a/config/picom/shaders/sdf_mask.glsl b/config/picom/shaders/sdf_mask.glsl
new file mode 100644
index 0000000..3e73770
--- /dev/null
+++ b/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);
+}
diff --git a/config/picom/shaders/shiny.glsl b/config/picom/shaders/shiny.glsl
new file mode 100644
index 0000000..16636ac
--- /dev/null
+++ b/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);
+}
diff --git a/config/picom/shaders/terminal_vignette.glsl b/config/picom/shaders/terminal_vignette.glsl
new file mode 100644
index 0000000..4e5aa21
--- /dev/null
+++ b/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);
+}