Linux

I try to organise my data in the cleanest way possible, with the less double possible etc... I end up using a lot of symbolic links. When doing maintenance, sometimes I want to navigate in the "unlogical" way the data are organized, but the PWD variable is not necessarily very cooperative. This alias is really useful in my case :

alias realwd='cd -P .'  

Here is an example :

$ echo $PWD  
/home/me  
$ cd Videos/Torrents/  
$ echo $PWD  
/home/me/Videos/Torrents  
$ realwd  
$ echo $PWD  
/home/me/data/Torrents/Video  

I also do some X application, compositor and WM development, and I have a few aliases to simplify tasks like copying from an Xorg session to an Xnest (and the other way around), or reload the xrandr command from my .xinitrc without duplicating it.

alias screenconf='$(grep -o "xrandr[^&]*" ~/.xinitrc)'  
alias clip2xnext='xclip -selection clip -o -display :0 | xclip -selection clip -i -display :1'  
alias clip2xorg='xclip -selection clip -o -display :1 | xclip -selection clip -i -display :0'  

I have an alias for using MPV+yt-dlp with my firefox cookies :

alias yt="mpv --ytdl-raw-options='cookies-from-browser=firefox'"  

I can't stand too long lines of text on my monitor, particularly when reading manpages, so I set the MANWIDTH env variable.

# Note : if you know that *sometimes* your terminal will be smaller than 80 characters  
# refer to that https://wiki.archlinux.org/title/Man_page  
export MANWIDTH=80  

I use null-pointers a lot, with a shorthand.

# Note: env.sh actually provide other helpful aliases on their homepage  
function envs.sh() {  
	if [ $# != 1 ]; then  
		1>&2 printf "Error, need one argument.\n"  
		return 1  
	fi  
	curl -F'file=@'"$1" https://envs.sh/  
}  

The usual fake editor in my path, so that browsers and other applications open Vim the correct way.

#!/bin/sh  
# st_vim.sh - executable in my ~/.local/bin  
# for example in firefox's about:config :  
#   - view_source.editor.path : set to the value of $(which st_vim.sh)  
#   - view_source.editor.external : set to true  

st -- $EDITOR "$*"  

My .xinitrc is quite classical, I still have this in it (setup for dwm's title bar, people usually install much complicated programs) :

while true; do xsetroot -name "$(date +"%d %H:%M")"; sleep 60; done &  

I also have a lot of stupid scripts for server and desktop maintenance, disks cleaning etc... those are handy but are also very site-specific, let me know if your interested.

I often want to know the status code of a curl request, but I don't want that extra information to mess with the response body that it prints to stdout.

What to do?

Render an image instead, of course!

curlcat takes the same params as curl, but it uses iTerm2's imgcat tool to draw an "HTTP Cat" of the status code.

It even sends the image to stderr instead of stdout, so you can still pipe curlcat to jq or something.

#!/usr/bin/env zsh

stdoutfile=$( mktemp )
curl -sw "\n%{http_code}" $@ > $stdoutfile
exitcode=$?

if [[ $exitcode == 0 ]]; then
  statuscode=$( cat $stdoutfile | tail -1 )

  if [[ ! -f $HOME/.httpcat$statuscode ]]; then
    curl -so $HOME/.httpcat$statuscode https://http.cat/$statuscode
  fi

  imgcat $HOME/.httpcat$statuscode 1>&2
fi

cat $stdoutfile | ghead -n -1

exit $exitcode

Note: This is macOS-specific, as written, but as long as your terminal supports images, you should be able to adapt it just fine.

I wrote a script called please. You input please followed by any other command (e.g. please git clone, please wget blahblah) and a robotic voice will say "affirmative," then the command will run, and when it completes, the robotic voice reads out the exit code (e.g. "completed successfully" or "failed with status 1" etc.)

This is useful for when you have a command that takes a long time and you want to be alerted when it's finished. And it's a gentleman.

Here are probably the most useful ones. I prefer for rm to be interactive so I don't accidentally delete something important and for mkdir to create a parent directory if necessary.

alias rm='rm -i'
alias mkdir='mkdir -p'
alias podup='podman-compose down && podman-compose pull && podman-compose up -d'

This extract function (which I didn't make myself, I got it from when I was using nakeDeb) has been pretty useful too.

function extract()
{
     if [ -f $1 ] ; then
         case $1 in
             *.tar.bz2)   tar xvjf $1     ;;
             *.tar.gz)    tar xvzf $1     ;;
             *.bz2)       bunzip2 $1      ;;
             *.rar)       unrar x $1      ;;
             *.gz)        gunzip $1       ;;
             *.tar)       tar xvf $1      ;;
             *.tbz2)      tar xvjf $1     ;;
             *.tgz)       tar xvzf $1     ;;
             *.zip)       unzip $1        ;;
             *.Z)         uncompress $1   ;;
             *.7z)        7z x $1         ;;
             *.xz)        unxz $1         ;;
             *)           echo "'$1' cannot be extracted via >extract<" ;;
         esac
     else
         echo "'$1' is not a valid file"
     fi
}

alias fucking='sudo' (my coworkers often used prettyplease instead)

alias clip='xclip -selection clipboard'

When you pipe to this, for example ls | clip, it will stick the output of the command ran into the clipboard without needing to manually copy the output.

alias sl=“ls“

#Create a dir and cd into it
mkcd() { mkdir -p "$@" && cd "$@"; }

alias fuck='sudo $(history -p \!\!)'

One of favorites cds to the root of a project directory from a subdirectory,

# Changes to top-level directory of git repository.
alias gtop="cd \$(git rev-parse --show-toplevel)"

For doing stuff in a directory, I use a replacement for cd command.

For aliases:

alias +='git add'
alias +p='git add -p'
alias +u='git add -u'
alias -- -='cd -'
alias @='for i in'
alias c='cargo'
alias date='LANG=C date'
alias diff='cdiff'
alias gg='git grep -n'
alias grep='grep --color=auto'
alias ll='ls -o'
alias ls='ls -vFT0 --si --color=auto --time-style=long-iso'
alias rmd='rmdir'

I also have various small scripts and functions:

• a for package management (think apt but has simplified arguments which makes it faster to use in usual cases),
• e for opening file in Emacs,
• g for git,
• s for sudo.

And here’s ,:

$ cat ~/.local/bin/,
#!/bin/sh

if [ $# -eq 0 ]; then
	paste -sd,
else
	printf '%s\n' "$@" | paste -sd,
fi

$ which diffuc
diffuc: aliased to diff -uw --color=always

$ which grepnir
grepnir: aliased to grep -niIr

$ cat `which ts`
#!/bin/bash

if [ "$#" -lt 1 ]; then
                tmux list-sessions
                exit
fi

if ! tmux attach -t "$1"
then
                tmux new-session -s "$1"
fi

function seesv
    column -s, -t < $argv[1] | less -#2 -N -S
end

I used this a lot when I had to deal with CSV files — it simply shows the data in a nice format. It's an alias for the fish shell by the way.

I have a few interesting ones.

Download a video:

alias yt="yt-dlp -o '%(title)s-%(id)s.%(ext)s' "

Execute the previous command as root:

alias please='sudo $(fc -n -l -1)'

Delete all the Docker things. I do this surprisingly often:

alias docker-nuke="docker system prune --all --volumes --force"

This is a handy one for detecting a hard link

function is-hardlink {
  count=$(stat -c %h -- "${1}")
  if [ "${count}" -gt 1 ]; then
    echo "Yes.  There are ${count} links to this file."
  else
    echo "Nope.  This file is unique."
  fi
}

I run this one pretty much every day. Regardless of the distro I'm using, it Updates All The Things:

function up {
  if [[ $(command -v yay) ]]; then
    yay -Syu --noconfirm
    yay -Yc --noconfirm
  elif [[ $(command -v apt) ]]; then
    sudo apt update
    sudo apt upgrade -y
    sudo apt autoremove -y
  fi
  flatpak update --assumeyes
  flatpak remove --unused --assumeyes
}

I maintain an aliases file in GitLab with all the stuff I have in my environment if anyone is curious.

Since 720p downloading isn't really available on yt-dlp anymore, I made an alias for it

alias yt720p="yt-dlp -S vcodec:h264,fps,res:720,acodec:m4a"

alias qr='qrencode -t ansiutf8'

This makes qr codes in the terminal.

needs the qrencode package

Example usage and output:

felix@buttsexmachine:~$ qr lemmy.fish
█████████████████████████████
█████████████████████████████
████ ▄▄▄▄▄ █▄ ██ █ ▄▄▄▄▄ ████
████ █   █ █ █▄▀▄█ █   █ ████
████ █▄▄▄█ █▄▄▄███ █▄▄▄█ ████
████▄▄▄▄▄▄▄█▄▀ █▄█▄▄▄▄▄▄▄████
████▄▄▄ █▀▄▀▄▀ █▀▄▀▀   █ ████
████▄ ▀▄▀▄▄ ▀▄▄█ ▄▄▄█▀█ ▄████
██████▄███▄█▀█ ▄█▄ █▀█▀▄▄████
████ ▄▄▄▄▄ ██ ▀▀▀▀▄   ▀█▀████
████ █   █ █▀ ▀▄█▀▀▄▄  ▀█████
████ █▄▄▄█ █ ▀█ ▀█▀ █▄▄█▀████
████▄▄▄▄▄▄▄█▄▄█▄▄▄███▄▄██████
█████████████████████████████
█████████████████████████████
```*___*

alias cd..="cd .."

here we go:

dedup:

#!/usr/bin/awk -f
!x[$0]++

this removes duplicate lines, preserving line order

iter:

#!/usr/bin/bash
if [[ "${@}" =~ /$ ]]; then
    xargs -rd '\n' -I {} "${@}"{}
else
    xargs -rd '\n' -I {} "${@}" {}
fi

This executes a command for each line. It can also be used to compare two directories, ie:

du -sh * > sizes; ls | iter du -sh ../kittens/ > sizes2

fadeout:

#!/bin/bash
# I use this to fade out layered brown noise that I play at a volume of 130%
# This takes about 2 minutes to run, and the volume is at zero several seconds before it's done.
# ################
# DBUS_SESSION_BUS_ADDRESS is needed so that playerctl can find the dbus to use MPRIS so it can control mpv
export DBUS_SESSION_BUS_ADDRESS="unix:path=/run/user/1000/bus"
# ################
for i in {130..0}
do
    volume=$(echo "scale=3;$i/100" | bc)
    sleep 2.3
    playerctl --player=mpv volume $volume
done

lbn:

#!/bin/bash
#lbn_pid=$(cat ~/.local/state/lbn.pid)
if pgrep -fl layered_brown
then
	pkill -f layered_brown
else
	export DBUS_SESSION_BUS_ADDRESS="unix:path=/run/user/1000/bus"
	mpv -ao pulse ~/layered_brown_noise.mp3 >>lbn.log 2>&1 &
	sleep 3
	playerctl -p mpv volume 1.3 >>lbn.log 2>&1 &
fi

This plays "layered brown noise" by crysknife. It's a great sleep aid.

here are some aliases:

alias m='mpc random off; mpc clear'
alias mpcc='ncmpcpp'
alias thesaurus='dict -d moby-thesaurus'
alias wtf='dict -d vera'
alias tvplayer='mpv -fs --geometry=768x1366+1366+0'

I usually set up an alias or script to update everything on my system. For example, on Ubuntu, I would do this: alias sysup='snap refresh && apt update && apt upgrade'

And on Arch, I do this: alias sysup ='flatpak update && paru'

Funny enough you'd need to use sudo to run this on Ubuntu, but not in the Arch example because paru being neat

on most of my systems I get tired of constantly lsing after a cd so I combine them:

cd(){
    cd $1 && ls
}

(excuse if this doesn't work, I am writing this from memory)

I also wrote a function to access docker commands quicker on my Truenas system. If passed nothing, it enters the docker jailmaker system, else it passes the command to docker running inside the system.

docker () {
        if [[ "$1" == "" ]]; then
                jlmkr shell docker
                return
        else
                sudo systemd-run --pipe --machine docker docker "$@"
                return
        fi
}

I have a few similar shortcuts for programs inside jailmaker and long directories that I got sick of typing out.

This tmux wrapper is remarkably convenient:

Usage:

# Usage: t [session-name]
#
# With no arguments:
#   Lists existing tmux sessions, or prints "[No sessions]" if none exist.
#
# With a session name:
#   Attempts to attach to the named tmux session.
#   If the session does not exist, creates a new session with that name.
#
# Examples:
#   t            # Lists all tmux sessions
#   t dev        # Attaches to "dev" session or creates it if it doesn't exist

function t {
	if [[ -z $1 ]]; then
		tmux ls 2> /dev/null || echo "[No sessions]"
	else
		tmux attach -t $@ 2> /dev/null
		if [[ $? -ne 0 ]]; then
			tmux new -s $@
		fi
	fi
}

alias gimme='git checkout'

alias ed=$EDITOR

Extremely convenient on a qwerty keyboard.

This should probably be a default nowadays. Does even a single person here use the real ed ?

i use

alias kimg='kitty +kitten icat' 

to display images in my terminal pretty simple but nice

jmpd(jump directory): fuzzy finds and opens directory with fzf

# fish shell
function jmpd
    set _selection $(fzf --walker=dir);
    if test -n "$_selection"
        cd "$_selection";
    end
end

I'll share 3:

alias chx='chmod +x'
alias rr='rm -rf'
alias shrug="echo '¯\_(ツ)_/¯'"

I've only used aliases twice so far. The first was to replace yt-dlp with a newer version because the version that comes pre-installed in Linux Mint is too outdated to download videos from YouTube. The second was because I needed something called "Nuget". I don't remember exactly what Nuget is but I think it was a dependency for some application I tried several months ago.

alias yt-dlp='/home/j/yt-dlp/yt-dlp'
alias nuget="mono /usr/local/bin/nuget.exe"

it's somewhat vibe coded but the one i probably use the most is this one to swap between speakers and headset. the device name to look for is just put directly in there, it'd take some adjustment to run it on different machines. this is in my .bashrc:

# switch sinks
toggle_audio() {
  # Find headset sink ID dynamically
  headset_id=$(pactl list sinks short | grep "Plantronics" | awk '{print $1}')
  
  # Find speakers sink ID dynamically
  speakers_id=$(pactl list sinks short | grep "pci-0000_05_00.6" | awk '{print $1}')
  
  # Get current default sink
  current_sink=$(pactl get-default-sink)
  
  # Get current sink ID
  current_id=$(pactl list sinks short | grep "$current_sink" | awk '{print $1}')
  
  # Toggle between the two
  if [ "$current_id" = "$headset_id" ]; then
    pactl set-default-sink "$speakers_id"
    echo "Switched to speakers (Sink $speakers_id)"
  else
    pactl set-default-sink "$headset_id"
    echo "Switched to headset (Sink $headset_id)"
  fi
}

generally i try not to use too many custom things because for work i regularly work on all kinds of different servers and i've just been too lazy to set up some solution to keep it all in sync. someday....