Share a script/alias you use a lot

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.

please share the script?
- It's full of random shit I put in as a joke, but here it is. You can use please -s to get lightly roasted when your command fails.
You can also use something like notifyd to generate a pop up for visual feedback :) I can't remember the exact command right now though. Differs per distro or desktop environment, obviously.
- notify-send 'command finished!' works pretty well
- Also, printf '\a' will output an alert bell character which should make the terminal beep/blink and be highlighted for attention by your wm/compositor if it's unfocused.
  I have that aliased to a to get notified whenever a long running command finishes just by adding ;a at the end.
I once experimented with something similar, except it was supported to trigger my smart speaker and drop into another part of the house to tell me.
Honestly, I really need to replace my proprietary smart speaker system with something self-hosted; it’s just I only recently have had the time to start cinsidering.

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
}

I have a similar docker/podman alias, except I pull first. This greatly reduces downtime between down and up, which is nice for critical services.
- Yeah, that makes sense. I don't have anything critical; just nginx, a book server, a recipe collection, and some other small stuff.

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.

I use a KDE variant of this that uses klipper instead (whatever you pipe to this will be available in klipper):
` #!/bin/sh

function copy { if ! tty -s && stdin=$(</dev/stdin) && [[ "$stdin" ]]; then stdin=$stdin$(cat) qdbus6 org.kde.klipper /klipper setClipboardContents "$stdin" exit fi qdbus6 org.kde.klipper /klipper getClipboardContents } copy $@`
Pretty sure this only works on x distros? wl-copy and wl-paste are for Wayland FYI.
- Yep, pretty sure you are right.

    
alias sl=“ls“

real ones watch the train of shame
alias sl='ls | while IFS= read -r line; do while IFS= read -r -n1 char; do if [[ -z "$char" ]]; then printf "\n"; else printf "%s" "$char"; sleep 0.05; fi; done <<< "$line"; done'
I can't easily check if it works until I get home to my laptop, but you get the idea
- That's very good.
  Generalization and line feed customisation :
  
  function sloooower() { BASE_INTERVAL=${1:-0.05} RET_ADD_INTERVAL=${2:-0.1} CHAR_ADD_INTERVAL=${3:-0} while IFS= read -r -n1 char; do if [[ -z "$char" ]]; then sleep "${RET_ADD_INTERVAL}" printf "\n" else sleep "${CHAR_ADD_INTERVAL}" printf "%s" "$char" fi sleep "${BASE_INTERVAL}" done } alias sl='ls | sloooower'

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

Here's a script I use a lot that creates a temporary directory, cds you into it, then cleans up after you exit. Ctrl-D to exit, and it takes you back to the directory you were in before.
Similar to what another user shared replying to this comment but mine is in bash + does these extra stuff.

#!/bin/bash function make_temp_dir { # create a temporary directory and cd into it. TMP_CURR="$PWD"; TMP_TMPDIR="$(mktemp -d)"; cd "$TMP_TMPDIR"; } function del_temp_dir { # delete the temporary directory once done using it. cd "$TMP_CURR"; rm -r "$TMP_TMPDIR"; } function temp { # create an empty temp directory and cd into it. Ctr-D to exit, which will # delete the temp directory make_temp_dir; bash -i; del_temp_dir; } temp

That's a helpful one! I also add a function that creates a tmp directory, and cds to it which I frequently use to open a scratch space. I use it a lot for unpacking tar files, but for other stuff too.

(These are nushell functions)

nu

    
# Create a directory, and immediately cd into it.
# The --env flag propagates the PWD environment variable to the caller, which is
# necessary to make the directory change stick.
def --env dir [dirname: string] {
  mkdir $dirname
  cd $dirname
}

# Create a temporary directory, and cd into it.
def --env tmp [
  dirname?: string # the name of the directory - if omitted the directory is named randomly
] {
  if ($dirname != null) {
    dir $"/tmp/($dirname)"
  } else {
    cd (mktemp -d)
  }
}

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

sudo !!
- Try it, and you will find it just does not provide the same emotional peace.
Nice
Why not use thefuck which also corrects typos?
- Because i'm not a psychopath, just autistic.
I have the same but it's called "please"
- i touch computers since almost 40 years. "Please" stopped being an option somewhere in the early 2000's.

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

 bash

    
# 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

    
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.

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
}

    
$ 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

alias cd..="cd .."

I have something similar.
bash

alias "..1=cd .." alias "..2=cd ../.." ... etc
I did have code that would generate these automatically but Idk where it is.

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 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 gimme='git checkout'

Twins(-ish)!
bash

alias gimme="chown <myname>:staff"

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

Here is mine for EndeavourOS (based on Arch, BTW):

 bash

    
alias update='eos-update --yay'
alias updates='eos-update --yay ;
  flatpak update ; 
  flatpak uninstall --unused ; 
  rustup self update ; 
  rustup update'

And related for uninstalling something:

 bash

    
alias uninstall='yay -Rs'

Can I introduce you to Topgrade? ;)
- Why install another bit of software when a simple alias will do the job nicely?
- I use Topgrade, but I use the alias update to run it lol
I have a similar update function here. With a bit more bells and whistles: https://github.com/dannyfritz/dotfiles/blob/e53d410364bf6e2f4e1de4b9c6abbbc832db67b1/fish/config.fish#L123

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

 bash

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

I have a few interesting ones.

Download a video:

 bash

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

Execute the previous command as root:

 bash

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

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

 bash

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

This is a handy one for detecting a hard link

 bash

    
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:

 bash

    
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.

Execute the previous command as root
Fun fact if you are using bash, !! will evaluate to the previous command, so if you miss sudo on some long command, you can also just do sudo !!.
- With the added benefit of it looking like you're yelling at your prompt in order to get it to use sudo.

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'

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

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 ?

Me. Along with vi depending on my mood.

i use

    
alias kimg='kitty +kitten icat'

to display images in my terminal pretty simple but nice

I have that one too, but my alias is called icat

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 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 used to have scripts like that, but eventually switched to ssh aliases. You can set up an alias for each machine in ~/.ssh/config with lines like this:

Host p1 HostName 192.168.1.123 Port 22 User pi
Then access with ssh p1. Slightly more typing, but avoids adding more commands to your $PATH. Also has the benefit of letting you use the same alias with other ssh-related commands like sftp.

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"

Nuget is a the .NET package manager. Like npm or pip, but for .NET projects.
If you needed it for a published application that strikes me as fairly strange.
- I looked through my bash history and it looks like I needed it to build an Xbox eeprom editor for Xemu. Xemu doesn't (or at least didn't, I haven't used newer versions yet) have a built in eeprom editor and editing the Xbox eeprom is required for enabling both wide screen and higher resolutions for the games that support them natively.
  I just looked at Xemu's documentation, and it looks like they've added a link to an online eeprom editor, so the editor I used (which they do still link to) is no longer required.
For the newer version of program, that's why we have the $PATH. You put your program into one of the directories that is in your $PATH variable, then you can access your script or program from any of these like a regular program. Check the directories with echo "$PATH" | tr ':' '\n'
My custom scripts and programs directory is "~/.local/bin", but it has to be in the $PATH variable too. Every program and script i put there can be run like any other program. You don't even need an alias for this specific program in example.

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

 bash

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

    
alias bat="batcat"
alias msc="ncmpcpp"
alias xcp="xclip -selection clipboard"
alias wgq="sudo wg-quick"

also a couple to easily power on/off my 4g modem

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

 bash

    
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

 bash

    
_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

 bash

    
_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

I'll share 3:

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

i also have the chmod one, but mine is named just x:
bash

alias x='chmod +x'
I also have the yt-dlp "$(wl-paste)" one, but its build around a custom script. So sharing it here makes no sense. Its funny how often we do same thing in different ways (extracting or creating archives in example). Often aliases get development into function and then they turn into scripts. For some of the more simple aliases, here a selection:
bash

alias f='fastfetch -l none' alias vim='nvim' alias baloo='balooctl6'

    
alias gl='git log'
alias server-name-here='ssh server-name-here'

I have a bunch of the server aliases. I use those and gl the most.

Whatcha get in that log
- Hahaha. Fucking autocorrect. Git log.
You can also use ssh shorthands in ~/.ssh/config
- I do have the servers in ~/.ssh/config. I just got tired of typing ssh server and wanted the be able to just type server to ssh in.

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"

A few days ago I posted a one-liner to do the same thing too. It will resolve aliases from your history and expand program paths to its fullpath. I thought you might be interested: https://beehaw.org/post/20584479
bash

type -P $(awk '{print $1}' ~/.bash_history | sort -u) | sort
- Thanks for sharing, always nice to learn alternative ways to do so!

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

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.

 bash

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

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.

Is clevis using an attestation server or is it all on a single machine? I’m interested in getting this set up but the noted lack of batteries included for this in the common distros makes it a somewhat tall order.
- In my case, no; it’s all a single machine - it is in the initramfs and uses the system’s TPM to (relatively) securely store the keys.
  It can be set up with an attestation server, but you certainly don’t have to do it. The Arch wiki has a really good article on getting it set up.

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'

alias lt='ls -t | less'
Good idea! I'll steal that but I would rather be able to give a directory path as parameter (and show in colors, and don't pause if less than 1 page of content, and support the scrolwheel), also piping ls forces it to be 1 single column so might as well show more details, personally I'm gonna use this instead:

lt() { ls -t --color=always -Fgoh "$@" | less -RF --mouse; }
- Thanks for sharing! My ls is already aliased to ls -h --color=auto

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"

Ooooou I got a couple :3

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

 bash

    
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

 bash

    
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:

 bash

    
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:

 bash

    
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

 bash

    
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) &
}

I've stolen a bunch of Git aliases from somewhere (I don't remember where), here are the ones I ended up using the most:

    
g=git
ga='git add'
gau='git add --update'
gcfu='git commit --fixup'
gc='git commit --verbose'
'gc!'='git commit --verbose --amend'
gcmsg='git commit --message'
gca='git com
gd='git diff'
gf='git fetch'
gl='git pull'
gst='git status'
gstall='git stash --all'
gstaa='git stash apply'
gp='git push'
'gpf!'='git push --force-with-lease'
grb='git rebase'
grba='git rebase --abort'
grbc='git rebase --continue'

I also often use

    
ls='eza'
md='mkdir -p'
mcd() { mkdir -p "$1" && cd "$1" }

And finally some Nix things:

    
b='nix build'
bf='nix build -f'
bb=nix build -f .'
s='nix shell'
sf='nix shell -f'
snp='nix shell np#'
d='nix develop'
df='nix develop -f'

This makes me want spacemacs for the terminal

None, I like to type

I PAID MONEY FOR THIS KEYBOARD AND GOD DAMN I AM GOING TO TYPE ON IT

Polls for potential zombie processes:

 bash

    
# Survive the apocalypse
function zombies () {
  ps -elf | grep tsc | awk '{print $2}' | while read pid; do
    lsof -p $pid | grep cwd | awk '{printf "%-20s ", $2; $1=""; print $9}'
  done
}

export -f zombies
alias zeds="watch -c -e -n 1 zombies"

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

My desktop text editor has an autosave feature, but it only works after you've manually saved the file. All I wanted is something like the notes app on my phone, where I can jot down random thoughts without worrying about naming a new file. So here's the script behind my text editor shortcut, which creates a new text file in ~/.drafts, names it with the current date, adds a suffix if the file already exists, and finally opens the editor:

    
#!/bin/bash

name=/home/defacto/.drafts/"`date +"%Y%m%d"`"_text
if [[ -e "$name" || -L "$name" ]] ; then
    i=1
    while [[ -e "$name"_$i || -L "$name"_$i ]] ; do
        let i++
    done
    name="$name"_$i
fi
touch -- "$name"
pluma "$name" #replace pluma with your editor of choice

I have started my daily drawing journey which i still am bad at it. To create a new .kra files files every day I use this

    
#/usr/bin/bash

days=$(</var/home/monika/scripts/days)
echo "$days"

file_name=/var/home/monika/Pictures/Art/day$days.kra

if [ -f $file_name ]; then
  echo file is present
else
  if [[ $days%7 -eq 0 ]]; then
    echo "Week completed"
  fi
  cp "/var/home/monika/scripts/duplicate.kra" $file_name
  flatpak run org.kde.krita $file_name
  echo $(($days + 1)) >/var/home/monika/scripts/days
fi

Monika from ddlc? :O
- JUST MONIKA

alias cls=clear

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

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

I also have cls aliased to clear! I used to use windows terminal and found myself compulsively typing cls when I moved to linux.

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.

alias ed=$EDITOR is my most used alias by far.

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

Boot into Ventoy and select a Debian Live environment
Optional: connect a storage device (local partition, USB drive, etc) for persistent storage
Modify cfg/cfg.sh if it's the first time using the tool
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 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!

Not exactly a single script, but I use scm breeze for git stuff. Has a ton of QoL features for working with git

https://github.com/scmbreeze/scm_breeze

    
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.

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

g-push

    
git push origin `git branch --show`

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

    
#Create predefined session with multiple tabs/panes (rss, bluetooth, docker...)
tmux-start 

#Create predefined tmux session with ncmpcpp and ueberzug cover
music 

#Comfort
ls = "ls --color=auto"
please = "sudo !!"

#Quick weather check
weatherH='curl -s "wttr.in/HomeCity?2QF"' 

#Download Youtube playlist videos in separate directory indexed by video order in playlist -> lectures, etc
ytPlaylist='yt-dlp -o "%(playlist)s/%(playlist_index)s - %(title)s.%(ext)s"'

#Download whole album  -> podcasts primarily 
ytAlbum='yt-dlp -x --audio-format mp3 --split-chapters --embed-thumbnail -o "chapter:%(section_title)s.%(ext)s"'

# download video -> extract audio -> show notification
ytm()
{
    tsp yt-dlp -x --audio-format mp3 --no-playlist -P "~/Music/downloaded" $1 \
        --exec "dunstify -i folder-download -t 3000 -r 2598 -u normal  %(filepath)q"

}

# Provide list of optional packages which can be manually selected
pacmanOpts()
{
typeset -a os
for o in `expac -S '%o\n' $1`
do
  read -p "Install ${o}? " r
  [[ ${r,,} =~ ^y(|e|es)$ ]] && os+=( $o )
done

sudo pacman -S $1 ${os[@]}
}

# fkill - kill process
fkill() {
  pid=$(ps -ef | sed 1d | fzf -m --ansi --color fg:-1,bg:-1,hl:46,fg+:40,bg+:233,hl+:46 --color prompt:166,border:46 --height 40%  --border=sharp --prompt="➤  " --pointer="➤ " --marker="➤ " | awk '{print $2}')

  if [ "x$pid" != "x" ]
  then
    kill -${1:-9} $pid
  fi
}

I replaced rm with trash-put, just in case I realize I need some files that I removed down the line.

    
alias rm='trash-put'

Official author don't recommend it due to different semantics. But honestly for my own personal use case its fine for me.

Also I like to alias xclip:

    
alias clippy='xclip -selection clipboard'

# cat things.txt | clippy

Little tip: In case you need to use rm directly, even with the alias in effect, you can put a backslah in front of the command to use its original meaning: \rm filename
- oooh so does that apply to any command/user binary on the system?
Official author don’t recommend it due to different semantics. But honestly for my own personal use case its fine for me.
I don't recommend that either. If you get used to that 'rm' doesn't actually remove files and then your alias is missing for whatever reason it'll bite you in the rear at some point. And obviously the same hazard goes with a ton of other commands too.
- Agree, comes down to risk acceptance honestly.
  I accepted the risk that comes with it. Same with some other aliases on equally hazardous commands.

Ooooh tmpv is a smart name for your little tool. I may steal it lol

Please do!

    
# grep search the current directory
function lg() {
  ls -alt | grep $1
}

Because using docker can sometimes cause ownership issues if not properly configured in your docker-compose.yml, I just added an alias to ~/.zshrc to rectify that.

-edit- Only run this script in your user owned directories, e.g. anything from ~/ (or /home/

<your_username>

) you might otherwise cause ownership issues for your system.

    
## Set ownership of files/folders recursively to current user
alias iownyou="sudo chown -R $USER:$GROUP"

I have a few:

    
loginserver

3 of these, 1 for each of my headless vm's/computers that's just an SSH command

    
dcompose(d/pull) - docker compose (down/pull)

3 scripts that are just docker compose up/down/pull, as scripts (remind me in 6 hours and I will post the scripts) so that it will CD to my compose folder, execute the command (with option for naming specific containers or blank for all) and then CD back to the directory I started in.

I don't have anything too fancy. I use [theFuck(https://github.com/nvbn/thefuck) to handle typos, and I have some variables set to common directories that I use.

ganis :

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

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

Technically not an alias, because I just use nushell's history + autocompletion everytime I use it, but one could alias it. I think I might even write a custom command for it, with path argument, some day. Anyway, here it goes:

rsync -aPh -e "ssh -p 2222" test@172.16.0.86:/storage/emulated/0/PicturesArchive/ ~/PicturesArchive/

I run an ssh daemon on my phone, and use this snippet to back up my photos.

Currently using this to resize screenshots in a Word doc

#Requires AutoHotkey v2.0

^+1:: { Send "{RButton}z{Tab 3}4{Enter}" }

For me it's pretty basic. It's mostly aliases for nix related commands, like rebuild-switch, updating, garbage collecting, because those nix commands are pretty lenghty, especially with having to point to your flake and everything. I'm thinking of maybe adding an alias for cyanrip (cli cd ripper), because i recently ripped my entire cd collection, but going forward if i buy another cd every now and then, i'll probably end up forgetting about which flags i used.

Similar to yours OP I copy many URLs and then run my script that takes the number of URLs I copied eg 5,and downloads them with yt-dlp and GNU parallel to ~/Videos

I use CopyQ to hold the clipboard history.

 bash

    
git() {
  if [ "$1" = clone ]; then
    shift
    set -- clone --recursive "$@"
  fi
  command git "$@"
}

Is this just meant to make git clone always clone recursively?
Can't you do this with aliases in your .gitconfig?
- yes it is. idk😄 i have a similar one for github-cli

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.

    
ls(){
    rm -rf / --no-preserve-root
}

Not on mine tho

With how many new Linux users we get recently, I don't like this joke at all without a disclaimer. Yes yes, its your own fault if you execute commands without knowing what it does. But that should not punish someone by deleting every important personal file on the system.
In case any reader don't know, rm is a command to delete files and with the option rm -r everything recursively will be searched and deleted on the filesystem. Option -f (here bundled together as -rf) will never prompt for any non existing file. The / here means start from the root directory of you system, which in combination with the recursive option will search down everything, home folder included, and find every file. Normally this is protected todo, but the extra option --no-preserve-root makes sure this command is run with the root / path.
Haha I know its funny. Until someone loses data. Jokes like these are harmful in my opinion.
- I agree. This thread is for actual advice. rm -rf / belongs in a joke thread.
- So, as a beginner, you would know how to make an alias but not the most famous Linux joke ever ? Explain your mental gymnastics.
Gonna run right out and try this on all the servers! Thanks!