And that’s pretty much it. Its super fast and minimal, and works pretty much anywhere. There is even a Wayland clone of it, which I don’t use but at least its there.

Rofi is so good, I got really fired up when my fellow fedizen @hyde mentioned how rofi isn’t for him, and he will stick to the default AwesomeWM launcher, I couldn’t help myself, and decided to write this post and answer to his complaints.

First of all. This is all written in a jokeful manner, no hard feelings or anything.

Seriously? You use pass as your password manager, you use mutt for email, stuff like fzf and a bunch of other tools, you even got a weekly series of CLI tool recommendations. HOW DARE YOU disrespect rofi like THAT!?

Rofi can be integrated with pretty much all of the above. You can use tools such as rofi-pass to autofill your passwords everywhere (kind of better than KeepassXC Browser extensions tbh). You could create many kinds of things with neomutt, like handling mailto: links

You can pretty much pipe whatever you want on rofi, and create general scripts for a ton of stuff. Compared to some launchers that come built-in in some desktop environments or window managers. Rofi will work on them all and can be customized quite a lot.

The only thing that comes close to rofi is one of its inspirations, dmenu. But given that it is even more bare bones and any additions have to be patched (rather than simply configured with rofi). I find it a little harder to sell for most.

I have a few posts sharing scripts, some of them using rofi and its simply fantastic. I’ve a couple other scripts you may be interested in checking out!

I actually recently changed the script to edit tags to use just rofi. You can see some it, as well as some more of my rofi scripts in my dotfiles

This is day 16 of #100DaysToOffload

For some reason, my mother decided to barge into my room to clean up for me, and soon my siblings joined for the massacre. They basically started all over again, opening containers, drawers and reordering everything she saw out of place. I wanted to do it all alone while listening to some podcasts but it was just impossible.

I was really mad at first, but it soon turned kinda wholesome, I still have a few nostalgic things from my childhood. Some toys, my puzzle collection, an old photo album, a lot of keychains (for some reason I ignore), my small watch collection, and other miscellaneous things. In the end, I have to admit that they did a better job than I could have, and we had a good time, so it was all cool.

I also took some time later to do some cleanup. I backed up some pictures from my phone and compressed them. Using tools such as ImageMagick and the like.

This is a quick script I used, that will compress the image but will preserve its modified date to its creation date. I like this because sorting images by date is easier for me. I actually used ChatGPT for this script. 😉

for filename in *.jpg; do
	mogrify -verbose -resize 1600 -quality 85 "$filename" "$filename"

  date_string=${filename:4:8}
  time_string=${filename:13:4}
  
  # Create the timestamp in the format YYYYMMDDHHMM
  timestamp="${date_string}${time_string}"

  # Use the touch command to modify the file's timestamps
  touch -m -t "$timestamp" "$filename"
  
  echo "modifying $filename with timestamp $timestamp"
  
done

I made some new folders, reorganized some stuff and I am getting ready for switching to a new Android 13 rom. I have to do some backups, but I am almost ready! We’ll see.

For some reason I feel like I need to delete and uninstall every app and file I don’t need, even though I will wipe it completely anyways. I am just weird like that.

This is day 11 of #100DaysToOffload

Anyways, a couple posts ago I shared how to sort tags in different ways, the truth is I’ve been meaning to do some cleaning up, inspired by Adam’s post.

He used the usual commands such as sed and grep, and I decided to quickly write a script to edit the desired tags for any file in a similar manner.

#!/usr/bin/bash
#
file=$1
oldtags=$(cat $1 | grep "tags:" | head -1 | awk '{for (i=2; i<NF; i++) printf $i " "; print $NF}')

echo $oldtags > /tmp/tagedit
vim /tmp/tagedit

newtags=$(cat /tmp/tagedit)

rm -fv /tmp/tagedit

sed -i "s/$oldtags/$newtags/g" "$file"

This code is rather simple, it takes the path of a file, which is given as an argument, running something like

./edit-tags.sh filename

That filename is parsed, using grep, head and awk. a new temporary file containing all existing tags of that file gets opened with vim, containing the existing tags. From there I can add or remove tags as I please, and once saved, I replace the original file accordingly.

It is rather simple, and I think it could be done better. So please, I beg you to give me any suggestions to improve it. I tried my best to understand stuff like getopts and the like, to have arguments and flags but I just didn’t really get it.

Regardless, this is day 5 of my second attempt at #100DaysToOffload

• finish writing
• git add, git commit, git push
• write toot on mastodon sharing my blogpost
• copy toot link
• paste toot link id on original blogpost
• git add, git commit, git push
• comments section now works!

However, I decided to summon the power of the command line and bash scripting once again, and I finally managed to automate pretty much all of it.

It depends on some basic tools such as sed, cut, grep, but it also requires a very simple mastodon client for the command line, toot, you probably have it all installed already, and toot is not hard to setup either way.

There really is not a lot to talk about other than this. Here is the script, its not really super clean or anything (any suggestion are absolutely welcome) but at least its serviceable.

#!/usr/bin/bash

if git rev-parse --git-dir > /dev/null 2>&1; then
    : # This is a valid git repository

    # All markdown files start with YYYY-MM-DD
    lastpost=$(/usr/bin/ls ${markdown_posts_folder}/*.md | sort -r | head -n 1) 
    getdesc=$(grep "description:" $lastpost | cut -d " " -f2-)
    geturl=$(grep "permalink:" $lastpost | cut -d " " -f2-)
    gettags=$(grep "tags:" $lastpost | cut -d " " -f2- | sed -r 's/([^ ]+)/#\1/g')
    post=$(echo -e "${getdesc} \n\nhttps://joelchrono.xyz/${geturl} \n\n${gettags} #blogpost")
    posturl=$(toot post "$post" | cut -d/ -f5)
    echo $posturl
    sed -i "s/commentsid/$posturl/g" "$lastpost"

    git add *
    git commit -m "automatically added comments"
    git push

    exit

# directory may not be the top level.
# Check the output of the git rev-parse command if you care
else
    : # this is not a git repository
    echo "Run this inside of website folder"
    exit

fi

There you go, I hope you find it useful, maybe you can improve it even further. If so, make sure to let me know, I am still learning these things.

The script comes as a request by Ru, or at least this is what I hope she meant when she posted:

Static site users who embed images frequently – what’s your workflow for it? #AskFedi

Well, my previous workflow was simple enough:

1. Take pictures.
2. Move to assets folder.
3. Rename them to something like $date-$filename_without_spaces.png.
4. Add markdown syntax and type the whole thing.
5. Cry because you messed up the directory path.

So I went ahead and decided to work on a little script I named aijk (Add image to Jekyll), using bash and rofi, tools that I’ve used before with decent success. I am actually really happy of how it turned out.

The script

#!/bin/bash

### AIJK (Add image to Jekyll)
### By joelchrono12

pic=$1
name=$(rofi -l 0 -width 50 -p "Title" -dmenu)
filen=$(echo $name | tr " ,.!" "-"| awk '{print tolower($0)}')
today=$(date +"%Y-%m-%d")
filename=($today-$filen)
path=/path/to/website #without / at the end
imgs=/from/site_root/to/assets/ #example = /assets/img/blogs/
last_post=$(/usr/bin/ls /path/to/markdown/files/*.md | sort -r | head -n 1)

convert $1 -quality 75 ${path}${imgs}${filename}.png

printf "\n![${name}](${imgs}${filename}.png)" >> $last_post

How to use

Once added to your $PATH and making it executable, all you need is to change the required paths in the script, I think most of you will be able to figure it out on your own, but reach me out if you need help.

You can run it just by doing this:

aijk file.png

This is how it works:

• Obtain picture file from argument.
• Add a Title to file via a rofi input.
• Create filename for file itself.
• Set paths to different required things (depends on your site).
• Get the latest markdown files from your site.
• Make changes to picture so its smaller or whatever (can be customized, requires ImageMagick).
• Print formatted markdown line to bottom of the latest markdown file.

Adding a Graphical option for mouse users

You can run this script with absolute ease from your terminal, if that’s what you want, but I also figured out a way to do it from a GUI if you are using Thunar as a file manager (might be possible with others, haven’t checked).

1. Open Thunar > Edit > Configure custom actions.
2. Add a new entry for aijk and save it.

1. Set the appearance conditions to images only.
2. Right click on any image to try it out!

Final thoughts

I am not completely happy with how this works. But this is usable and easy to expand, there could be a way to select the destination file instead of just getting the latest one. But I don’t normally add new images to old posts anyways, so I figured most people would be ok with how this works right now.

The script also assumes you want to start all your files with the date, and that your markdown files also start with the dates, since sort will fail to place the line in the latest file, if such file is not the first in its output.

There is also no way to do this with multiple files as of now, I might be able to come up with something, I could just create another script that makes use of this one to make multiple additions at once.

Anyways, this is what I’ll do now to add images, I will simply right click, click again and give them a name!. Or do it properly in the terminal, whatever fits me best.

This has been day 95 of #100DaysToOffload. Make sure to check out Ru’s website, since she single-handedly managed to inspire me to work on this quick script.

NOTE: This is actually day 96, from here it all went wrong. If you don’t understand this note, [read here]

Because of that, I got access to some nice things, like a website, a gemini capsule and an email address, which is kind of nice. I have been using that site as a place to mirror this very same website in case anything happens. Like losing my current domain or anything like that.

Blop is a pretty nice static site generator that is basically just a bash script that uses other programs such as sed, awk and pandoc to put together a simple site generated from markdown files and simple templates.

However, it had a pretty serious issue, at least for me. The generated html files ended with *.html instead of being a clean url like here in Jekyll.

So I forked the project, put some work into it and I actually managed to do it!

I am not that great of a bash coder, and it was not really a matter of bash but of knowing where to look and using / to search for the right things in Vim.

In the end I now have clean URLs in my alternative site, which is kind of great.

You can take a look at my fork, which is not really that different from the original in my tildegit repository.

This has been day 83 of #100DaysToOffload

That works fine, but it’s not the best way to backup the constant changes I usually do to customize the way my programs look or act, and as a customization freak, that happens quite often.

I had seen many different ways to backup dotfiles: git bare repos, yadm, symlinking scripts, and of course, GNU Stow.

All of these methods have their up and downs, but in the end, stow convinced me, and I decided to give it a try. According to their home page:

GNU Stow is a symlink farm manager which takes distinct packages of software and/or data located in separate directories on the filesystem, and makes them appear to be installed in the same place.

If you don’t really understand it yet, don’t worry, I don’t either! But in this blog, I will do my best to show you the steps to backup your current config files, I hope whoever reads this finds it useful.

Creating a dotfiles repository

The first step to backup your dotfiles, is to create an empty repository in some hosting service, such as GitHub, Codeberg or SourceHut. This is optional if you only want to see how stow works, but necessary to have an external backup outside your computer. Once you are done, clone the empty repo to your home directory, or in any place you want. (This tutorial will be using the home directory).

To clone a repo, just do:

git clone https://site.com/link/to/repo

In my case, I use Tildegit, a Gitea instance, so my command looks like this.

git clone https://tildegit.org/chrono/dotfiles.git

You can clone my dotfiles if you want to use them, here they are if you are interested.

Using stow to backup your configuration

Before actually backing something up, we need to install stow, depending on your distribution, you can install it with your package manager of choice. In my case, Endeavor is based on Arch, so I do:

$ sudo pacman -S stow

Lets start by backing up the configuration of a single program. While we can backup our whole .config folder, that’s not a good idea, since some programs store important information that should stay private, and I think its better to only backup what we have actually configured. For this example, I will backup my picom configurations.

The first step is to create a new directory to use as a base (if you cloned your empty repo, you’ll be using that). You also have to create a folder structure, depending on where you want the configuration to be stored, this depends on the location the program will read its configuration from. We’ll refer to this folder as dotfiles.

If you want to add a README file or other stuff that you is not a config files, you can create another directory inside of dotfiles, in my case, I have made a stow_home folder, which will be where we’ll run the stow command. ¹

Lets explain how stow works. Picom expects its config file in ~/.config/picom/picom.conf, so, inside of the new home_stow directory, we recreate that folder structure, but using the program name (picom) instead of the tilde (~), which usually refers to the home folder. ²

Lets put all of this together in the terminal.

mkdir dotfiles && cd dotfiles # mkdir only if you didn't clone it
touch README.md other_file.txt # optional
mkdir -p ~/dotfiles/stow_home/picom/.config/picom/
mv ~/.config/picom/ ~/dotfiles/stow_home/picom/.config/

Once you do that, your picom folder is no longer in the .config directory, but inside of dotfiles/home_stow, following the same folder structure, as if home_stow was the /home directory, followed by the user picom and the path to the picom configuration files. ³

Now we repeat this process with all of the files and directories we want to back up. Once done, the behavior of the programs you use, such as vim, should revert to their default configurations, since the user config files are no longer there. So, now its time to fix that! Inside of stow_home, run the following command:

stow -vt ~ *

This will symlink everything inside of stow_home ⁴, targetting ~ as the starting point. The -v flag will let you know of everything being done, so you should see an output like this, depending on the programs you backed up:

# $ stow -vt ~ *
LINK: .config/awesome => ../dotfiles/stow_home/awesome/.config/awesome
LINK: .config/bat => ../dotfiles/stow_home/bat/.config/bat
LINK: .config/dunst => ../dotfiles/stow_home/dunst/.config/dunst
LINK: .config/nvim => ../dotfiles/stow_home/nvim/.config/nvim
LINK: .config/picom => ../dotfiles/stow_home/picom/.config/picom
LINK: .config/rofi => ../dotfiles/stow_home/rofi/.config/rofi
LINK: .config/spectrwm => ../dotfiles/stow_home/spectrwm/.config/spectrwm

File versioning with git

If you stumbled upon this guide, you probably know the necesary git commands to backup everything to the service you chose at the beginning of this guide.

Generally, everytime you do changes you only need to follow these three commands, inside of your dotfiles folder.

git add *
git commit -m "Added config files"
git push

Remember that the last command will not work if you don’t have an external repository.

The manual of GNU Stow contains a lot more than what I mentioned here, like unlinking and other flags that can be used and might be useful for your use case.

Finishing up

Anyways, that’s all folks, this has been day 54 of #100DaysToOffload, you can check out my dotfiles if you want to see how stow looks once setup, besides, my Spectrwm configuration is quite sick if I do say so myself.

If you feel like a step is not clear enough, please let me know in the comments or via e-mail.

Secret bonus script!

So, if you read until the end of this blog. I actually did a pretty decent bash script to automate everything here.

All you need to do is configure it to your liking and run it like this

dotstow file_or_folder

The script is as follows, it uses basic tools like cut and of course, stow

#!/usr/bin/bash
# Dotstow - Backup your chosen dotfiles in one go using stow.
# Run it outside of the folder/file you want to back up
# $ dotstow file-or-program
# This program was made by joelchrono12

STOW_DIR=$HOME/dotfiles/stow_home
DIR=$(pwd | cut -d '/' -f4-)
NEW_DIR=$STOW_DIR/$1/$DIR
mkdir -pv $NEW_DIR
mv -v $1 $NEW_DIR
cd $STOW_DIR
stow -vt ~ $1

The program does not check if a folder already exists or anything like that. So feel free to send any suggestions and changes to it in a comment or using git send-email to my email address.