Linux

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"

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"
}

To answer your question realistically I did history | sed "s/.* //" | sort | uniq -c | sort -n

which returned as first non standard command lr which from my grep lr ~/.bashrc is alias lr="ls -lrth"

Here is on that I actually don't use, but want to use it in scripts. It is meant to be used by piping it. It's simple branch with user interaction. I don't even know if there is a standard program doing exactly that already.

# usage: yesno [prompt]
# example:
#   yesno && echo yes
#   yesno Continue? && echo yes || echo no
yesno() {
    local prompt
    local answer
    if [[ "${#}" -gt 0 ]]; then
        prompt="${*} "
    fi
    read -rp "${prompt}[y/n]: " answer
    case "${answer}" in
    [Yy0]*) return 0 ;;
    [Nn1]*) return 1 ;;
    *) return 2 ;;
    esac
}

Hey OP, consider using $XDG_RUNTIME_DIR instead of /tmp. It's now the more proper place for these kinds of things to avoid permission issues, although I'm sure you're on a single user system like most people. I have clipboard actions set to download with yt-dlp :)

My favorite aliases are:

alias dff='findmnt -D -t nosquashfs,notmpfs,nodevtmpfs,nofuse.portal,nocifs,nofuse.kio-fuse'

alias lt='ls -t | less'

Ooooou I got a couple :3

This one is just a basic mirror fixing thing cuz sometimes I go a while without updating pacman:

alias fixpkg='rate-mirrors --protocol https arch | sudo tee /etc/pacman.d/mirrorlist && sudo pacman -Syy'

This function I made to create virtual audio sinks so I can route audios via qpw and play earrape into discord calls if I want XD

create_vsink() {
    local sink_name=${1:-vsink}  # Default sink name is 'vsink' if no input is provided
    local description=${2:-"Virtual Sink"}  # Default description
    pactl load-module module-null-sink sink_name="$sink_name" sink_properties=device.des>
    echo "Virtual sink '$sink_name' created with description '$description'."
}

Simple parser function I made that makes a whole repo using my git key so it's not just locally created I kinda forgot why I made it tbh:

git_clone() {
    local url="${1#https://}"  # Remove "https://" if present
    git clone "https://$git_key@$url"
}

Awesome mpv function I made that allows for real time pitch+speed shifting via hotkeys and is flexible with extra parameters and shit:

mpv_pitch() {
    if [[ -z "$1" ]]; then
        echo "Usage: mpv_pitch <file> [mpv-options]"
        return 1
    fi
    local file="$1"
    shift
    mpv --input-conf=/dev/stdin "$file" "$@" <<EOF
SHIFT+RIGHT add audio-pitch-correction 0; add pitch 0.01; add speed 0.01  # Decrease pit>
SHIFT+LEFT add audio-pitch-correction 0; add pitch -0.01; add speed -0.01 # Increase pit>
EOF
}

Automatic audio router for firefox audio streams that uses the aforementioned create_sink function to make a specific sink that I can use carla on to mix and make cool shit out of haha

firefox_crush() {
    create_vsink CrunchSink "CrunchSink" 
    firefox --name firefox-vc &

    (while true; do
        SINK_INPUT_ID=$(pactl list sink-inputs short | grep "firefox" | awk '{print $1}')
        if [[ -n "$SINK_INPUT_ID" ]]; then
            pactl move-sink-input "$SINK_INPUT_ID" CrunchSink
            break
        fi
        sleep 0.25
    done) &
}

On MacOS, to open the current directory in Finder: alias f='open -a Finder ./'

I use Clevis to auto-unlock my encrypted root partition with my TPM; this means when my boot partition is updated (E.G a kernel update), I have to update the PCR register values in my TPM. I do it with my little script /usr/bin/update_pcr:

#!/bin/bash
clevis luks regen -d /dev/nvme1n1p3 -s 1 tpm2

I run it with sudo and this handles it for me. The only issue is I can't regenerate the binding immediately after the update; I have to reboot, manually enter my password to decrypt the drive, and then do it.

Now, if I were really fancy and could get it to correctly update the TPM binding immediately after the update, I would have something like an apt package shim with a hook that does it seamlessly. Honestly, I'm surprised that distributions haven't developed robust support for this; the technology is clearly available (I'm using it), but no one seems to have made a user-friendly way for the common user to have TPM encryption in the installer.

i use

alias kimg='kitty +kitten icat' 

to display images in my terminal pretty simple but nice

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 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!

g-push

git push origin `git branch --show`

For docker: I’m not following best practices. I have a giant docker compose file for my entire home lab, this is how I update things:

alias dockpull="docker compose pull"
alias dockup="docker compose up -d --remove-orphans"

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

alias cls=clear

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

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

None, I like to type

# Copy pwd into clipboard using pbcopy
alias cpwd="pwd | tr -d '\n' | pbcopy && echo 'pwd copied into clipboard'"

git() {
  if [ "$1" = "cd" ]; then
    shift
    cd "./$(command git rev-parse --show-cdup)$*"
  else
    command git "$@"
  fi
}

This lets you run git cd to go to the root of your repo, or git cd foo/bar to go to a path relative to that root. You can't do it as an alias because it's conditional, and you can't do it as a git-cd command because that wouldn't affect the current shell.