Linux

alias cls=clear

My first language was QB, so it makes me chuckle.

Also, alias cim=vim. If I had a penny...

I made this one to find binaries in NixOs and other systems

get_bin_path() {
        paths=${2:-$PATH}
        for dr in $(echo $paths | tr ':' '\n') ; do
                if [ -f "$dr/$1" ] ; then
                        echo "$dr/$1"
                        return 0
                fi
        done
        return 1
}

Then I made this one to, if I have a shell o opened inside neovim it will tell the neovim process running the shell to open a file on it, instead of starting a new process

_nvim_con() {
        abs_path=$(readlink --canonicalize "$@" | sed s'| |\\ |'g)
        $(get_bin_path nvim) --server $NVIM --remote-send "<ESC>:edit $abs_path<CR>"
        exit
}

# start host and open file
_nvim_srv() {
        $(get_bin_path nvim) --listen $HOME/.cache/nvim/$$-server.pipe $@
}

if [ -n "$NVIM" ] ; then
        export EDITOR="_nvim_con"
else
        export EDITOR="_nvim_srv"
fi

Lastly this bit: which if it detects a file and a line number split by a : it will open the file and jump to the line

_open() {
        path_parts=$(readlink --canonicalize "$@" | sed s'| |\\ |'g | sed 's/:/\t/' )
        file=$(echo "$path_parts" | awk ' { print $1 }' )
        line=$(echo "$path_parts" | awk ' { print $2 }' )

        if [ -n "$line" ] ; then
                # has line number
                if [ -n "$NVIM" ] ; then
                        $(get_bin_path nvim) --server $NVIM --remote-send "<ESC>:edit $file<CR>:+$line<CR>"
                        exit
                else
                        $(get_bin_path nvim) --listen $HOME/.cache/nvim/$$-server.pipe $file "+:$line"
                fi
        else
                $EDITOR $file
        fi
}

alias nvim="_open"

all of my bash config is here

alias sl=“ls“

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.

alias nmtui="NEWT_COLORS='root=black,black;window=black,black;border=white,black;listbox=white,black;label=blue,black;checkbox=red,black;title=green,black;button=white,red;actsellistbox=white,red;actlistbox=white,gray;compactbutton=white,gray;actcheckbox=white,blue;entry=lightgray,black;textbox=blue,black' nmtui"

It's nmtui but pretty!

well i have a script. ive named it "shazam". it either creates or attachs to a tmux session named after the base name of the dir (first arg or current working directory). i also have "fzf-shazam" as the same suggests itll open a fzf finder to choose a dir to "shazam"

alias scr=screen -dRU

I don't know why Screen has any other flags. I do not want to bother learning the keyboard shortcuts for tmux even though its probably works better

None, I like to type

To save videos from certain streaming sites that are not supported by yt-dlp, I catch the M3U playlist used by the page and with that I use this script that gets ffmpeg to put together the pieces into a single file.

#!/bin/bash
if [ "$1" == "-h" ] || [ $# -lt 2 ]; then
	echo Download a video from a playlist into a single file
	echo usage: $(basename $0) PLAYLIST OUTPUT_VID
	exit
fi

nbparts=$(grep ^[^#] $1 | wc -l)

echo -e "\e[38;5;202m Downloading" $(( nbparts - 1 )) "parts \e[00m"
time ffmpeg -hide_banner -allowed_extensions ALL -protocol_whitelist file,http,https,tcp,tls,crypto -i $1 -codec copy $2

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 ?

ganis :

git add -A && sudo nixos-rebuild switch --impure -j$(nproc)

Everyone who uses nixos probably has a similar alias set x)

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"

i use

alias kimg='kitty +kitten icat' 

to display images in my terminal pretty simple but nice

Well, my full functions.sh won't fit in a comment, so here's 2 of my more unique functions that makes life a little easier when contributing to busy OSS projects:

# Git fork sync functions
# Assumes standard convention: origin = your fork, upstream = original repo
## Sync fork with upstream before starting work
gss() {
        # Safety checks
        if ! git rev-parse --git-dir >/dev/null 2>&1; then
                echo "❌ Not in a git repository"
                return 1
        fi

        # Check if we're in a git operation state
        local git_dir=$(git rev-parse --git-dir)
        if [[ -f "$git_dir/rebase-merge/interactive" ]] || [[ -d "$git_dir/rebase-apply" ]] || [[ -f "$git_dir/MERGE_HEAD" ]]; then
                echo "❌ Git operation in progress. Complete or abort current rebase/merge first:"
                echo "   git rebase --continue  (after resolving conflicts)"
                echo "   git rebase --abort     (to cancel rebase)"
                echo "   git merge --abort      (to cancel merge)"
                return 1
        fi

        # Check for uncommitted changes
        if ! git diff-index --quiet HEAD -- 2>/dev/null; then
                echo "❌ You have uncommitted changes. Commit or stash them first:"
                git status --porcelain
                echo ""
                echo "💡 Quick fix: git add . && git commit -m 'WIP' or git stash"
                return 1
        fi

        # Check for required remotes
        if ! git remote get-url upstream >/dev/null 2>&1; then
                echo "❌ No 'upstream' remote found. Add it first:"
                echo "   git remote add upstream <upstream-repo-url>"
                return 1
        fi

        if ! git remote get-url origin >/dev/null 2>&1; then
                echo "❌ No 'origin' remote found. Add it first:"
                echo "   git remote add origin <your-fork-url>"
                return 1
        fi

        local current_branch=$(git branch --show-current)

        # Ensure we have a main branch locally
        if ! git show-ref --verify --quiet refs/heads/main; then
                echo "❌ No local 'main' branch found. Create it first:"
                echo "   git checkout -b main upstream/main"
                return 1
        fi

        echo "🔄 Syncing fork with upstream..."
        echo "   Current branch: $current_branch"

        # Fetch with error handling
        if ! git fetch upstream; then
                echo "❌ Failed to fetch from upstream. Check network connection and remote URL."
                return 1
        fi

        echo "📌 Updating local main..."
        if ! git checkout main; then
                echo "❌ Failed to checkout main branch"
                return 1
        fi

        if ! git reset --hard upstream/main; then
                echo "❌ Failed to reset main to upstream/main"
                return 1
        fi

        echo "⬆️  Pushing updated main to fork..."
        if ! git push origin main; then
                echo "❌ Failed to push main to origin. Check push permissions."
                return 1
        fi

        echo "🔀 Rebasing feature branch on updated main..."
        if ! git checkout "$current_branch"; then
                echo "❌ Failed to checkout $current_branch"
                return 1
        fi

        if ! git rebase main; then
                echo "❌ Rebase failed due to conflicts. Resolve them and continue:"
                echo "   1. Edit conflicted files"
                echo "   2. git add <resolved-files>"
                echo "   3. git rebase --continue"
                echo "   Or: git rebase --abort to cancel"
                return 1
        fi

        echo "✅ Ready to work on branch: $current_branch"
}

## Sync fork and push feature branch
gsp() {
        # Safety checks
        if ! git rev-parse --git-dir >/dev/null 2>&1; then
                echo "❌ Not in a git repository"
                return 1
        fi

        local git_dir=$(git rev-parse --git-dir)
        if [[ -f "$git_dir/rebase-merge/interactive" ]] || [[ -d "$git_dir/rebase-apply" ]] || [[ -f "$git_dir/MERGE_HEAD" ]]; then
                echo "❌ Git operation in progress. Complete or abort first."
                return 1
        fi

        if ! git diff-index --quiet HEAD -- 2>/dev/null; then
                echo "❌ You have uncommitted changes. Commit or stash them first:"
                git status --porcelain
                return 1
        fi

        if ! git remote get-url upstream >/dev/null 2>&1; then
                echo "❌ No 'upstream' remote found"
                return 1
        fi

        if ! git remote get-url origin >/dev/null 2>&1; then
                echo "❌ No 'origin' remote found"
                return 1
        fi

        local current_branch=$(git branch --show-current)

        # Prevent pushing from main
        if [[ "$current_branch" == "main" ]]; then
                echo "❌ Cannot push from main branch. Switch to your feature branch first:"
                echo "   git checkout <your-feature-branch>"
                return 1
        fi

        # Show what we're about to do
        echo "⚠️  About to sync and push branch: $current_branch"
        echo "   This will:"
        echo "   • Fetch latest changes from upstream"
        echo "   • Rebase your branch on updated main"
        echo "   • Force-push to your fork (updates PR)"
        echo ""

        read -p "Continue? [y/N]: " -n 1 -r
        echo

        if [[ ! $REPLY =~ ^[Yy]$ ]]; then
                echo "❌ Operation cancelled"
                return 0
        fi

        echo "🔄 Final sync with upstream..."
        if ! git fetch upstream; then
                echo "❌ Failed to fetch from upstream"
                return 1
        fi

        echo "📌 Updating local main..."
        if ! git checkout main; then
                echo "❌ Failed to checkout main"
                return 1
        fi

        if ! git reset --hard upstream/main; then
                echo "❌ Failed to reset main"
                return 1
        fi

        if ! git push origin main; then
                echo "❌ Failed to push main to origin"
                return 1
        fi

        echo "🔀 Rebasing feature branch..."
        if ! git checkout "$current_branch"; then
                echo "❌ Failed to checkout $current_branch"
                return 1
        fi

        if ! git rebase main; then
                echo "❌ Rebase failed. Resolve conflicts and try again:"
                echo "   git add <resolved-files> && git rebase --continue"
                echo "   Then run 'gsp' again"
                return 1
        fi

        echo "🚀 Pushing feature branch to fork..."
        if ! git push origin "$current_branch" --force-with-lease; then
                echo "❌ Failed to push to origin. The branch may have been updated."
                echo "   Run 'git pull origin $current_branch' and try again"
                return 1
        fi

        echo "✅ Feature branch $current_branch successfully pushed to fork"
}

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.

I wrote this suite of scripts a few years ago and still use them to:

1. Boot into Ventoy and select a Debian Live environment
2. Optional: connect a storage device (local partition, USB drive, etc) for persistent storage
3. Modify cfg/cfg.sh if it's the first time using the tool
4. Run setup.sh to configure the environment into a familiar/productive state

The tools are flexible on hardware (more directed toward x64 systems at this time), and I (almost) never have to worry about OS upgrades. Just boot into a newer live OS image once it's ready. They are still a work-in-progress and still have a few customizations that I should abstract for more general use, but it's FOSS in case anyone has merge requests, issues, suggestions, etc.

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

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
}

I alias traditional stuff to better, usually drop-in versions of that thing on computers that have the better thing. I often forget which systems have the better thing, so this helps me get the better experience if I was able to install it at some point. For example I alias cat to bat, or top to htop, or dig to drill, etc.

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 have a collection of about 8 machines around the house (a lot of Raspberry Pi) that I ssh around to from various points.

I have setup scripts named: ssp1 ssp2 ssba ss2p etc. to ssh into the various machines, and of course shared public ssh keys among them to skip the password prompt. So, yes, once you are "in" one machine in my network, if you know this, you are "in" all of them, but... it's bloody convenient.

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.