Skip Navigation

Share a script/alias you use a lot

A while ago I made a tiny function in my ~/.zshrc to download a video from the link in my clipboard. I use this nearly every day to share videos with people without forcing them to watch it on whatever site I found it. What's a script/alias that you use a lot?

 undefined
    
# Download clipboard to tmp with yt-dlp
tmpv() {
  cd /tmp/ && yt-dlp "$(wl-paste)"
}

  
150 comments
  • 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.

  • alias qr='qrencode -t ansiutf8'

    This makes qr codes in the terminal.

    needs the qrencode package

    Example usage and output:

     undefined
        
    felix@buttsexmachine:~$ qr lemmy.fish
    █████████████████████████████
    █████████████████████████████
    ████ ▄▄▄▄▄ █▄ ██ █ ▄▄▄▄▄ ████
    ████ █   █ █ █▄▀▄█ █   █ ████
    ████ █▄▄▄█ █▄▄▄███ █▄▄▄█ ████
    ████▄▄▄▄▄▄▄█▄▀ █▄█▄▄▄▄▄▄▄████
    ████▄▄▄ █▀▄▀▄▀ █▀▄▀▀   █ ████
    ████▄ ▀▄▀▄▄ ▀▄▄█ ▄▄▄█▀█ ▄████
    ██████▄███▄█▀█ ▄█▄ █▀█▀▄▄████
    ████ ▄▄▄▄▄ ██ ▀▀▀▀▄   ▀█▀████
    ████ █   █ █▀ ▀▄█▀▀▄▄  ▀█████
    ████ █▄▄▄█ █ ▀█ ▀█▀ █▄▄█▀████
    ████▄▄▄▄▄▄▄█▄▄█▄▄▄███▄▄██████
    █████████████████████████████
    █████████████████████████████
    *___*
      
  • on most of my systems I get tired of constantly lsing after a cd so I combine them:

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

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

  • 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

  • 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:

     undefined
        
    # 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"
    }
    
      
  •  undefined
        
    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.

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

  • 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)"
    
      
  •  undefined
        
    $ which diffuc
    diffuc: aliased to diff -uw --color=always
    
    
      
     undefined
        
    $ which grepnir
    grepnir: aliased to grep -niIr
    
    
      
     undefined
        
    $ 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
    
      
  • here we go:

    dedup:

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

    this removes duplicate lines, preserving line order

    iter:

     undefined
            #!/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:

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

    fadeout:

     undefined
            #!/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:

     undefined
            #!/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:

     undefined
            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'
      
  • 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
    
      
  • 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.

     undefined
        
    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:

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

  • 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
    }
    
      
150 comments