Always read and understand anything you copy into your terminal.

I’ll document the SSH scripts I regularly use here. I suggest creating a .functions file in your root directory, adding whichever functions you find interesting to it, and finally appending source .functions to your .bash_profile to initialize the functions on startup. You can also add these colors to the top of your .functions file since a couple functions use colors.

bold=$(tput bold)
underline=$(tput smul)
reset=$(tput sgr0)
red=$(tput setaf 1)
green=$(tput setaf 2)
blue=$(tput setaf 4)


cd and ls at the same time. Useful if you’re like me and always want to see what files are available when navigating the terminal.

function cdls() {
	builtin cd "$@" && ls


Make a new Python virtual environment and activate it.

function mkvenv() {
    python3 -m venv venv
    source venv/bin/activate
    pip install --upgrade pip


Create a new Git repository locally and push it to GitHub. Requires having the GitHub CLI installed (run brew install gh to install with Homebrew).

# Style variables
bold=$(tput bold)
blue=$(tput setaf 4)
red=$(tput setaf 1)
green=$(tput setaf 2)
reset=$(tput sgr0)
# Function to check if a command exists
command_exists() {
    command -v "$1" &> /dev/null
# Function to print a step message
print_step() {
    echo "${bold}${blue}=> $1${reset}"
# Function to print success message
print_success() {
    echo "${bold}${green}$1${reset}"
# Function to print error message
print_error() {
    echo "${bold}${red}$1${reset}"
# Function to initialize the git repository
initialize_git() {
    if ! command_exists git; then
        print_error "Git could not be found. Please install it before proceeding."
        return 1
    print_step "Initializing the git repository..."
    git init -b main
    git add .
    git commit -m "Initial commit"
    print_success "Git repository initialized successfully."
    # Setup Python project if applicable
    if [[ "$is_python_project" == "yes" ]]; then
# Function to setup a Python project
setup_python_project() {
    print_step "Setting up the Python project environment..."
    # Create .gitignore
    echo "venv/" >> .gitignore
    # Create the virtual environment and activate it
    python3 -m venv venv
    source venv/bin/activate
    print_success "Python virtual environment created and activated."
    # Create .pre-commit-config.yaml with the provided configuration
    cat << EOF > .pre-commit-config.yaml
  - repo:
    rev: v4.4.0
      - id: trailing-whitespace
      - id: end-of-file-fixer
  - repo:
    rev: v0.11.6
      - id: ssort
  - repo:
    rev: 5.12.0
      - id: isort
        args: ["--profile", "black", "--filter-files"]
  - repo:
    rev: 23.3.0
      - id: black
        args: ["--line-length", "120"]
    # Install pre-commit hooks
    pre-commit install
    print_success "Pre-commit hooks installed."
# Function to create a GitHub repository
create_github_repo() {
    if ! command_exists gh; then
        print_error "GitHub CLI could not be found. Please install it before proceeding."
        return 1
    print_step "Creating the GitHub repository..."
    if gh repo create "$directory" --source=. --remote=upstream --push --${visibility}; then
        print_success "Created the repo $directory on GitHub!"
        print_error "Failed to create the GitHub repo. Please check your network connection and try again."
        return 1
# Main function to make a git repository
mkgit() {
    # Ask for the directory name
    echo -n "${bold}${blue}Please enter the directory name: ${reset}"
    read directory
    if test -d "$directory"; then
        echo "${bold}${red}Error: Folder already exists.${reset}"
        return 1
    # Make sure this is running in the Documents folder
    if ! [[ "$(pwd)" =~ ~/Documents.*$ ]]; then
        echo "${bold}${red}Error: Please navigate to the documents folder before running this script.${reset}"
        return 1
    # Create a local directory and enter it
    mkdir "$directory" && cd "$directory"
    # Ask for repository visibility
    echo -n "${bold}${blue}Should the repository be public or private? (public/private): ${reset}"
    read visibility
    while [[ "$visibility" != "public" && "$visibility" != "private" ]]; do
        echo "${bold}${red}Invalid input. Please enter either 'public' or 'private': ${reset}"
        read visibility
    # Ask for README contents
    echo -n "${bold}${blue}What would you like the README to say?: ${reset}"
    read readme_content
    echo "$readme_content" >
    # Default .gitignore contents
    echo ".vscode/" >> .gitignore
    # Check if it's a Python project
    echo -n "${bold}${blue}Is this a Python project? (yes/no): ${reset}"
    read is_python_project
    # Ask for vscode settings
    echo -n "${bold}${blue}Would you like to add a .vscode/settings.json file? (yes/no): ${reset}"
    read vscode_answer
    if [[ "$vscode_answer" == "yes" ]]; then
        mkdir -p ".vscode" && touch ".vscode/settings.json"
    # Initialize local git repo
    # Prepare for linking local repo to GitHub


This is handy if you SSH into servers a lot from your terminal. It gives you a quick dropdown of your servers and uses the usernames and hostnames you provided ahead of time.

function sshgo() {
    # Define the colors and styles using ANSI escape codes
    local RED="\033[31m"
    local GREEN="\033[32m"
    local YELLOW="\033[33m"
    local CYAN="\033[36m"
    local BOLD="\033[1m"
    local RESET="\033[0m"
    # Define your SSH accounts as indexed arrays
    local labels=("1" "2" "3") # Labels for each account
    local descriptions=("GPU 1" "GPU 2" "Digital Ocean") # Descriptions for each account
    local commands=("user1@gpu1" "user2@gpu2" "root@") # SSH commands
    # Print a pretty list of your SSH accounts
    echo -e "${GREEN}${BOLD}SSH Accounts:${RESET}"
    echo -e "${CYAN}-------------${RESET}"
    for i in "${!labels[@]}"; do
        echo -e "[${YELLOW}${BOLD}${labels[$i]}${RESET}] ${CYAN}${descriptions[$i]}${RESET}"
    echo -e "${CYAN}-------------${RESET}"
    # Prompt the user to select an account
    read -p "Enter the number corresponding to the account you want to SSH into: " selection
    # Check if the entered number is valid
    if [[ ! " ${labels[@]} " =~ " ${selection} " ]]; then
        echo -e "${RED}Invalid selection. Please try again.${RESET}"
        return 1
    # Find the index of the selected label
    local index
    for i in "${!labels[@]}"; do
        if [[ "${labels[$i]}" == "${selection}" ]]; then
    # SSH into the selected account
    echo -e "${GREEN}Connecting to ${descriptions[$index]}...${RESET}"
    ssh ${commands[$index]}


Updates a dotfiles repository with relevant dotfiles. Will need to change file paths to match your machine.

function refresh_dots() {
    # Go to root
    cd ~
    # Refresh Brewfile
    rm Brewfile
    HOMEBREW_NO_AUTO_UPDATE=1 brew bundle dump
    # Copy main dotfiles
    cp .bash_prompt .bash_profile .bashrc .aliases .exports .functions .gitconfig .gitignore_global .git-completion.bash .hushlogin .inputrc .vimrc Brewfile .tmux.conf Documents/code/dotfiles
    # VSCode
    cp ~/Library/Application\ Support/Code/User/{settings.json,keybindings.json} Documents/code/dotfiles/vscode
    cp -R ~/Library/Application\ Support/Code/User/snippets Documents/code/dotfiles/vscode
    cp ~/.vscode/extensions/extensions.json Documents/code/dotfiles/vscode
    # Go to dotfiles folder
    cd ~/Documents/code/dotfiles


A handy add-on to Bash shells showing you how long each command takes to run. Great way to start gaining intuition on the relative amounts of time functions take. May need to run brew install coreutils. Idea credit to Swyx.

preexec() {
  timer=$(gdate +%s.%N)
precmd() {
  if [ -n "$timer" ]; then
    now=$(gdate +%s.%N)
    elapsed=$(echo "$now - $timer" | bc)
    timer_show=$(printf "%.2f" $elapsed)
    echo "Execution time: ${timer_show}s"
    unset timer