I think vipe is underrated; it takes whatever is on its stdin, shoves it in a temp file, opens your favorite text editor (EDITOR environment variable) and waits in the background until you finish editing the file and close it. Then it outputs the edited text to its stdout.

It's useful in all kinds of pipes, but personally I use it tons of times a day in combination with xclip, in something like this:

xclip -o -selection primary | vipe | xclip -i -selection clipboard

(I actually have a bit fancier version of this pipe wrapped in a Bash function named xvxx.)

On my setup, this takes my current text selection, opens it in vim, and lets me edit it before it sends it to the "traditional" Ctrl+C clipboard. It's super handy for editing comments like this one.

If you often find yourself writing complex Bash pipelines involving generating some output and then running set of commands per line (perhaps in a while loop), sometimes replacing the "selection part" with vipe can be easier than coming up with right filter.

find_or_ls_or_grep_something | vipe | for while read -r foo; do some_action "$foo"; done

And if you are really confident with Bash, you can go even a step further and do:

you might find something like this useful sometimes:

find_or_ls_or_grep_something | vipe | bash

and just create a large dumb one-off script, manually curating what's exactly done. Remember that editing large lists in vim can be made much easier by utilizing vim's ability to invoke unix filter commands (those greps and uniqs and seds et al.) on the buffer, and /or block editing mode using Ctrl+V (that last one method goes really well with column -t).

redshift -O 5000: 'redshift' is a utility that adjusts the color temperature of your display, '-O' allows you to set a specific temperature, and '5000' is what I like.

Edit: I also like xkill. xkill lets you click on a window or program and kills it. I need to do this frequently every time exit Kodi; the program stops, but the window is still there.

sudo shutdown 0

Prevents 99% of bugs and mistakes

The watch command is very useful, for those who don't know, it starts an automated loop with a default of two seconds and executes whatever commands you place after it.

It allows you to actively monitor systems without having to manually re-run your command.

So for instance, if you wanted to see all storage block devices and monitor what a new storage device shows up as when you plug it in, you could do:

watch lsblk

And see in real time the drive mount. Technically not "real time" because the default refresh is 2 seconds, but you can specify shorter or longer intervals.

Obviously my example is kind of silly, but you can combine this with other commands or even whole bash scripts to do some cool stuff.

I use $_ a lot, it allows you to use the last parameter of the previous command in your current command

mkdir something && cd $_

nano file
chmod +x $_

As a simple example.

If you want to create nested folders, you can do it in one go by adding -p to mkdir

mkdir -p bunch/of/nested/folders

Good explanation here:
https://koenwoortman.com/bash-mkdir-multiple-subdirectories/q

Sometimes starting a service takes a while and you're sitting there waiting for the terminal to be available again. Just add --no-block to systemctl and it will do it on the background without keeping the terminal occupied.

systemctl start --no-block myservice

pkill journalctl -b nvtop tail are great but I like: LANGUAGE=en_GB LC_ALL=en_GB.UTF-8 LANG=en_GB.UTF-8 <your GUI program> to run a GUI program in English for more universal compatibility for helping newbies and creating/reading non-terminal based documentation

find /path/to/starting/dir -type f -regextype egrep -regex 'some[[:space:]]*regex[[:space:]]*(goes|here)' -exec mv {} /path/to/new/directory/ \;

I routinely have to find a bunch of files that match a particular pattern and then do something with those files, and as a result, find with -exec is one of my top commands.

If you're someone who doesn't know wtf that above command does, here's a breakdown piece by piece:

• find - cli tool to find files based on lots of different parameters
• /path/to/starting/dir - the directory at which find will start looking for files recursively moving down the file tree
• -type f - specifies I only want find to find files.
• -regextype egrep - In this example I'm using regex to pattern match filenames, and this tells find what flavor of regex to use
• -regex 'regex.here' - The regex to be used to pattern match against the filenames
• -exec - exec is a way to redirect output in bash and use that output as a parameter in the subsequent command.
• mv {} /path/to/new/directory/ - mv is just an example, you can use almost any command here. The important bit is {}, which is the placeholder for the parameter coming from find, in this case, a full file path. So this would read when expanded, mv /full/path/of/file/that/matches/the/regex.file /path/to/new/directory/
• \; - This terminates the command. The semi-colon is the actual termination, but it must be escaped so that the current shell doesn't see it and try to use it as a command separator.

I'm a big enjoyer of pushd and popd

so if youre in a working dir and need to go work in a different dir, you can pushd ./, cd to the new dir and do your thing, then popd to go back to the old dir without typing in the path again

List open files sudo lsof -i -P

Network traffic by hardware sudo tcpdump -i en1 -nn -s0

Current processes top -l 1

when I forget to include sudo in my command:

sudo !!

ctrl+r on bash will let you quickly search and execute previous commands by typing the first few characters usually.

it's much more of a game changer than it first meets the eye.

Ctrl-z to suspend the running program.

bg to make it continue running in the background.

jobs to get an overview of background programs.

fg to bring a program to the foreground.

Search for github repos of dotfiles and read through people's shell profiles, aliases, and functions. You'll learn a lot.

i do not know if this counts as a command but you might want to check Atuin, what it does is help you find, manage and edit the commands you used in your shell history saves you a lot of time

A couple I use (concept of not exact), that I haven't seen in the thread yet:

Using grep as diff: grep -Fxnvf orig.file copy.file

Using xargs -

xargs reads items from the standard input, delimited by blanks (which can be protected with double or single quotes or a backslash) or newlines, and executes the command (default is /bin/echo) one or more times with any initial-arguments followed by items read from standard input.

EG: $ find ~/Pictures -name "*.png" -type f -print0 | xargs -0 tar -cvzf images.tar.gz