generate ascii art using a custom font file

toilet {{input_text}} -f {{font_filename}}


toilet {{input_text}} --filter {{filter_name}}


start an application with the procfile in the current directory


start an application with a specified procfile


run oneoff commands with the process's environment


start all processes except the one named "worker"


display all process trees rooted at processes owned by specified user


check quotas on all mounted nonnfs filesystems


force check even if quotas are enabled (this can cause damage or loss to quota files)


check quotas on a given filesystem in debug mode


check quotas on a given filesystem, displaying the progress

sudo quotacheck --verbose {{mountpoint}}


sudo quotacheck --user {{user}} {{mountpoint}}


sudo quotacheck --group {{group}} {{mountpoint}}


display only the mime type, and not the filename


determine the mime type of stdin (does not check a filename)


display debug information about how the mime type was determined


display all the possible mime types of a given file in confidence order


explicitly specify the 2letter language code of the output


sudo chage --maxdays {{10}} {{username}}


sudo chage --maxdays {{-1}} {{username}}


sudo chage --expiredate {{YYYY-MM-DD}} {{username}}


force user to change password on next log in


tell the kernel about the existence of the specified partition

addpart {{device}} {{partition}} {{start}} {{length}}


run the daemon with a configuration file


run the daemon with the standard perloginsession message bus configuration


run the daemon with the standard systemwide message bus configuration


set the address to listen on and override the configuration value for it


force the message bus to write to the system log for messages


view the rules which are currently applied


permanently move the interface into the block zone, effectively blocking all communication

firewall-cmd --permanent --zone={{block}} --change-interface={{enp1s0}}


permanently open the port for a service in the specified zone (like port 443 when in the `public` zone)

firewall-cmd --permanent --zone={{public}} --add-service={{https}}


permanently close the port for a service in the specified zone (like port 80 when in the `public` zone)

firewall-cmd --permanent --zone={{public}} --remove-service={{http}}


permanently open two arbitrary ports in the specified zone

firewall-cmd --permanent --zone={{public}} --add-port={{25565/tcp}} --add-port={{19132/udp}}


reload firewalld to force rule changes to take effect


display information only for the current cpu


display raw hex information with no decoding


create a uuidv1 based on the current time


create a uuidv5 of the name with a specified namespace prefix

uuidgen --sha1 --namespace {{@dns|@url|@oid|@x500}} --name {{object_name}}


compute and display the wpapsk key for a given ssid reading the passphrase from stdin


compute and display wpapsk key for a given ssid specifying the passphrase as an argument


display a summary of the top 10 historical uptime records


display the downtime between reboots instead of the kernel version


create a copy with unixstyle line endings

dos2unix -n {{filename}} {{new_filename}}


check and repair a btrfs filesystem (dangerous)

sudo btrfs check --repair {{path/to/partition}}


sudo btrfs check --progress {{path/to/partition}}


verify the checksum of each data block (if the filesystem is good)

sudo btrfs check --check-data-csum {{path/to/partition}}


use the `n`th superblock (`n` can be 0, 1 or 2)

sudo btrfs check --super {{n}} {{path/to/partition}}


sudo btrfs check --repair --init-csum-tree {{path/to/partition}}


sudo btrfs check --repair --init-extent-tree {{path/to/partition}}


play a wav sound file over the default target


play a wav sound file at a different volume level


generate a permuted index where the first field of each line is an index reference


generate a permuted index with automatically generated index references


generate a permuted index with a fixed width


generate a permuted index with a list of filtered words


generate a permuted index with sysvstyle behaviors


perform a dry run (print what would be done without actually doing it)


generate a ramdisk environment based on the `linux` preset


generate a ramdisk environment based on the `linuxlts` preset


generate ramdisk environments based on all existing presets (used to regenerate all the initramfs images after a change in `/etc/mkinitcpio.conf`)


generate an initramfs image using an alternative configuration file

mkinitcpio --config {{path/to/mkinitcpio.conf}} --generate {{path/to/initramfs.img}}


generate an initramfs image for a kernel other than the one currently running (the installed kernel releases can be found in `/usr/lib/modules/`)

mkinitcpio --kernel {{kernel_version}} --generate {{path/to/initramfs.img}}


get the statistics for the placement groups in a cluster


ceph osd pool create {{pool_name}} {{page_number}}


ceph osd pool rename {{current_name}} {{new_name}}


create new user with a default home directory


useradd --shell {{path/to/shell}} {{name}}


create new user belonging to additional groups (mind the lack of whitespace)

useradd --groups {{group1,group2}} {{name}}


create new system user without a home directory

useradd --no-create-home --system {{name}}


open the terminal with a title of `example`


open the terminal with a dark blue background and yellow foreground (font color)


open the terminal with 100 characters per line and 35 lines, in screen position x=200px, y=20px


open the terminal using a serif font and a font size equal to 20


copy the output from a command to the x11 primary selection area (clipboard)


copy the output from a command to a given x11 selection area

echo 123 | xclip -selection {{primary|secondary|clipboard}}


copy the output from a command to the system clipboard, using short notation


copy the contents of a file into the system clipboard


copy the contents of a png into the system clipboard (can be pasted in other programs correctly)

xclip -sel clip -t image/png {{input_file.png}}


copy the user input in the console into the system clipboard


paste the contents of the x11 primary selection area to the console


paste the contents of the system clipboard to the console


display a report of cpu and disk statistics since system startup


display a report of cpu and disk statistics with units converted to megabytes


display disk statistics with disk names (including lvm)


display extended disk statistics with disk names for device "sda"


display incremental reports of cpu and disk statistics every 2 seconds


search for a package that owns a specific file


list only files provided by a package located within the `bin` or `sbin` directory

pkgfile --list --binaries {{package_name}}


search for a package that owns a specific file using caseinsensitive matching


search for a package that owns a specific file in the `bin` or `sbin` directory


search for a package that owns a specific file, displaying the package version


search for a package that owns a specific file in a specific repository

pkgfile --repo {{repository_name}} {{filename}}


get the current screen brightness as a percentage


increase backlight to 100%, over 60 seconds (value given in ms), using 60 steps


display the current configuration (or dry run)


configure the server to use a different password hashing algorithm


enable network information service (nis)


enable winbind (active directory) authentication


display information about a specific undo file

e2undo -h {{path/to/undo_file}} {{/dev/sdXN}}


perform a dryrun and display the candidate blocks for replaying

e2undo -nv {{path/to/undo_file}} {{/dev/sdXN}}


perform an undo operation and display verbose information

e2undo -v {{path/to/undo_file}} {{/dev/sdXN}}


write the old contents of the block to an undo file before overwriting a file system block

e2undo -z {{path/to/file.e2undo}} {{path/to/undo_file}} {{/dev/sdXN}}


find which processes are accessing a file or directory


show more fields (`user`, `pid`, `access` and `command`)


kill all processes accessing a file or directory (sends the `sigkill` signal)


find which processes are accessing the filesystem containing a specific file or directory


rename files using a perl common regular expression (substitute 'foo' with 'bar' wherever found)


dryrun  display which renames would occur without performing them


force renaming even if the operation would remove existing destination files


convert filenames to lower case (use `f` in caseinsensitive filesystems to prevent "already exists" errors)


change to a specific runlevel, but don't stop any existing services


download the latest firmware metadata from lvfs


list the updates available for devices on your system


pause for 5 seconds at startup before launching


list binary packages which would be generated from a rpm spec file


get summary information for single binary packages generated from a rpm spec file

rpmspec --query --queryformat "{{%{name}: %{summary}\n}}" {{path/to/rpm.spec}}


get the source package which would be generated from a rpm spec file

rpmspec --query --srpm {{path/to/rpm.spec}}


check a file, printing extra [i]nformational messages


upgrade installed packages to the newest available versions


install a new package and assume yes to all questions


find which packages provide a given file


sudo pacman-key --populate {{archlinux}}


sudo pacman-key --add {{path/to/keyfile.gpg}}


sudo pacman-key --recv-keys "{{uid|name|email}}"


sudo pacman-key --lsign-key "{{uid|name|email}}"


sudo pacman-key --delete "{{uid|name|email}}"


display information about jobs with changed status


display process id of process group leader


open an lxterminal window, run a command, and then exit


open an lxterminal window with multiple tabs


open an lxterminal window with a specific title


open an lxterminal window with a specific working directory


reduce pdf file size to 150 dpi images for reading on a ebook device

gs -dNOPAUSE -dQUIET -dBATCH -sDEVICE=pdfwrite -dPDFSETTINGS=/ebook -sOutputFile={{output.pdf}} {{input.pdf}}


convert pdf file (pages 1 through 3) to an image with 150 dpi resolution

gs -dQUIET -dBATCH -dNOPAUSE -sDEVICE=jpeg -r150 -dFirstPage={{1}} -dLastPage={{3}} -sOutputFile={{output_%d.jpg}} {{input.pdf}}


gs -dQUIET -dBATCH -dNOPAUSE -sDEVICE=pdfwrite -sOutputFile={{output.pdf}} {{input.pdf}}


gs -dQUIET -dBATCH -dNOPAUSE -sDEVICE=pdfwrite -sOutputFile={{output.pdf}} {{input1.pdf}} {{input2.pdf}}


convert from postscript file to pdf file

gs -dQUIET -dBATCH -dNOPAUSE -sDEVICE=pdfwrite -sOutputFile={{output.pdf}} {{input.ps}}


upgrade to the latest development release


create a new volume group called vg1 using the `/dev/sda1` device


create a new volume group called vg1 using multiple devices

vgcreate {{vg1}} {{/dev/sda1}} {{/dev/sdb1}} {{/dev/sdc1}}


xinput set-prop {{id}} {{setting_id}} {{value}}


open a serial port using the specified baud rate

microcom --port {{path/to/serial_port}} --speed {{baud_rate}}


establish a telnet connection to the specified host


daemonize -p {{path/to/pidfile}} {{command}} {{command_arguments}}


use a lock file to ensure that only one instance runs at a time

daemonize -l {{path/to/lockfile}} {{command}} {{command_arguments}}


sudo daemonize -u {{user}} {{command}} {{command_arguments}}


show the current readings of all sensor chips


search for packages that contain the specified file or path


search for packages that match the regular expression given in `pattern`

apt-file {{search|find}} --regexp {{regular_expression}}


show highlevel information about disk drives and block devices


show detailed information about a device

udisksctl info --block-device {{/dev/sdX}}


show detailed information about a device partition

udisksctl info --block-device {{/dev/sdXN}}


mount a device partition and prints the mount point

udisksctl mount --block-device {{/dev/sdXN}}


udisksctl unmount --block-device {{/dev/sdXN}}


bruteforce a password with a length of 4 to 8 characters, and contains only alphanumeric characters (order matters)

fcrackzip --brute-force --length 4-8 --charset aA1 {{archive}}


bruteforce a password in verbose mode with a length of 3 characters that only contains lowercase characters, `$` and `%`

fcrackzip -v --brute-force --length 3 --charset a:$% {{archive}}


bruteforce a password that contains only lowercase and special characters

fcrackzip --brute-force --length 4 --charset a! {{archive}}


bruteforce a password containing only digits, starting from the password `12345`

fcrackzip --brute-force --length 5 --charset 1 --init-password 12345 {{archive}}


fcrackzip --use-unzip --dictionary --init-password {{wordlist}} {{archive}}


show a summary of services and their status


include services in all runlevels in the summary


show all outputs and configuration files to attach to a bug report


show paths to kscreen configuration files


show kscreen output information and configuration


show the current kscreen configuration as json


display help including qt specific commandline options


enter an interactive repl (use `exit` or ctrl + d to exit)


connect to a database with the currently logged in user


connect to a database with the specified user


connect to a database on the specified host with the specified user

mycli -u {{user}} -h {{host}} {{database_name}}


create entries from scratch instead of updating


print errors and the fragmentation count before and after each file


display a calendar for the current month


display previous, current and next month


display a calendar for a specific year (4 digits)


display a calendar for a specific month and year


synchronize list of packages and versions available


upgrade installed packages to the newest available versions


show information related to configured repositories


sudo btrfs scrub start {{path/to/btrfs_mount}}


show the status of an ongoing or last completed scrub

sudo btrfs scrub status {{path/to/btrfs_mount}}


sudo btrfs scrub cancel {{path/to/btrfs_mount}}


sudo btrfs scrub resume {{path/to/btrfs_mount}}


start a scrub, but wait until the scrub finishes before exiting

sudo btrfs scrub start -B {{path/to/btrfs_mount}}


start a scrub in quiet mode (does not print errors or statistics)

sudo btrfs scrub start -q {{path/to/btrfs_mount}}


perform a calculation in noninteractive mode


search for duplicate extents in a directory and show them


deduplicate duplicate extents on a btrfs or xfs (experimental) filesystem


use a hash file to store extent hashes (less memory usage and can be reused on subsequent runs)

duperemove -r -d --hashfile={{path/to/hashfile}} {{path/to/directory}}


limit i/o threads (for hashing and dedupe stage) and cpu threads (for duplicate extent finding stage)

duperemove -r -d --hashfile={{path/to/hashfile}} --io-threads={{N}} --cpu-threads={{N}} {{path/to/directory}}


run command in existing processes network namespace

nsenter -t {{pid}} -n {{command}} {{command_arguments}}


run a new command in an existing processes pstable namespace

nsenter -t {{pid}} -p {{command}} {{command_arguments}}


run command in existing processes ipc namespace

nsenter -t {{pid}} -i {{command}} {{command_arguments}}


open a newlineseparated list of images, reading filenames from standard input


open a spaceseparated list of images as a slideshow


open a spaceseparated list of images in thumbnail mode


display reports every 2 seconds for 5 times


decompress from a file to the current directory


decompress from a file to the current directory using a specific number of processor threads

lrzuntar -p {{8}} {{path/to/archive.tar.lrz}}


decompress from a file to the current directory and silently overwrite items that already exist


lrzuntar -O {{path/to/directory}} {{archive.tar.lrz}}


delete the compressed file after decompression


print the current brightness of the display backlight


set the brightness of the display backlight to a specified percentage within range


increase brightness by a specified increment


decrease brightness by a specified decrement


show a list of all last logged in users since a given time


show a list of all last logged in users until a given time


show a list of all logged in users at a specific time


show a list of all last logged in users and translate the ip into a hostname


check status of currently active interfaces


generate a public key from a private key

wg pubkey < {{path/to/private_key}} > {{path/to/public_key}}


wg genkey | tee {{path/to/private_key}} | wg pubkey > {{path/to/public_key}}


list misspelled words from standard input


run aspell with a different language (takes twoletter iso 639 language code)


list misspelled words from standard input and ignore words from personal word list

cat {{file}} | aspell --personal={{personal-word-list.pws}} {{list}}


convert a translated po file back to a document

po4a-translate --format {{text}} --master {{path/to/master.doc}} --po {{path/to/result.po}} --localized {{path/to/translated.txt}}


remove from 3rd column till the end of each line


remove from the 3rd column till the 5th column of each line


disable all interfaces which are enabled


display the current state of the system (known screens, resolutions, ...)


disable disconnected outputs and enable connected ones with default settings


change the resolution and update frequency of displayport 1 to 1920x1080, 60hz


set the resolution of hdmi2 to 1280x1024 and put it on the right of dp1

xrandr --output {{HDMI2}} --mode {{1280x1024}} --right-of {{DP1}}


xrandr --output {{LVDS1}} --brightness {{0.5}}


grub-install --target={{x86_64-efi}} --efi-directory={{path/to/efi_directory}} --bootloader-id={{GRUB}}


install grub preloading specific modules

grub-install --target={{x86_64-efi}} --efi-directory={{path/to/efi_directory}} --modules="{{part_gpt part_msdos}}"


remove a user and their home, but backup their files into a `.tar.gz` file in the specified directory

deluser --backup-to {{path/to/backup_directory}} --remove-home {{username}}


remove a user, and all files owned by them


analyze logs for a range of dates at a certain level of detail

logwatch --range {{yesterday|today|all|help}} --detail {{low|medium|others}}'


restrict report to only include information for a selected service

logwatch --range {{all}} --service {{apache|pam_unix|etc}}


display ext2, ext3 and ext4 filesystem information


display the blocks which are reserved as bad in the filesystem


force display filesystem information even with nonrecognisable feature flags


only display the superblock information and not any of the block group descriptor detail information


print the detailed group information block numbers in hexadecimal format


set up a wireless connection interactively


interactively set up a connection to a network and obscure the password


start a game on a certain level (there are nine official levels)


start the pacman4console level editor, saving to a specified text file


trim unused blocks on all mounted partitions that support it


trim unused blocks on a specified partition


send a wol packet to a device in another subnet based on its ip


send a wol packet to a device in another subnet based on its hostname


send a wol packet to a specific port on a host


read hardware addresses, ip addresses/hostnames, optional ports and secureon passwords from a file


open a new konsole in a specific directory


run a specific command and do not close the window after it exits


open a konsole in the background and bring to the front when ctrl+shift+f12 (by default) is pressed


open a konsole with the emergency fallback profile


create an empty ip set which will contain ip addresses


ipset save {{set_name}} > {{path/to/ip_set}}


remove a user along with their home directory and mail spool


userdel --root {{path/to/other/root}} {{name}}


update the list of available packages and versions (it's recommended to run this before other `aptget` commands)


install a package, or update it to the latest available version


remove a package and its configuration files


upgrade all installed packages to their newest available versions


clean the local repository  removing package files (`.deb`) from interrupted downloads that can no longer be downloaded


remove all packages that are no longer needed


upgrade installed packages (like `upgrade`), but remove obsolete packages and install additional packages to meet new dependencies


show usage help, including the program version


test the configuration file and then exit


test plugin data collection functionality and then exit


specify a custom configuration file location


play a specific file (sampling rate, bit depth, etc. will be automatically determined for the file format)


play the first 10 seconds of a specific file at 2500 hz

aplay --duration={{10}} --rate={{2500}} {{path/to/file}}


play the raw file as a 22050 hz, mono, 8bit, mulaw `.au` file

aplay --channels={{1}} --file-type {{raw}} --rate={{22050}} --format={{mu_law}} {{path/to/file}}


create a wordlist file from the given url up to 2 links depth

cewl --depth {{2}} --write {{path/to/wordlist.txt}} {{url}}


output an alphanumeric wordlist from the given url with words of minimum 5 characters

cewl --with-numbers --min_word_length {{5}} {{url}}


output a wordlist from the given url in debug mode including email addresses


output a wordlist from the given url using http basic or digest authentication

cewl --auth_type {{basic|digest}} --auth_user {{username}} --auth_pass {{password}} {{url}}


output a wordlist from the given url through a proxy

cewl --proxy_host {{host}} --proxy_port {{port}} {{url}}


display information about logical volumes


change default display to show more details


display tracking stats for the chrony daemon


print the time sources that chrony is currently using


display stats for sources currently used by chrony daemon as a time source


step the system clock immediately, bypassing any slewing


display verbose information about each ntp source


sudo a2disconf --quiet {{configuration_file}}


do a dry run and print the configuration to stdout


show cpu statistics at a 2 second interval for 10 times


show memory statistics for all processes whose command name include "fox" or "bird"


connect with a defined configuration file


terminate the previously created connection


create a copy with dosstyle line endings

unix2dos -n {{filename}} {{new_filename}}


do not show any idle or zombie processes


show the individual threads of a given process


show only the processes with the given pid(s), passed as a commaseparated list. (normally you wouldn't know pids off hand. this example picks the pids from the process name)


show information about the current connection


connect to the default host (irc.ofct.net) with the nickname set in the `$user` environment variable


connect to a given host, using a given nickname


connect to a given host, using a given nickname and password

sic -h {{host}} -n {{nickname}} -k {{password}}


create a copy with unixstyle line endings

mac2unix -n {{filename}} {{new_filename}}


execute brute force against an ftp server using a file containing usernames and a file containing passwords

medusa -M ftp -h host -U {{path/to/username_file}} -P {{path/to/password_file}}


execute a login attempt against an http server using the username, password and useragent specified

medusa -M HTTP -h host -u {{username}} -p {{password}} -m USER-AGENT:"{{Agent}}"


execute a brute force against a mysql server using a file containing usernames and a hash

medusa -M mysql -h host -U {{path/to/username_file}} -p {{hash}} -m PASS:HASH


execute a brute force against a list of smb servers using a username and a pwdump file

medusa -M smbnt -H {{path/to/hosts_file}} -C {{path/to/pwdump_file}} -u {{username}} -m PASS:HASH


fake the time to this evening, before printing the result of `date`


open a new `bash` shell, which uses yesterday as the current date


simulate how a program would act next friday night

faketime '{{next Friday 1 am}}' {{path/to/program}}


spawn 2 workers to stress test io and timeout after 5 seconds


spawn 2 workers to stress test memory (each worker allocates 256m bytes)


spawn 2 workers spinning on write()/unlink() (each worker writes 1g bytes)


make a package (run in the same directory as a `pkgbuild`)


make a package and install its dependencies


same as above, but install the package with `pacman` when done


make a package, but skip source checksums


clean up work directories after a successful build


rename files using simple substitutions (substitute 'foo' with 'bar' wherever found)


dryrun  display which renames would occur without performing them


prepend "foo" to all filenames in the current directory


rename a group of increasingly numbered files zeropadding the numbers up to 3 digits


x0vncserver -display {{:0}} -passwordfile {{path/to/file}}


start a vnc server using a specific port

x0vncserver -display {{:0}} -rfbport {{port}}


print information about all the commands in the acct (record file)


display commands executed by a given user


display information about a given command executed on the system


display information about commands executed on a given terminal


start an interactive shell (`bash`, by default) in a new root directory


specify the user (other than the current user) to run the shell as

arch-chroot -u {{user}} {{path/to/new/root}}


run a custom command (instead of the default `bash`) in the new root directory

arch-chroot {{path/to/new/root}} {{command}} {{command_arguments}}


specify the shell, other than the default `bash` (in this case, the `zsh` package should have been installed in the target system)


report i/o and transfer rate issued to physical devices, one per second (press ctrl+c to quit)


report a total of 10 network device statistics, one per 2 seconds


report cpu utilization, one per 2 seconds


report a total of 20 memory utilization statistics, one per second


report the run queue length and load averages, one per second


report paging statistics, one per 5 seconds


pretend to load a module into the kernel, but don't actually do it


remove a module and those that depend on it from the kernel

sudo modprobe --remove-dependencies {{module_name}}


sudo modprobe --show-depends {{module_name}}


filter tcp sockets by states, only/exclude


show all tcp sockets connected to the local https port (443)


show all tcp sockets listening on the local 8080 port


show all tcp sockets along with processes connected to a remote ssh port


show all udp sockets connected on specific source and destination ports

ss -u 'sport == :{{source_port}} and dport == :{{destination_port}}'


show all tcp ipv4 sockets locally connected on the subnet 192.168.0.0/16


start the partition manipulator with a specific device


create a new partition table for a specific device and manage it


start htop displaying processes owned by a specific user


sort processes by a specified `sort_item` (use `htop sort help` for available options)


see interactive commands while running htop


list global (extern) functions in a file (prefixed with t)


list all symbols, even debugging symbols


demangle c++ symbols (make them readable)


display information about a container, image, or volume using a name or id


docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' {{container}}


display the path to the container's log file

docker inspect --format='{{.LogPath}}' {{container}}


docker inspect --format='{{.Config.Image}}' {{container}}


display the configuration information as json

docker inspect --format='{{json .Config}}' {{container}}


docker inspect --format='{{range $p, $conf := .NetworkSettings.Ports}} {{$p}} -> {{(index $conf 0).HostPort}} {{end}}' {{container}}


launch steam, printing debug messages to stdout


launch steam and enable its inapp debug console tab


log into steam with the specified credentials


compile and run sequential erlang program as a common script and then exit

erlc {{files}} && erl -noshell '{{mymodule:myfunction(arguments)}}, init:stop().'


erl -remsh {{nodename}}@{{hostname}} -sname {{custom_shortname}} -hidden -setcookie {{cookie_of_remote_node}}


tell the erlang shell to load modules from a directory


check terminal's openness to write messages


disable receiving messages from the write command


enable receiving messages from the write command


retrieve all public ssh keys of a remote host


retrieve all public ssh keys of a remote host listening on a specific port


retrieve certain types of public ssh keys of a remote host

ssh-keyscan -t {{rsa,dsa,ecdsa,ed25519}} {{host}}


manually update the ssh known_hosts file with the fingerprint of a given host

ssh-keyscan -H {{host}} >> ~/.ssh/known_hosts


execute the binary from a given npm module


in case a package has multiple binaries, specify the package name along with the binary


compare files or directories, showing the line numbers

delta --line-numbers {{path/to/old_file_or_directory}} {{path/to/new_file_or_directory}}


compare files or directories, showing the differences side by side

delta --side-by-side {{path/to/old_file_or_directory}} {{path/to/new_file_or_directory}}


compare files or directories, ignoring any git configuration settings

delta --no-gitconfig {{path/to/old_file_or_directory}} {{path/to/new_file_or_directory}}


compare, rendering commit hashes, file names, and line numbers as hyperlinks, according to the hyperlink spec for terminal emulators

delta --hyperlinks {{path/to/old_file_or_directory}} {{path/to/new_file_or_directory}}


display supported languages and associated file extensions


add a timestamp to the beginning of each line


add timestamps with microsecond precision


add [i]ncremental timestamps with microsecond precision, starting from zero


convert existing timestamps in a text file (eg. a log file) into [r]elative format


display calendar for the month of february of the year 2010


provide calendar sheet with week numbers


change starting day of week to 1st day of the week (monday)


display the previous, current and next month surrounding today


compress a file, creating a compressed version next to the file


decompress a file, creating an uncompressed version next to the file


compress a file specifying the output filename

brotli {{file.ext}} -o {{compressed_file.ext.br}}


decompress a brotli file specifying the output filename

brotli -d {{compressed_file.ext.br}} -o {{file.ext}}


specify the compression level. 1=fastest (worst), 11=slowest (best)

brotli -q {{11}} {{file.ext}} -o {{compressed_file.ext.br}}


fix issues in the specified directory (defaults to the pear standard)


display a list of installed coding standards


specify a coding standard to validate against

phpcbf {{path/to/directory}} --standard {{standard}}


specify commaseparated file extensions to include when sniffing

phpcbf {{path/to/directory}} --extensions {{file_extension(s)}}


a commaseparated list of files to load before processing

phpcbf {{path/to/directory}} --bootstrap {{file(s)}}


generate an rsa private key of 2048 bits, saving it to a specific file

openssl genpkey -algorithm rsa -pkeyopt rsa_keygen_bits:{{2048}} -out {{filename.key}}


generate an elliptic curve private key using the curve `prime256v1`, saving it to a specific file

openssl genpkey -algorithm EC -pkeyopt ec_paramgen_curve:{{prime256v1}} -out {{filename.key}}


generate an `ed25519` elliptic curve private key, saving it to a specific file

openssl genpkey -algorithm {{ED25519}} -out {{filename.key}}


figlet {{input_text}} -f {{path/to/font_file.flf}}


use a font from the default font directory (the extension can be omitted)

figlet {{input_text}} -f {{font_filename}}


align the data of a zip file on 4byte boundaries

zipalign {{4}} {{path/to/input.zip}} {{path/to/output.zip}}


check that a zip file is correctly aligned on 4byte boundaries and display the results in a verbose manner

zipalign -v -c {{4}} {{path/to/input.zip}}


analyze a vhdl source file and produce an object file


elaborate a design (where `{{design}}` is the name of a configuration unit, entity unit or architecture unit)


run an elaborated design and dump output to a waveform file

ghdl -r {{design}} --wave={{output.ghw}}


git bug ls "{{status}}:{{open}} {{sort}}:{{edit}}"


specify the upstream server doing the forwarding


lt --port {{8000}} --subdomain {{subdomain}}


open the tunnel url in the default web browser


convert a docbook xml document to pdf format


convert a docbook xml document to html format and store the resulting files in a separate directory

xmlto -o {{path/to/html_files}} {{html}} {{document.xml}}


convert a docbook xml document to a single html file


specify a stylesheet to use while converting a docbook xml document

xmlto -x {{stylesheet.xsl}} {{output_format}} {{document.xml}}


convert a graph from `mm` to `gv` format


cat {{input.mm}} | mm2gv > {{output.gv}}


listen to a port, wait for an incoming connection and transfer data to stdio


create a connection to a host and port, transfer data in stdio to connected host


forward incoming data of a local port to another host and port


start local server for current project on port 4567


start local server for current project on a specified port


build the project in the current directory to prepare for deployment


deploy the middleman project in the current directory


start an interactive terminal after starting the server


print a summary of the image exif metadata


print all metadata (exif, iptc, xmp) with interpreted values


delete all metadata, preserving the file timestamp


rename the file, prepending the date and time from metadata (not from the file timestamp)

exiv2 -r {{'%Y%m%d_%H%M%S_:basename:'}} {{path/to/file}}


install a package (see `pip install` for more install examples)


list routes and do not resolve ip addresses to hostnames


list listening tcp and udp ports (+ user and process if you're root)

netstat --listening --program --numeric --tcp --udp --extend


extract the preview image from the raw file


save the file with size up to the given maximums max1 and max2


delete files that are not tracked by git


interactively delete files that are not tracked by git


show what files would be deleted without actually deleting them


forcefully delete files that are not tracked by git


forcefully delete directories that are not tracked by git


delete untracked files, including ignored files in `.gitignore` and `.git/info/exclude`


display a calendar for the current month


display the previous, current, and next months


display a calendar for a specific year (4 digits)


display a calendar for a specific month and year


generate one passphrase with the default options


generate one passphrase whose first letters of each word match the provided argument


build and upload a sketch to an arduino nano with an atmega328p cpu, connected on port `/dev/ttyacm0`

arduino --board {{arduino:avr:nano:cpu=atmega328p}} --port {{/dev/ttyACM0}} --upload {{path/to/file.ino}}


set the preference `name` to a given `value`


build a sketch, put the build results in the build directory, and reuse any previous build results in that directory

arduino --pref build.path={{path/to/build_directory}} --verify {{path/to/file.ino}}


save any (changed) preferences to `preferences.txt`


start and manage all services in a directory as the current user


start and manage all services in a directory as root


search for files containing a string or regular expression in the current directory recursively


search for lines matching a pattern, printing [o]nly the matched text and not the rest of the line


limit search to files of a specific type


do not search in files of a specific type


ack --count --no-filename "{{search_pattern}}"


print the file names and the number of matches for each file only

ack --count --files-with-matches "{{search_pattern}}"


list all the values that can be used with `type`


generate documentation for java source code and save the result in a directory

javadoc -d {{path/to/directory/}} {{path/to/java_source_code}}


generate documentation with a specific encoding

javadoc -docencoding {{UTF-8}} {{path/to/java_source_code}}


generate documentation excluding some packages

javadoc -exclude {{package_list}} {{path/to/java_source_code}}


sphinx-build -b {{html|epub|text|latex|man|...}} {{path/to/source_dir}} {{path/to/build_dir}}


build documentations intended for readthedocs.io (requires the sphinxrtdtheme pip package)

sphinx-build -b {{html}} {{path/to/docs_dir}} {{path/to/build_dir}}


(gdb) target extended-remote {{localhost}}:{{4500}}


show only the 5 latest entries in the reflog


check the values of all attributes on a file


check the value of a specific attribute on a file

git check-attr {{attribute}} {{path/to/file}}


check the value of a specific attribute on files

git check-attr --all {{path/to/file1}} {{path/to/file2}}


check the value of a specific attribute on one or more files

git check-attr {{attribute}} {{path/to/file1}} {{path/to/file2}}


use the (default) memcheck tool to show a diagnostic of memory usage by `program`


use memcheck to report all possible memory leaks of `program` in full detail

valgrind --leak-check=full --show-leak-kinds=all {{program}}


use the cachegrind tool to profile and log cpu cache operations of `program`


use the massif tool to profile and log heap memory and stack usage of `program`

valgrind --tool=massif --stacks=yes {{program}}


create stabilisation file to be able to remove camera shakes

transcode -J stabilize -i {{input_file}}


remove camera shakes after creating stabilisation file, transform video using xvid

transcode -J transform -i {{input_file}} -y xvid -o {{output_file}}


resize the video to 640x480 pixels and convert to mpeg4 codec using xvid

transcode -Z 640x480 -i {{input_file}} -y xvid -o {{output_file}}


listen on a specified port and print any data received


nc -w {{timeout_in_seconds}} {{ipaddress}} {{port}}


keep the server up after the client detaches


act as proxy and forward data from a local tcp port to the given remote host

nc -l {{local_port}} | nc {{hostname}} {{remote_port}}


zfs set compression=on {{pool_name/filesystem_name}}


zfs set mountpoint={{/my/mount/path}} {{pool_name/filesystem_name}}


start a proxy and save all output to a file


filter a saved traffic file to just post requests

mitmdump -nr {{input_filename}} -w {{output_filename}} "{{~m post}}"


start an access point, forking into the background

sudo hostapd -B {{path/to/hostapd.conf}}


start a gui specifying the background color

sudo tlmgr gui -background "{{#f39bc3}}"


start a gui specifying the foreground color

sudo tlmgr gui -foreground "{{#0ef3bd}}"


start a gui specifying the font and font size


sudo tlmgr gui -geometry {{width}}x{{height}}-{{xpos}}+{{ypos}}


start a gui passing an arbitrary x resource string


kind create cluster --name {{cluster_name}}


get details about clusters, nodes, or the kubeconfig


merge two pdfs into one with the default suffix "joined"


merge the first page of each given file together

pdfjoin {{path/to/file1.pdf path/to/file2.pdf ...}} {{1}} --outfile {{output_file}}


save pages 3 to 5 followed by page 1 to a new pdf with custom suffix

pdfjoin {{path/to/file.pdf}} {{3-5,1}} --suffix {{rearranged}}


pdfjoin {/path/to/file1.pdf}} {{2-}} {{file2}} {{last-3}} --outfile {{output_file}}


compile and begin debugging the main package in the current directory (by default, with no arguments)


compile and begin debugging a specific package


compile a test binary and begin debugging the compiled program


attach to a running process and begin debugging


dlv trace {{package}} --regexp '{{regular_expression}}'


store data that you type from the keyboard


store each of the next lines you enter as values of an array


specify the number of maximum characters to be read

read -n {{character_count}} {{variable}}


use a specific character as a delimiter instead of a new line


do not let backslash (\) act as an escape character


read -p "{{Enter your input here: }}" {{variable}}


do not echo typed characters (silent mode)


read stdin and perform an action on every line


pg_dump {{db_name}} > {{output_file.sql}}


pg_dump -U {{username}} {{db_name}} > {{output_file.sql}}


pg_dump -h {{host}} -p {{port}} {{db_name}} > {{output_file.sql}}


dump a database into a customformat archive file

pg_dump -Fc {{db_name}} > {{output_file.dump}}


dump only database data into an sqlscript file

pg_dump -a {{db_name}} > {{path/to/output_file.sql}}


dump only schema (data definitions) into an sqlscript file

pg_dump -s {{db_name}} > {{path/to/output_file.sql}}


generate a default template configuration file `doxyfile`


generate documentation using an existing configuration file


list all available repositories from which a package can be installed


get all namespaces in the current cluster


get deployments in a specified namespace

kubectl get deployments -n {{namespace}}


get kubernetes objects defined in a yaml manifest

kubectl get -f {{path/to/manifest}}.yaml


prepare the php extension in the current directory for compiling


delete files previously created by phpize


check if a version string respects the semantic versioning format (prints an empty string if it does not match)


convert a version string to the semantic versioning format


test if `1.2.3` matches the `^1.0` range (prints an empty string if it does not match)


test multiple version strings and return only the ones that match


start a container, attaching stdout and stderr and forwarding signals


start one or more spaceseparated containers


symlink all files recursively to a given directory

stow --target={{path/to/target_directory}} {{file1 directory1 file2 directory2}}


delete symlinks recursively from a given directory

stow --delete --target={{path/to/target_directory}} {{file1 directory1 file2 directory2}}


simulate to see what the result would be like

stow --simulate --target={{path/to/target_directory}} {{file1 directory1 file2 directory2}}


stow --restow --target={{path/to/target_directory}} {{file1 directory1 file2 directory2}}


exclude files matching a regular expression

stow --ignore={{regular_expression}} --target={{path/to/target_directory}} {{file1 directory1 file2 directory2}}


open a file displaying from a specific line


search for a string (press `n` to go to the next match)


list module dependencies and available updates


display all bookmarks matching "keyword" and with "privacy" tag


add bookmark with tags "search engine" and "privacy"

buku --add {{https://example.com}} {{search engine}}, {{privacy}}


remove "search engine" tag from a bookmark

buku --update {{bookmark_id}} --tag {{-}} {{search engine}}


pack the currently checked out commit into a zip archive


display a 32bit checksum, size in bytes and filename


calculate the sha512 checksum for a file


calculate sha512 checksums for multiple files


calculate and save the list of sha512 checksums to a file

sha512sum {{path/to/file1}} {{path/to/file2}} > {{path/to/file.sha512}}


read a file of sha512 sums and verify all files have matching checksums


only show a message for files for which verification fails

sha512sum --check --quiet {{path/to/file.sha512}}


list all available tex live packages, prefexing installed ones with `i`


show information about a specific package


list all files contained in a specific package


show only specific information about a package

tlmgr info {{package_name}} --data "{{name}},{{category}},{{installed}},{{size}},{{depends}},..."


print all available packages as json encoded array


set screen update delay to 2 centiseconds (20 milliseconds)


start a singlenode etcd cluster, listening for client requests on a custom url


start a singlenode etcd cluster with a custom name


start a singlenode etcd cluster with extensive metrics available at http//localhost2379/debug/pprof/


print 40 random characters from boccaccio's decameron

lorem --randomize -c {{40}} --decamerone


run tasks in playbook with custom host inventory

ansible-playbook {{playbook}} -i {{inventory_file}}


run tasks in playbook with extra variables defined via the commandline

ansible-playbook {{playbook}} -e "{{variable1}}={{value1}} {{variable2}}={{value2}}"


run tasks in playbook with extra variables defined in a json file

ansible-playbook {{playbook}} -e "@{{variables.json}}"


run tasks in playbook for the given tags

ansible-playbook {{playbook}} --tags {{tag1,tag2}}


run tasks in a playbook starting at a specific task

ansible-playbook {{playbook}} --start-at {{task_name}}


print file with author name and commit hash on each line


print file with author email and commit hash on each line


generate a random password (8 to 10 characters long, containing letters and numbers)


generate a 5 to 10 characters long password

makepasswd --minchars {{5}} --maxchars {{10}}


generate a password containing only the characters "b", "a" or "r"


create a new gist from a spaceseparated list of files


gh gist create {{filename}} --desc "{{description}}"


list gists owned by the currently logged in user


view a gist in the default browser without rendering markdown


build the first project file in the current directory


set one or more semicolonseparated targets to build


set one or more semicolonseparated properties


display detailed information at the end of the log about how the project was configured


run commands from a script file and then exit


define environment variables for the shell process


load the specified `.xonsh` or `.json` configuration files

xonsh --rc {{path/to/file1.xonsh}} {{path/to/file2.json}}


skip loading the `.xonshrc` configuration file


search a disk for bad blocks by using a nondestructive readonly test


search an unmounted disk for bad blocks with a nondestructive readwrite test


search an unmounted disk for bad blocks with a destructive write test


search an unmounted disk for bad blocks with a destructive write test and show verbose status


search an unmounted disk in destructive mode and output found blocks to a file

sudo badblocks -o {{path/to/file}} -w {{/dev/sdX}}


search an unmounted disk in destructive mode with improved speed using 4k block size and 64k block count


add a specified package to `go.mod` in modulemode or install the package in gopathmode


modify the package with a given version in moduleaware mode


return a list of installed fonts in your system


return a list of installed fonts with given name


return the number of installed fonts in your system


display the currently registered api token


create a new spark project with braintree stubs


create a new spark project with teambased billing stubs

spark new {{project_name}} --team-billing


print information about the operating system, shell, php, and wpcli (`wp`) installation


download a fresh wordpress installation to current directory, optionally specifying the locale


create basic `wpconfig` file (assuming database on `localhost`)

wp config create --dbname={{dbname}} --dbuser={{dbuser}} --dbpass={{dbpass}}


replace all instances of a string in the database

wp search-replace {{old_string}} {{new_string}}


import the contents of a wordpress extended rss (wxr) file


create random passwords (default password length is 8)


create a password with at least 1 symbol (s), 1 number (n), 1 uppercase (c), 1 lowercase (l)


create a password with maximum length of 16


create a password that doesn't appear in a dictionary (the dictionary file has to be provided)


phpstorm --line {{line_number}} {{path/to/file}}


phpstorm diff {{path/to/left_file}} {{path/to/right_file}}


compile a pdf document, specifying an output directory


compile a pdf document, exiting if errors occur


add a file from local to the filesystem, pin it and print the relative hash


add a directory and its files recursively from local to the filesystem and print the relative hash


save a remote file and give it a name but not pin it


remove unpinned files from local storage


start emacs in console mode (without an x window)


start an emacs server in the background (accessible via `emacsclient`)


stop a running emacs server and all its instances, asking for confirmation on unsaved files


export an svg file into a bitmap with the default format (png) and the default resolution (96 dpi)

inkscape {{filename.svg}} -o {{filename.png}}


export an svg file into a bitmap of 600x400 pixels (aspect ratio distortion may occur)

inkscape {{filename.svg}} -o {{filename.png}} -w {{600}} -h {{400}}


export the drawing (bounding box of all objects) of an svg file into a bitmap

inkscape {{filename.svg}} -o {{filename.png}} -D


export a single object, given its id, into a bitmap

inkscape {{filename.svg}} -i {{id}} -o {{object.png}}


export an svg document to pdf, converting all texts to paths

inkscape {{filename.svg}} -o {{filename.pdf}} --export-text-to-path


duplicate the object with id="path123", rotate the duplicate 90 degrees, save the file, and quit inkscape

inkscape {{filename.svg}} --select=path123 --verb="{{EditDuplicate;ObjectRotate90;FileSave;FileQuit}}"


search for "wikipedia" using the default search engine


launch firefox in safe mode, with all extensions disabled


take a screenshot of a web page in headless mode

firefox --headless --screenshot {{path/to/output_file.png}} {{https://example.com/}}


use a specific profile to allow multiple separate instances of firefox to run at once

firefox --profile {{path/to/directory}} {{https://example.com/}}


package and compress files and directories [r]ecursively

zip -r {{compressed.zip}} {{path/to/file}} {{path/to/directory1}} {{path/to/directory2}}


e[x]clude unwanted files from being added to the compressed archive

zip -r {{compressed.zip}} {{path/to/directory}} -x {{path/to/exclude}}


archive a directory and its contents with the highest level [9] of compression

zip -r -{{9}} {{compressed.zip}} {{path/to/directory}}


create an encrypted archive (user will be prompted for a password)

zip -e -r {{compressed.zip}} {{path/to/directory}}


zip -d {{compressed.zip}} "{{foo/*.tmp}}"


archive a directory and its contents to a multipart [s]plit zip file (e.g. 3 gb parts)

zip -r -s {{3g}} {{compressed.zip}} {{path/to/directory}}


list files within a specified archive (without extracting them)


tlmgr backup {{package}} --backupdir {{path/to/backup_directory}}


tlmgr backup clean {{package1 package2 ...}}


start redis server, using the default port (6379), and write logs to stdout


start redis server, using the default port, as a background process


start redis server, using the specified port, as a background process

redis-server --port {{port}} --daemonize yes


start redis server with a custom configuration file


make a directed graph acyclic by reversing some edges

acyclic {{path/to/input.gv}} > {{path/to/output.gv}}


print if a graph is acyclic, has a cycle, or is undirected, producing no output graph


only run tests containing a specific string in their names


set the number of simultaneous running test cases


test artifacts in release mode, with optimizations


run an app in a temporary virtual environment


install a package in a virtual environment and add entry points to path


run an app in a temporary virtual environment with a package name different from the executable

pipx run --spec {{httpx-cli}} {{httpx}} {{http://www.github.com}}


send mail (the content should be typed after the command, and ended with `ctrl+d`)


send mail with content passed from another command

echo "{{content}}" | mailx -s "{{subject}}" {{to_addr}}


mailx -s "{{subject}}" {{to_addr}} < {{content.txt}}


send mail to a recipient and cc to another address

mailx -s "{{subject}}" -c {{cc_addr}} {{to_addr}}


mailx -s "{{subject}}" -r {{from_addr}} {{to_addr}}


mailx -a {{file}} -s "{{subject}}" {{to_addr}}


show information about a particular virtual machine


start a virtual machine in headless mode

VBoxManage startvm {{name|uuid}} -type headless


shutdown the virtual machine and save its current state

VBoxManage controlvm {{name|uuid}} savestate


shutdown down the virtual machine without saving its state

VBoxManage controlvm {{name|uuid}} poweroff


VBoxManage extpack install --replace {{VboxExtensionPackFileName}}


change the standard input buffer size to 512 kib


change the standard output buffer to linebuffered


change the standard error buffer to unbuffered


display the disassembled output of executable sections


display a complete binary hex dump of all sections


print lines of code in the current directory


print lines of code in the target directory


print lines of code with stats for individual files


print lines of code without .gitignore (etc.) files (e.g. two u flags will additionally count hidden files and dirs)


calculate contributions for the current git repository


exclude files/directories that match the specified regular expression

git fame --excl "{{regular_expression}}"


calculate contributions made after the specified date

git fame --since "{{3 weeks ago|2021-05-13}}"


display contributions in the specified format

git fame --format {{pipe|yaml|json|csv|tsv}}


display contributions per file extension


compress a file into a new file with the `.zst` suffix


compress a file specifying the compression level, where 1=fastest, 19=slowest and 3=default


unlock higher compression levels (up to 22) using more memory (both for compression and decompression)


start a new project with the package manager


run the test suites from the given files


run the test suites from files within the current and subdirectories, whose paths match the given regular expression


run the tests whose names match the given regular expression


run test suites related to a given source file


run test suites related to all uncommitted files


watch files for changes and automatically rerun related tests


install a package, automatically installing dependencies

raco pkg install --auto {{package_source}}


install the current directory as a package


build (or rebuild) bytecode, documentation, executables, and metadata indexes for collections

raco setup {{collection1 collection2 ...}}


raco test {{path/to/tests1.rkt path/to/tests2.rkt ...}}


rar a {{path/to/archive_name.rar}} {{path/to/file1}} {{path/to/file2}} {{path/to/file3}}


rar a {{path/to/archive_name.rar}} {{path/to/directory}}


split the archive into parts of equal size (50m)

rar a -v{{50M}} -R {{path/to/archive_name.rar}} {{path/to/file_or_directory}}


rar a -p{{password}} {{path/to/archive_name.rar}} {{path/to/file_or_directory}}


encrypt file data and headers with password

rar a -hp{{password}} {{path/to/archive_name.rar}} {{path/to/file_or_directory}}


rar a -m{{compression_level}} {{path/to/archive_name.rar}} {{path/to/file_or_directory}}


compile the project or solution in the current directory


compile a .net project or solution in debug mode


dotnet build --configuration {{Release}}


dotnet build --verbosity {{quiet|minimal|normal|detailed|diagnostic}}


dotnet build --runtime {{runtime_identifier}}


dotnet build --output {{path/to/directory}}


long format list (permissions, ownership, size and modification date) of all files


display a tree of files, three levels deep


list files sorted by modification date (oldest first)


list files with their headers, icons, and git statuses


don't list files mentioned in `.gitignore`


print either a single page (e.g. 2) or a range of pages (e.g. 2–16)

lpr -o page-ranges={{2|2-16}} {{path/to/file}}


print doublesided either in portrait (long) or in landscape (short)

lpr -o sides={{two_sided_long_edge|two_sided_short_edge}} {{path/to/file}}


set page size (more options may be available depending on setup)

lpr -o media={{a4|letter|legal}} {{path/to/file}}


enter an interactive ipython session after running a python script


print the path to the directory for the default ipython profile


clear the ipython history database, deleting all entries


start a repl session either with the project or standalone


generate scaffolding for a new project based on a template

boot --dependencies boot/new new --template {{template_name}} --name {{project_name}}


build for development (if using the boot/new template)


build for production (if using the boot/new template)


extract pages 13, 5 and 610 from a pdf file and save them as another one

pdftk {{input.pdf}} cat {{1-3 5 6-10}} output {{output.pdf}}


merge (concatenate) a list of pdf files and save the result as another one

pdftk {{file1.pdf file2.pdf ...}} cat output {{output.pdf}}


split each page of a pdf file into a separate file, with a given filename output pattern

pdftk {{input.pdf}} burst output {{out_%d.pdf}}


rotate all pages by 180 degrees clockwise

pdftk {{input.pdf}} cat {{1-endsouth}} output {{output.pdf}}


rotate third page by 90 degrees clockwise and leave others unchanged

pdftk {{input.pdf}} cat {{1-2 3east 4-end}} output {{output.pdf}}


list object paths for a specific service


list methods, signals and properties available on a specific object


execute a specific method passing arguments and display the returned value

qdbus {{service_name}} {{/path/to/object}} {{method_name}} {{argument1}} {{argument2}}


display the current brightness value in a kde plasma session


set a specific brightness to a kde plasma session


invoke volume up shortcut in a kde plasma session

qdbus {{org.kde.kglobalaccel}} {{/component/kmix}} {{invokeShortcut}} "{{increase_volume}}"


sudo prosodyctl adduser {{user@example.com}}


sudo prosodyctl passwd {{user@example.com}}


sudo prosodyctl deluser {{user@example.com}}


check out a pull request for a specific remote


fswebcam -r {{width}}x{{height}} {{filename}}


take a picture from selected device(default is `/dev/video0`)


take a picture with timestamp(timestamp string is formatted by strftime)

fswebcam --timestamp {{timestamp}} {{filename}}


display an annotated skeleton configuration xml file


generate documentation for the current working directory


generate documentation using a specific configuration file


only run the metadata collection process


only run the documentation generator process


display an app's metadata (version, permissions, etc.)


create a new apk archive with files from the specified directory

aapt package -F {{path/to/app.apk}} {{path/to/directory}}


create a new nimble package in the current directory


mount -t {{filesystem_type}} {{path/to/device_file}} {{path/to/target_directory}}


mount a cdrom device (with the filetype iso9660) to `/cdrom` (readonly)

mount -t {{iso9660}} -o ro {{/dev/cdrom}} {{/cdrom}}


mount all the filesystem defined in `/etc/fstab`


mount a specific filesystem described in `/etc/fstab` (e.g. `/dev/sda1 /my_drive ext2 defaults 0 2`)


mount --bind {{path/to/old_dir}} {{path/to/new_dir}}


log in with a token from standard input (created in https//github.com/settings/tokens)

echo {{your_token}} | gh auth login --with-token


log in with a specific github enterprise server

gh auth login --hostname {{github.example.com}}


refresh the session to ensure authentication credentials have the correct minimum scopes (removes additional scopes requested previously)


gh auth refresh --scopes {{write:org,read:public_key}}


convert to pdf expanding the output to fill the paper

pdftocairo {{path/to/file.pdf}} {{output.pdf}} -pdf -expand


convert to svg specifying the first/last page to convert

pdftocairo {{path/to/file.pdf}} {{output.svg}} -svg -f {{first_page}} -l {{last_page}}


pdftocairo {{path/to/file.pdf}} {{output.png}} -png -r 200


convert to grayscale tiff setting paper size to a3

pdftocairo {{path/to/file.pdf}} -tiff -gray -paper A3


convert to png cropping x and y pixels from the topleft corner

pdftocairo {{path/to/file.pdf}} -png -x {{x_pixels}} -y {{y_pixels}}


synchronize imap account between host1 and host2

imapsync --host1 {{host1}} --user1 {{user1}} --password1 {{secret1}} --host2 {{host2}} --user2 {{user2}} --password2 {{secret2}}


copy files from depot into the client workspace


p4 edit -c {{changelist_number}} {{filename}}


display list of files modified by changelist


check if a specific package name is available in the npm registry


find similar package names in the npm registry


jump to a directory that contains the given pattern


jump to a subdirectory (child) of the current directory that contains the given pattern


open a directory that contains the given pattern in the operating system file manager


remove nonexisting directories from the autojump database


show the entries in the autojump database


change xdg's desktop directory to the specified directory (must be absolute)

xdg-user-dirs-update --set DESKTOP "{{path/to/directory}}"


write the result to the specified dryrunfile instead of the `userdirs.dirs` file

xdg-user-dirs-update --dummy-output "{{path/to/dry_run_file}}" --set {{xdg_user_directory}} "{{path/to/directory}}"


display general information about a binary (architecture, type, endianness)


stl2gts < {{path/to/file.stl}} > {{path/to/file.gts}}


convert an stl file to a gts file and revert face normals

stl2gts --revert < {{path/to/file.stl}} > {{path/to/file.gts}}


convert an stl file to a gts file and do not merge vertices

stl2gts --nomerge < {{path/to/file.stl}} > {{path/to/file.gts}}


convert an stl file to a gts file and display surface statistics

stl2gts --verbose < {{path/to/file.stl}} > {{path/to/file.gts}}


run tests with default configuration or as configured in `mocha.opts`


run tests contained at a specific location


run tests that match a specific grep pattern


run tests on changes to javascript files in the current directory and once initially


show the default paper size used by all tex live programs


set the default paper size for all tex live programs to a4


show the default paper size used by a specific tex live program


set the default paper size for a specific tex live program to a4


list all available paper sizes for a specific tex live program


dump the default paper size used by all tex live programs in json format


scrapy genspider {{spider_name}} {{website_domain}}


fetch a webpage as scrapy sees it and print the source to stdout


open a webpage in the default browser as scrapy sees it (disable javascript for extra fidelity)


open scrapy shell for url, which allows interaction with the page source in a python shell (or ipython if available)


report what would be removed by git prune without removing it


prune unreachable objects and display what has been pruned to stdout


prune unreachable objects while showing progress


attach `lldb` to a running process with a given pid


wait for a new process to launch with a given name, and attach to it


connect to a local database on port 3306, using the current user's username


connect to a database (user will be prompted for a password)


mycli -h {{database_host}} -P {{port}} -u {{username}} {{database_name}}


ssh-copy-id -i {{path/to/certificate}} {{username}}@{{remote_host}}


copy the given public key to the remote with specific port

ssh-copy-id -i {{path/to/certificate}} -p {{port}} {{username}}@{{remote_host}}


vala {{path/to/file.vala}} --pkg {{gtk+-3.0}}


sudo tlmgr install --reinstall {{package}}


simulate installing a package without making any changes


install a package without its dependencies

sudo tlmgr install --no-depends {{package}}


sudo tlmgr install --file {{path/to/package}}


apply the default style of 4 spaces per indent and no formatting changes


apply the java style with attached braces


apply the allman style with broken braces


apply a custom indent using spaces. choose between 2 and 20 spaces


apply a custom indent using tabs. choose between 2 and 20 tabs


change the password of the current user interactively


make the password of the account blank (it will set the named account passwordless)


lookup the ip(s) associated with a hostname (a records)


get a detailed answer for a given domain (a records)


query a specific dns record type associated with a given domain name

dig +short {{example.com}} {{A|MX|TXT|CNAME|NS}}


get all types of records for a given domain name


specify an alternate dns server to query


perform a reverse dns lookup on an ip address (ptr record)


find authoritative name servers for the zone and display soa records


perform iterative queries and display the entire trace path to resolve a domain name


play the 5th track in the currently loaded playlist


start peco on all files in the specified directory

find {{path/to/directory}} -type f | peco


okular {{path/to/file1 path/to/file2 ...}}


okular --page {{page_number}} {{path/to/file}}


open a document and start the print dialog


open a document and search for a specific string

okular --find {{search_string}} {{path/to/file}}


run commands from a script, printing each command before executing it


execute commands from a script, stopping at the first error


launch gnucash and load the previously opened file


launch gnucash and load the specified file


ping a host only a specific number of times


ping a host, specifying the interval in seconds between requests (default is 1 second)


ping a host without trying to lookup symbolic names for addresses


ping a host and ring the bell when a packet is received (if your terminal supports it)


run a basic benchmark, performing at least 10 runs


hyperfine '{{make target1}}' '{{make target2}}'


change minimum number of benchmarking runs


run a command before each benchmark run (to clear caches, etc.)

hyperfine --prepare '{{make clean}}' '{{make}}'


run a benchmark where a single parameter changes for each run

hyperfine --prepare '{{make clean}}' --parameter-scan {{num_threads}} {{1}} {{10}} '{{make -j {num_threads}}}'


boot from image emulating i386 architecture


boot from image emulating x64 architecture


boot qemu instance with a live iso image

qemu-system-i386 -hda {{image_name.img}} -cdrom {{os_image.iso}} -boot d


qemu-system-i386 -m 256 -hda image_name.img -cdrom os-image.iso -boot d


boot from physical device (e.g. from usb to test bootable medium)


display basic information about the current app and available commands


cake schema_cache build --connection {{connection}}


start a development web server (defaults to port 8765)


generate a hexdump from a binary file and display the output


generate a hexdump from a binary file and save it as a text file


display a more compact output, replacing consecutive zeros (if any) with a star


display the output with 10 columns of one octet (byte) each


display output only up to a length of 32 bytes


display the output in plain mode, without any gaps between the columns


revert a plaintext hexdump back into binary, and save it as a binary file

xxd -r -p {{input_file}} {{output_file}}


detect file(s) encoding according to the system's locale


detect file(s) encoding specifying a language in the posix/c locale format (e.g. zh_cn, en_us)

enca -L {{language}} {{file1 file2 ...}}


enca -L {{language}} -x {{to_encoding}} {{file1 file2 ...}}


create a copy of an existing file using a different encoding

enca -L {{language}} -x {{to_encoding}} < {{original_file}} > {{new_file}}


install a repository's specified submodules


add a git repository as a submodule at the specified directory

git submodule add {{repository_url}} {{path/to/directory}}


update every submodule to its latest commit


find the processes that have a given file open


find the process that opened a local internet port


list files opened by the given command or process


list files opened by a specific process, given its pid


find the process that is listening on a local tcp port


display a live stream for the statistics of all running containers


display a live stream of statistics for a spaceseparated list of containers


change the columns format to display container's cpu usage percentage

docker stats --format "{{.Name}}:\t{{.CPUPerc}}"


display statistics for all containers (both running and stopped)


disable streaming stats and only pull the current stats


check the consistency of the whole tex live installation


check the consistency of the whole tex live information in verbose mode


check if all tex live executables are present


check if all files listed in the local tlpdb are present


check for duplicate filenames in the runfiles sections


run a scheme program (with no repl output)


print the text message as a large banner (quotes are optional)


print the text message as a banner with a width of 50 characters


subliminal download -l {{en}} {{video.ext}}


print the number of commits per contributor and the total number of commits


execute the script in a given scheme file


listen on a port or a unix domain socket (the default is port 37146) for remote repl connections


avrdude -p {{AVR_device}} -c {{programmer}} -U flash:r:{{file.hex}}:i


avrdude -p {{AVR_device}} -c {{programmer}} -U flash:w:{{file.hex}}


clang++ $(llvm-config --cxxflags --ldflags --libs) --output {{path/to/output_executable}} {{path/to/source.cc}}


print the `prefix` of your llvm installation


print all targets supported by your llvm build


start minetest in server mode by hosting a specific world


consume messages starting with the newest offset


consume messages starting with the oldest offset and exit after the last message is received

kafkacat -C -t {{topic}} -b {{brokers}} -o beginning -e


consume messages as a kafka consumer group

kafkacat -G {{group_id}} {{topic}} -b {{brokers}}


echo {{message}} | kafkacat -P -t {{topic}} -b {{brokers}}


kafkacat -P -t {{topic}} -b {{brokers}} {{path/to/file}}


list metadata for all topics and brokers


get offset for a topic/partition for a specific point in time

kafkacat -Q -t {{topic}}:{{partition}}:{{unix_timestamp}} -b {{brokers}}


print the version of installed `gitextras`


restore an archive into an existing database

pg_restore -d {{db_name}} {{archive_file.dump}}


pg_restore -U {{username}} -d {{db_name}} {{archive_file.dump}}


pg_restore -h {{host}} -p {{port}} -d {{db_name}} {{archive_file.dump}}


list database objects included in the archive


clean database objects before creating them

pg_restore --clean -d {{db_name}} {{archive_file.dump}}


pg_restore -j {{2}} -d {{db_name}} {{archive_file.dump}}


return pids of any running processes with a matching command string


search for processes including their commandline options

pgrep --full "{{process_name}} {{parameter}}"


search for processes run by a specific user


view documentation for the original command


register a node at a puppet server and apply the received catalog

puppet agent --test --server {{puppetserver_fqdn}} --serverport {{port}} --waitforcert {{poll_time}}


run the agent in the background (uses settings from `puppet.conf`)


run the agent once in the foreground, then exit


log every resource being evaluated (even if nothing is being changed)


create a dump of all databases (this will place the files inside a directory called "dump")


create a dump of a given collection within a given database

mongodump --collection {{collection_name}} --db {{database_name}}


connect to a given host running on a given port, and create a dump

mongodump --host {{host}} --port {{port}}


create a dump of a given database with a given username; user will be prompted for password

mongodump --username {{username}} {{database}} --password


validate a device by checking the files in a given directory


convert a file to the text format and display it to the console


open a file and enter normal mode, to execute commands


enter insert mode from normal mode, to write text into the file


escape insert mode, to go back to normal mode


replace all instances of "foo" in the current file with "bar"


unselect all secondary selections, and keep only the main one


search for numbers and select the first two


carp -b --optimize {{path/to/file.carp}}


render an html file to png, including an additional user stylesheet

weasyprint {{path/to/input.html}} {{path/to/output}}.png --stylesheet {{path/to/stylesheet.css}}


output additional debugging information when rendering

weasyprint {{path/to/input.html}} {{path/to/output}}.pdf --verbose


specify a custom resolution when outputting to png

weasyprint {{path/to/input.html}} {{path/to/output}}.png --resolution {{300}}


specify a base url for relative urls in the input html file

weasyprint {{path/to/input.html}} {{path/to/output}}.png --base-url {{url_or_filename}}


fork and clone a github repository by its url


fork and clone a github repository by its slug


attempt to extract streams from the url specified, and if it's successful, print out a list of available streams to choose from


open a stream with the specified quality


select the highest or lowest available quality


specify which player to use to feed stream data to (vlc is used by default if found)

streamlink --player={{mpv}} {{example.com/stream}} {{best}}


specify the amount of time to skip from the beginning of the stream. for live streams, this is a negative offset from the end of the stream (rewind)

streamlink --hls-start-offset {{[HH:]MM:SS}} {{example.com/stream}} {{best}}


skip to the beginning of a live stream, or as far back as possible

streamlink --hls-live-restart {{example.com/stream}} {{best}}


write stream data to a file instead of playing it

streamlink --output {{path/to/file.ts}} {{example.com/stream}} {{best}}


open the stream in the player, while at the same time writing it to a file

streamlink --record {{path/to/file.ts}} {{example.com/stream}} {{best}}


ansbile-inventory --list --inventory {{path/to/file_or_script_or_directory}}


ansible-inventory --list --output {{path/to/file}}


output commands to set ls_color using default colors


output commands to set ls_color using colors from a file


view the default colors for file types and extensions


run a process that can live beyond the terminal


print a full list of committers to stdout instead of to the `authors` file


append the list of committers to the `authors` file and open it in the default editor


append the list of committers, excluding emails, to the `authors` file and open it in the default editor


show the network address of the host name


show the fqdn (fully qualified domain name)


display the username, line, and time of all currently loggedin sessions


display information only for the current terminal session


display all available information with table headers


create a new haskell project in the current directory


build the project in the current directory


run tests of the project in the current directory


list each branch showing date, latest commit hash and message


extract the sound from a video and save it as mp3

ffmpeg -i {{video.mp4}} -vn {{sound}}.mp3


convert frames from a video or gif into individual numbered images

ffmpeg -i {{video.mpg|video.gif}} {{frame_%d.png}}


combine numbered images (`frame_1.jpg`, `frame_2.jpg`, etc) into a video or gif

ffmpeg -i {{frame_%d.jpg}} -f image2 {{video.mpg|video.gif}}


quickly extract a single frame from a video at time mmss and save it as a 128x128 resolution image

ffmpeg -ss {{mm:ss}} -i {{video.mp4}} -frames 1 -s {{128x128}} -f image2 {{image.png}}


trim a video from a given start time mmss to an end time mm2ss2 (omit the to flag to trim till the end)

ffmpeg -ss {{mm:ss}} -to {{mm2:ss2}} -i {{video.mp4}} -codec copy {{output.mp4}}


convert avi video to mp4. aac audio @ 128kbit, h264 video @ crf 23

ffmpeg -i {{input_video}}.avi -codec:audio aac -b:audio 128k -codec:video libx264 -crf 23 {{output_video}}.mp4


remux mkv video to mp4 without reencoding audio or video streams

ffmpeg -i {{input_video}}.mkv -codec copy {{output_video}}.mp4


convert mp4 video to vp9 codec. for the best quality, use a crf value (recommended range 1535) and bvideo must be 0

ffmpeg -i {{input_video}}.mp4 -codec:video libvpx-vp9 -crf {{30}} -b:video 0 -codec:audio libopus -vbr on -threads {{number_of_threads}} {{output_video}}.webm


publish a temperature value of 32 on the topic `sensors/temperature` to 192.168.1.1 (defaults to `localhost`) with quality of service (`qos`) set to 1


publish timestamp and temperature data on the topic `sensors/temperature` to a remote host on a nonstandard port


publish light switch status and retain the message on the topic `switches/kitchen_lights/status` to a remote host because there may be a long period of time between light switch events

mosquitto_pub -r -h "{{iot.eclipse.org}}" -t {{switches/kitchen_lights/status}} -m "{{on}}"


send the contents of a file (`data.txt`) as a message and publish it to `sensors/temperature` topic

mosquitto_pub -t {{sensors/temperature}} -f {{data.txt}}


send the contents of a file (`data.txt`), by reading from stdin and send the entire input as a message and publish it to `sensors/temperature` topic

mosquitto_pub -t {{sensors/temperature}} -s < {{data.txt}}


read newline delimited data from stdin as a message and publish it to `sensors/temperature` topic

{{echo data.txt}} | mosquitto_pub -t {{sensors/temperature}} -l


connect to a remote server with a specific identity (private key)

ssh -i {{path/to/key_file}} {{username}}@{{remote_host}}


connect to a remote server using a specific port

ssh {{username}}@{{remote_host}} -p {{2222}}


run a command on a remote server with a [t]ty allocation allowing interaction with the remote command

ssh {{username}}@{{remote_host}} -t {{command}} {{command_arguments}}


ssh tunneling dynamic port forwarding (socks proxy on `localhost1080)

ssh -D {{1080}} {{username}}@{{remote_host}}


ssh tunneling forward a specific port (`localhost9999` to `example.org80`) along with disabling pseudo[t]ty allocation and executio[n] of remote commands

ssh -L {{9999}}:{{example.org}}:{{80}} -N -T {{username}}@{{remote_host}}


ssh jumping connect through a jumphost to a remote server (multiple jump hops may be specified separated by comma characters)

ssh -J {{username}}@{{jump_host}} {{username}}@{{remote_host}}


agent forwarding forward the authentication information to the remote machine (see `man ssh_config` for available options)


capture the traffic of a specific interface


capture all tcp traffic showing contents (ascii) in console


capture the traffic from a specific interface, source, destination and destination port


capture all traffic except traffic over port 22 and save to a dump file

tcpdump -w {{dumpfile.pcap}} port not {{22}}


format the configuration in the current directory


format the configuration in the current directory and subdirectories


do not list files that were formatted to stdout


initialize a new github cli extension project in a directory of the same name


install an extension from a github repository

gh extension install {{owner}}/{{repository}}


display information related to a deployment


log in into an account or create a new one


initialize an example project (a new directory will be created)


find files containing "foo", and print the line matches in context


find files containing "foo" in a specific directory


find files containing "foo", but only list the filenames


find files containing "foo" caseinsensitively, and print only the match, rather than the whole line


find "foo" in files with a name matching "bar"


find files whose contents match a regular expression


run gource in a directory (if it isn't the repository's root directory, the root is sought up from there)


run gource in the current directory, with a custom output resolution


set a custom timescale for the animation


set how long each day should be in the animation (this combines with c, if provided)


set fullscreen mode and a custom background color


overwrite a file, leaving zeroes instead of random data


show possible updates without updating anything


show the network utilization for a specific network interface


show dns queries with a given dns server

bandwhich --show-dns --dns-server {{dns_server_ip}}


render a `png` image with a filename based on the input filename and output format (uppercase o)

circo -T {{png}} -O {{path/to/input.gv}}


render a `svg` image with the specified output filename (lowercase o)

circo -T {{svg}} -o {{path/to/image.svg}} {{path/to/input.gv}}


render the output in `ps`, `pdf`, `svg`, `fig`, `png`, `gif`, `jpg`, `json`, or `dot` format

circo -T {{format}} -O {{path/to/input.gv}}


render a `gif` image using stdin and stdout

echo "{{digraph {this -> that} }}" | circo -T {{gif}} > {{path/to/image.gif}}


start an interactive shell with a new database


open an interactive shell against an existing database


execute an sql statement against a database and then exit

sqlite3 {{path/to/database.sqlite3}} '{{SELECT * FROM some_table;}}'


list alive hosts within a subnet generated from a netmask


list alive hosts within a subnet generated from an ip range


list unreachable hosts within a subnet generated from a netmask


generate an encrypted file that can be decrypted with a passphrase

age --passphrase --output {{path/to/encrypted_file}} {{path/to/unencrypted_file}}


generate a key pair, saving the private key to an unencrypted file and printing the public key to stdout


encrypt a file with one or more public keys that are entered as literals

age --recipient {{public_key_1}} --recipient {{public_key_2}} {{path/to/unencrypted_file}} --output {{path/to/encrypted_file}}


encrypt a file with one or more public keys that are specified in a recipients file

age --recipients-file {{path/to/recipients_file}} {{path/to/unencrypted_file}} --output {{path/to/encrypted_file}}


age --decrypt --output {{path/to/decrypted_file}} {{path/to/encrypted_file}}


age --decrypt --identity {{path/to/private_key_file}} --output {{path/to/decrypted_file}} {{path/to/encrypted_file}}


clone a repository using its slug (owners can omit the username)


create a fork of the current repository (cloned from another user) under your github profile


push the current local branch to github and create a pr for it in the original repository

hub push {{remote_name}} && hub pull-request


create a pr of the current (already pushed) branch, reusing the message from the first commit


create a new branch with the contents of a pull request and switch to it


upload the current (localonly) repository to your github account


fetch git objects from upstream and update local branches


find rows that have a certain string in column 1

csvgrep -c {{1}} -m {{string_to_match}} {{data.csv}}


find rows in which columns 3 or 4 match a certain regular expression

csvgrep -c {{3,4}} -r {{regular_expression}} {{data.csv}}


find rows in which the "name" column does not include the string "john doe"

csvgrep -i -c {{name}} -m "{{John Doe}}" {{data.csv}}


sudo tlmgr update --all --exclude {{package}}


update all packages, making a backup of the current packages


update a specific package without updating its dependencies

sudo tlmgr update --no-depends {{package}}


simulate updating all packages without making any changes


copy a file or directory from the host to a container

docker cp {{path/to/file_or_directory_on_host}} {{container_name}}:{{path/to/file_or_directory_in_container}}


copy a file or directory from a container to the host

docker cp {{container_name}}:{{path/to/file_or_directory_in_container}} {{path/to/file_or_directory_on_host}}


copy a file or directory from the host to a container, following symlinks (copies the symlinked files directly, not the symlinks themselves)

docker cp --follow-link {{path/to/symlink_on_host}} {{container_name}}:{{path/to/file_or_directory_in_container}}


http --form {{example.org}} {{name='bob'}} {{profile_picture@'bob.png'}}


pass a username and password for server authentication

http --auth {{username:password}} {{example.org}}


cat {{data.txt}} | http PUT {{example.org}}


display file using default settings octal format, 8 bytes per line, byte offsets in octal, and duplicate lines replaced with `*`


display file in verbose mode, i.e. without replacing duplicate lines with `*`


display file in hexadecimal format (2byte units), with byte offsets in decimal format

od --format={{x}} --address-radix={{d}} -v {{path/to/file}}


display file in hexadecimal format (1byte units), and 4 bytes per line

od --format={{x1}} --width={{4}} -v {{path/to/file}}


display file in hexadecimal format along with its character representation, and do not print byte offsets

od --format={{xz}} --address-radix={{n}} -v {{path/to/file}}


read only 100 bytes of a file starting from the 500th byte

od --read-bytes {{100}} --skip-bytes={{500}} -v {{path/to/file}}


compile source file(s) and create an executable


compile source file(s) and create an executable with a custom name


compile source file(s) and create object file(s)


compile source file(s), link with object file(s), and create an executable


create a new empty file(s) or change the times for existing file(s) to current time


set the times on a file to a specific date and time

touch -t {{YYYYMMDDHHMM.SS}} {{filename}}


use the times from a file to set the times on a second file


browse for vnc servers in a specified domain


view documentation for the original command


keepassxc-cli lookup {{path/to/database_file}} {{name}}


keepassxc-cli ls {{path/to/database_file}} {{/path/to/directory}}


add an entry with an autogenerated password

keepassxc-cli add --generate {{path/to/database_file}} {{entry_name}}


keepassxc-cli rm {{path/to/database_file}} {{entry_name}}


copy an entry's password to the clipboard

keepassxc-cli clip {{path/to/database_file}} {{entry_name}}


keepassxc-cli clip --totp {{path/to/database_file}} {{entry_name}}


generate a password with 16 printable ascii characters

keepassxc-cli generate --lower --upper --numeric --special --length {{16}}


launch kate, creating a new instance even if one is already open


open a file in kate with the cursor at the specific line

kate --line {{line_number}} {{path/to/file}}


open a file in kate with the cursor at the specific line and column

kate --line {{line_number}} --column {{column_number}} {{path/to/file}}


launch kate, creating a new temporary file with contents read from stdin


display the current date using the default locale's format


display the current date in utc and iso 8601 format


display the current date as a unix timestamp (seconds since the unix epoch)


display a specific date (represented as a unix timestamp) using the default format


convert a specific date to the unix timestamp format


display the current date using the rfc3339 format (`yyyymmdd hhmmss tz`)


restore an unstaged file to the version of the current commit (head)


restore an unstaged file to the version of a specific commit

git restore --source {{commit}} {{path/to/file}}


discard all unstaged changes to tracked files


discard all changes to files, both staged and unstaged


interactively select sections of files to restore


start beanstalkd, listening on port 11300


start beanstalkd listening on a custom port and address

beanstalkd -l {{ip_address}} -p {{port_number}}


persist work queues by saving them to disk


sync to the persistence directory every 500 milliseconds

beanstalkd -b {{path/to/persistence_directory}} -f {{500}}


display the directory stack with a space between each entry


display the directory stack with one entry per line


display only the nth entry in the directory stack, starting at 0


list files and directories in the current directory, one per line, with details


list with sizes displayed in humanreadable units (kb, mb, gb)


list including hidden files (starting with a dot)


list files and directories sorting entries by size (largest first)


list files and directories sorting entries by modification time (newest first)


recursively list all files and directories in a specific directory


view documentation for the original command


list the contents of the tree on a branch


list the contents of the tree on a commit, recursing into subtrees


list only the filenames of the tree on a commit


simulate uninstalling a package without making any changes


uninstall a package without its dependencies

sudo tlmgr remove --no-depends {{package}}


uninstall a package and back it up to a specific directory

sudo tlmgr remove --backupdir {{path/to/directory}} {{package}}


uninstall all of tex live, asking for confirmation


git rename-remote {{upstream}} {{origin}}


install the development version of a library from a git repository


print the uncompressed contents of a gzipped file to the standard output


print compression details of a gzipped file to the standard output


start qt creator and restore the last session


start qt creator but don't load the specified plugin


start qt creator but don't load any plugins


start qt creator in presentation mode with popups for keyboard shortcuts


start qt creator and show the diff from a specific commit


display simplified representation of every byte


log into a registry with a specific username (user will be prompted for a password)


log into a registry with username and password

docker login --username {{username}} --password {{password}} {{server}}


log into a registry with password from stdin

echo "{{password}}" | docker login --username {{username}} --password-stdin


cut out the first sixteen characters of each line of stdin


cut out the first sixteen characters of each line of the given files


cut out everything from the 3rd character to the end of each line


cut out the fifth field of each line, using a colon as a field delimiter (default delimiter is tab)


cut out the 2nd and 10th fields of each line, using a semicolon as a delimiter


cut out the fields 3 through to the end of each line, using a space as a delimiter


unpublish a published post to edit it as a draft again


resize all jpeg images in the directory to 50% of their initial size


resize all images starting with "dsc" to 800x600


convert all pngs in the directory to jpeg


halve the saturation of all image files in the current directory


double the brightness of all image files in the current directory


scan all files recursively in a specific directory


specify a virus database file or directory of files


scan the current directory and output only infected files


move infected files to a specific directory


run any `tlmgr` subcommand in the interactive shell


print the version of the current protocoll


convert 5th field (1indexed) to iec units without converting header

ls -l | numfmt --header={{1}} --field={{5}} --to={{iec}}


convert to iec units, pad with 5 characters, left aligned


read ip addresses / networks to scan from a file


bootstrap a kubernetes worker node and join it to a cluster


create a new bootstrap token with a ttl of 12 hours


check if the kubernetes cluster is upgradeable and which versions are available


upgrade kubernetes cluster to a specified version


view the kubeadm configmap containing the cluster's configuration


revert changes made to the host by 'kubeadm init' or 'kubeadm join'


initialize a new or existing terraform configuration


verify that the configuration files are syntactically valid


format configuration according to terraform language style conventions


split a file, each split having 10 lines (except the last split)


split a file into 5 files. file is split such that each split has same size (except the last split)


split a file with 512 bytes in each split (except the last split; use 512k for kilobytes and 512m for megabytes)


split a file with at most 512 bytes in each split without breaking lines


list all properties in one's active configuration


gcloud config set project {{project_name}}


gcloud compute ssh {{user}}@{{instance}}


display all google compute engine instances in a project. instances from all zones are listed by default


update a kubeconfig file with the appropriate credentials to point kubectl to a specific cluster in google kubernetes engine

gcloud container clusters get-credentials {{cluster_name}}


create an image from a specific container

docker commit {{container}} {{image}}:{{tag}}


apply a `cmd` dockerfile instruction to the created image

docker commit --change="CMD {{command}}" {{container}} {{image}}:{{tag}}


apply an `env` dockerfile instruction to the created image

docker commit --change="ENV {{name}}={{value}}" {{container}} {{image}}:{{tag}}


create an image with a specific author in the metadata

docker commit --author="{{author}}" {{container}} {{image}}:{{tag}}


create an image with a specific comment in the metadata

docker commit --message="{{comment}}" {{container}} {{image}}:{{tag}}


create an image without pausing the container during commit

docker commit --pause={{false}} {{container}} {{image}}:{{tag}}


attach to a session, creating it if it doesn't exist


attach to a session with `dvtm`, creating it if it doesn't exist


mount remote directory from server with specific port

sshfs {{username}}@{{remote_host}}:{{remote_directory}} -p {{2222}}


sshfs -o follow_symlinks {{username}}@{{remote_host}}:{{remote_directory}} {{mountpoint}}


send a message with the content of `message.txt` to the mail directory of local user `username`


send an email from you@yourdomain.com (assuming the mail server is configured for this) to test@gmail.com containing the message in `message.txt`

sendmail -f {{you@yourdomain.com}} {{test@gmail.com}} < {{message.txt}}


send an email from you@yourdomain.com (assuming the mail server is configured for this) to test@gmail.com containing the file `file.zip`

sendmail -f {{you@yourdomain.com}} {{test@gmail.com}} < {{file.zip}}


call a command and display its output if it returns a nonzero exit code


compile in debug mode, which causes the resulting parser to write additional information to the standard output


bison --output {{path/to/output.c}} {{path/to/file.y}}


take a list of file names from standard input and add them [o]nto an archive in cpio's binary format

echo "{{file1}} {{file2}} {{file3}}" | cpio -o > {{archive.cpio}}


copy all files and directories in a directory and add them [o]nto an archive, in [v]erbose mode

find {{path/to/directory}} | cpio -ov > {{archive.cpio}}


p[i]ck all files from an archive, generating [d]irectories where needed, in [v]erbose mode


after editing the file, refresh the current patch with the changes


apply all the patches in the series file


print files and directories up to 'num' levels of depth (where 1 means the current directory)


print hidden files too with colorization on


print the tree without indentation lines, showing the full path instead (use `n` to not escape nonprintable characters)


print the size of each file and the cumulative size of each directory, in humanreadable format


print files within the tree hierarchy, using a wildcard (glob) pattern, and pruning out directories that don't contain matching files


print directories within the tree hierarchy, using the wildcard (glob) pattern, and pruning out directories that aren't ancestors of the wanted one

tree -P {{directory_name}} --matchdirs --prune


print the tree ignoring the given directories


copy a single file (open an editor with the source filename on the left and the target filename on the right)


copy files, but swap the positions of the source and the target filenames in the editor


measure the current upload speed in addition to download speed


display results on a single line to reduce spacing


lookup a, aaaa, and mx records of a domain


lookup a field (cname, txt,...) of a domain


specify an alternate dns server to query


give the [u]ser who owns a file the right to e[x]ecute it


give the [u]ser rights to [r]ead and [w]rite to a file/directory


remove e[x]ecutable rights from the [g]roup


give [a]ll users rights to [r]ead and e[x]ecute


give [o]thers (not in the file owner's group) the same rights as the [g]roup


change permissions recursively giving [g]roup and [o]thers the ability to [w]rite


recursively give [a]ll users [r]ead permissions to files and e[x]ecute permissions to subdirectories within a directory


display information on all available gpus and processes using them


monitor overall gpu usage with 1second update interval


start `bc` in interactive mode using the standard math library


calculate the result of an expression and force the number of decimal places to 10


calculate the result of an expression with sine and cosine using `mathlib`


expose a local http service on a given port


expose a local http service on a specific host


expose tls traffic for a specific host and port


recursively check the current directory, showing progress on the screen and logging error messages to a file


recursively check a given directory, and don't print progress messages


check a given file, specifying which tests to perform (by default only errors are shown)


check a given file, ignoring specific tests

cppcheck --suppress={{test_id1}} --suppress={{test_id2}} {{path/to/file.cpp}}


check the current directory, providing paths for include files located outside it (e.g. external libraries)

cppcheck -I {{include/directory_1}} -I {{include/directory_2}} .


check a microsoft visual studio project (`*.vcxproj`) or solution (`*.sln`)


move a single file (open an editor with the source filename on the left and the target filename on the right)


qmv -d {{path/to/directory1}} {{path/to/directory2}} {{path/to/directory3}}


move all files and directories inside a directory


move files, but swap the positions of the source and the target filenames in the editor


convert `filename.pdf` to plain text and print it to standard output


convert `filename.pdf` to plain text and save it as `filename.txt`


convert `filename.pdf` to plain text and preserve the layout


convert `input.pdf` to plain text and save it as `output.txt`


convert pages 2, 3 and 4 of `input.pdf` to plain text and save them as `output.txt`

pdftotext -f {{2}} -l {{4}} {{input.pdf}} {{output.txt}}


stack new {{package_name}} {{template_name}}


compile a project and recompile every time a file changes


compile a project and execute a command after compilation


run a program and pass an argument to it

stack exec {{program_name}} -- {{argument}}


create a new angular application inside a directory


add a new component to one's application

ng generate component {{component_name}}


add a new directive to one's application

ng generate directive {{directive_name}}


run the application with the following command in its root directory


check the version of your current angular installation


envoy run --path {{path/to/directory}} {{task_name}}


dump a task as a bash script for inspection


check python files in a specific directory


check python files in a directory recursively


check all python files found in multiple directories

pyflakes iterSourceCode {{path/to/directory_1}} {{path/to/directory_2}}


perform a regular expression substitution in the whole file


list available (paired and reachable) devices