DEV Community: ADEBI Châ-Fine Ayédoun

🚀 Hibernate Like a Boss on Arch/EndeavourOS with Dracut + Swapfile

ADEBI Châ-Fine Ayédoun — Thu, 14 Aug 2025 06:38:02 +0000

💡 Because sometimes you just wanna close the lid, go make noodles, and come back like nothing happened.

1️⃣ Check your RAM & plan the swap

Hibernation stores all your RAM into the swap.
Rule: swap size ≥ RAM × 1.2 (just to be safe).

Mine:

free -h

Mem:  7.6G total

👉 I’ll make a 9G swapfile.

2️⃣ Create the swapfile

Let’s make it, lock it, and enable it:

sudo fallocate -l 9G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

3️⃣ Make it permanent in `/etc/fstab`

echo '/swapfile none swap defaults 0 0' | sudo tee -a /etc/fstab

No more "oops my swap disappeared after reboot".

4️⃣ Grab the UUID and offset

The kernel needs to know where your swap lives:

# UUID of the partition containing swapfile
findmnt -no UUID -T /swapfile

# Offset of the swapfile
filefrag -v /swapfile | awk '{if($1=="0:"){print $4}}' | sed 's/\.\.//'

Write those down — we’ll need them in the GRUB step.

5️⃣ Tell GRUB about it

Edit /etc/default/grub:

sudo nano /etc/default/grub

Find:

GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"

Change to:

GRUB_CMDLINE_LINUX_DEFAULT="quiet splash resume=UUID=<your_uuid_here> resume_offset=<your_offset_here>"

Update GRUB:

sudo grub-mkconfig -o /boot/grub/grub.cfg

6️⃣ Teach Dracut to resume

Create /etc/dracut.conf.d/resume.conf:

echo 'add_dracutmodules+=" resume "' | sudo tee /etc/dracut.conf.d/resume.conf

Rebuild initramfs:

sudo dracut --regenerate-all --force

7️⃣ Test the magic ✨

sudo systemctl hibernate

If your PC powers off and comes back with everything exactly where you left it,
congratulations — you’re now a hibernation wizard 🧙‍♂️.

🔥 Bonus: Suspend-then-Hibernate

Suspend to RAM first, then hibernate after a delay (battery saver’s dream):

sudo mkdir -p /etc/systemd/sleep.conf.d
sudo nano /etc/systemd/sleep.conf.d/hibernate.conf

Put:

[Sleep]
HibernateDelaySec=30min

Run:

sudo systemctl suspend-then-hibernate

🏆 Done!

Now your Arch/EndeavourOS box can sleep like a cat 🐈 and wake up like it’s got super memory powers.

How to Install and Configure GLPI on Mx Linux (Debian base) (Apache, PHP, MariaDB)

ADEBI Châ-Fine Ayédoun — Wed, 28 May 2025 18:01:29 +0000

✅ 1. System Requirements & Packages

🔧 Install Apache, PHP, and MariaDB/MySQL:

sudo apt update
sudo apt install apache2 mariadb-server php php-mysql php-gd php-intl php-curl php-mbstring php-xml php-bz2 php-zip unzip wget

🔧 Enable the required Apache modules:

sudo a2enmod rewrite
sudo systemctl restart apache2

✅ 2. Download and Install GLPI

cd /tmp
wget https://github.com/glpi-project/glpi/releases/download/10.0.14/glpi-10.0.14.tgz
tar -xvzf glpi-10.0.14.tgz
sudo mv glpi /var/www/
sudo chown -R www-data:www-data /var/www/glpi

✅ 3. Apache Configuration

Create a configuration file for the VirtualHost:

sudo nano /etc/apache2/sites-available/glpi.conf

Paste the following:

<VirtualHost *:80>
    ServerName glpi.localhost

    DocumentRoot /var/www/glpi/public

    <Directory /var/www/glpi/public>
        Require all granted
        AllowOverride All

        RewriteEngine On

        RewriteCond %{HTTP:Authorization} ^(.+)$
        RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]

        RewriteCond %{REQUEST_FILENAME} !-f
        RewriteRule ^(.*)$ index.php [QSA,L]
    </Directory>
</VirtualHost>

Enable the site:

sudo a2ensite glpi.conf
sudo systemctl reload apache2

✅ 4. Edit `/etc/hosts`

Add this domain for local development:

sudo nano /etc/hosts

Add the following line:

127.0.0.1 glpi.localhost

✅ 5. Database Configuration

Start MySQL and create the database and user:

sudo mysql -u root -p

In the MySQL terminal:

CREATE DATABASE glpidb CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'glpiuser'@'localhost' IDENTIFIED BY 'strongpassword';
GRANT ALL PRIVILEGES ON glpidb.* TO 'glpiuser'@'localhost';
FLUSH PRIVILEGES;
EXIT;

✅ 6. Access via Browser

Open your browser and go to:

http://glpi.localhost

You should see the GLPI installer 🎉

✅ Fixing the GLPI `session.cookie_httponly` warning:

Open the PHP configuration file:

Depending on your PHP version, the file might be:

   sudo nano /etc/php/8.2/apache2/php.ini

Replace 8.2 with your actual version if different. You can check it with:

   php -v

Search for the following line: Press Ctrl + W and type:

   session.cookie_httponly

Edit or add the following line:

   session.cookie_httponly = On

Save and exit (Ctrl + O, then Enter, then Ctrl + X)
Restart Apache to apply the changes:

   sudo systemctl restart apache2

✅ Verification

To make sure the directive is applied:

php -i | grep session.cookie_httponly

You should see:

session.cookie_httponly => On => On

🧙‍♂️ XBPS — The Gandalf of Package Managers on Void Linux

ADEBI Châ-Fine Ayédoun — Mon, 14 Apr 2025 18:39:51 +0000

Imagine a package manager that doesn’t talk to you like an old, dusty manpage, but moves like a ninja — silent, fast, and absolutely reliable. Meet XBPS (X Binary Package System), the unsung hero behind Void Linux that’ll make you go “damn, that’s smooth” every time you install something.

Welcome to the world of Void Linux, where we do things the Void way: no systemd, no bloat, just pure, clean power — and at the center of it all is XBPS, the little beast that makes everything run like a charm 🏎️.

🧬 Born and Bred in Void

XBPS wasn’t forked from apt or borrowed from pacman. Nope. It was built from scratch, in C, by the creators of Void Linux. Why? Because if you’re gonna build a whole distro from zero, might as well create your own package manager that actually gets your vibe.

XBPS is:

Fast ⚡
Lightweight like a single-window htop
Rock-solid like an i3wm setup after 48 hours of rice and grind

And best of all? It handles transactions, dependency hell, signature verification... all while making it look effortless.

🛠️ Commands You’ll Love (aka Your New Superpowers)

xbps-install – install anything you want, like a boss → sudo xbps-install neofetch to flex that setup
xbps-remove – uninstall cleanly, without leaving ghost files behind → sudo xbps-remove firefox (yeah we know you prefer qutebrowser 👀)
xbps-query – spy tool for everything package-related → xbps-query -l | grep emacs if you're that kind of hacker
xbps-install -Syu – full system upgrade, the Void way → no drama, just magic

🧠 The Smart Stuff Under the Hood

What makes XBPS really shine is its brain. It uses a transactional system: every install or removal is done atomically. If anything breaks mid-way, it rolls back like a pro. Your system doesn’t end up in a weird limbo with broken deps.

Plus, it verifies package signatures. So yeah, you’re protected from sketchy packages trying to sneak into your system like it’s the Wild West.

🔍 A Chill Example

sudo xbps-install cowsay fortune-mod

Then...

fortune | cowsay

Boom. Your terminal is now 27% funnier 🐮💬

And that’s the kind of stuff you do when your system is clean, fast, and rock-solid.

🚀 Why You’ll Love It (Even if You’ve Dated pacman or zypper)

🧼 It’s clean. No shady business.
⚡ It’s fast. Really fast.
🧘 It handles failure like a Zen master. Rolls back. Breathes. Tries again.
👑 It’s native to Void. Not bolted on like some afterthought.

XBPS is the kind of package manager that doesn’t scream for attention — but always delivers. You trust it. You rely on it. You lowkey brag about it.

📚 Wanna Dive Deeper?

Void Linux official docs – actually helpful, shocker!

💭 Final Thoughts

XBPS is like that quiet friend who always has the right command, the cleanest setup, and the patience to help you fix your system at 3AM after a “just one tweak” moment.

If you want a package manager that does the job without unnecessary noise, and fits perfectly in a techy-but-chill workflow — XBPS is your guy.

📝 Dev.to Post: "Bagels – A Logic Game in Python

ADEBI Châ-Fine Ayédoun — Wed, 19 Mar 2025 06:23:48 +0000

🎮 Bagels – A Logic Game in Python

Hey everyone! Today, I’m sharing a fun little Python project: Bagels, a deductive logic game. 🧠💡

The goal? Guess a secret 3-digit number within 10 attempts.

But instead of getting direct hints, you receive clues to help you figure out the correct number:

🟢 Game Rules:

Fermi → A digit is correct and in the right place ✅
Pico → A digit is correct but in the wrong place 🔄
Bagels → No correct digits ❌

Example:

If the secret number is "123" and you enter "132", you’ll see:

Fermi Pico Pico (1 is correct and in the right place, while 3 and 2 are correct but misplaced).

🚀 Source Code

Here’s the full implementation in Python:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
    Nom du fichier : bagels.py
    Description : Un jeu de déduction logique pour
    deviner un nombre secret à trois chiffres.
    Vous avez 10 chances pour deviner le nombre.
    - Pico -> Un chiffre correct, mauvaise position.
    - Fermi -> Un chiffre correct, bonne position.
    - Bagels -> Aucun chiffre correct.

    Auteur : ADEBI Ayedoun Châ-Fine achafine@gmail.com
    Date : 03/16/2025
"""

import random

# Constante
GUESSES = 10  # NOMBRE DE CHANCES
DIGIT_LEN = 3  # NOMBRE DE CHIFFRES DU NOMBRE
MENU = """
    Bagels, a deductive logic game.
    By ADEBI Ayedoun Châ-Fine achafine@gmail.com

    Je suis en train de penser à un nombre à 3 chiffres.
    Essais de deviner lequel.
    Voici quelques indices :
    Quand je dis:       Voici ce à quoi je pense:
        Pico            Un chiffre est correct mais à la mauvaise position
        Fermi           Un chiffre est correct et à la bonne position
        Bagels          Aucun des chiffres n'est correct
    Vous avez 10 essais :
"""


def generer_nombre_secret():
    """ Générer un nombre secret unique à trois chiffres
    sous forme de liste.
    """
    chiffres = list(range(1, 10))
    random.shuffle(chiffres)
    return [str(chiffres[i]) for i in range(DIGIT_LEN)]


def obtenir_indices(input_list, guess_number):
    """Comparer l'entrée utilisateur avec le nombre secret
    et retourne des indices.
    """
    result = []
    for i in range(len(input_list)):
        if input_list[i] == guess_number[i]:
            result.append("Fermi")
        elif input_list[i] in guess_number:
            result.append("Pico")
    return " ".join(result) if result else "Bagels"


def valide_saisie():
    """Gère l'entrée utilisateur, l'utilisateur doit entrer
    un nombre à trois chiffres"""
    while True:
        saisie = input("> ").strip()
        if len(saisie) == DIGIT_LEN and saisie.isdigit():
            return list(saisie)
        print("Entrée invalide, vous devez entrer un nombre à trois chiffres")


def main():
    """Boucle principale du jeu"""
    rejouer = ""
    while True:
        guess_number = generer_nombre_secret()
        for i in range(GUESSES):
            print("Devine #", i+1)
            input_nbre = valide_saisie()
            if input_nbre == guess_number:
                print("Vous l'avez trouvé")
                break
            else:
                print(obtenir_indices(input_nbre, guess_number))
        else:
            print("Game Over!")
        print("Voulez-vous encore jouer ?? (oui ou non)")
        while True:
            rejouer = input("> ").strip().lower()
            if rejouer in ["oui", "non"]:
                break
            else:
                print("Vous devez répondre par 'oui' ou 'non' ")
        if rejouer == "non":
            print("Merci d'avoir joué")
            break


if __name__ == "__main__":
    print(MENU)
    main()

🔍 Code Breakdown

The program generates a random 3-digit secret number.
The user enters a guess and receives a clue in return.
The game loops for up to 10 attempts or until the player finds the correct number.
At the end, the player can choose to replay or exit the game.

📌 How Can We Improve It?

I have a few ideas, but I’d love to hear your suggestions!

For example:

Add a hard mode where the secret number has no repeated digits.
Create a graphical version using Tkinter or Pygame.
Implement a multiplayer mode, where Player 1 sets a number and Player 2 tries to guess it.

What do you think? Any other improvements you'd suggest? 🚀

💬 Let me know in the comments if you tried the game or have any optimizations to propose!

📌 Follow me for more Python and development content!

👉 [Dev.to / GitHub / Twitter Profile]

Recursion, Tail Recursion, and Recursive Data Structures: A Deep Dive 😎💻

ADEBI Châ-Fine Ayédoun — Sun, 09 Mar 2025 22:51:56 +0000

Introduction

Recursion is one of those things that looks like a simple concept on paper but can quickly turn into a labyrinth of confusion 😵. Yet, it's one of the most powerful tools in a programmer's toolbox—if you know how to wield it properly 💪. In this article, we’ll dissect recursion, talk about its slightly more optimized cousin, tail recursion, and explore how recursion fits like a glove with recursive data structures. Grab your code editor, your thinking cap, and possibly a cup of coffee (or tea, or whatever helps you think ☕), because we’re about to get recursive 🔄.

What Is Recursion? (And Why Does It Keep Calling Itself? 🧐)

At its core, recursion is a function calling itself to solve smaller instances of a problem. It's like a Russian nesting doll—each smaller doll represents a smaller subproblem, and eventually, you hit a base case, which is your smallest doll (or, in the case of recursion, your "base case") 🪆.

How Does It Work?

Let’s start with a classic example: factorial. The factorial of a number n (denoted n!) is the product of all integers from 1 to n. So,

n! = n * (n - 1) * (n - 2) * ... * 1

In recursion, this would look something like:

def factorial(n):
if n == 0: # Base case
return 1
else:
return n * factorial(n - 1) # Recursive call

In this example, the function factorial calls itself with a smaller argument (n-1), and keeps going until n becomes 0, where it hits the base case and starts returning the results 🔁.

Base Case and Recursive Case: The Dynamic Duo 👯

Every recursive function has two key components:

Base Case: The condition that stops the recursion. Without it, you’ll end up with an infinite loop of function calls that end up crashing your program. Not great 😬.
Recursive Case: The part where the function calls itself with modified arguments to reduce the problem size. This is where the magic happens ✨.

The Dark Side of Recursion (aka Memory Problems 😱)

Recursion is amazing, but like a good superhero, it has its weaknesses. One of the main issues with recursion is memory consumption 💾. Each recursive call adds a new "layer" to the call stack, and if you recurse too deeply, you’ll get a stack overflow. It’s like trying to put one too many plates in the dishwasher—it'll break 🤯.

Tail Recursion: The Superhero of Recursion 🦸‍♂️💥

Now, imagine a world where recursion doesn’t add to the call stack like an overenthusiastic chef stacking dirty dishes 🥴. Enter tail recursion. This is where recursion becomes super efficient and can be optimized into an iterative process, saving you memory and processing power 🧠⚡.

What Makes Tail Recursion Special? 🤔

In tail recursion, the recursive call is the last thing that happens before the function returns a result. This allows compilers or interpreters to optimize the recursion by "reusing" the current function's stack frame, which makes the recursion behave more like an iteration—faster and less memory-hungry 🔥.

Here’s the factorial function, but optimized with tail recursion:

def factorial_tail(n, acc=1):
if n == 0:
return acc
else:
return factorial_tail(n - 1, acc * n)

Notice the difference? We’re passing along an accumulator (acc) to keep track of the result as we go. The function calls itself, but there's nothing left to do after the recursive call—this is the tail call. It’s a recursive function with a clear exit strategy! 🚪

Why Is Tail Recursion Better? 💡

In non-tail recursion, the function needs to remember all the previous calls, which makes the call stack grow 📈. Tail recursion allows the compiler or interpreter to optimize the process by reusing the current stack frame, so you can recalculate huge numbers without blowing up your memory 💣.

In short, tail recursion is like having your cake and eating it too 🎂. It gives you recursion’s elegance while still being efficient. Delicious, right? 😋

Recursive Data Structures: The Perfect Match for Recursion 🤝

Now, let’s talk about recursive data structures, because recursion and recursion-friendly data structures are like peanut butter and jelly 🥪. They go hand in hand. Some data structures are naturally recursive, which means they’re already structured in a way that makes them perfect for recursion 💯.

Linked Lists 📝

A linked list is a structure where each element (node) contains a reference to the next node. It’s recursive because each list is essentially a "list" of a single element followed by another list. Here’s a simple recursive traversal of a linked list:

def traverse_linked_list(node):
if node is None: # Base case: empty list
return
else:
print(node.value) # Process current node
traverse_linked_list(node.next) # Recursive call

Each node is like a mini-problem that points to a smaller problem (next node) 🔄. So, naturally, recursion fits like a glove 👌.

Binary Trees 🌳

Binary trees are another data structure that’s inherently recursive. Each node has two children (left and right), and those children are themselves trees. If you want to traverse or manipulate a tree, recursion is the most natural way to go. Here’s a simple depth-first search (DFS) traversal:

def traverse_tree(node):
if node is None:
return
print(node.value) # Process the current node
traverse_tree(node.left) # Recursive call on the left child
traverse_tree(node.right) # Recursive call on the right child

Each node's left and right children are smaller instances of the same tree, which makes recursion a perfect fit 🌱.

Graphs 🌐

Graphs are a bit more complex, but recursion still shines through ✨. Whether you’re performing depth-first search (DFS) or exploring connected components, recursion can handle traversals like a champ 🏆. If you know how to handle recursive traversal of trees, graph traversal isn’t far behind 🧑‍💻.

Why Are Recursive Data Structures So Recursion-Friendly? 🤷‍♂️

Well, they are recursive by definition. Each element of the structure points to another instance of the same thing, so solving a problem within them naturally involves breaking it down into smaller, similar subproblems. Recursion is the perfect method for that kind of breakdown 🔥.

Conclusion

Recursion is a tool that can make your code elegant, clean, and surprisingly powerful 💥. But, like all powerful tools, it requires understanding and caution 🧐. Enter tail recursion, which optimizes the whole process, and you get a supercharged version of recursion that’s both efficient and effective 🚀. When you add recursive data structures into the mix, recursion becomes the ultimate problem-solving technique 🏅.

So, the next time you’re faced with a problem that seems too complex to solve with a loop, ask yourself: "Can I break this down recursively?" And if the answer is "Yes," then you’re about to enter the wonderful, infinite (but not too infinite) world of recursion—where every call is just another layer of problem-solving goodness 🎉. Happy coding! 👨‍💻👩‍💻

🚀 Mastering Rofi in i3: A Cool & Fun Guide

ADEBI Châ-Fine Ayédoun — Fri, 27 Dec 2024 10:10:57 +0000

So, you've installed Rofi, jazzed it up with some sweet themes from adi1090x, and now you're ready to turn it into a powerful, futuristic multitool. Let’s dive into customizing your workflow with Rofi!

1️⃣ Install & Configure Rofi

Clone the repository for amazing pre-made themes:

   git clone https://github.com/adi1090x/rofi.git ~/rofi-themes

Navigate to the cloned directory:

   cd ~/rofi-themes

Run the setup script to install the themes:

   ./setup.sh

Choose your desired theme style during setup (light, dark, or custom). Themes are installed in ~/.config/rofi.

2️⃣ Make Rofi Pop with i3 Keybindings

Add the following to your i3 configuration file (~/.config/i3/config):

🔹 Launch Rofi in "drun" mode (app launcher):

bindsym $mod+d exec --no-startup-id rofi -show drun -theme ~/.config/rofi/config.rasi

🔹 Switch to "run" mode (execute commands):

bindsym $mod+r exec --no-startup-id rofi -show run -theme ~/.config/rofi/config.rasi

🔹 Switch to "window" mode (manage windows):

bindsym $mod+w exec --no-startup-id rofi -show window -theme ~/.config/rofi/config.rasi

🔹 Enable "file browser" mode (navigate files):

To browse files, ensure Rofi Scripts are installed from the adi1090x repo:

bindsym $mod+f exec --no-startup-id rofi -modi filebrowser -show filebrowser -theme ~/.config/rofi/config.rasi

Reload i3 ($mod+Shift+R) to apply these bindings.

3️⃣ Tips & Tricks for Using Rofi

💡 Switch Between Modes Dynamically

While in any mode (e.g., drun), type Ctrl+Tab to cycle through modes like:
- drun → App Launcher
- run → Command Runner
- window → Window Switcher
- filebrowser → File Manager

💡 Search Smarter in "drun" Mode

Search for apps by typing their name (e.g., fir for Firefox).
Use arrow keys to navigate and hit Enter to launch.

💡 Use "run" Mode Like a Pro

Type commands directly:
- htop → Launch system monitor.
- shutdown now → Turn off your system.
Rofi remembers past commands, making it quicker to access frequent ones.

💡 Master the "window" Mode

Quickly switch between open windows:
- Type part of the window name.
- Example: Type "term" to jump to an open terminal.

💡 Browse Files with Rofi (Filebrowser Mode)

Launch the file browser mode and navigate files using:
- Arrow keys → Navigate.
- Tab → Auto-complete.
- Enter → Open the file or directory.

4️⃣ Rofi Keyboard Shortcuts

Key	Function
Ctrl+Tab	Switch between modes (drun, run, etc.)
Enter	Select an option
Esc	Exit Rofi
Arrow Keys	Navigate the menu
Alt+Enter	Launch in a terminal (requires setup)

5️⃣ Customize Themes for a Futuristic Look

🔹 Edit a Theme:

Rofi themes are located in ~/.config/rofi. Open and tweak a theme:

nano ~/.config/rofi/config.rasi

🔹 Change Colors for Abstract Vibes:

Background: Neon with transparency:

  background: rgba(0, 0, 0, 0.8);

Highlight Selected Items:

  selected-background: #00FFAB;  /* Neon green */
  selected-foreground: #FFFFFF;

🔹 Rounded Corners:

Add modern rounded corners for a clean UI:

  border-radius: 10px;

6️⃣ Fun Rofi Ideas

Game Launcher:
- Bind $mod+g to launch Rofi with a custom list of games.
Spotify Control:
- Use Rofi to search and play songs with Rofi Spotify.
SSH Connection Manager:
- Add a mode to manage SSH connections for servers.
Calculator Mode:
- Add a script for quick calculations using Rofi.

Now you're all set to make Rofi your supertool in i3! 🎉 Feel free to experiment and share your favorite Rofi setups!

🌟 Ready to transform your desktop into a superpower? Let's get started! 🚀

ADEBI Châ-Fine Ayédoun — Fri, 27 Dec 2024 09:58:12 +0000

Part 1: Installing XFCE and i3

Step 1: Get Ready for Action - Install XFCE and i3

Before we begin, you need to install XFCE (a lightweight, awesome desktop) and i3 (a tiling window manager that’ll make you feel like a wizard). It’s simple:

For Ubuntu/Debian users:

Open up your terminal and type:

sudo apt update && sudo apt install i3 xfce4 xfce4-goodies

For Void Linux users:

Type this into the terminal to make your computer even cooler:

sudo xbps-install -S i3 xfce4 xfce4-goodies

Now, sit back and relax while the magic happens (aka, your system installs all the goodies).

Part 2: Let's Get to Work — Set Up i3 as the Window Manager

Alright, it’s time to do some wizardry and make i3 take control of your windows. 😎

Step 2: Tweak XFCE to Make i3 Your Window Manager

Log into XFCE first! If you're using a login manager like LightDM, select the XFCE session to log in.
Tell XFCE to Use i3:
We’re going to tell XFCE, "Hey, i3 is now in charge!":
Open a terminal and run this command:

   xfconf-query -c xfce4-session -p /sessions/Failsafe/Client0_Command -t string -s "i3" --create

Restart and See the Magic: Log out, then log back in. You’ll now see i3 taking charge with all the power of XFCE still backing it up. 😁

Part 3: Make it Look Cool — Wallpapers and Panels

Step 3: Set Your Wallpaper Like a Boss Using feh

We’re going to make your desktop look awesome with a wallpaper, using feh. It’s lightweight and fast—perfect for i3!

Install feh:
- Debian/Ubuntu:
```
 sudo apt install feh
```

Void Linux:
```
 sudo xbps-install -S feh
```

Set the Wallpaper: Now, we’re going to make your desktop look amazing:

   feh --bg-scale /path/to/your/wallpaper.jpg

(Replace /path/to/your/wallpaper.jpg with your wallpaper file’s location).

Make it Stick:
Want the wallpaper to stick around? We’ll make sure it shows up every time i3 starts:
- Open your i3 config file:
```
 nano ~/.config/i3/config
```

Add this line to the file:

 exec --no-startup-id feh --bg-scale /path/to/your/wallpaper.jpg

Save it, then reload i3 with Mod + Shift + R. Now you have the wallpaper forever!

Step 4: XFCE Panel — The Superhero of Your Desktop (Optional)

We’re going to bring the XFCE panel to life! 🎉

Open the XFCE Panel Preferences:

   xfce4-panel --preferences

Adjust the panel settings—move it, resize it, and add things like a clock, system tray, and application menu.
Autostart the Panel:
Let’s make sure the panel starts automatically when i3 does:
- Open your i3 config file:
```
 nano ~/.config/i3/config
```

Add this line to start the panel every time i3 launches:
```
 exec --no-startup-id xfce4-panel &
```

Save and reload i3, and you’ll have your XFCE panel right on top of i3. Cool, right? 😎

Part 4: Make i3 Even More Fun — Customizations

Step 5: Keybindings for i3 — Control Your World

Now, we’re going to make sure i3 listens to your every command. We’ll set up some cool keybindings for a smooth ride!

Open your i3 config file:

   nano ~/.config/i3/config

Add some sweet keybindings. Here are some to start:
- Open terminal with Mod + Enter:
```
 bindsym $mod+Return exec i3-sensible-terminal
```

Open Firefox with Mod + B:
```
 bindsym $mod+b exec firefox
```

Switch between windows (move your focus like a ninja):

 bindsym $mod+j focus left
 bindsym $mod+k focus down
 bindsym $mod+l focus up
 bindsym $mod+semicolon focus right

Save the file, and reload i3 (Mod + Shift + R). Now you’re ready to control your world with these shortcuts!

Step 6: i3 Gaps — Because Gaps are Cool

Want some extra space between your windows for that extra flair? Let’s install i3-gaps, the cool sibling of i3.

Install i3-gaps:
- Debian/Ubuntu:
```
 sudo apt install i3-gaps
```

Void Linux:
```
 sudo xbps-install -S i3-gaps
```

Set up your gaps: Open your i3 config file (~/.config/i3/config) and add this:

   gaps inner 10
   gaps outer 10

(Adjust the numbers for bigger/smaller gaps.)

Reload i3, and voilà! Your windows have sweet gaps between them.

Part 5: Extra Cool Tweaks — Because You’re a Power User Now

Step 7: Install Rofi — Your Stylish App Launcher

Want to launch apps like a pro? Let’s install Rofi!

Install Rofi:
- Debian/Ubuntu:
```
 sudo apt install rofi
```

Void Linux:
```
 sudo xbps-install -S rofi
```

Set it up in i3: Add this line to your i3 config file:

   bindsym $mod+d exec rofi -show drun

Reload i3, and now you have a super sleek app launcher! 🚀

Conclusion: You’re Now a Master of XFCE + i3! 🎉

Look at you now! You’ve set up i3 with XFCE, customized your desktop, and made it look awesome. You’re officially a Linux wizard! 🧙‍♂️✨

Feel free to explore and tweak more settings—because Linux is all about personalization. Have fun experimenting and making your setup unique. The possibilities are endless!

If you run into any roadblocks or just want to add something cool, come back to this guide anytime.

Happy Linuxing! 😎🎉

🎨 Customize Void Linux with Polybar, PulseAudio, pavucontrol, nm-applet, NetworkManager, i3, and feh

ADEBI Châ-Fine Ayédoun — Mon, 23 Dec 2024 11:34:52 +0000

Turn your Void Linux setup into a personalized masterpiece! In this tutorial, we’ll guide you through installing and configuring essential tools for a polished, productive, and eye-catching system.

🎯 What We’re Setting Up

Polybar: A sleek, customizable status bar.
PulseAudio and pavucontrol: Sound management made simple.
nm-applet and NetworkManager: A graphical tool for network connections.
i3 Window Manager: Lightweight and tiling for power users.
feh: Set and manage your wallpaper effortlessly.

🛠️ Prerequisites

A running Void Linux installation.
A terminal and root access.

🌟 Step 1: Install Required Packages

Update your package index:

sudo xbps-install -Syu

Install i3

sudo xbps-install -S i3

Install Polybar

sudo xbps-install -S polybar

Install PulseAudio and pavucontrol

sudo xbps-install -S pulseaudio pavucontrol

Install nm-applet and NetworkManager

sudo xbps-install -S network-manager-applet NetworkManager

Install feh

sudo xbps-install -S feh

⚙️ Step 2: Configure NetworkManager

Enable and start NetworkManager:

sudo ln -s /etc/sv/NetworkManager /var/service

Check if it's running:

sudo sv status NetworkManager

🎵 Step 3: Configure PulseAudio and Sound Control

Enable PulseAudio by adding the following to your .xinitrc (if you use startx):

pulseaudio --start &

Launch pavucontrol from your terminal or bind it to a key in your i3 config:

pavucontrol

📐 Step 4: Configure i3

Generate a Default Config

If you haven’t already, generate an i3 config file:

mkdir -p ~/.config/i3
cp /etc/i3/config ~/.config/i3/config

Add Startup Applications

Edit ~/.config/i3/config to autostart your tools:

exec --no-startup-id nm-applet &
exec --no-startup-id pulseaudio --start &
exec --no-startup-id feh --bg-scale ~/Pictures/wallpaper.jpg
exec --no-startup-id ~/.config/polybar/launch.sh

🖼️ Step 5: Set Up feh for Wallpapers

Place your desired wallpaper in ~/Pictures/.

Set it as your background:

feh --bg-scale ~/Pictures/wallpaper.jpg

Make this persistent by adding the command to your i3 config (as shown above).

📊 Step 6: Configure Polybar

Create a Configuration File

Generate the default Polybar config:

mkdir -p ~/.config/polybar
cp /usr/share/doc/polybar/config ~/.config/polybar/config

Launch Polybar

Create a launch script:

   nano ~/.config/polybar/launch.sh

Add:

   #!/bin/bash
   killall -q polybar
   polybar mybar &

Make it executable:

   chmod +x ~/.config/polybar/launch.sh

Run the script:

   ~/.config/polybar/launch.sh

🎨 Step 7: Personalize Polybar

Edit the ~/.config/polybar/config file to customize your bar. For example, add a volume module:

[module/volume]
type = internal/volume
format-volume = " %percentage%%"
format-muted = " Muted"

🚀 Step 8: Test Your Setup

Restart i3 with:

   $mod+Shift+R

Verify:
- i3 loads with your wallpaper.
- Polybar displays correctly.
- nm-applet appears in the tray.
- pavucontrol manages sound.

🎨 Final Touch: Make It Yours!

Experiment with i3 keybindings for productivity.
Customize Polybar themes from Polybar Themes GitHub.
Add modules for CPU, RAM, weather, or anything you fancy!

Enjoy your fully customized Void Linux environment! 🌌

🚀 Void Linux Base Installation: A Fun Adventure

ADEBI Châ-Fine Ayédoun — Mon, 23 Dec 2024 11:27:00 +0000

Welcome to the void! 🖤 This tutorial will guide you step by step through installing Void Linux, the lightweight and versatile distro that puts you in control. Let’s turn this challenge into a rewarding adventure!

🎯 Why Void Linux?

XBPS: A unique package manager that’s fast and efficient.
Runit: A lightweight init system for quicker boot times.
Minimalism: No bloat—only what you want.

🛠️ What You’ll Need

A 64-bit system.
A USB stick (4GB or more).
A good internet connection.
A cool head and a sense of adventure. 😎

🌟 Step 1: Download Void Linux ISO

Visit Void Linux Downloads.
Pick the Base Live ISO for your system architecture (usually x86_64).

Pro Tip: If you’re unsure about your system, the x86_64 version is your best bet.

💾 Step 2: Create a Bootable USB

Use a tool like Etcher, Rufus, or the command line:

   sudo dd if=void-live-x86_64-*.iso of=/dev/sdX bs=4M status=progress

Replace /dev/sdX with your USB device name.

Caution: Double-check the device name—dd doesn’t forgive mistakes! 😱

🚀 Step 3: Boot into the Void

Insert your USB and restart your computer.
Access your BIOS/UEFI settings and boot from the USB.
Choose the Void Linux option from the menu.

🖥️ Step 4: Partition Your Drive

Use cfdisk to partition your disk. Example:
- 1GB for /boot (EFI system if needed).
- Swap space (optional, 2GB+).
- Remaining space for /.
Format the partitions:

   mkfs.ext4 /dev/sdX1  # Replace with your partition
   mkfs.vfat -F 32 /dev/sdX2  # For EFI systems
   mkswap /dev/sdX3  # If you created a swap

📦 Step 5: Install Void Linux

Mount your partitions:

   mount /dev/sdX1 /mnt
   mkdir -p /mnt/boot/efi
   mount /dev/sdX2 /mnt/boot/efi
   swapon /dev/sdX3

Run the installer:

   void-installer

Follow the prompts to configure:
- Keyboard layout.
- Network settings.
- Hostname and user setup.
- Filesystem configuration.

⚙️ Step 6: Install Bootloader

Select GRUB during the installer setup.
Run:

   grub-install --target=x86_64-efi --efi-directory=/mnt/boot/efi --bootloader-id=void_grub
   grub-mkconfig -o /mnt/boot/grub/grub.cfg

🎉 Step 7: Reboot and Enjoy

Exit the installer and unmount partitions:

   umount -R /mnt
   reboot

Remove the USB stick during reboot.

Welcome to the Void! 🌌

🤓 Post-Installation Tips

Update the system:

   sudo xbps-install -Syu

Install essential tools:

   sudo xbps-install -S vim git base-devel

Explore and customize your environment (window manager, dotfiles, etc.).

📚 Resources

Feel free to share your journey to the void or ask for help! 🎩

🐍🎉 Fun and Comprehensive Guide to Installing and Setting Up Anaconda, AIMA Python, and Jupyter Notebook! 🎓📒

ADEBI Châ-Fine Ayédoun — Mon, 23 Dec 2024 03:23:51 +0000

Welcome, Python adventurer! 🚀 Ready to supercharge your data science, AI, and machine learning journey? Let’s dive into setting up Anaconda, installing AIMA Python, and mastering Jupyter Notebook. No boring steps here—just fun, functional, and fabulous learning! 🤓💡

🛠️ Prerequisites

Before we start, ensure you have:

A laptop or PC 🖥️ (Linux, Windows, or macOS—all are welcome!).
A stable internet connection 🌐.
Some coffee ☕ or snacks 🍪 because coding is better fueled.

Step 1: 🚀 Installing Anaconda

Anaconda is your one-stop shop for Python, libraries, and environments. Here's how to install it:

1️⃣ Download Anaconda

Go to Anaconda's download page.
Choose your OS (Windows/Linux/macOS) and download the installer.

2️⃣ Install Anaconda

Windows/macOS: Double-click the installer and follow the wizard.
Linux: Open a terminal, navigate to the download folder, and run:

  bash Anaconda3*.sh

Follow the prompts (keep pressing Enter, say yes when it asks!).

3️⃣ Test Installation

After installation, restart your terminal and type:

conda --version

🎉 If you see something like conda 23.x.x, you're golden!

Step 2: 🐍 Setting Up a Python Environment

Anaconda makes it easy to create isolated environments for projects.

1️⃣ Create a New Environment

Run:

conda create -n aima python=3.9 -y

-n aima: Creates an environment named aima.
python=3.9: Specifies Python 3.9.

2️⃣ Activate the Environment

conda activate aima

🎉 You’re now in your aima environment. All installs here won’t affect your system Python.

Step 3: 📦 Installing AIMA Python

AIMA Python is a set of Python implementations for the examples in the classic book Artificial Intelligence: A Modern Approach.

1️⃣ Clone the Repository

In your terminal:

git clone https://github.com/aimacode/aima-python.git
cd aima-python

2️⃣ Install Requirements

Still inside your aima environment, run:

pip install -r requirements.txt

This installs all necessary libraries for AIMA Python. 🚀

Step 4: 📒 Setting Up Jupyter Notebook

Jupyter is like a magic spellbook for Python. Let’s configure it!

1️⃣ Install Jupyter Notebook

conda install jupyter -y

2️⃣ Start Jupyter Notebook

Inside the aima-python directory:

jupyter notebook

🎉 A browser window will open, showing your notebook interface!

3️⃣ Run an AIMA Notebook

In the Jupyter interface:

Navigate to the notebooks folder.
Open a notebook like search.ipynb and hit Shift + Enter to execute cells.

Step 5: 🎨 Customize and Have Fun!

Make your environment yours with these tweaks:

1️⃣ Install Jupyter Themes

Add some flair with:

pip install jupyterthemes
jt -t chesterish

2️⃣ Experiment with AIMA Python

Explore examples like pathfinding, search algorithms, and logic games. Modify code cells, rerun them, and see the magic unfold. 🧙‍♂️✨

💡 Troubleshooting Tips

Anaconda Command Not Found: Ensure Anaconda is added to your PATH during installation or run:

  export PATH="$HOME/anaconda3/bin:$PATH"

Environment Activation Issue: Use the full path to activate:

  source ~/anaconda3/bin/activate aima

Library Errors in Jupyter: Double-check that Jupyter is installed in your current environment.

🌟 What’s Next?

Deep Dive into AI: Explore the AIMA book alongside the notebooks.
Try Projects: Implement your own AI algorithms using AIMA as a guide.
Share the Love: Show off your Jupyter-powered AI creations to friends or on GitHub!

🎉 You Did It!

You’re all set to conquer AI and Python programming with Anaconda, AIMA Python, and Jupyter Notebook. Now go forth and code like a wizard! 🧙‍♀️🐍✨

Questions? Ask away or dive deeper into the AIMA repo or Jupyter docs.

The Dotfiles Quest: Becoming a Configuration Wizard 🧙‍♂️

ADEBI Châ-Fine Ayédoun — Sun, 22 Dec 2024 10:01:33 +0000

Welcome, adventurer! Today, we embark on an epic quest to tame your Linux system, turning your configurations into sharable, portable, and easily manageable treasures known as dotfiles. Let’s sprinkle some magic and turn your mundane setup into a masterpiece.

Level 1: Understand the Magic of Dotfiles

Dotfiles are hidden configuration files (starting with .) that Linux and many programs use to customize their behavior. They live in your home directory (e.g., ~/.bashrc, ~/.vimrc).

Why should you care about dotfiles?

Portability: Move your setup to any system.

Backup: Never lose your customizations.

Version Control: Undo or tweak changes like a wizard.

Level 2: Prepare for the Quest

Equip yourself with these tools before venturing out:

🛠 Tools You'll Need

Git: For tracking your dotfiles.

sudo xbps-install -S git # Void Linux

Stow (optional but recommended): For managing symlinks.

sudo xbps-install -S stow

Level 3: Summon the Dotfiles Directory

This is your castle where all configurations reside.

Create the Directory:

mkdir ~/dotfiles
cd ~/dotfiles

Move Your Files: Relocate your precious configuration files into this directory.

mkdir -p ~/dotfiles/bash ~/dotfiles/vim
mv ~/.bashrc ~/dotfiles/bash/.bashrc
mv ~/.vimrc ~/dotfiles/vim/.vimrc

Organize by Programs: Keep a clean kingdom:

~/dotfiles/
bash/
.bashrc
vim/
.vimrc

Level 4: Enchant Your System with Symlinks

Here’s where the real magic begins. We’ll use symlinks to keep your system pointing to the dotfiles while they remain safe in your castle.

🪄 Manual Symlinking

ln -s ~/dotfiles/bash/.bashrc ~/.bashrc
ln -s ~/dotfiles/vim/.vimrc ~/.vimrc

🪄 Using GNU Stow (The Auto-Wizard Way)

Go to your dotfiles directory:

cd ~/dotfiles

Stow your configurations:

stow bash
stow vim

Stow will automatically create symlinks for you.

Level 5: Cast the Git Spell

We’re ready to track changes, share our setup, and show off to our Linux buddies.

🧙‍♀️ Initialize Git:

cd ~/dotfiles
git init
git add .
git commit -m "First commit of my magical dotfiles"

🧙‍♀️ Share the Magic:

Push your dotfiles to GitHub (or any Git host):

git remote add origin https://github.com//dotfiles.git
git branch -M main
git push -u origin main

Level 6: Portability Potion

On a new system? Clone your repository and recreate your kingdom:

Clone Your Dotfiles:

git clone https://github.com//dotfiles.git ~/dotfiles

Recreate Symlinks: If using stow:

cd ~/dotfiles
stow bash
stow vim

Level 7: Add Some Magic Features

Dotfiles can do more than store configs. They can automate and personalize your system!

🪄 Bash Aliases

In ~/dotfiles/bash/.bashrc, add:

alias ll='ls -la --color=auto'
alias gs='git status'
alias please='sudo'

🪄 Vim Themes

Use plugins or set colors directly in ~/dotfiles/vim/.vimrc:

syntax on
colorscheme desert

🪄 Custom Scripts

Add scripts like ~/dotfiles/scripts/fix_wifi.sh and make them executable:

chmod +x ~/dotfiles/scripts/fix_wifi.sh

Level 8: Keep Upgrading Your Arsenal

Dotfiles evolve as you do. Add more configurations, track new programs, and refine your setup. Here are some ideas:

Tweak your i3wm, polybar, or rofi configs.

Manage aliases, functions, and environment variables.

Keep adding comments for clarity.

Level 9: Master the Art of Sharing

Show your dotfiles to the world! But remember to:

Avoid Sensitive Info: Use .gitignore for secrets.

Write Documentation: Create a README.md with setup instructions.

Use Branches: Experiment with new configurations safely.

Level 10: Victory!

Congratulations, Configuration Wizard! 🧙‍♂️ You now have:

A clean, sharable dotfiles setup.

Version-controlled customizations.

Symlinks for effortless management.

Your Linux journey has just begun. Keep tweaking and remember: "With great dotfiles comes great responsibility!"

🎉 The Fun Beginner’s Guide to Bluetooth on Void Linux 🎉

ADEBI Châ-Fine Ayédoun — Sat, 21 Dec 2024 12:25:27 +0000

So you’ve chosen Void Linux, the Linux of legends. Now you want Bluetooth? Let’s get this wireless party started! Grab your favorite snack, and let’s dive into the wonderful (sometimes wacky) world of Bluetooth on Void Linux. 🚀

Step 1: Getting Your Bluetooth Superpowers (Install the Basics)

First, we need to summon the magical tools to make Bluetooth work. Void Linux doesn’t come with Bluetooth pre-enabled because, well, it likes to keep you on your toes.

🛠️ Install Bluez (The Brain of Bluetooth)

Bluez is like the wizard behind the curtain. Without it, nothing happens.

sudo xbps-install -S bluez

🎩 Install Blueman (Your Bluetooth Sidekick)

Who doesn’t love a good GUI? Blueman makes Bluetooth as easy as pie.

sudo xbps-install -S blueman

💻 For Terminal Ninjas (Optional)

Prefer typing spells instead of clicking buttons? Install bluez-utils:

sudo xbps-install -S bluez-utils

Step 2: Wake Up the Bluetooth Beast

Void Linux doesn’t like doing things automatically (where’s the fun in that?). So, we need to start the Bluetooth service.

🔑 Step 2.1: Tell Bluetooth to Boot with Your System

Link the service to your system’s startup magic:

sudo ln -s /etc/sv/bluetoothd /var/service/

🛡️ Step 2.2: Start Bluetooth Right Now

Make Bluetooth stretch and yawn:

sudo sv start bluetoothd

📋 Step 2.3: Double-Check Its Mood

Is Bluetooth awake or snoozing? Let’s see:

sudo sv status bluetoothd

If it says something like runsv running, congratulations! Bluetooth is ready to mingle.

Step 3: Blueman Time!

You’ve done the hard work. Now let’s let Blueman do the heavy lifting.

Launch Blueman Manager:
- Search for it in your applications, or just type:
```
 blueman-manager
```
Party Time! 🎉
- Click Search to find devices.
- Click your device and hit Pair.
- Done! (Maybe grab a celebratory snack?)

Step 4: Terminal Magic for Cool Kids

If you’re feeling brave, use bluetoothctl. It’s like texting your Bluetooth devices—just cooler.

Open the Chat Line:

   bluetoothctl

Turn On Bluetooth (Duh):

   power on

Make Yourself Discoverable (Show Off):

   discoverable on

Find Devices (Bluetooth Tinder):

   scan on

Pair with a Device (It’s a Match!):

   pair XX:XX:XX:XX:XX:XX

Connect (Make It Official):

   connect XX:XX:XX:XX:XX:XX

Trust the Device (For BFFs Only):

   trust XX:XX:XX:XX:XX:XX

Step 5: Troubleshooting Without Tears

Something went wrong? Don’t panic. You’re still the boss.

💥 Bluetooth Is Blocked?

Check if it’s being stubborn:

sudo rfkill list

If blocked, give it a little nudge:

sudo rfkill unblock bluetooth

💻 Restart the Bluetooth Wizard

When in doubt, restart:

sudo sv restart bluetoothd

📜 Look for Clues

Check logs to see what’s up:

sudo tail -f /var/log/messages

Step 6: Add Blueman to i3wm (For the Aesthetic)

Want quick access to Blueman in your i3 status bar? Let’s make it happen!

Open your i3 config file:

   nano ~/.config/i3/config

Add this line to launch Blueman with a shortcut:

   bindsym $mod+b exec blueman-manager

Reload i3 to make the magic happen:

   i3-msg reload

Now press $mod+b, and BAM—Bluetooth at your fingertips!

Step 7: Be a Bluetooth Pro

By now, you’ve earned your Void Linux Bluetooth badge. Celebrate by:

Streaming your favorite songs on wireless headphones.
Transferring files like a pro.
Flexing your newfound skills to friends who still think Bluetooth is “complicated.”

🎉 YOU DID IT!

Go ahead, connect all the things, and bask in the wireless glory. Let me know if your Bluetooth journey needs more spice. ✨

DEV Community: ADEBI Châ-Fine Ayédoun

🚀 Hibernate Like a Boss on Arch/EndeavourOS with Dracut + Swapfile

1️⃣ Check your RAM & plan the swap

2️⃣ Create the swapfile

3️⃣ Make it permanent in /etc/fstab

4️⃣ Grab the UUID and offset

5️⃣ Tell GRUB about it

6️⃣ Teach Dracut to resume

7️⃣ Test the magic ✨

🔥 Bonus: Suspend-then-Hibernate

🏆 Done!

How to Install and Configure GLPI on Mx Linux (Debian base) (Apache, PHP, MariaDB)

✅ 1. System Requirements & Packages

🔧 Install Apache, PHP, and MariaDB/MySQL:

🔧 Enable the required Apache modules:

✅ 2. Download and Install GLPI

✅ 3. Apache Configuration

✅ 4. Edit /etc/hosts

✅ 5. Database Configuration

✅ 6. Access via Browser

✅ Fixing the GLPI session.cookie_httponly warning:

✅ Verification

🧙‍♂️ XBPS — The Gandalf of Package Managers on Void Linux

🧬 Born and Bred in Void

🛠️ Commands You’ll Love (aka Your New Superpowers)

🧠 The Smart Stuff Under the Hood

🔍 A Chill Example

🚀 Why You’ll Love It (Even if You’ve Dated pacman or zypper)

📚 Wanna Dive Deeper?

💭 Final Thoughts

📝 Dev.to Post: "Bagels – A Logic Game in Python

🎮 Bagels – A Logic Game in Python

🚀 Source Code

🔍 Code Breakdown

📌 How Can We Improve It?

Recursion, Tail Recursion, and Recursive Data Structures: A Deep Dive 😎💻

🚀 Mastering Rofi in i3: A Cool & Fun Guide

1️⃣ Install & Configure Rofi

2️⃣ Make Rofi Pop with i3 Keybindings

🔹 Launch Rofi in "drun" mode (app launcher):

🔹 Switch to "run" mode (execute commands):

🔹 Switch to "window" mode (manage windows):

🔹 Enable "file browser" mode (navigate files):

3️⃣ Tips & Tricks for Using Rofi

💡 Switch Between Modes Dynamically

💡 Search Smarter in "drun" Mode

💡 Use "run" Mode Like a Pro

💡 Master the "window" Mode

💡 Browse Files with Rofi (Filebrowser Mode)

4️⃣ Rofi Keyboard Shortcuts

5️⃣ Customize Themes for a Futuristic Look

🔹 Edit a Theme:

🔹 Change Colors for Abstract Vibes:

🔹 Rounded Corners:

6️⃣ Fun Rofi Ideas

🌟 Ready to transform your desktop into a superpower? Let's get started! 🚀

Part 1: Installing XFCE and i3

Step 1: Get Ready for Action - Install XFCE and i3

For Ubuntu/Debian users:

For Void Linux users:

Part 2: Let's Get to Work — Set Up i3 as the Window Manager

Step 2: Tweak XFCE to Make i3 Your Window Manager

Part 3: Make it Look Cool — Wallpapers and Panels

Step 3: Set Your Wallpaper Like a Boss Using feh

Step 4: XFCE Panel — The Superhero of Your Desktop (Optional)

Part 4: Make i3 Even More Fun — Customizations

Step 5: Keybindings for i3 — Control Your World

Step 6: i3 Gaps — Because Gaps are Cool

Part 5: Extra Cool Tweaks — Because You’re a Power User Now

Step 7: Install Rofi — Your Stylish App Launcher

Conclusion: You’re Now a Master of XFCE + i3! 🎉

🎨 Customize Void Linux with Polybar, PulseAudio, pavucontrol, nm-applet, NetworkManager, i3, and feh

🎯 What We’re Setting Up

🛠️ Prerequisites

🌟 Step 1: Install Required Packages

Install i3

Install Polybar

Install PulseAudio and pavucontrol

Install nm-applet and NetworkManager

Install feh

3️⃣ Make it permanent in `/etc/fstab`

✅ 4. Edit `/etc/hosts`

✅ Fixing the GLPI `session.cookie_httponly` warning: