nvim: use pywal colorscheme using neopywal

.config/fastfetch/config.jsonc

@@ -0,0 +1,80 @@
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "display": {
+        "separator": " "
+    },
+    "modules": [
+        {
+            "key": "╭───────────╮",
+            "type": "custom"
+        },
+        {
+            "key": "│ {#31} user    {#keys}│",
+            "type": "title",
+            "format": "{user-name}"
+        },
+        {
+            "key": "│ {#32} display {#keys}│",
+            "type": "display",
+            "compactType": "original-with-refresh-rate"
+        },
+        {
+            "key": "│ {#33}󰅐 uptime  {#keys}│",
+            "type": "uptime"
+        },
+        {
+            "key": "│ {#34}󱦟 install {#keys}│",
+            "type": "command",
+            "text": "birth_install=$(stat -c %W /); current=$(date +%s); time_progression=$((current - birth_install)); days_difference=$((time_progression / 86400)); echo $days_difference days"
+        },
+        {
+            "key": "│ {#35} kernel  {#keys}│",
+            "type": "kernel"
+        },
+        {
+            "key": "│ {#36}󰇄 desktop {#keys}│",
+            "type": "de"
+        },
+        {
+            "key": "│ {#32} shell   {#keys}│",
+            "type": "shell"
+        },
+        {
+            "key": "│ {#33}󰍛 cpu     {#keys}│",
+            "type": "cpu",
+            "showPeCoreCount": true
+        },
+        {
+            "key": "│ {#31}󰢮 gpu     {#keys}│",
+            "type": "gpu",
+            "format": "{2}"
+        },
+        {
+            "key": "│ {#34}󰉉 disk    {#keys}│",
+            "type": "disk",
+            "folders": "/"
+        },
+        {
+            "key": "│ {#35} memory  {#keys}│",
+            "type": "memory"
+        },
+        {
+            "key": "│ {#36}󰩟 network {#keys}│",
+            "type": "localip",
+            "format": "{ipv4} ({ifname})"
+        },
+        {
+            "key": "├───────────┤",
+            "type": "custom"
+        },
+        {
+            "key": "│ {#39} colors  {#keys}│",
+            "type": "colors",
+            "symbol": "circle"
+        },
+        {
+            "key": "╰───────────╯",
+            "type": "custom"
+        }
+    ]
+}

.config/fastfetch/config_more.jsonc

@@ -0,0 +1,109 @@
+{
+    "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
+    "logo": {
+    	"height": 10,
+    	"padding": {
+    		"top": 1
+    	}
+},
+"display": {
+"separator": " 󰑃  "
+},
+"modules": [
+    "break",
+    {
+    "type": "os",
+    "key": " DISTRO",
+    "keyColor": "yellow"
+    },
+
+    {
+    "type": "kernel",
+    "key": "│ ├",
+    "keyColor": "yellow"
+    },
+    {
+    "type": "packages",
+    "key": "│ ├󰏖",
+    "keyColor": "yellow"
+    },
+    {
+    "type": "shell",
+    "key": "│ └",
+    "keyColor": "yellow"
+    },
+    {
+    "type": "wm",
+    "key": " DE/WM",
+    "keyColor": "blue"
+    },
+    {
+    "type": "wmtheme",
+    "key": "│ ├󰉼",
+    "keyColor": "blue"
+    },
+    {
+    "type": "icons",
+    "key": "│ ├󰀻",
+    "keyColor": "blue"
+    },
+    {
+        "type": "cursor",
+        "key": "│ ├",
+        "keyColor": "blue"
+    },
+    {
+        "type": "terminalfont",
+        "key": "│ ├",
+        "keyColor": "blue"
+    },
+    {
+    "type": "terminal",
+    "key": "│ └",
+    "keyColor": "blue"
+    },
+    {
+    "type": "host",
+    "key": "󰌢 SYSTEM",
+    "keyColor": "green"
+    },
+    {
+    "type": "cpu",
+    "key": "│ ├󰻠",
+    "keyColor": "green"
+    },
+    {
+    "type": "gpu",
+    "key": "│ ├󰻑",
+    "format": "{2}",
+    "keyColor": "green"
+    },
+    {
+            "type": "display",
+    "key": "│ ├󰍹",
+    "keyColor": "green",
+    "compactType": "original-with-refresh-rate"
+    },
+    {
+    "type": "memory",
+    "key": "│ ├󰾆",
+    "keyColor": "green"
+    },
+    {
+    "type": "swap",
+    "key": "│ ├󰓡",
+    "keyColor": "green"
+    },
+    {
+    "type": "uptime",
+    "key": "│ ├󰅐",
+    "keyColor": "green"
+    },
+    {
+    "type": "display",
+    "key": "│ └󰍹",
+    "keyColor": "green"
+    },
+    "break"
+    ]
+}

.config/foot/foot.ini

@@ -1,7 +1,7 @@
 include=~/.cache/wal/colors-foot.ini
 
 [main]
-font=JetBrains Mono Nerd Font:size=12
+font=JetBrains Mono Nerd Font:size=11
 # pad=15x15
 
 [colors]

.config/gtk-2.0/gtkrc-2.0

@@ -2,8 +2,8 @@
 # Any customization should be done in ~/.gtkrc-2.0.mine instead.
 
 include "/home/krolyxon/.gtkrc-2.0.mine"
-gtk-theme-name="Tokyonight-Dark"
+gtk-theme-name="Adwaita-dark"
-gtk-icon-theme-name="Tokyonight-Dark-Cyan"
+gtk-icon-theme-name="Yaru"
 gtk-font-name="JetBrainsMonoNL Nerd Font Mono 11"
 gtk-cursor-theme-name="default"
 gtk-cursor-theme-size=24

.config/gtk-3.0/settings.ini

@@ -1,6 +1,6 @@
 [Settings]
-gtk-theme-name=Tokyonight-Dark
+gtk-theme-name=Adwaita-dark
-gtk-icon-theme-name=Tokyonight-Dark-Cyan
+gtk-icon-theme-name=Yaru
 gtk-font-name=JetBrainsMonoNL Nerd Font Mono 11
 gtk-cursor-theme-name=default
 gtk-cursor-theme-size=24

.config/hypr/shaders/01_red_tint.glsl

@@ -0,0 +1,16 @@
+#version 300 es
+// Pure Red Channel Shader - OPTIMIZED
+precision highp float;
+
+in vec2 v_texcoord;
+uniform sampler2D tex;
+out vec4 fragColor;
+
+// Using Rec. 709 for consistency
+const vec3 LUMA = vec3(0.2126, 0.7152, 0.0722);
+
+void main() {
+    vec4 pixColor = texture(tex, v_texcoord);
+    float gray = dot(pixColor.rgb, LUMA);
+    fragColor = vec4(gray, 0.0, 0.0, pixColor.a);
+}

.config/hypr/shaders/02_green_tint.glsl

@@ -0,0 +1,16 @@
+#version 300 es
+// Pure Green Channel Shader - FIXED
+precision highp float;
+
+in vec2 v_texcoord;
+uniform sampler2D tex;
+out vec4 fragColor;
+
+const vec3 LUMA = vec3(0.2126, 0.7152, 0.0722);
+
+void main() {
+    vec4 pixColor = texture(tex, v_texcoord);
+    float gray = dot(pixColor.rgb, LUMA);
+    // FIXED: Now correctly outputs to GREEN channel
+    fragColor = vec4(0.0, gray, 0.0, pixColor.a);
+}

.config/hypr/shaders/03_blue_tint.glsl

@@ -0,0 +1,15 @@
+#version 300 es
+// Pure Blue Channel Shader - OPTIMIZED
+precision highp float;
+
+in vec2 v_texcoord;
+uniform sampler2D tex;
+out vec4 fragColor;
+
+const vec3 LUMA = vec3(0.2126, 0.7152, 0.0722);
+
+void main() {
+    vec4 pixColor = texture(tex, v_texcoord);
+    float gray = dot(pixColor.rgb, LUMA);
+    fragColor = vec4(0.0, 0.0, gray, pixColor.a);
+}

.config/hypr/shaders/04_optics_compensate.glsl

@@ -0,0 +1,72 @@
+#version 300 es
+// Retro CRT Shader - FULLY OPTIMIZED
+// Fixes: Resolution-aware scanlines, proper vignette, edge clamping,
+//        correct aberration direction, anti-aliased scanlines
+
+precision highp float;
+
+in vec2 v_texcoord;
+uniform sampler2D tex;
+out vec4 fragColor;
+
+// --- CONFIGURATION ---
+const float CURVATURE = 3.5;
+const float SCANLINE_STRENGTH = 0.25;
+// Approximate screen height in pixels (adjust to your resolution)
+const float SCREEN_HEIGHT = 1080.0;
+// Scanlines per screen height (lower = thicker lines)
+const float SCANLINE_COUNT = 540.0;
+const float ABERRATION = 0.002;
+const float VIGNETTE_RADIUS = 1.00;
+const float VIGNETTE_SOFTNESS = 0.45;
+// Phosphor glow simulation
+const float GLOW = 0.03;
+
+vec2 curveUV(vec2 uv) {
+    uv = uv * 2.0 - 1.0;
+    vec2 offset = abs(uv.yx) / vec2(CURVATURE);
+    uv = uv + uv * offset * offset;
+    uv = uv * 0.5 + 0.5;
+    return uv;
+}
+
+void main() {
+    vec2 uv = curveUV(v_texcoord);
+    
+    // Black bezel for out-of-bounds
+    if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) {
+        fragColor = vec4(0.0, 0.0, 0.0, 1.0);
+        return;
+    }
+    
+    // FIXED: Clamp aberration samples to prevent edge artifacts
+    vec2 centerDist = uv - 0.5;
+    vec2 aberrOffset = centerDist * ABERRATION;
+    
+    // FIXED: Correct direction - red focuses short, blue focuses long
+    float r = texture(tex, clamp(uv + aberrOffset, 0.0, 1.0)).r;
+    float g = texture(tex, uv).g;
+    float b = texture(tex, clamp(uv - aberrOffset, 0.0, 1.0)).b;
+    vec3 color = vec3(r, g, b);
+    
+    // FIXED: Anti-aliased scanlines that don't shimmer during scroll
+    // Using smooth triangle wave instead of harsh sine
+    float scanlinePhase = uv.y * SCANLINE_COUNT * 2.0;
+    float scanline = abs(fract(scanlinePhase) - 0.5) * 2.0; // Triangle wave 0-1
+    scanline = smoothstep(0.0, 1.0, scanline); // Smooth it
+    float scanlineFactor = 1.0 - (SCANLINE_STRENGTH * (1.0 - scanline));
+    color *= scanlineFactor;
+    
+    // Subtle phosphor glow (brightens slightly between scanlines)
+    color += GLOW * (1.0 - scanline);
+    
+    // FIXED: Proper circular vignette with correct smoothstep bounds
+    float dist = length(centerDist) * 2.0; // 0 at center, ~1.414 at corners
+    float vignette = 1.0 - smoothstep(VIGNETTE_RADIUS, VIGNETTE_RADIUS + VIGNETTE_SOFTNESS, dist);
+    color *= vignette;
+    
+    // Subtle brightness boost to compensate for darkening effects
+    color *= 1.1;
+    
+    fragColor = vec4(clamp(color, 0.0, 1.0), 1.0);
+}

.config/hypr/shaders/05_sketch.glsl

@@ -0,0 +1,89 @@
+#version 300 es
+precision highp float;
+
+in vec2 v_texcoord;
+uniform sampler2D tex;
+out vec4 fragColor;
+
+// --- CONFIGURATION ---
+const float edge_threshold = 0.15;      // Sensitivity (0.05-0.5) - lower = more edges
+const float edge_softness = 0.08;       // Anti-aliasing amount
+const float line_thickness = 1.0;       // 1.0 = normal, 2.0 = thicker
+const float line_darkness = 0.05;       // 0.0 = pure black, higher = lighter
+const float paper_brightness = 0.98;    // Paper color
+const float paper_grain = 0.03;         // Paper texture intensity
+const float noise_reduction = 0.5;      // Reduces speckles in smooth areas
+// ---------------------
+
+float luminance(vec3 color) {
+    return dot(color, vec3(0.2126, 0.7152, 0.0722));
+}
+
+float hash12(vec2 p) {
+    vec3 p3 = fract(vec3(p.xyx) * 0.1031);
+    p3 += dot(p3, p3.yzx + 33.33);
+    return fract((p3.x + p3.y) * p3.z);
+}
+
+// Sample luminance with bounds checking
+float sampleLum(vec2 uv) {
+    vec2 safe_uv = clamp(uv, 0.0, 1.0);
+    return luminance(texture(tex, safe_uv).rgb);
+}
+
+void main() {
+    vec2 screen_res = vec2(textureSize(tex, 0));
+    vec2 pixel_size = line_thickness / screen_res;
+    vec2 pixel_coords = v_texcoord * screen_res;
+    
+    // Sobel kernel sampling with proper edge clamping
+    float tl = sampleLum(v_texcoord + vec2(-pixel_size.x, -pixel_size.y));
+    float t  = sampleLum(v_texcoord + vec2( 0.0,          -pixel_size.y));
+    float tr = sampleLum(v_texcoord + vec2( pixel_size.x, -pixel_size.y));
+    float l  = sampleLum(v_texcoord + vec2(-pixel_size.x,  0.0));
+    float c  = sampleLum(v_texcoord);  // Center pixel
+    float r  = sampleLum(v_texcoord + vec2( pixel_size.x,  0.0));
+    float bl = sampleLum(v_texcoord + vec2(-pixel_size.x,  pixel_size.y));
+    float b  = sampleLum(v_texcoord + vec2( 0.0,           pixel_size.y));
+    float br = sampleLum(v_texcoord + vec2( pixel_size.x,  pixel_size.y));
+    
+    // Sobel operators
+    float Gx = (tr + 2.0 * r + br) - (tl + 2.0 * l + bl);
+    float Gy = (bl + 2.0 * b + br) - (tl + 2.0 * t + tr);
+    float gradient = sqrt(Gx * Gx + Gy * Gy);
+    
+    // Calculate local variance for noise reduction
+    // (reduces speckles in smooth areas while preserving real edges)
+    float mean = (tl + t + tr + l + c + r + bl + b + br) / 9.0;
+    float variance = 0.0;
+    variance += (tl - mean) * (tl - mean);
+    variance += (t - mean) * (t - mean);
+    variance += (tr - mean) * (tr - mean);
+    variance += (l - mean) * (l - mean);
+    variance += (c - mean) * (c - mean);
+    variance += (r - mean) * (r - mean);
+    variance += (bl - mean) * (bl - mean);
+    variance += (b - mean) * (b - mean);
+    variance += (br - mean) * (br - mean);
+    variance = sqrt(variance / 9.0);
+    
+    // Adaptive threshold: require stronger edges in noisy areas
+    float adaptive_threshold = edge_threshold + variance * noise_reduction;
+    
+    // Smooth edge detection (anti-aliased)
+    float edge = smoothstep(
+        adaptive_threshold - edge_softness,
+        adaptive_threshold + edge_softness,
+        gradient
+    );
+    
+    // Paper texture
+    float paper = paper_brightness;
+    paper -= hash12(pixel_coords * 0.4) * paper_grain;
+    paper -= hash12(pixel_coords * 2.1) * paper_grain * 0.4;
+    
+    // Final blend
+    float final_value = mix(paper, line_darkness, edge);
+    
+    fragColor = vec4(vec3(final_value), 1.0);
+}

.config/hypr/shaders/06_wobble.glsl

@@ -0,0 +1,72 @@
+#version 300 es
+precision highp float;
+
+in vec2 v_texcoord;
+uniform sampler2D tex;
+uniform float TIME;
+out vec4 fragColor;
+
+// --- CONFIGURATION ---
+const float wobble_speed = 3.0;         // Animation speed
+const float wobble_frequency = 15.0;    // Wave density
+const float wobble_amplitude = 0.025;   // Displacement amount
+const float edge_fade = 0.1;            // Fade near edges (0.0 to disable)
+const bool  organic_motion = true;      // Multi-frequency for natural look
+const bool  prevent_edge_artifacts = true;
+// ---------------------
+
+void main() {
+    // Use local time to prevent floating point precision issues with large TIME values
+    float t = mod(TIME, 628.318);  // Wrap at 2*PI*100
+    
+    vec2 new_uv = v_texcoord;
+    
+    // Calculate edge fade mask (reduces artifacts at screen borders)
+    float edge_mask = 1.0;
+    if (edge_fade > 0.0) {
+        vec2 dist_to_edge = min(v_texcoord, 1.0 - v_texcoord);
+        float min_dist = min(dist_to_edge.x, dist_to_edge.y);
+        edge_mask = smoothstep(0.0, edge_fade, min_dist);
+    }
+    
+    float amplitude = wobble_amplitude * edge_mask;
+    
+    float h_offset, v_offset;
+    
+    if (organic_motion) {
+        // Layer multiple frequencies for organic, natural motion
+        // Different speeds prevent repetitive patterns
+        
+        // Horizontal wobble (based on Y position)
+        h_offset = 0.0;
+        h_offset += sin(v_texcoord.y * wobble_frequency * 1.0 + t * wobble_speed * 1.00) * 0.50;
+        h_offset += sin(v_texcoord.y * wobble_frequency * 2.1 + t * wobble_speed * 1.37) * 0.30;
+        h_offset += sin(v_texcoord.y * wobble_frequency * 0.5 + t * wobble_speed * 0.71) * 0.20;
+        
+        // Vertical wobble (based on X position)
+        v_offset = 0.0;
+        v_offset += cos(v_texcoord.x * wobble_frequency * 0.9 + t * wobble_speed * 1.13) * 0.50;
+        v_offset += cos(v_texcoord.x * wobble_frequency * 1.7 + t * wobble_speed * 0.83) * 0.30;
+        v_offset += cos(v_texcoord.x * wobble_frequency * 0.4 + t * wobble_speed * 1.41) * 0.20;
+        
+        // Add subtle interaction between axes
+        h_offset += sin(v_texcoord.x * wobble_frequency * 0.3 + t * wobble_speed * 0.5) * 0.1;
+        v_offset += cos(v_texcoord.y * wobble_frequency * 0.3 + t * wobble_speed * 0.6) * 0.1;
+        
+    } else {
+        // Simple single-frequency wobble
+        h_offset = sin(v_texcoord.y * wobble_frequency + t * wobble_speed);
+        v_offset = cos(v_texcoord.x * wobble_frequency + t * wobble_speed);
+    }
+    
+    new_uv.x += h_offset * amplitude;
+    new_uv.y += v_offset * amplitude;
+    
+    // Prevent sampling outside texture bounds
+    if (prevent_edge_artifacts) {
+        // Clamp with small margin to prevent edge bleeding
+        new_uv = clamp(new_uv, 0.002, 0.998);
+    }
+    
+    fragColor = texture(tex, new_uv);
+}

.config/hypr/shaders/07_chromatic_aberration.glsl

@@ -0,0 +1,43 @@
+#version 300 es
+// Chromatic Aberration Shader for Hyprland - OPTIMIZED
+// Fixes: Edge clamping, aspect ratio correction, quadratic falloff
+
+precision highp float;
+
+in vec2 v_texcoord;
+uniform sampler2D tex;
+out vec4 fragColor;
+
+// --- CONFIGURATION ---
+const float STRENGTH = 0.010;
+// Set to your monitor's aspect ratio (16/9, 21/9, etc.) or use 1.0 for uncorrected
+const float ASPECT_RATIO = 16.0 / 9.0;
+// Use quadratic falloff for more realistic lens distortion
+const bool QUADRATIC_FALLOFF = true;
+
+void main() {
+    // Aspect-corrected center distance
+    vec2 distFromCenter = v_texcoord - 0.5;
+    distFromCenter.x *= ASPECT_RATIO;
+    
+    // Calculate offset magnitude
+    float dist = length(distFromCenter);
+    float falloff = QUADRATIC_FALLOFF ? dist * dist : dist;
+    
+    // Normalize direction and apply strength
+    vec2 dir = normalize(distFromCenter + 0.0001); // Prevent div by zero
+    vec2 offset = dir * falloff * STRENGTH;
+    offset.x /= ASPECT_RATIO; // Correct back for sampling
+    
+    // Sample with clamped coordinates to prevent edge artifacts
+    vec2 redCoord = clamp(v_texcoord - offset, 0.0, 1.0);
+    vec2 blueCoord = clamp(v_texcoord + offset, 0.0, 1.0);
+    
+    float r = texture(tex, redCoord).r;
+    vec4 centerPixel = texture(tex, v_texcoord);
+    float g = centerPixel.g;
+    float b = texture(tex, blueCoord).b;
+
+    // Preserve alpha from center sample
+    fragColor = vec4(r, g, b, centerPixel.a);
+}

.config/hypr/shaders/08_newspaper.glsl

@@ -0,0 +1,114 @@
+#version 300 es
+precision highp float;  // CRITICAL: Prevents many artifacts
+
+in vec2 v_texcoord;
+uniform sampler2D tex;
+out vec4 fragColor;
+
+// --- CONFIGURATION ---
+const float dot_spacing = 4.0;          // 3.0-6.0 recommended
+const int   color_levels = 4;           // Posterization levels
+const vec3  paper_color = vec3(0.95, 0.92, 0.85);
+const float paper_texture_strength = 0.04;
+const float dot_softness = 1.5;         // Higher = softer dot edges (anti-aliasing)
+const float ink_darkness = 0.95;        // How dark the ink appears (0.0-1.0)
+const bool  use_dithering = true;       // Reduces posterization banding
+// ---------------------
+
+// Improved hash function - less pattern artifacts than sin-based
+float hash12(vec2 p) {
+    vec3 p3 = fract(vec3(p.xyx) * 0.1031);
+    p3 += dot(p3, p3.yzx + 33.33);
+    return fract((p3.x + p3.y) * p3.z);
+}
+
+// Smoother 2D noise for paper texture
+float valueNoise(vec2 p) {
+    vec2 i = floor(p);
+    vec2 f = fract(p);
+    
+    // Smooth interpolation
+    vec2 u = f * f * (3.0 - 2.0 * f);
+    
+    float a = hash12(i);
+    float b = hash12(i + vec2(1.0, 0.0));
+    float c = hash12(i + vec2(0.0, 1.0));
+    float d = hash12(i + vec2(1.0, 1.0));
+    
+    return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
+}
+
+float luminance(vec3 color) {
+    return dot(color, vec3(0.2126, 0.7152, 0.0722));
+}
+
+// Bayer 4x4 dithering matrix - reduces posterization banding
+float bayerDither(vec2 pos) {
+    ivec2 p = ivec2(mod(pos, 4.0));
+    int index = p.x + p.y * 4;
+    
+    // Bayer matrix values
+    float matrix[16] = float[16](
+         0.0,  8.0,  2.0, 10.0,
+        12.0,  4.0, 14.0,  6.0,
+         3.0, 11.0,  1.0,  9.0,
+        15.0,  7.0, 13.0,  5.0
+    );
+    
+    return (matrix[index] / 16.0) - 0.5;
+}
+
+void main() {
+    vec2 screen_res = vec2(textureSize(tex, 0));
+    vec2 pixel_coords = v_texcoord * screen_res;
+    
+    // 1. Sample original with clamped coordinates (prevents edge artifacts)
+    vec2 safe_uv = clamp(v_texcoord, 0.0, 1.0);
+    vec3 original_color = texture(tex, safe_uv).rgb;
+    
+    // 2. Posterize with optional dithering to reduce banding
+    float levels = float(color_levels);
+    vec3 posterized_color;
+    
+    if (use_dithering) {
+        // Add dither before quantization
+        float dither = bayerDither(pixel_coords) / (levels * 2.0);
+        posterized_color = floor((original_color + dither) * levels) / (levels - 1.0);
+    } else {
+        posterized_color = floor(original_color * levels) / (levels - 1.0);
+    }
+    posterized_color = clamp(posterized_color, 0.0, 1.0);
+    
+    // 3. Create layered paper texture (more natural looking)
+    float paper_noise = 0.0;
+    paper_noise += valueNoise(pixel_coords * 0.5) * 0.6;           // Large grain
+    paper_noise += valueNoise(pixel_coords * 1.5) * 0.3;           // Medium grain  
+    paper_noise += hash12(pixel_coords) * 0.1;                      // Fine grain
+    paper_noise *= paper_texture_strength;
+    
+    vec3 textured_paper = max(paper_color - paper_noise, 0.0);     // Prevent negative
+    
+    // 4. Create halftone grid
+    vec2 cell_coords = pixel_coords / dot_spacing;
+    vec2 grid_uv = fract(cell_coords);
+    
+    // 5. Calculate halftone dot
+    // Use sqrt for area-proportional dots (perceptually correct)
+    float lum = luminance(posterized_color);
+    float darkness = 1.0 - lum;
+    float dot_radius = sqrt(darkness) * 0.5;  // Area proportional to darkness
+    
+    // Distance from cell center
+    float dist = length(grid_uv - 0.5);
+    
+    // Anti-aliased dot edge using screen-space derivatives
+    // This adapts to any resolution automatically
+    float pixel_width = fwidth(dist) * dot_softness;
+    float dot_mask = smoothstep(dot_radius - pixel_width, dot_radius + pixel_width, dist);
+    
+    // 6. Combine: ink color where dots are, paper elsewhere
+    vec3 ink_color = posterized_color * ink_darkness;
+    vec3 final_color = mix(ink_color, textured_paper, dot_mask);
+    
+    fragColor = vec4(final_color, 1.0);
+}

.config/hypr/shaders/09_pixelated.glsl

@@ -0,0 +1,28 @@
+#version 300 es
+// Pixelation Shader - OPTIMIZED
+// Fixes: Sample from pixel CENTER (not corner), aspect ratio support
+
+precision highp float;
+
+in vec2 v_texcoord;
+uniform sampler2D tex;
+out vec4 fragColor;
+
+// --- CONFIGURATION ---
+// Pixels across the shorter dimension (height usually)
+const float PIXEL_COUNT = 350.0;
+// Set to your aspect ratio, or 1.0 for square pixels
+const float ASPECT_RATIO = 16.0 / 9.0;
+
+void main() {
+    // Calculate pixel dimensions accounting for aspect ratio
+    vec2 pixelCount = vec2(PIXEL_COUNT * ASPECT_RATIO, PIXEL_COUNT);
+    vec2 pixelSize = 1.0 / pixelCount;
+    
+    // FIXED: Sample from pixel CENTER, not corner
+    // This prevents the "swimming" artifact when content moves
+    vec2 pixelCoord = floor(v_texcoord * pixelCount) + 0.5;
+    vec2 sampleCoord = pixelCoord / pixelCount;
+    
+    fragColor = texture(tex, sampleCoord);
+}

.config/hypr/shaders/10_grayscale.glsl

@@ -0,0 +1,40 @@
+#version 300 es
+// Grayscale Shader for Hyprland - OPTIMIZED
+// Added: Optional gamma-correct conversion for accurate luminance
+
+precision highp float;
+
+in vec2 v_texcoord;
+uniform sampler2D tex;
+out vec4 fragColor;
+
+// Rec. 709 Luma coefficients (sRGB/HDTV standard)
+const vec3 LUMA_709 = vec3(0.2126, 0.7152, 0.0722);
+
+// Set to true for gamma-correct grayscale (more accurate but slightly slower)
+const bool GAMMA_CORRECT = false;
+
+// sRGB gamma functions
+float toLinear(float c) {
+    return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4);
+}
+float toSRGB(float c) {
+    return c <= 0.0031308 ? c * 12.92 : 1.055 * pow(c, 1.0/2.4) - 0.055;
+}
+
+void main() {
+    vec4 pixColor = texture(tex, v_texcoord);
+    
+    float gray;
+    if (GAMMA_CORRECT) {
+        // Convert to linear space, compute luminance, convert back
+        vec3 linear = vec3(toLinear(pixColor.r), toLinear(pixColor.g), toLinear(pixColor.b));
+        float luminance = dot(linear, LUMA_709);
+        gray = toSRGB(luminance);
+    } else {
+        // Fast path: direct computation in gamma space
+        gray = dot(pixColor.rgb, LUMA_709);
+    }
+
+    fragColor = vec4(vec3(gray), pixColor.a);
+}

.config/hypr/shaders/11_invert.glsl

@@ -0,0 +1,30 @@
+#version 300 es
+// Invert Colors Shader - OPTIMIZED
+// Added: Optional luminance-preserving mode
+
+precision highp float;
+
+in vec2 v_texcoord;
+uniform sampler2D tex;
+out vec4 fragColor;
+
+// Set true for "smart invert" that preserves relative brightness
+const bool PRESERVE_LUMINANCE = false;
+const vec3 LUMA = vec3(0.2126, 0.7152, 0.0722);
+
+void main() {
+    vec4 color = texture(tex, v_texcoord);
+    vec3 inverted = 1.0 - color.rgb;
+    
+    if (PRESERVE_LUMINANCE) {
+        // Adjust inverted colors to match original luminance
+        float origLuma = dot(color.rgb, LUMA);
+        float invLuma = dot(inverted, LUMA);
+        if (invLuma > 0.001) {
+            inverted *= origLuma / invLuma;
+            inverted = clamp(inverted, 0.0, 1.0);
+        }
+    }
+    
+    fragColor = vec4(inverted, color.a);
+}

.config/hypr/shaders/12_posterization.glsl

@@ -0,0 +1,39 @@
+#version 300 es
+// Posterization Shader - OPTIMIZED
+// Fixes: Proper rounding, optional dithering to reduce banding
+
+precision highp float;
+
+in vec2 v_texcoord;
+uniform sampler2D tex;
+out vec4 fragColor;
+
+// --- CONFIGURATION ---
+const float COLOR_LEVELS = 4.0;
+// Enable dithering to reduce visible banding
+const bool DITHER = true;
+
+// Simple dither pattern
+float dither(vec2 pos) {
+    // 4x4 Bayer matrix approximation
+    vec2 p = fract(pos * 0.5);
+    float d = fract(dot(p, vec2(0.75, 0.5)));
+    return (d - 0.5) / COLOR_LEVELS;
+}
+
+void main() {
+    vec4 color = texture(tex, v_texcoord);
+    
+    vec3 posterized;
+    if (DITHER) {
+        // Add dither noise before quantization
+        float ditherValue = dither(gl_FragCoord.xy);
+        posterized = floor((color.rgb + ditherValue) * COLOR_LEVELS + 0.5) / COLOR_LEVELS;
+    } else {
+        // FIXED: Use round() behavior instead of floor() for better color accuracy
+        posterized = floor(color.rgb * COLOR_LEVELS + 0.5) / COLOR_LEVELS;
+    }
+    
+    posterized = clamp(posterized, 0.0, 1.0);
+    fragColor = vec4(posterized, color.a);
+}

.config/hypr/shaders/13_sepia.glsl

@@ -0,0 +1,33 @@
+#version 300 es
+// Sepia Tone Shader - OPTIMIZED
+// Fixes: Clamping to prevent overflow on bright pixels
+
+precision highp float;
+
+in vec2 v_texcoord;
+uniform sampler2D tex;
+out vec4 fragColor;
+
+// W3C standard Sepia Matrix (column-major for GLSL)
+const mat3 SEPIA_MATRIX = mat3(
+    0.393, 0.769, 0.189,  // Red output weights
+    0.349, 0.686, 0.168,  // Green output weights
+    0.272, 0.534, 0.131   // Blue output weights
+);
+
+// Sepia intensity (0.0 = no effect, 1.0 = full sepia)
+const float INTENSITY = 1.0;
+
+void main() {
+    vec4 color = texture(tex, v_texcoord);
+    
+    vec3 sepia = color.rgb * SEPIA_MATRIX;
+    
+    // FIXED: Clamp to prevent overflow artifacts on bright pixels
+    sepia = clamp(sepia, 0.0, 1.0);
+    
+    // Optional: blend with original for partial effect
+    vec3 final = mix(color.rgb, sepia, INTENSITY);
+    
+    fragColor = vec4(final, color.a);
+}

.config/hypr/shaders/14_vibrance.glsl

@@ -0,0 +1,37 @@
+#version 300 es
+// Vignette Shader - OPTIMIZED  
+// Fixes: Aspect ratio correction for circular vignette, safe smoothstep bounds
+
+precision highp float;
+
+in vec2 v_texcoord;
+uniform sampler2D tex;
+out vec4 fragColor;
+
+// --- CONFIGURATION ---
+const float RADIUS = 0.65;
+const float SOFTNESS = 0.45;
+const float STRENGTH = 0.5;
+// Set to your monitor's aspect ratio for circular vignette
+const float ASPECT_RATIO = 16.0 / 9.0;
+
+void main() {
+    vec4 color = texture(tex, v_texcoord);
+    
+    // FIXED: Aspect-corrected distance for circular (not elliptical) vignette
+    vec2 centered = v_texcoord - 0.5;
+    centered.x *= ASPECT_RATIO;
+    float dist = length(centered);
+    // Normalize so corner distance is ~1.0 regardless of aspect ratio
+    dist /= length(vec2(ASPECT_RATIO * 0.5, 0.5));
+    
+    // FIXED: Ensure smoothstep has valid bounds (edge1 > edge0)
+    float innerEdge = RADIUS;
+    float outerEdge = RADIUS + SOFTNESS;
+    float vignette = 1.0 - smoothstep(innerEdge, outerEdge, dist);
+    
+    // Apply with strength control
+    color.rgb = mix(color.rgb, color.rgb * vignette, STRENGTH);
+    
+    fragColor = color;
+}

.config/hypr/shaders/15_anaglyph_3d.glsl

@@ -0,0 +1,35 @@
+#version 300 es
+// Anaglyph 3D Shader - OPTIMIZED
+// Fixes: Edge clamping, alpha preservation, depth-aware separation
+
+precision highp float;
+
+in vec2 v_texcoord;
+uniform sampler2D tex;
+out vec4 fragColor;
+
+// --- CONFIGURATION ---
+const float SEPARATION = 0.003;
+// Make separation stronger at edges (simulates depth from screen curvature)
+const bool DEPTH_AWARE = true;
+
+void main() {
+    vec2 offset = vec2(SEPARATION, 0.0);
+    
+    // Optional: Increase separation toward screen edges for more depth
+    if (DEPTH_AWARE) {
+        float edgeFactor = abs(v_texcoord.x - 0.5) * 2.0; // 0 at center, 1 at edges
+        offset.x *= 1.0 + edgeFactor * 0.5;
+    }
+    
+    // Clamp coordinates to prevent edge sampling artifacts
+    vec2 leftCoord = clamp(v_texcoord - offset, 0.0, 1.0);
+    vec2 rightCoord = clamp(v_texcoord + offset, 0.0, 1.0);
+    
+    vec4 leftEye = texture(tex, leftCoord);
+    vec4 rightEye = texture(tex, rightCoord);
+    vec4 center = texture(tex, v_texcoord);
+    
+    // Combine: Red from left, Cyan (GB) from right
+    fragColor = vec4(leftEye.r, rightEye.g, rightEye.b, center.a);
+}

.config/hypr/shaders/16_vignette.glsl

@@ -0,0 +1,37 @@
+#version 300 es
+// Vignette Shader for Hyprland
+// Description: Darkens the edges of the screen to draw focus to the center.
+// Uses smoothstep for a high-quality, organic falloff.
+
+precision highp float;
+
+in vec2 v_texcoord;
+uniform sampler2D tex;
+out vec4 fragColor;
+
+// --- CONFIGURATION ---
+// The radius where the darkening begins (0.0 is center, 0.8 is near corners)
+const float RADIUS = 0.85;
+// How soft the transition is (higher = smoother gradient)
+const float SOFTNESS = 0.85;
+// The strength of the darkness (0.0 = no vignette, 1.0 = pitch black corners)
+const float STRENGTH = 0.8;
+
+void main() {
+    // 1. Sample the original screen color
+    vec4 color = texture(tex, v_texcoord);
+
+    // 2. Calculate distance from center (0.5, 0.5)
+    float dist = distance(v_texcoord, vec2(0.5));
+
+    // 3. Calculate vignette factor using smoothstep for high-quality falloff
+    // We invert the smoothstep range so 1.0 is center and 0.0 is edges
+    float vignette = smoothstep(RADIUS, RADIUS - SOFTNESS, dist);
+
+    // 4. Apply the vignette strength
+    // Mix between the original color and the darkened version
+    // This allows us to control intensity without changing the geometry of the falloff
+    color.rgb = mix(color.rgb, color.rgb * vignette, STRENGTH);
+
+    fragColor = color;
+}

.config/hypr/shaders/vibrance.glsl

@@ -0,0 +1,40 @@
+#version 300 es
+// Saturation & Contrast Shader for Hyprland
+// Description: Allows fine-tuning of screen vibrancy and dynamic range.
+// Efficiently applies saturation followed by contrast.
+
+precision highp float;
+
+in vec2 v_texcoord;
+uniform sampler2D tex;
+out vec4 fragColor;
+
+// --- CONFIGURATION ---
+// 0.0 = Grayscale, 1.0 = Normal, 1.5 = Vibrant, 2.0 = Deep Fried
+const float SATURATION = 3.0;
+
+// 1.0 = Normal, 1.2 = High Contrast, 0.8 = Low Contrast (Faded)
+const float CONTRAST = 1.0;
+// ---------------------
+
+// Rec. 709 Luma coefficients for accurate saturation calculations
+const vec3 luma = vec3(0.2126, 0.7152, 0.0722);
+
+void main() {
+    // 1. Sample texture
+    vec4 color = texture(tex, v_texcoord);
+    
+    // 2. Apply Saturation
+    // Calculate the grayscale value (luminance)
+    float gray = dot(color.rgb, luma);
+    // Interpolate between grayscale and original color
+    vec3 satColor = mix(vec3(gray), color.rgb, SATURATION);
+    
+    // 3. Apply Contrast
+    // We shift color values so 0.5 is the "pivot" point.
+    // Values > 0.5 get pushed up, values < 0.5 get pushed down.
+    vec3 finalColor = (satColor - 0.5) * CONTRAST + 0.5;
+    
+    // 4. Output
+    fragColor = vec4(finalColor, color.a);
+}

.config/hypr/source/keybinds.conf

@@ -76,18 +76,24 @@ bind = $mainMod SHIFT, S, movetoworkspace, special:magic
 workspace = special:h, on-created-empty: $terminal
 bind = $mainMod SHIFT, Return, togglespecialworkspace, h
 
-# Screen Rotate
-bindld = CTRL ALT, R, Rotate Screen Clockwise, exec,  hypr_screen_rotate.sh -90
-bindld = CTRL ALT SHIFT, R, Rotate Screen Anti-Clockwise, exec,  hypr_screen_rotate.sh +90
 
 # Accessibility: Zoom
 cursor:zoom_disable_aa = true
 # Zoom In
-binded = SUPER SHIFT, equal, Zoom In, exec, sh -c "hyprctl keyword cursor:zoom_factor \"$(hyprctl getoption cursor:zoom_factor | awk 'NR==1 {print $2 * 1.25}')\""
+binded = SUPER, equal, Zoom In, exec, sh -c "hyprctl keyword cursor:zoom_factor \"$(hyprctl getoption cursor:zoom_factor | awk 'NR==1 {print $2 * 1.25}')\""
 # Zoom Out
-binded = SUPER SHIFT, minus, Zoom Out, exec, sh -c "hyprctl keyword cursor:zoom_factor \"$(hyprctl getoption cursor:zoom_factor | awk 'NR==1 {val = $2 / 1.25; if (val < 1.0) val = 1.0; print val}')\""
+binded = SUPER, minus, Zoom Out, exec, sh -c "hyprctl keyword cursor:zoom_factor \"$(hyprctl getoption cursor:zoom_factor | awk 'NR==1 {val = $2 / 1.25; if (val < 1.0) val = 1.0; print val}')\""
 # Reset Zoom
-bindld = SUPER SHIFT, BACKSPACE, Reset Zoom, exec, hyprctl keyword cursor:zoom_factor 1.0
+bindld = SUPER, BACKSPACE, Reset Zoom, exec, hyprctl keyword cursor:zoom_factor 1.0
+
+# Screen Rotate
+bindld = $mainMod CTRL, comma, Rotate Screen Anti-Clockwise, exec,  hypr_screen_rotate.sh +90
+bindld = $mainMod CTRL, period, Rotate Screen Clockwise, exec,  hypr_screen_rotate.sh -90
+
+# --- Hyprshade (Visual Filters) ---
+bindd = $mainMod CTRL, S, Shader Menu, exec, hypr_shader_menu.sh
+bindld = $mainMod CTRL, X, Disable Shader, exec, hyprshade off
+bindld = $mainMod CTRL, V, Vibrant Shader, exec, hyprshade on vibrance
 
 # Scroll through existing workspaces with mainMod + scroll
 bind = $mainMod, mouse_down, workspace, e+1

.config/nvim/lazy-lock.json

@@ -23,6 +23,7 @@
   "mini.hipatterns": { "branch": "main", "commit": "add8d8abad602787377ec5d81f6b248605828e0f" },
   "mini.icons": { "branch": "main", "commit": "ff2e4f1d29f659cc2bad0f9256f2f6195c6b2428" },
   "mini.pairs": { "branch": "main", "commit": "d5a29b6254dad07757832db505ea5aeab9aad43a" },
+  "neopywal": { "branch": "master", "commit": "09188d79b45694141ec779d05cbcc75f994639d1" },
   "noice.nvim": { "branch": "main", "commit": "7bfd942445fb63089b59f97ca487d605e715f155" },
   "nui.nvim": { "branch": "main", "commit": "de740991c12411b663994b2860f1a4fd0937c130" },
   "nvim-lint": { "branch": "master", "commit": "c47b71d146a0b638f46672e6704c322369385df6" },

.config/nvim/lua/plugins/colorscheme.lua

@@ -1,12 +1,44 @@
 return {
-    {
+    -- {
-        "folke/tokyonight.nvim",
+    --     "folke/tokyonight.nvim",
+    --     opts = {
+    --         transparent = true,
+    --         styles = {
+    --             sidebars = "transparent",
+    --             floats = "transparent",
+    --         },
+    --     },
+    -- },
+
+    "RedsXDD/neopywal.nvim",
+    name = "neopywal",
+    lazy = false,
+    priority = 1000,
     opts = {
-            transparent = true,
+        transparent_background = true,
-            styles = {
+        plugins = {
-                sidebars = "transparent",
+            alpha = true,
-                floats = "transparent",
+            dashboard = false,
+            git_gutter = true,
+            indent_blankline = true,
+            lazy = true,
+            lazygit = true,
+            noice = false,
+            notify = true,
+            nvim_cmp = true,
+            mini = {
+                hipatterns = true,
+                indentscope = {
+                    enabled = false,
+                },
+                pick = true,
+                starter = true,
             },
         },
     },
+
+    config = function(_, opts)
+        require("neopywal").setup(opts)
+        vim.cmd.colorscheme("neopywal")
+    end,
 }

.config/tmux/tmux.conf

@@ -1,39 +1,13 @@
+# ================================
+# TMUX • Transparent Minimal Rice
+# ================================
 
-##### tmux.conf - tuned for Foot (Wayland) + preserve transparency + truecolor #####
+# -------- Keybinds ---------
-
-# responsiveness
-set -s escape-time 0
-set-option -g history-limit 5000
-
-# prefix
 unbind C-b
 set -g prefix2 C-s
 set -g prefix C-Space
-
-# numbering
-set -g base-index 1
-setw -g pane-base-index 1
-set -g renumber-windows on
-
-# reload quickly
 bind r source-file ~/.config/tmux/tmux.conf
 
-##### transparency & styles #####
-# let the terminal compositor handle the background (keeps transparency)
-set -g window-style 'bg=default'
-set -g window-active-style 'bg=default'
-set -g status-style 'bg=default'
-
-# default-terminal: use a screen-compatible value to avoid missing terminfo,
-# but tell tmux to pass 24-bit color capability for common terminal names
-set -g default-terminal "screen-256color"
-set -ga terminal-overrides ",screen-256color:Tc,foot:Tc,xterm-256color:Tc,alacritty:Tc"
-
-##### vi mode / copy #####
-set-window-option -g mode-keys vi
-bind -T copy-mode-vi v send-keys -X begin-selection
-bind -T copy-mode-vi y send-keys -X copy-pipe-and-cancel 'wl-copy'
-
 ##### keys #####
 bind h select-pane -L
 bind j select-pane -D
@@ -47,9 +21,53 @@ bind -r C-j resize-pane -D 5
 bind -r C-k resize-pane -U 5
 bind -r C-l resize-pane -R 5
 
-##### plugins (temporarily disable if debugging) #####
+# -------- General --------
-set -g @plugin 'tmux-plugins/tpm'
+set -g default-terminal "tmux-256color"
-# Tokyo Night can override bg — comment out while debugging
+set -ga terminal-overrides ",*:RGB"
-set -g @plugin 'fabioluciano/tmux-tokyo-night'
-run '~/.config/tmux/plugins/tpm/tpm'
 
+set -g mouse on
+set -g base-index 1
+setw -g pane-base-index 1
+set -g renumber-windows on
+set -sg escape-time 0
+set -g history-limit 50000
+setw -g mode-keys vi
+set -g focus-events on
+
+# -------- Transparency Everywhere --------
+set -g window-style 'bg=default'
+set -g window-active-style 'bg=default'
+set -g pane-border-style 'bg=default,fg=#7a7977'
+set -g pane-active-border-style 'bg=default,fg=#e4e1db'
+
+# -------- Status Bar (Transparent + Minimal) --------
+set -g status-position bottom
+set -g status-style 'bg=default,fg=#c8c5c1'
+
+set -g status-left-length 40
+set -g status-right-length 40
+
+# Left section with icons (FA)
+set -g status-left '#[fg=#c8c5c1]   #S  │ '
+
+# No right side (clean)
+set -g status-right ''
+
+# Window list clean & icon-styled
+setw -g window-status-format '#[fg=#a9a7a2]   #I:#W '
+setw -g window-status-current-format '#[fg=#e4e1db,bold]   #I:#W '
+
+setw -g window-status-separator ''
+
+# Message popup
+set -g message-style 'bg=default,fg=#d0ccc7,bold'
+set -g message-command-style 'bg=default,fg=#d0ccc7'
+
+# -------- Extra Clean Tweaks --------
+setw -g monitor-activity off
+set -g visual-activity off
+setw -g clock-mode-colour '#5fff5f'
+
+# -------- Optional: TPM --------
+# set -g @plugin 'tmux-plugins/tpm'
+# run '~/.tmux/plugins/tpm/tpm'

.config/waybar/config.jsonc

@@ -107,6 +107,7 @@
         "format-alt": "{icon} ",
         "format-good": "{icon} {capacity:3}%",
         "format-full": "{icon} {capacity:3}%",
+       "tooltip-format": "{timeTo}\nHealth: {health}%\nPower Draw: {power:.2f} W\nCycles: {cycles}\n\nLMB: Toggle Format\nRMB: Timeout Settings",
         "format-icons": [
             "",
             "",

.local/bin/hypr/hypr_shader_menu.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Check deps
+command -v fuzzel >/dev/null || { echo "fuzzel not found"; exit 1; }
+command -v hyprshade >/dev/null || { echo "hyprshade not found"; exit 1; }
+
+# Get shader list
+mapfile -t SHADERS < <(hyprshade ls)
+
+# Add "off" at top
+SHADERS=("off" "${SHADERS[@]}")
+
+# Show in fuzzel
+CHOICE=$(printf "%s\n" "${SHADERS[@]}" \
+    | fuzzel --dmenu --prompt "Hyprshade > " \
+    | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+
+# User cancelled
+[[ -z "$CHOICE" ]] && exit 0
+
+# Apply
+if [[ "$CHOICE" == "off" ]]; then
+    hyprshade off
+else
+    hyprshade on "$CHOICE"
+fi
+
+# Optional notification
+command -v notify-send >/dev/null && notify-send "Hyprshade" "Applied: $CHOICE"
+

.local/bin/waldl

@@ -33,7 +33,8 @@ atleast=1920x1080
 
 # the menu command used when no query is provided
 sh_menu () {
-	: | dmenu -p "search wallhaven: "
+	# : | dmenu -p "search wallhaven: "
+    fuzzel --lines=0 --dmenu -p "search wallhaven: "
 	# ROFI: comment the previous line and uncomment the next line for rofi
 	# rofi -dmenu -l 0 -p "search wallpapers"
 }

README.md

@@ -3,11 +3,6 @@
 <img src="https://github.com/krolyxon/dotfiles/blob/master/assets/fullscreen.png">
 <img src="https://github.com/krolyxon/dotfiles/blob/master/assets/fullscreen2.png">
 
-## prerequisites
-```bash
-sudo pacman -S git gum
-```
-
 ## Usage
 ```bash
 cd $HOME

install.sh

@@ -5,6 +5,9 @@ trap 'log WARN "Interrupted by user"; exit 130' INT
 INSTALL_STATUS="none"   # none | partial | complete | failed
 AUTO_YES=0
 
+#######################
+## Arguement Parsing ##
+#######################
 for arg in "$@"; do
     case "$arg" in
         --yes|--ci|--non-interactive)
@@ -38,24 +41,6 @@ if [[ "$EUID" -eq 0 ]]; then
     exit 1
 fi
 
-
-## Check if gum is installed
-if ! command -v gum >/dev/null 2>&1; then
-    echo "gum is required. Install it first."
-    exit 1
-fi
-
-## Check if git is installed
-if ! command -v git >/dev/null 2>&1; then
-    echo "git is required. Install it first."
-    exit 1
-fi
-
-
-currentDir="$(dirname "$(readlink -f "$0")")"
-cd "$currentDir"
-
-
 choose_packages() {
     local -n arr=$1
     gum choose --no-limit \
@@ -93,10 +78,23 @@ confirm() {
     gum confirm --default=false "$msg"
 }
 
+install_prerequisites() {
+    sudo pacman -S --needed --noconfirm stow gum git zsh
+}
+
+
 #################
 ## GATEKEEPING ##
 #################
 
+## Installs prerequisites
+log INFO "Installing prerequisites: "
+install_prerequisites
+
+currentDir="$(dirname "$(readlink -f "$0")")"
+cd "$currentDir"
+
+
 DISCLAIMER=$(gum style \
   --border double \
   --border-foreground 196 \
@@ -231,7 +229,7 @@ Proceed with system configuration (stow, shell)?"; then
 
     log INFO "Running stow..."
     stow . --no-folding \
-        && log INFO "✅ Dotfiles stowed with overwrite." \
+        && log INFO "Dotfiles stowed with overwrite." \
         || log ERROR "Stow failed"
     fi
 
@@ -247,7 +245,7 @@ Proceed with system configuration (stow, shell)?"; then
         log INFO "Skipping: zsh is already the default shell"
     fi
 else
-    log WARN "Aborted configuration, didn't configure anything"
+    log ERROR "Aborted stow, didn't configure or install anything"
     exit 1
 fi
 

packages/pkg_aur.sh

@@ -4,11 +4,12 @@
 export pkg_aur=(
     "envycontrol"
     "htop-vim"
+    "hyprshade"
     "jmtpfs"
     "keepmenu"
     "keyd-git"
     "zen-browser-bin"
     "python-pywal16"
-    "tokyonight-gtk-theme-git"
+    "yaru-icon-theme"
     "zsh-fast-syntax-highlighting-git"
 )

packages/pkg_dev_tools.sh

@@ -1,7 +1,6 @@
 #!/bin/env bash
 
 export pkg_dev_tools=(
-    "git"
     "neovim"
     "platformio-core"
     "tmux"

packages/pkg_utils.sh

@@ -27,7 +27,6 @@ export pkg_utils=(
     "ghostscript"
     "gobject-introspection"
     "gparted"
-    "grub"
     "gvfs"
     "gvfs-mtp"
     "imagemagick"
@@ -63,7 +62,6 @@ export pkg_utils=(
     "ripgrep"
     "rsync"
     "sshfs"
-    "stow"
     "tesseract"
     "transmission-cli"
     "noto-fonts"
@@ -72,7 +70,6 @@ export pkg_utils=(
     "ttf-jetbrains-mono-nerd"
     "tree"
     "unzip"
-    "waybar"
     "wget"
     "woff2-font-awesome"
     "wtype"
@@ -83,7 +80,6 @@ export pkg_utils=(
     "zathura-pdf-mupdf"
     "zip"
     "zola"
-    "zsh"
     "zsh-autosuggestions"
 )