# AdvanceCOMP
Compress PNGs and overwrite them:                           $ advpng -z4i 20 <file>...

# Bash
Restart Bash:                                               $ exec bash
List aliases:                                               $ alias
Locate a Bash function definition:                          $ shopt -s extdebug && declare -F <function> && shopt -u extdebug
Remove the last job from the job table:                     $ disown
Remove a job from the job table:                            $ disown <jobid>
Make a job ignore SIGHUB:                                   $ disown -h <jobid>
Set an environment variable for current session:            $ export <var>=<value>

# btrfs-progs
Create a Btrfs file system:                                 See mkfs.btrfs notes.
Change the label on a Btrfs file system:                    $ sudo umount <mountpoint> && sudo btrfs filesystem label /dev/<partition> <newlabel>

# Cargo
Install Rust packages:                                      $ cargo install <package>...
Uninstall binaries for Rust packages:                       $ cargo uninstall <package>...
List installed Rust packages:                               $ cargo install --list

# ClamAV
Update virus databases for ClamAV:                          $ sudo freshclam
Scan files for viruses using ClamAV:                        $ clamscan -ir <path>

# CUPS
List devices available to CUPS:                             $ sudo lpinfo -lv
List printers using CUPS:                                   $ lpstat -a
List print jobs using CUPS:                                 $ lpstat -l
Cancel a print job using CUPS (supports tab completion):    $ cancel <job>
Restart CUPS:                                               $ sudo systemctl restart cups

# curl
Download a file:                                            $ curl -L <url> -o <outfile>
Print an HTTP header:                                       $ curl -I <url>

# DNF
Install remote RPMs:                                        $ sudo dnf install <package>...
Remove installed RPMs:                                      $ sudo dnf remove <package>...
List enabled RPM repositories:                              $ dnf repolist
List installed RPMs:                                        $ dnf list --installed [*<package>*...]
List installed RPMs that require the given RPM:             $ dnf repoquery --installed --recursive --whatrequires *<package>*
List user-installed RPMs:                                   $ dnf repoquery --userinstalled [*<package>*...]
List user-installed RPMs that require the given RPM:        $ dnf repoquery --userinstalled --recursive --whatrequires *<package>*
List all RPMs that require the given RPM:                   $ dnf repoquery --recursive --whatrequires *<package>*
List RPMs installed from the given repository:              $ dnf repository-packages <repoid> list --installed
Show changelogs for RPMs:                                   $ dnf changelog <package>...
Show information about RPM package groups:                  $ dnf group info <group>...

# Docker
Start the Docker daemon:                                    $ sudo systemctl start docker
Stop the Docker daemon:                                     $ sudo systemctl stop docker
List running Docker containers:                             $ sudo docker container ls
List all Docker containers:                                 $ sudo docker container ls -a
Remove all stopped Docker containers:                       $ sudo docker container prune
Remove the given Docker containers:                         $ sudo docker container rm <container>...
List all Docker images:                                     $ sudo docker image ls
Remove the given Docker images:                             $ sudo docker image rm <image>...
List all Docker volumes:                                    $ sudo docker volume ls
Remove all unused Docker volumes:                           $ sudo docker volume prune
Remove the given Docker volumes:                            $ sudo docker volume rm <volume>...
Remove unused Docker containers, images, etc:               $ sudo docker system prune -a
List Docker networks:                                       $ sudo docker network ls
Show info on the given Docker network:                      $ sudo docker network inspect <network>
Build images for a Docker app:                              $ sudo docker compose build
Start containers for a Docker app:                          $ sudo docker compose up [--build]
Print logs for a Docker app:                                $ sudo docker compose logs
Stop containers for a Docker app:                           $ sudo docker compose down
Remove containers for a Docker app:                         $ sudo docker compose rm -s
Run a command in an existing Docker container:              $ sudo docker compose exec [-u root] <service> <command>
Run psql in an existing Docker container:                   $ sudo docker compose exec -u postgres postgres psql -c SQL <database>
Run a command in a new Docker container:                    $ sudo docker compose run [-u root] <service> <command>
Run Bash in an existing Docker container:                   $ sudo docker compose exec [-u root] <service> bash
Run Bash in a new Docker container:                         $ sudo docker compose run [-u root] <service> bash

# dpkg
Remove an architecture supported by dpkg:                   $ sudo dpkg --remove-architecture <architecture>
Print the changelog for a deb package:                      $ apt-get changelog <package>
Install a local deb package:                                $ sudo apt-get install ./<name>.deb
Install remote deb packages:                                $ sudo apt-get update && sudo apt-get install <package>[/<codename>-backports]...
Reinstall remote deb packages:                              $ sudo apt-get update && sudo apt-get reinstall <package>[/<codename>-backports]...
Install updates for installed deb packages:                 $ sudo apt-get update && sudo apt-get dist-upgrade && sudo apt-get autoremove
Uninstall deb packages:                                     $ sudo apt-get remove <package>... && sudo apt-get autoremove
Uninstall deb packages and remove their config files:       $ sudo apt-get purge <package>... && sudo apt-get autoremove
List installed deb packages:                                $ dpkg-query -l [<pattern>]
List installed deb backports:                               $ dpkg-query -l | rg '~bpo'
List default deb packages:                                  $ dpkg-query -Wf '${Priority}\t${Package}\n' | rg '^required|^important|^standard' | sort
List deb packages installed manually:                       $ rg -z "Commandline: apt" /var/log/apt/history.log*
List installed reverse dependencies of a deb package:       $ apt-rdepends -r -s PreDepends --state-follow Installed --state-show Installed <package>
Find deb package that includes an installed program:        $ which <program> | xargs dpkg -S
Print info about an installed deb packages:                 $ apt-cache show <package>
Print the priority info for an installed deb package:       $ apt-cache policy <package>
Print the priorities of deb sources:                        $ apt-cache policy

# Dunst
Restart Dunst (e.g., after updating config):                $ pkill dunst; background dunst

# e2fsprogs
Create an ext2/3/4 file system:                             See mke2fs notes.
Change the label on an ext2/3/4 file system:                $ sudo e2label /dev/<partition> <label>
Remove the label on an ext2/3/4 file system:                $ sudo e2label /dev/<partition> ""
Check an ext2/3/4 file system:                              $ sudo umount /dev/<partition> && sudo e2fsck /dev/<partition>

# Emacs
Start Emacs with no configuration:                          $ emacs -q
Start Emacs with no window system:                          $ emacs -nw

# exfat-utils
Check an exFAT file system:                                 $ sudo umount /dev/<partition> && sudo exfatfsck /dev/<partition>

# ExifTool
Print metadata in images and media files:                   $ exiftool <files>

# fd
Find files:                                                 $ fd -H <pattern> [<path>...]
Find files, including files in ~/.ignore:                   $ fd -u <pattern> [<path>...]
Find files, excluding files that match a pattern:           $ fd -H --exclude=<pattern> <pattern> [<path>...]
Find files modified after the specified date:               $ fd -H --changed-within=<YYYY-MM-DD> <pattern> [<path>...]
Find files modified before the specified date:              $ fd -H --changed-before=<YYYY-MM-DD> <pattern> [<path>...]
Count files:                                                $ fd -u <pattern> [<path>...] | wc -l

# file
Print file type:                                            $ file <file>...
Print MIME type of file:                                    $ file -b --mime-type <file>...

# Firefox
Start Firefox Profile Manager:                              $ firefox -P
Start Firefox with the given profile:                       $ firefox -P <profile>

# Fontconfig
List installed fonts:                                       $ fc-list : family | sort
List installed font files:                                  $ fc-list : file | sort

# Git
Create a Git repo:                                          $ git init [&& git config user.name "<name>"] [&& git config user.email <email>]
Clone a Git repo:                                           $ git clone [-b <branch>] [--depth <depth>] [--recursive] <repo> <newdir>
Clone a Git repo and all branches (i.e., mirror):           $ cd <newdir> && git clone --mirror <repo> .git && git config --unset core.bare && git reset --hard
List Git settings:                                          $ git config [--global|--local] -l
Set a Git variable:                                         $ git config [--global] <var> "<value>"
Unset a Git variable:                                       $ git config [--global] --unset <var>
List all Git branches:                                      $ git branch -av
List local Git branches:                                    $ git branch -v
List remote-tracking Git branches:                          $ git branch -rv
Create a Git branch:                                        $ git branch <newbranch>
Switch to a Git branch:                                     $ git checkout <branch>
Create and switch to a Git branch:                          $ git checkout -b <newbranch> [<branch|tag>]
Rename a Git branch:                                        $ git branch -m <oldbranch> <newbranch>
Remove a local Git branch:                                  $ git branch -D <branch>
Remove a remote-tracking Git branch:                        $ git branch -D -r <branch>
Remove all remote-tracking Git branches:                    $ git branch -r | xargs git branch -D -r
Unset a Git branch's upstream branch:                       $ git branch --unset-upstream [<branch>]
Stage all modified files for a Git commit:                  $ git add -A [--dry-run]
Stage the given files for a Git commit:                     $ git add [--dry-run] <file>...
Commit changes to current Git branch:                       $ git commit -m <message>
Apply commit to current Git branch:                         $ git cherry-pick <commit>
Print Git commit logs:                                      $ git log [--grep=<pattern>] [--author=<pattern>]
Print commit message and diff for a Git commit:             $ git show <commit>
Merge a Git branch into current branch:                     $ git merge <branch> [-X ours|theirs]
Merge a Git tag into current branch:                        $ git merge <tag>
Pull a Git branch:                                          $ git pull --rebase [<remote> [<remotebranch>[:<localbranch>]]]
Pull a Git branch and auto-resolve conflicts:               $ git pull --rebase [<remote> [<remotebranch>[:<localbranch>]]] [-X ours|theirs]
Pull all Git branches:                                      $ git pull --all [<remote>]
Download all tags to current Git repo:                      $ git fetch -t
List tags of a remote Git repo:                             $ git ls-remote -t <remote>
Rebase current Git branch onto remote branch:               $ git pull --rebase <remotebranch> [<localbranch>]
Remove a remote Git branch:                                 $ git push [-f] <remote> --delete <branch>
Push to a Git branch:                                       $ git push [-f] [<remote> [<localbranch>[:<remotebranch>]]]
Interactively rebase the last Git commits:                  $ git rebase -i HEAD~<amount> [<localbranch>]
List remotes for current Git repo:                          $ git remote -v
Add a remote (e.g., origin) to current Git repo:            $ git remote add <name> <url>
Change the URL for a Git repo:                              $ git remote set-url <name> <newurl>
Remove stale Git branches:                                  $ git remote prune [--dry-run] <repo>
Rename a remote for current Git repo:                       $ git remote rename <oldname> <newname>
Remove last Git commit and uncommitted changes:             $ git reset --hard HEAD~1
Untrack a file in the current Git repo:                     $ git rm -r --cached <file>
Untrack all files in the current Git repo:                  $ git rm -r --cached .
Initialize and update Git submodules:                       $ git submodule update --init

# GNU coreutils
Resume suspended job:                                       $ bg <jobid>
Change ownership of file:                                   $ chown [-R] <owner>:<group> <file>...
Change file permissions (a.k.a. modes):                     $ chmod [-R] [u|g|o][+|-|=][r|w|x] <file>...
Print MD5 checksum of file:                                 $ cksum -a md5 <file>...
Print SHA-224 checksum of file:                             $ cksum -a sha224 <file>...
Print SHA-256 checksum of file:                             $ cksum -a sha256 <file>...
Print SHA-384 checksum of file:                             $ cksum -a sha384 <file>...
Print SHA-512 checksum of file:                             $ cksum -a sha512 <file>...
Print the path of a command (alternative to `type`):        $ command -v <command>
Edit crontab file:                                          $ crontab -e
List crontab entries:                                       $ crontab -l
Print disk usage:                                           $ df
Print disk usage of a directory:                            $ du -ah [--max-depth=<num>] [<dir>] | sort -h
Print first lines of a file:                                $ head [--lines=<num>] <file>
Print info about user (e.g., UID and groups):               $ id [<user>]
Print current user's name:                                  $ id -un
List jobs in current session:                               $ jobs
Terminate a process:                                        $ kill <pid>
Kill a process:                                             $ kill -9 <pid>
Create a symbolic link:                                     $ ln -s <source> <target>
Run job in foreground:                                      $ fg <jobid>
Find files larger or smaller than a size:                   $ find [<path>...] -size [+|-]<size>[k|M|G] | xargs ls
Print current user's name:                                  $ logname
List desktop entries:                                       $ ls /usr/share/applications ~/.local/share/applications
List installed widget toolkit themes:                       $ ls /usr/share/themes
List installed icon themes and pointer/cursor themes:       $ ls /usr/share/icons
Manage mail in /var/mail/<user>:                            $ mail
Print MD5 checksum of file:                                 $ md5sum <file>...
Run a command that will ignore SIGHUP:                      $ nohup <command> &
List processes:                                             $ ps -e
List environment variables:                                 $ printenv
Print the value of an environment variable:                 $ printenv <var>
Print working directory:                                    $ pwd
Print absolute path of file:                                $ realpath -es <file>...
Replace pattern in text and print all text:                 $ sed -E 's/<pattern>/<replacement>/' <file>
Replace pattern in text and print matching lines:           $ sed -nE 's/<pattern>/<replacement>/p' <file>
Replace pattern in range (lines 1-10) and print all text:   $ sed -E '1,10s/<pattern>/<replacement>/' <file>
Remove first line in file:                                  $ sed -i '1d' <file>...
Prepend string to non-empty file:                           $ sed -i '1i <string>' <file>...
Print SHA-224 checksum of file:                             $ sha224sum <file>...
Print SHA-256 checksum of file:                             $ sha256sum <file>...
Print SHA-384 checksum of file:                             $ sha384sum <file>...
Print SHA-512 checksum of file:                             $ sha512sum <file>...
Monitor a file for appended text:                           $ tail -f <file>
Print last lines of a file:                                 $ tail [-n <amount>] <file>
Redirect stdout to file:                                    $ <command> | tee <file>...
Redirect and append stdout to file:                         $ <command> | tee -a <file>...
Send (not redirect) streams to file:                        $ <command> |& tee <file>...
Append (not redirect) streams to file:                      $ <command> |& tee -a <file>...
Print execution time of a command:                          $ time <command>
Change file timestamps:                                     $ touch <file>...
Describe a command (e.g., print the path):                  $ type <command>
Print system architecture:                                  $ uname -m
Print Linux kernel name and version:                        $ uname -sr
List users who are logged in:                               $ who
Print current user's name:                                  $ whoami

# GNU gzip
Compress a file with gzip compression:                      $ gzip <file>
Decompress a gzipped file:                                  $ gzip -dk <name>.gz

# GnuPG
List OpenPGP public keys:                                   $ gpg -k
List OpenPGP secret keys:                                   $ gpg -K
Change password for OpenPGP secret key:                     $ gpg --passwd <uid>
Remove OpenPGP public key:                                  $ gpg --delete-key <uid>
Remove OpenPGP secret key:                                  $ gpg --delete-secret-key <uid>
Remove OpenPGP key pair:                                    $ gpg --delete-secret-and-public-key <uid>
Export OpenPGP public key(s):                               $ gpg --export [-a <uid>] > <name>.asc
Export OpenPGP secret key(s):                               $ gpg --export-secret-keys [-a <uid>] > <name>.asc
Encrypt file with OpenPGP public key:                       $ gpg -er UID <file>
Encrypt file with password:                                 $ gpg -c <file>
Decrypt OpenPGP-encrypted file:                             $ gpg -d <file>
Generate a random ID:                                       $ gpg --gen-random 30
Edit OpenPGP key pair:                                      See GnuPG notes.

# gThumb
Reset gThumb settings:                                      $ gsettings reset-recursively org.gnome.gthumb
Reset gThumb settings:                                      $ dconf reset -f /org/gnome/gthumb/

# hyperfine
Benchmark a command:                                        $ hyperfine --warmup 3 '<command>'

# ImageMagick
Convert an image with ImageMagick:                          $ magick source.ppm [<options>] dest.jpg
Resize a photo with ImageMagick to share via email:         $ magick source.jpg -resize 1280 -quality 80 dest.jpg
List file formats supported by ImageMagick:                 $ magick -list format

# Info-ZIP
Create a ZIP archive:                                       $ zip -r [--encrypt] <name>.zip <file>...
List files in a ZIP archive:                                $ unzip -l <name>.zip
Extract files from a ZIP archive:                           $ unzip <name>.zip -d <newdir>

# kmod
List Linux kernel modules (a.k.a. drivers):                 $ lsmod

# less
Monitor a file for appended text:                           $ less -R +F <file>

# libnotify
Send a libnotify-based desktop notification:                $ notify-send <summary> [<body>]

# Linux
List groups on the system:                                  $ cat /etc/group

# mu
Show info about mu's message database:                      $ mu info

# My scripts
Replace link in Org files:                                  $ replace '\[\[file:before.org\]\[Before\]\]' '[[file:after.org][After]]' [<path>...]
Delete line in files (with the best preview):               $ replace '(.*\n)<line>\n(.*)' '$1$2'

# npm
Install an npm package:                                     $ npm i [-g|-D] [--legacy-peer-deps] <package>[@<version>]
Install an npm package from GitHub:                         $ npm i [-g|-D] github:<user>/<repo>[#<commitid>]
Install npm packages listed in a package.json file:         $ rm node_modules package-lock.json && npm install
Uninstall npm packages:                                     $ npm uninstall [-g] <package>...
List npm packages:                                          $ npm ls [-g]
Run local npm package binary:                               $ npx <command>

# Openbox
Reload Openbox configuration:                               $ openbox --reconfigure
Restart Openbox:                                            $ openbox --restart
Select window and list properties used by Openbox:          $ obxprop | rg '^_OB_APP' | sort

# OpenSSH
SSH into remote system:                                     $ ssh <user>@<address>
Generate SSH key:                                           $ ssh-keygen -t ed25519
Change password for SSH key:                                $ ssh-keygen -pf ~/.ssh/<file>

# optiPNG
Compress a PNG:                                             $ optipng -o 7 -strip all [-dir <outdir>] [-out <outfile>] <file>
Compress multiple PNGs:                                     $ optipng -o 7 -strip all [-dir <outdir>] <files>

# Oxipng
Compress a PNG:                                             $ oxipng -Zo max --strip all [--out <outfile>] <file>
Compress multiple PNGs:                                     $ oxipng -Zo max --strip all [--dir <outdir>] <files>

# p7zip
Extract files from a 7z archive:                            $ 7zr x [-o<outputdir>] <file>.7z

# Parted
List block devices:                                         $ sudo parted -l

# pass
List passwords managed by pass:                             $ pass
Search for passwords managed by pass:                       $ pass grep <string>

# pdfgrep
Search PDFs:                                                $ pdfgrep -nr <pattern> [<path>...]

# pip
List Python packages installed in ~/.local:                 $ pip list --user
Install Python packages in ~/.local:                        $ pip install --user <package>...
Upgrade Python packages in ~/.local:                        $ pip install -U --upgrade-strategy=eager --user <package>...
Uninstall Python packages in ~/.local:                      $ pip uninstall <package>...
Uninstall all Python packages in ~/.local:                  $ for pkg in $(pip list --user | awk 'NR > 2 { print $1 }'); do pip uninstall "$pkg"; done

# pngcrush
Compress a PNG:                                             $ pngcrush -brute <infile> <outfile>
Compress multiple PNGs:                                     $ pngcrush -brute [-d <outdir>] [-e .pngcrush.png] <files>

# PNGOUT
Compress a PNG:                                             $ pngout <infile> <outfile>

# pngquant
Compress a PNG:                                             $ pngquant -Q 65 -s 1 --strip [-o <outfile>] <file>
Compress multiple PNGs:                                     $ pngquant -Q 65 -s 1 --strip [--ext .pngquant.png] <file>...

# Postgres
Restart Postgres server:                                    $ sudo systemctl restart postgresql
Create Postgres database:                                   $ sudo -u postgres createdb -O postgres <db>
Connect to Postgres:                                        $ sudo -u postgres psql [<db>]
List Postgres databases:                                    $ sudo -u postgres psql -l
List tables in Postgres database:                           $ sudo -u postgres psql -c "\dt" <db>
List columns of Postgres database table:                    $ sudo -u postgres psql -c "\d+ <table>" <db>
List users in Postgres database:                            $ sudo -u postgres psql -c "SELECT id, name, email FROM users;" <db>
Change password of Postgres role:                           $ sudo -u postgres psql -c "ALTER ROLE <role> WITH PASSWORD '<password>';"
Print row count of Postgres database table:                 $ sudo -u postgres psql -c "SELECT count(*) FROM <table>;" <db>

# procps
Print memory usage:                                         $ free -h
Print how long the system has been running:                 $ uptime -p

# psmisc
List processes:                                             $ killall <tab> <tab>
Terminate processes:                                        $ killall -w <processnames>
Kill processes:                                             $ killall -ws 9 <processnames>

# PulseAudio
Start PulseAudio:                                           $ pulseaudio --start
Stop PulseAudio:                                            $ pulseaudio --kill
Run PulseAudio Volume Control:                              $ pavucontrol
List sound cards:                                           $ pacmd list-cards
List audio sources/inputs:                                  $ pactl list sources
List audio sinks/outputs:                                   $ pactl list sinks
Set volume for source/input:                                $ pactl set-source-volume <source> <percentage>
Set volume for sink/output:                                 $ pactl set-sink-volume <sink> <percentage>
Toggle mute for source/input:                               $ pactl set-source-mute <source> toggle
Toggle mute for sink/output:                                $ pactl set-sink-mute <sink> toggle

# QEMU
Create a qcow2 disk image for a VM:                         $ qemu-img create -f qcow2 <name>.qcow2 30G
Start a VM (after creating a qcow2 disk image):             $ qemu-system-x86_64 -cpu max -accel kvm -smp 4 -m 4G [-cdrom <iso|sr0>] <name>.qcow2

# Readline
List default Readline key bindings:                         $ bind -p | rg ': '
List custom Readline key bindings:                          $ bind -X

# ripgrep
Print lines matching a pattern:                             $ rg [-i] <pattern> <path>...
Print lines matching a pattern in certain files:            $ fd -H <pattern> [<path>...] -x rg -nH [-i] <pattern>
Print lines matching a pattern, including compressed files: $ rg -z [-i] <pattern> <path>...
Print lines that don't match a pattern:                     $ rg -v [-i] <pattern> <path>...

# rsync
Syncronize files:                                           $ rsync -vaAXh [--exclude=PATTERN --delete-excluded] SRC... [DEST]

# SANE
List scanners:                                              $ scanimage -L
Perform a test scan of a document:                          $ scanimage -T
Scan a document:                                            $ scanimage > <name>.pnm

# scrot
Save a screenshot:                                          $ scrot --delay 5 --quality 100 ~/pending/screenshot.png

# SELinux
Show status of SELinux:                                     $ sestatus

# shadow-utils
Run command as the given user:                              $ su -c <command> <user>
Change current user's password:                             $ passwd
List users on the system:                                   $ sudo passwd -aS
Add a user to a group:                                      $ sudo gpasswd -a <user> <group>
Add a user to a group:                                      $ sudo usermod -aG <group> <user>
Remove a user from a group:                                 $ sudo gpasswd -d <user> <group>
Remove a user from the system:                              $ sudo userdel <user>
Remove a group from the system:                             $ sudo groupdel <group>

# sudo
Run command as the given user:                              $ sudo -u <user> <command>
Print value of variable for root user:                      $ sudo sh -c 'echo $<var>'

# systemd
List systemd services:                                      $ systemctl [--user] [--state=enabled] list-unit-files
List systemd timers:                                        $ systemctl [--user] [--all] list-timers
Print status of a systemd service:                          $ systemctl [--user] status <service>
Enable a systemd system/user service:                       $ [sudo] systemctl [--user] enable <service>
Start a systemd system/user service:                        $ [sudo] systemctl [--user] start <service>
Restart a systemd system/user service:                      $ [sudo] systemctl [--user] restart <service>
Stop a systemd system/user service:                         $ [sudo] systemctl [--user] stop <service>
Disable a systemd system/user service:                      $ [sudo] systemctl [--user] disable <service>
Reload systemd unit files for system/user services:         $ [sudo] systemctl [--user] daemon-reload
Shut down the system:                                       $ sudo systemctl poweroff
Restart the system:                                         $ sudo systemctl reboot
List available system locales:                              $ localectl list-locales
List system and user paths                                  $ systemd-path

# tar
List files in a tar archive:                                $ tar -tf <file>.tar
Extract files from a tar archive:                           $ tar -xf <file>.tar
Create a tar archive:                                       $ tar -cf <file>.tar <dir>
Create a gzipped tar archive:                               $ tar -czf <file>.tar.gz <dir>
Create an xzipped tar archive:                              $ tar -cJf <file>.tar.xz <dir>

# tree
List contents of a directory:                               $ tree [-L <level>] [<dir>]

# UnRAR
List files in a RAR archive:                                $ unrar l <name>.rar
Extract files from a RAR archive:                           $ unrar x <name>.rar

# util-linux
Open optical disk tray:                                     $ eject
Close optical disk tray:                                    $ eject -t
List mounted file systems:                                  $ findmnt
List CPU info:                                              $ lscpu
List block devices:                                         $ lsblk
Edit fstab:                                                 $ sudo micro /etc/fstab
Mount a file system:                                        $ sudo mount [<devicepartition|iso>] <mountpoint>
Mount all file systems in fstab:                            $ sudo mount -a
Unmount a file system:                                      $ sudo umount <mountpoint>

# Wget
Download a file:                                            $ wget [-O <newfile>] <url>
Download a file and overwrite existing file:                $ wget -N <url>
Download a website recursively:                             $ wget -mkp <url>
Resume a download:                                          $ wget -c <url>
Check if a remote file exists:                              $ wget --spider <url>

# Wrangler
Run a dev server for a Cloudflare Pages project:            $ npx wrangler pages dev [<dir>]
Deploy a static website to Cloudflare Pages:                $ npx wrangler pages deploy

# X11
Print X server's DPI:                                       $ xdpyinfo | rg resolution
Print a window's class name (e.g., for Openbox config):     $ xprop | rg 'CLASS'
List input devices (e.g., USB mouse and keyboard):          $ xinput list
List properties for input device (e.g., USB mouse):         $ xinput list-props <device>
Set property for input device (e.g., USB mouse):            $ xinput set-prop <device> <property> <value>
Load X resources:                                           $ xrdb <file>
List X resources:                                           $ xrdb -query

# xdg-user-dirs
Set the XDG user directories in user-dirs.dirs:             $ xdg-user-dirs-update

# xdg-utils
Print MIME type of a file:                                  $ xdg-mime query filetype <file>
Set default app for a MIME type:                            $ xdg-mime default APP.desktop <mimetype>
Open file in default app:                                   $ xdg-open <file>
Set default web browser:                                    $ xdg-settings set default-web-browser <browser>.desktop

# xorriso
Print status and summary of optical disk:                   $ xorriso -dev /dev/sr0 -toc
Create ISO image using a directory as input:                $ xorriso -for_backup -outdev <name>.iso -map <dir> /
Burn ISO image to optical disc using xorriso:               $ sudo umount /dev/sr0; sudo xorrecord -v dev=/dev/sr0 blank=as_needed <name>.iso
Burn directory to optical disc:                             $ sudo umount /dev/sr0; sudo xorriso -for_backup -outdev /dev/sr0 -blank as_needed -map <dir> /

# Zopfli
Compress a PNG:                                             $ zopflipng -m <infile> <outfile>
Compress multiple PNGs:                                     $ zopflipng -m --prefix=<outdir|fileprefix> <files>