merge the first page of each file together

pdfjam {{files...}} 1 --outfile {{path/to/output_file.pdf}}


pdfjam {{path/to/file1.pdf 3-5,1}} {{path/to/file2.pdf 4-6}} --outfile {{path/to/output_file.pdf}}


sign an a4 page (adjust delta to height for other formats) with a scanned signature by overlaying them

pdfjam {{path/to/file.pdf}} {{path/to/signature}} --fitpaper true --outfile {{path/to/signed.pdf}} --nup "{{1x2}}" --delta "{{0 -842pt}}"


arrange the pages from the input file into a fancy 2x2 grid

pdfjam {{path/to/file.pdf}} --nup {{2x2}} --suffix {{4up}} --preamble '{{\usepackage{fancyhdr} \pagestyle{fancy}}}'


reverse the order of pages within each given file and concatenate them

pdfjam {{files...}} {{last-1}} --suffix {{reversed}}


start a wizard to choose what kind of code (e.g. module, service, form, etc.) to generate


directly specify the kind of code to generate


generate the code in a specific directory


synthesize and print the cloudformation template for the specified stack(s)


compare the specified stack with the deployed stack or a local cloudformation template


create a new cdk project in the current directory for a specified language


open the cdk api reference in your browser


view documentation for the original command


open moe and create a backup file (file~) when saving edits


start skim on all files in the specified directory


select multiple files with `shift + tab` and write to a file

find {{path/to/directory}} -type f | sk --multi > {{filename}}


show changed files which are not yet added for commit


don't show untracked files in the output


show output in [s]hort format along with [b]ranch info


list the available quotation database files


print a quotation from one of the database files listed by `fortune f`


convert a file to one of the supported output formats, using the default parameters

assimp export {{input_file.stl}} {{output_file.obj}}


convert a file using custom parameters (the dox_cmd.h file in assimp's source code lists available parameters)

assimp export {{input_file.stl}} {{output_file.obj}} {{parameters}}


display a summary of a 3d file's contents


list all supported subcommands ("verbs")


get help on a specific subcommand (e.g. the parameters specific to it)


compile a nsis script in strict mode (treat warnings as errors)


show help on a git subcommand (like `commit`, `log`, etc.)


execute a git subcommand on a custom repository root path


execute a git subcommand with a given configuration set

git -c '{{config.key}}={{value}}' {{subcommand}}


gzip several files at once, using all cores

parallel gzip ::: {{file1}} {{file2}} {{file3}}


read arguments from stdin, run 4 jobs at once


convert jpg images to png using replacement strings


parallel xargs, cram as many args as possible onto one command


break stdin into ~1m blocks, feed each block to stdin of new command

cat {{big_file.txt}} | parallel --pipe --block 1M {{command}}


parallel -S {{machine1}},{{machine2}} {{command}} ::: {{arg1}} {{arg2}}


convert delimiters to a custom character

csvformat -D "{{custom_character}}" {{data.csv}}


convert line endings to carriage return (^m) + line feed


abort the process of applying a patch file


apply as much of a patch file as possible, saving failed hunks to reject files


show information about the latest commit (hash, message, changes, and other metadata)


show information about the commit associated with a given tag


show information about the 3rd commit from the head of a branch


show a commit's message in a single line, suppressing the diff output


show only statistics (added/removed characters) about the changed files


show only the list of added, renamed or deleted files


show the contents of a file as it was at a given revision (e.g. branch, tag or commit)


start the server, printing error messages to the console


start the server, saving logging output to a custom log file


print the default arguments and their values and exit


start the server, reading arguments and values from a file


start the server and listen on a custom port


verify a signed file using a detached signature


add a file to the list of keyrings (a single exported key also counts as a keyring)

gpgv --keyring {{./alice.keyring}} {{path/to/signature}} {{path/to/file}}


generate an ed25519 key with 100 key derivation function rounds


generate an rsa 4096bit key with email as a comment

ssh-keygen -t {{dsa|ecdsa|ed25519|rsa}} -b {{4096}} -C "{{comment|email}}"


remove the keys of a host from the known_hosts file (useful when a known host has a new key)


retrieve the fingerprint of a key in md5 hex

ssh-keygen -l -E {{md5}} -f {{~/.ssh/filename}}


change the type of the key format (for example from openssh format to pem), the file will be rewritten inplace

ssh-keygen -p -N "" -m {{PEM}} -f {{~/.ssh/OpenSSH_private_key}}


edit the crontab file for the current user


edit the crontab file for a specific user


replace the current crontab with the contents of the given file


view a list of existing cron jobs for current user


remove all cron jobs for the current user


sample job which runs at 1000 every day (* means any value)


sample job which runs every minute on the 3rd of april


sample job which runs a certain script at 0230 every friday

30 2 * * Fri {{/absolute/path/to/script.sh}}


list all python versions under the `${pyenv_root}/versions` directory


install a python version under the `${pyenv_root}/versions` directory


uninstall a python version under the `${pyenv_root}/versions` directory


set python version to be used globally in the current machine


set python version to be used in the current directory and all directories below it


run tests on a specific environment (e.g. python 3.6)


force the virtual environment to be recreated


sync two directories (creates log first time these two directories are synchronised)


automatically accept the (nonconflicting) defaults

unison {{path/to/directory_1}} {{path/to/directory_2}} -auto


unison {{path/to/directory_1}} {{path/to/directory_2}} -ignore {{pattern}}


run tests in the current directory. note expects you to have a 'phpunit.xml'


run tests annotated with the given group


run tests and generate a coverage report in html


show a list of existing remotes, their names and url


git remote add {{remote_name}} {{remote_url}}


change the url of a remote (use `add` to keep the existing url)

git remote set-url {{remote_name}} {{new_url}}


git remote rename {{old_name}} {{new_name}}


enable verbose mode and print unexpected errors in x


run on server using udp mode and set server port to listen on 5001


iperf -u -c {{server_address}} -p {{5001}}


start the deluge daemon on a specific port


start the deluge daemon using a specific configuration file


start the deluge daemon and output the log to a file


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


let a steam locomotive run through your terminal


start a repl and load the specified haskell source file


start a repl and enable a language option


start a repl and enable some level of compiler warnings (e.g. `all` or `compact`)


start a repl with a colonseparated list of directories for finding source files


list all running processes including the full command string


search for a process that matches a string


list all processes of the current user in extra full format


list all processes of the current user as a tree


analyse duplicated code for a specific file or directory


analyse using fuzzy matching for variable names


specify a minimum number of identical lines (defaults to 5)

phpcpd --min-lines {{number_of_lines}} {{path/to/file_or_directory}}


specify a minimum number of identical tokens (defaults to 70)

phpcpd --min-tokens {{number_of_tokens}} {{path/to/file_or_directory}}


exclude a directory from analysis (must be relative to the source)

phpcpd --exclude {{path/to/excluded_directory}} {{path/to/file_or_directory}}


phpcpd --log-pmd {{path/to/log_file}} {{path/to/file_or_directory}}


print stack and locks information of a java process


open a core dump in interactive debug mode

jhsdb clhsdb --core {{path/to/core_dump}} --exe {{path/to/jdk/bin/java}}


jhsdb debugd --pid {{pid}} --serverid {{optional_unique_id}}


connect to a process in interactive debug mode


start syncthing without opening a web browser


change the address upon which the web interface listens


show filepaths to the files used by syncthing


convert markdown or html to ebook with toc, title and author

ebook-convert {{source}} {{destination}} --level1-toc="//h:h1" --level2-toc="//h:h2" --level3-toc="//h:h3" --title={{title}} --authors={{author}}


list printers present on the machine and whether they are enabled for printing


display all available status information


show a list of print jobs queued by the specified user


tile images into a grid, automatically resizing images larger than the grid cell size

montage {{image1.png}} {{image2.jpg}} {{imageN.png}} montage.jpg


tile images into a grid, automatically calculating the grid cell size from the largest image

montage {{image1.png}} {{image2.jpg}} {{imageN.png}} -geometry +0+0 montage.jpg


set the grid cell size and resize images to fit it before tiling

montage {{image1.png}} {{image2.jpg}} {{imageN.png}} -geometry 640x480+0+0 montage.jpg


limit the number of rows and columns in the grid, causing input images to overflow into multiple output montages

montage {{image1.png}} {{image2.jpg}} {{imageN.png}} -geometry +0+0 -tile 2x3 montage_%d.jpg


resize and crop images to fill their grid cells before tiling

montage {{image1.png}} {{image2.jpg}} {{imageN.png}} -geometry +0+0 -resize 640x480^ -gravity center -crop 640x480+0+0 montage.jpg


evaluate javascript code by passing it as an argument


evaluate and print result, useful to see node's dependencies versions


activate inspector, pausing execution until a debugger is connected once source code is fully parsed

node --no-lazy --inspect-brk {{path/to/file}}


start recording in file named "typescript"


execute quietly without start and done messages


terminate a program using the default sigterm (terminate) signal


list available signal names (to be used without the `sig` prefix)


terminate a program using the sighup (hang up) signal. many daemons will reload instead of terminating


terminate a program using the sigint (interrupt) signal. this is typically initiated by the user pressing `ctrl + c`


signal the operating system to immediately terminate a program (which gets no chance to capture the signal)


signal the operating system to pause a program until a sigcont ("continue") signal is received


send a `sigusr1` signal to all processes with the given gid (group id)


extract pages from pdf file and make a separate pdf file for each page


specify the first/start page for extraction

pdfseparate -f {{3}} {{path/to/source_filename.pdf}} {{path/to/destination_filename-%d.pdf}}


pdfseparate -l {{10}} {{path/to/source_filename.pdf}} {{path/to/destination_filename-%d.pdf}}


generate secure, hardtomemorize passwords


generate password with at least one capital letter in them


convert wav to opus using default options


convert stereo audio at the highest quality level

opusenc --bitrate {{512}} {{path/to/input.wav}} {{path/to/output}}.opus


convert 5.1 surround sound audio at the highest quality level

opusenc --bitrate {{1536}} {{path/to/input.flac}} {{path/to/output}}.opus


convert speech audio at the lowest quality level

opusenc {{path/to/input.wav}} --downmix-mono --bitrate {{6}} {{path/to/out}}.opus


show all uncommitted changes (including staged ones)


show only staged (added, but not yet committed) changes


show changes from all commits since a given date/time (a date expression, e.g. "1 week 2 days" or an iso date)

git diff 'HEAD@{3 months|weeks|days|hours|seconds ago}'


show only names of changed files since a given commit


output a summary of file creations, renames and mode changes since a given commit


compare a single file between two branches or commits

git diff {{branch_1}}..{{branch_2}} [--] {{path/to/file}}


compare different files from the current branch to other branch

git diff {{branch}}:{{path/to/file2}} {{path/to/file}}


start an ssh session, restarting when a monitoring port fails to return data

autossh -M {{monitor_port}} "{{ssh_command}}"


forward a local port to a remote one, restarting when necessary

autossh -M {{monitor_port}} -L {{local_port}}:localhost:{{remote_port}} {{user}}@{{host}}


fork `autossh` into the background before executing `ssh` and don't open a remote shell

autossh -f -M {{monitor_port}} -N "{{ssh_command}}"


run in the background, with no monitoring port, and instead send ssh keepalive packets every 10 seconds to detect failure

autossh -f -M 0 -N -o "ServerAliveInterval 10" -o "ServerAliveCountMax 3" "{{ssh_command}}"


run in the background, with no monitoring port and no remote shell, exiting if the port forward fails

autossh -f -M 0 -N -o "ServerAliveInterval 10" -o "ServerAliveCountMax 3" -o ExitOnForwardFailure=yes -L {{local_port}}:localhost:{{remote_port}} {{user}}@{{host}}


run in the background, logging `autossh` debug output and `ssh` verbose output to files

AUTOSSH_DEBUG=1 AUTOSSH_LOGFILE={{path/to/autossh_log_file.log}} autossh -f -M {{monitor_port}} -v -E {{path/to/ssh_log_file.log}} {{ssh_command}}


extract zip file(s) (for multiple files, separate file paths by spaces)


unzip {{compressed_file(s)}} -d {{path/to/put/extracted_file(s)}}


list the contents of a zip file without extracting


extract the contents of the file(s) to stdout alongside the extracted file names


extract a zip file created on windows, containing files with nonascii (e.g. chinese or japanese characters) filenames


download the file pointed to by the specified uri with the specified output name


aria2c --force-sequential {{url_1}} {{url_2}}


download from multiple sources with each uri pointing to the same file


download the uris listed in a file with limited parallel downloads


aria2c --ftp-user={{username}} --ftp-passwd={{password}} {{url}}


display the first few lines of a parquet file


print the content and metadata of a parquet file


concatenate several parquet files into the target one

parquet-tools merge {{path/to/parquet1}} {{path/to/parquet2}} {{path/to/target_parquet}}


print the count of rows in a parquet file


print the column and offset indexes of a parquet file


recursively remove a directory and all its subdirectories


forcibly remove a directory, without prompting for confirmation or showing error messages


interactively remove multiple files, with a prompt before every removal


remove files in verbose mode, printing a message for each removed file


display the entire revision history of the repository


display the revision history with an ascii graph


display the revision history with file names matching a specified pattern


display the revision history, excluding file names that match a specified pattern


display the log information for a specific revision


display the revision history for a specific branch


display the revision history for a specific date


display revisions committed by a specific user


format c/c++ source according to the linux style guide, automatically back up the original files, and replace with the indented versions

indent --linux-style {{path/to/source.c}} {{path/to/another_source.c}}


format c/c++ source according to the gnu style, saving the indented version to a different file

indent --gnu-style {{path/to/source.c}} -o {{path/to/indented_source.c}}


format c/c++ source according to the style of kernighan & ritchie (k&r), no tabs, 3 spaces per indent, and wrap lines at 120 characters

indent --k-and-r-style --indent-level3 --no-tabs --line-length120 {{path/to/source.c}} -o {{path/to/indented_source.c}}


specify user and group (id or name) to use


search for a package via its name or description


start a nix shell with the specified packages available

nix run {{nixpkgs.pkg1 nixpkgs.pkg2 nixpkgs.pkg3...}}


optimise nix store disk usage by combining duplicate files


start an interactive environment for evaluating nix expressions


upgrade nix to the latest stable version


display inserted, deleted and modified changes as a table


display metadata for a given file in the console


store the output to a given file along with displaying in the console


display the list of metadata attributes that can be extracted


show a decorated tree graph for all branches annotated with tags and branch names


list all supported operations (enabled operations are indicated with asterisks)


run all enabled operations but don't actually apply the changes

virt-sysprep --domain {{vm_name}} --dry-run


virt-sysprep --domain {{vm_name}} --operations {{operation1,operation2,...}}


generate a new `/etc/machineid` file and enable customizations to be able to change the host name to avoid network conflicts

virt-sysprep --domain {{vm_name}} --enable {{customizations}} --hostname {{host_name}} --operation {{machine-id}}


approve the pull request of the current branch


merge the pull request associated with the current branch interactively


start wordgrinder (loads a blank document by default)


subscribe to the topic `sensors/temperature` information with quality of service (`qos`) set to 1. (the default hostname is `localhost` and port 1883)

mosquitto_sub -t {{sensors/temperature}} -q {{1}}


subscribe to all broker status messages publishing on `iot.eclipse.org` port 1885 and print published messages verbosely

mosquitto_sub -v -h "iot.eclipse.org" -p 1885 -t {{\$SYS/#}}


subscribe to multiple topics matching a given pattern. (+ takes any metric name)


print a float number with the unicode euro sign


print a text message composed with environment variables


store a formatted message in a variable (does not work on zsh)

printf -v {{myvar}} {{"This is %s = %d\n" "a year" 2016}}


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

qpdf --empty --pages {{input.pdf}} {{1-3,5,6-10}} -- {{output.pdf}}


merge (concatenate) all the pages of a list of pdf files and save the result as a new pdf

qpdf --empty --pages {{file1.pdf}} {{file2.pdf}} {{file3.pdf}} -- {{output.pdf}}


merge (concatenate) given pages from a list of pdf files and save the result as a new pdf


write each group of n pages to a separate output file with a given filename pattern

qpdf --split-pages=n {{input.pdf}} {{out_%d.pdf}}


rotate certain pages of a pdf with a given angle


remove the password from a passwordprotected file

qpdf --password={{password}} --decrypt {{input.pdf}} {{output.pdf}}


remove spaces and other undesirable characters from a file's name


show how detox would rename all the files in a directory tree


remove spaces and other undesirable characters from all files in a directory tree


render a man page as plain text, and display the result


render a man page using the ascii output device, and display it using a pager

groff -man -T ascii {{manpage.1}} | less


groff -man -T html {{manpage.1}} > {{page.html}}


process a roff file using the `tbl` and `pic` preprocessors, and the `me` macro set


run a `groff` command with preprocessor and macro options guessed by the `grog` utility


show loggedin users info without a header


build a sandboxed nix expression (on nonnixos)

nix-build --attr {{expression_name}} --option sandbox true


encrypt a specified file for a specified recipient, writing the output to a new file with `.gpg` appended

gpg2 --encrypt --recipient {{alice@example.com}} {{path/to/doc.txt}}


encrypt a specified file with only a passphrase, writing the output to a new file with `.gpg` appended


decrypt a specified file, writing the result to the standard output


export the public key of a specified email address to the standard output

gpg2 --export --armor {{alice@example.com}}


export the private key with a specified email address to the standard output

gpg2 --export-secret-keys --armor {{alice@example.com}}


decrypt output immediately, without waiting for a keystroke


decrypt the content of a file, with a custom output color

cat {{path/to/file}} | nms -a -f {{blue|white|yellow|black|magenta|green|red}}


tput cup {{y_coordinate}} {{x_coordinate}}


set foreground (af) or background (ab) color


show number of columns, lines, or colors


git config --global diff.tool "{{meld}}"


use the default diff tool to show staged changes


use a specific tool (opendiff) to show changes since a given commit

git difftool --tool={{opendiff}} {{commit}}


copy a file into another directory, keeping the filename


recursively copy a directory's contents to another location (if the destination exists, the directory is copied inside it)

cp -r {{path/to/source_directory}} {{path/to/target_directory}}


copy a directory recursively, in verbose mode (shows files as they are copied)

cp -vr {{path/to/source_directory}} {{path/to/target_directory}}


copy text files to another location, in interactive mode (prompts user before overwriting)

cp -i {{*.txt}} {{path/to/target_directory}}


cp -L {{link}} {{path/to/target_directory}}


git verify-commit {{commit_hash1 optional_commit_hash2 ...}}


check commits for a gpg signature and show details of each commit

git verify-commit {{commit_hash1 optional_commit_hash2 ...}} --verbose


check commits for a gpg signature and print the raw details

git verify-commit {{commit_hash1 optional_commit_hash2 ...}} --raw


display the names and values of shell variables


mark variables that are modified or created for export


set various options, e.g. enable `vi` style line editing


make a bootable usb drive from an isohybrid file (such like `archlinuxxxx.iso`) and show the progress

dd if={{file.iso}} of=/dev/{{usb_drive}} status=progress


clone a drive to another drive with 4 mib block, ignore error and show progress

dd if=/dev/{{source_drive}} of=/dev/{{dest_drive}} bs=4M conv=noerror status=progress


generate a file of 100 random bytes by using kernel random driver

dd if=/dev/urandom of={{random_file}} bs=100 count=1


benchmark the write performance of a disk

dd if=/dev/zero of={{file_1GB}} bs=1024 count=1000000


generate a system backup into an img file and show the progress

dd if=/dev/{{drive_device}} of={{path/to/file.img}} status=progress


restore a drive from an img file and show the progress

dd if={{path/to/file.img}} of=/dev/{{drive_device}} status=progress


check progress of an ongoing dd operation (run this command from another shell)


download a torrent to a specific directory

transmission-cli --download-dir {{path/to/download_directory}} {{url|magnet|path/to/file}}


create a torrent file from a specific file or directory


transmission-cli --downlimit {{50}} {{url|magnet|path/to/file}}


transmission-cli --uplimit {{50}} {{url|magnet|path/to/file}}


transmission-cli --port {{port_number}} {{url|magnet|path/to/file}}


transmission-cli --blocklist {{blocklist_url|path/to/blocklist}} {{url|magnet|path/to/file}}


replace with the specified command using the current environment variables


replace with the specified command, clearing environment variables


replace with the specified command and login using the default shell


replace with the specified command and change the process name

exec -a {{process_name}} {{command -with -flags}}


list all sinks (or other types  sinks are outputs and sinkinputs are active audio streams)


change the default sink (output) to 1 (the number can be retrieved via the `list` subcommand)


toggle mute on the default sink (using the special name `@default_sink@`)

pactl set-sink-mute {{@DEFAULT_SINK@}} toggle


execute 100 http get requests to a given url


execute 100 http get requests, in concurrent batches of 10, to a url


execute 100 http post requests to a url, using a json payload from a file

ab -n {{100}} -T {{application/json}} -p {{path/to/file.json}} {{url}}


use http [k]eep alive, i.e. perform multiple requests within one http session


set the maximum number of seconds to spend for benchmarking


build the package or packages defined by the `cargo.toml` manifest file in the current working directory


build artifacts in release mode, with optimizations


compile with architecturespecific optimizations for the current cpu

cargo rustc --release -- -C target-cpu=native


compile with [s]ize optimization (`z` also turns off loop vectorization)


show the feed of a given url and wait for new entries appearing at the bottom


show the feed in reverse chronological order (newer at the bottom)


rsstail -u {{url}} -i {{interval_in_seconds}}


open the npm page of a specific package in the web browser


open the github repository of a specific package in the web browser


open the yarn page of a specific package in the web browser


go env -w {{GOBIN}}={{path/to/directory}}


create a gpg public and private key interactively


sign `doc.txt` without encryption (writes output to `doc.txt.asc`)


encrypt `doc.txt` for alice@example.com (output to `doc.txt.gpg`)

gpg --encrypt --recipient {{alice@example.com}} {{doc.txt}}


encrypt `doc.txt` with only a passphrase (output to `doc.txt.gpg`)


decrypt `doc.txt.gpg` (output to stdout)


export public key for alice@example.com (output to stdout)

gpg --export --armor {{alice@example.com}}


export private key for alice@example.com (output to stdout)

gpg --export-secret-keys --armor {{alice@example.com}}


combine several graph layouts (that already have layout information)

gvpack {{path/to/layout1.gv}} {{path/to/layout2.gv ...}} > {{path/to/output.gv}}


combine several graph layouts at the graph level, keeping graphs separate

gvpack -g {{path/to/layout1.gv}} {{path/to/layout2.gv ...}} > {{path/to/output.gv}}


combine several graph layouts at the node level, ignoring clusters

gvpack -n {{path/to/layout1.gv}} {{path/to/layout2.gv ...}} > {{path/to/output.gv}}


combine several graph layouts without packing

gvpack -u {{path/to/layout1.gv}} {{path/to/layout2.gv ...}} > {{path/to/output.gv}}


llvm-as -o {{path/to/out.bc}} {{path/to/source.ll}}


assemble an ir file and include a module hash in the produced bitcode file

llvm-as --module-hash -o {{path/to/out.bc}} {{path/to/source.ll}}


read an ir file from `stdin` and assemble it

cat {{path/to/source.ll}} | llvm-as -o {{path/to/out.bc}}


iex --erl "-kernel shell_history enabled"


view network settings of an ethernet adapter


display details of all interfaces, including disabled interfaces


join two files on the first (default) field


join two files using a comma (instead of a space) as the field separator


join field3 of file1 with field1 of file2


produce a line for each unpairable line for file1


navigate the current piece on a 2d plane


show file properties such as size, permissions, creation and access dates among others


clone a repository into a custom directory name

vcsh clone {{git_url}} {{repository_name}}


execute a git command on a managed repository


push/pull all managed repositories to/from remotes


write a custom `.gitignore` file for a managed repository


git subtree add --prefix={{path/to/directory/}} --squash {{repository_url}} {{branch_name}}


update subtree repository to its latest commit

git subtree pull --prefix={{path/to/directory/}} {{repository_url}} {{branch_name}}


merge recent changes up to the latest subtree commit into the subtree

git subtree merge --prefix={{path/to/directory/}} --squash {{repository_url}} {{branch_name}}


git subtree push --prefix={{path/to/directory/}} {{repository_url}} {{branch_name}}


extract a new project history from the history of a subtree

git subtree split --prefix={{path/to/directory/}} {{repository_url}} -b {{branch_name}}


display logs and changes for recent commits


display logs and changes for recent commits within the specified time frame

git whatchanged --since="{{2 hours ago}}"


display logs and changes for recent commits for specific files or directories


daemonize by forking into the background


highlight file syntax and print to standard output (language is inferred from the file extension)


explicitly set the language for syntax highlighting

pygmentize -l {{javascript}} {{input_file}}


list available lexers (processors for input languages)


pygmentize -f html -o {{output_file.html}} {{input_file.py}}


output an html file, with additional formatter options (full page, with line numbers)

pygmentize -f html -O "full,linenos=True" -o {{output_file.html}} {{input_file}}


compare files (lists changes to turn `old_file` into `new_file`)


diff --ignore-all-space {{old_file}} {{new_file}}


compare files, showing the differences side by side

diff --side-by-side {{old_file}} {{new_file}}


compare files, showing the differences in unified format (as used by `git diff`)

diff --unified {{old_file}} {{new_file}}


compare directories recursively (shows names for differing files/directories as well as changes made to files)

diff --recursive {{old_directory}} {{new_directory}}


compare directories, only showing the names of files that differ

diff --recursive --brief {{old_directory}} {{new_directory}}


create a patch file for git from the differences of two text files, treating nonexistent files as empty

diff --text --unified --new-file {{old_file}} {{new_file}} > {{diff.patch}}


create a hard link from a new file to an existing file


go build -o {{path/to/binary}} {{path/to/source.go}}


go build -o {{path/to/binary}} {{path/to/package}}


compile a main package into an executable, with data race detection

go build -race -o {{path/to/executable}} {{path/to/main/package}}


ansible-galaxy role info {{username}}.{{role_name}}


ansible-galaxy collection info {{username}}.{{collection_name}}


lint a file or directory recursively and show the line on which each error occurred


lint a file or directory recursively and ignore a list of rules. (all available rules can be found at flake8rules.com)

flake8 --ignore {{rule1,rule2}} {{path/to/file_or_directory}}


lint a file or directory recursively but exclude files matching the given globs or substrings

flake8 --exclude {{substring1,glob2}} {{path/to/file_or_directory}}


specify the initial zoom at page width or full page

xpdf -z {{page|width}} {{path/to/file.pdf}}


print a file to the console in rainbow colors


print the result of a textproducing command in rainbow colors


print a file to the console with animated rainbow colors


print a file to the console with 24bit (truecolor) rainbow colors


remove unused data created more than a specified amount of time in the past

docker system prune --filter="until={{hours}}h{{minutes}}m"


display realtime events from the docker daemon


display realtime events from containers streamed as valid json lines

docker system events --filter 'type=container' --format '{{json .}}'


initialize a database with a scale factor of 50 times the default size

pgbench --initialize --scale={{50}} {{database_name}}


benchmark a database with 10 clients, 2 worker threads, and 10,000 transactions per client

pgbench --client={{10}} --jobs={{2}} --transactions={{10000}} {{database_name}}


create a new python 3.6.6 virtual environment

pyenv virtualenv {{3.6.6}} {{virtualenv_name}}


create a commit object with the specified message

git commit-tree {{tree}} -m "{{message}}"


create a commit object reading the message from a file (use `` for stdin)

git commit-tree {{tree}} -F {{path/to/file}}


git commit-tree {{tree}} -m "{{message}}" --gpg-sign


create a commit object with the specified parent commit object

git commit-tree {{tree}} -m "{{message}}" -p {{parent_commit_sha}}


display help about a specific git subcommand


display help about a specific git subcommand in a web browser


display a list of all available git subcommands


list all possible configuration variables


display a cursor to kill a window when pressing the left mouse button (press any other mouse button to cancel)


display a cursor to select a window to kill by pressing any mouse button


scan file and output strings to `messages.po`


xgettext --output {{path/to/output_file}} {{path/to/input_file}}


xgettext --join-existing --output {{path/to/output_file}} {{path/to/input_file}}


don't add a header containing metadata to the output file


check the format of the specified refname


print the name of the last branch checked out


git check-ref-format --normalize {{refs/head/refname}}


view a summary of all the commits made, grouped alphabetically by author name


view a summary of all the commits made, sorted by the number of commits made


view a summary of all the commits made, grouped by the committer identities (name and email)


view a summary of the last 5 commits (i.e. specify a revision range)


view all users, emails and the number of commits in the current branch


view all users, emails and the number of commits in all branches


create a new searchable pdf/a file from a scanned pdf or image file


replace a scanned pdf file with a searchable pdf file


skip pages of a mixedformat input pdf file that already contain text

ocrmypdf --skip-text {{path/to/input.pdf}} {{path/to/output.pdf}}


clean, deskew, and rotate pages of a poor scan

ocrmypdf --clean --deskew --rotate-pages {{path/to/input_file}} {{path/to/output.pdf}}


set the metadata of the searchable pdf file

ocrmypdf --title "{{title}}" --author "{{author}}" --subject "{{subject}}" --keywords "{{keyword; key phrase; ...}}" {{path/to/input_file}} {{path/to/output.pdf}}


display a mirror of a specific device based on its id or ip address (find it under the `adb devices` command)


rotate the display screen. each incremental value adds a 90 degree counterclockwise rotation


set target directory for pushing files to device by drag and drop (nonapk)


switch to binary transfer mode (graphics, compressed files, etc)


transfer multiple files without prompting for confirmation on every file


download multiple files (glob expression)


delete multiple files on the remote server


show commits (and their messages) with equivalent commits upstream


specify a different upstream and topic branch


limit commits to those within a given limit

git cherry {{origin}} {{topic}} {{base}}


run a program. often used in scripts after the shebang (#!) for looking up the path to the program


remove variable from the environment and run a program


set multiple variables and run a program

env {{variable1}}={{value}} {{variable2}}={{value}} {{variable3}}={{value}} {{program}}


copy files to the destination, setting their ownership

install -o {{user}} {{path/to/source}} {{path/to/destination}}


copy files to the destination, setting their group ownership

install -g {{user}} {{path/to/source}} {{path/to/destination}}


copy files to the destination, setting their `mode`

install -m {{+x}} {{path/to/source}} {{path/to/destination}}


copy files and apply access/modification times of source to the destination

install -p {{path/to/source}} {{path/to/destination}}


accept everything prompted by the `aptget` command


show the details of a specific pod in a namespace

kubectl describe pods {{pod_name}} -n {{namespace}}


show the details of a specific node in a namespace

kubectl describe nodes {{node_name}} -n {{namespace}}


show details of kubernetes objects defined in a yaml manifest

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


save an image by redirecting stdout to a tar archive

docker save {{image}}:{{tag}} > {{path/to/file.tar}}


docker save --output {{path/to/file.tar}} {{image}}:{{tag}}


docker save --output {{path/to/file.tar}} {{image_name}}


cherrypick particular tags of an image to save

docker save --output {{path/to/file.tar}} {{image_name:tag1 image_name:tag2 ...}}


convert a string to a qr code and save to an output file

qrencode -o {{path/to/output_file.png}} {{string}}


convert an input file to a qr code and save to an output file

qrencode -o {{path/to/output_file.png}} -r {{path/to/input_file}}


convert a string to a qr code and print it in terminal


convert input from pipe to a qr code and print it in terminal


interactively select a run to see information about the jobs


display information about a specific run


display information about the steps of a job


check a specific workflow and exit with a nonzero status if the run failed

gh run view {{workflow_run_number}} --exit-status && {{echo "run pending or passed"}}


interactively select an active run and wait until it's done


display the jobs for a run and wait until it's done


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

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


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

osage -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

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


render a `gif` image using stdin and stdout

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


search for a pattern in the file (press `ctrl + n`/`ctrl + p` to go to next/previous match)


perform a substitution in the whole file

Ctrl + E replaceall "{{pattern}}" "{{replacement}}" <Enter>


send a post request with a json body (keyvalue pairs are added to a toplevel json object  e.g. `{"name" "john", "age" 25}`)

xh post {{httpbin.org/post}} {{name=john}} {{age:=25}}


send a get request with query parameters (e.g. `first_param=5&second_param=true`)

xh get {{httpbin.org/get}} {{first_param==5}} {{second_param==true}}


xh get {{httpbin.org/get}} {{header-name:header-value}}


make a get request and save the response body to a file

xh --download {{httpbin.org/json}} --output {{path/to/file}}


display the current mask in octal notation


display the current mask in symbolic (humanreadable) mode


change the mask symbolically to allow read permission for all users (the rest of the mask bits are unchanged)


set the mask (using octal) to restrict no permissions for the file's owner, and restrict all permissions for everyone else


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


cat {{input.gxl}} | gxl2gv > {{output.gv}}


read 4096 bytes from the device starting from 0x8000000


write firmware to device starting from 0x8000000

st-flash write {{firmware}}.bin {{0x8000000}}


start an interactive device monitor and listen to a specific port

pio device monitor --port {{/dev/ttyUSBX}}


start an interactive device monitor and set a specific baud rate (defaults to 9600)


start an interactive device monitor and set a specific eol character (defaults to `crlf`)


go to the menu of the interactive device monitor


search multiple directories, one recursively


search recursively for duplicates and display interactive prompt to pick which ones to keep, deleting the others


search recursively and delete duplicates without prompting


create a virtual machine with 1 gib ram and 12 gib storage and start debian installation

virt-install --name {{vm_name}} --memory {{1024}} --disk path={{path/to/image.qcow2}},size={{12}} --cdrom {{path/to/debian.iso}}


convert a gregorian date to a hijri date


convert a hirji date to a gregorian date


apply a range of commits to the current branch (see also `git rebase onto`)


apply multiple (nonsequential) commits to the current branch

git cherry-pick {{commit_1}} {{commit_2}}


add the changes of a commit to the working directory, without creating a commit


mutool convert -o {{image%d.png}} {{file.pdf}} {{1-10}}


convert pages 2, 3 and 5 of a pdf into text in the standard output

mutool draw -F {{txt}} {{file.pdf}} {{2,3,5}}


mutool merge -o {{output.pdf}} {{input1.pdf}} {{input2.pdf}}


query information about all content embedded in a pdf


extract all images, fonts and resources embedded in a pdf out into the current directory


print the outline (table of contents) of a pdf


restore any files deleted since the last commit


restore any files deleted or changed since the last commit


restore any files changed since the last commit, ignoring any files that were deleted

git checkout-index --all --force --no-create


export a copy of the entire tree at the last commit to the specified directory (the trailing slash is important)

git checkout-index --all --force --prefix={{path/to/export_directory/}}


run a command using the input data as arguments

{{arguments_source}} | xargs {{command}}


run multiple chained commands on the input data

{{arguments_source}} | xargs sh -c "{{command1}} && {{command2}} | {{command3}}"


delete all files with a `.backup` extension (`print0` uses a null character to split file names, and `0` uses it as delimiter)

find . -name {{'*.backup'}} -print0 | xargs -0 rm -v


execute the command once for each input line, replacing any occurrences of the placeholder (here marked as `_`) with the input line

{{arguments_source}} | xargs -I _ {{command}} _ {{optional_extra_arguments}}


parallel runs of up to `maxprocs` processes at a time; the default is 1. if `maxprocs` is 0, xargs will run as many processes as possible at a time

{{arguments_source}} | xargs -P {{max-procs}} {{command}}


git reset-file {{path/to/file}} {{commit_hash}}


open a file or directory in a new window


open a file or directory in an existing window


open atom in safe mode (does not load any additional packages)


prevent atom from forking into the background, keeping atom attached to the terminal


wait for atom window to close before returning (useful for git commit editor)


strip nondeterministic information from a file


strip nondeterministic information from a file manually specifying the filetype

strip-nondeterminism --type {{filetype}} {{path/to/file}}


strip nondeterministic information from a file; instead of removing timestamps set them to the specified unix timestamp

strip-nondeterminism --timestamp {{unix_timestamp}} {{path/to/file}}


start/stop/restart all processes in a group


show last 100 **bytes** of process stderr

supervisorctl tail -100 {{process_name}} stderr


supervisorctl tail -f {{process_name}} stdout


reload process config file to add/remove processes as necessary


push an android application to an emulator/device


reinstall an existing app, keeping its data


grant all permissions listed in the app manifest


quickly update an installed package by only updating the parts of the apk that changed

adb install --fastdeploy {{path/to/file.apk}}


compile a lua source file to lua bytecode

luac -o {{byte_code.luac}} {{source.lua}}


do not include debug symbols in the output

luac -s -o {{byte_code.luac}} {{source.lua}}


decode a file that was encoded with `uuencode` and print the result to stdout


decode a file that was encoded with `uuencode` and write the result to a file

uudecode -o {{path/to/decoded_file}} {{path/to/encoded_file}}


install all dependencies referenced in the `package.json` file (the `install` is optional)


install a module and save it as a dependency to the `package.json` file (add `dev` to save as a dev dependency)


uninstall a module and remove it from the `package.json` file


interactively create a `package.json` file


identify whether a module is a dependency and list other modules that depend upon it


move the cursor to the window on the left|right


copy the highlighted difference from the other window to the current window


copy the highlighted difference from the current window to the other window


initialize `gitsecret` in a local repository


grant access to the current git user's email


get the [s]ize of the head commit in bytes


get the [t]ype (blob, tree, commit, tag) of a given git object


pretty[p]rint the contents of a given git object based on its type


kubectl run --generator=run-pod/v1 nginx --image=nginx --port 80


run an nginx pod, setting the test_var environment variable

kubectl run --generator=run-pod/v1 nginx --image=nginx --env="TEST_VAR=testing"


show api calls that would be made to create an nginx container

kubectl run --generator=run-pod/v1 nginx --image=nginx --dry-run


run an ubuntu pod interactively, never restart it, and remove it when it exits

kubectl run --generator=run-pod/v1 -it temp-ubuntu --image=ubuntu:20.04 --restart=Never --rm -- /bin/bash


run an ubuntu pod, overriding the default command with echo, and specifying custom arguments

kubectl run --generator=run-pod/v1 temp-ubuntu --image=ubuntu:20.04 --command -- echo arg1 arg2 arg3


display the numeric identifier for the current host in hexadecimal


issue a certificate using an automatic dns api mode

acme.sh --issue --dns {{gnd_gd}} --domain {{example.com}}


issue a wildcard certificate (denoted by an asterisk) using an automatic dns api mode

acme.sh --issue --dns {{dns_namesilo}} --domain {{example.com}} --domain {{*.example.com}}


issue a certificate using a dns alias mode

acme.sh --issue --dns {{dns_cf}} --domain {{example.com}} --challenge-alias {{alias-for-example-validation.com}}


issue a certificate while disabling automatic cloudflare / google dns polling after the dns record is added by specifying a custom wait time in seconds

acme.sh --issue --dns {{dns_namecheap}} --domain {{example.com}} --dnssleep {{300}}


issue a certificate using a manual dns mode

acme.sh --issue --dns --domain {{example.com}} --yes-I-know-dns-manual-mode-enough-go-ahead-please


translate a word (language is detected automatically)


behave like a dictionary to get the meaning of a word


return a sorted list of best matching fonts


describe the format and basic characteristics of an image


describe the format and verbose characteristics of an image


collect dimensions of all jpeg files under current directory

identify -format "%f,%w,%h\n" *.{{jpg}} > {{path/to/filelist.csv}}


open a terminal with the specified title for the window


copy the contents of stdin to the clipboard

echo {{example}} | kitty +kitten clipboard


replace all occurrences of a character in a file, and print the result

tr {{find_character}} {{replace_character}} < {{filename}}


replace all occurrences of a character from another command's output

echo {{text}} | tr {{find_character}} {{replace_character}}


map each character of the first set to the corresponding character of the second set


delete all occurrences of the specified set of characters from the input

tr -d '{{input_characters}}' < {{filename}}


compress a series of identical characters to a single character

tr -s '{{input_characters}}' < {{filename}}


translate the contents of a file to uppercase

tr "[:lower:]" "[:upper:]" < {{filename}}


strip out nonprintable characters from a file


take a specific secret key and generate a text file with the secret data

paperkey --secret-key {{path/to/secret_key.gpg}} --output {{path/to/secret_data.txt}}


take the secret key data in `secret_data.txt` and combine it with the public key to reconstruct the secret key

paperkey --pubring {{path/to/public_key.gpg}} --secrets {{path/to/secret_data.txt}} --output {{secret_key.gpg}}


export a specific secret key and generate a text file with the secret data

gpg --export-secret-key {{key}} | paperkey --output {{path/to/secret_data.txt}}


initialize (or reencrypt) the storage using one or more gpg ids


save a new password and additional information (press ctrl + d on a new line to complete)

pass insert --multiline {{path/to/data}}


copy a password (first line of the data file) to the clipboard


generate a new random password with a given length, and copy it to the clipboard

pass generate -c {{path/to/data}} {{num}}


initialize a new git repository (any changes done by pass will be committed automatically)


install packages from http//atom.io/packages and themes from http//atom.io/themes


display the commands history list with line numbers


display the last 20 commands (in `zsh` it displays all commands starting from the 20th)


clear the commands history list (only for current `bash` shell)


overwrite history file with history of current `bash` shell (often combined with `history c` to purge history)


delete the history entry at the specified offset


view documentation for the original command


check if an ip address is up, and guess the remote host's operating system


try to determine whether the specified hosts are up and what their names are

nmap -sn {{ip_or_hostname}} {{optional_another_address}}


like above, but also run a default 1000port tcp scan if host seems up


also enable scripts, service detection, os fingerprinting and traceroute


assume good network connection and speed up execution


scan a specific list of ports (use `p` for all ports `165535`)

nmap -p {{port1,port2,…,portN}} {{address_or_addresses}}


perform tcp and udp scanning (use `su` for udp only, `sz` for sctp, `so` for ip)


perform full port, service, version detection scan with all default nse scripts active against a host to determine weaknesses and info


compare 2 files, ignoring all tabs and whitespace

sdiff -W {{path/to/file1}} {{path/to/file2}}


compare 2 files, ignoring whitespace at the end of lines

sdiff -Z {{path/to/file1}} {{path/to/file2}}


compare 2 files in a caseinsensitive manner

sdiff -i {{path/to/file1}} {{path/to/file2}}


compare and then merge, writing the output to a new file

sdiff -o {{path/to/merged_file}} {{path/to/file1}} {{path/to/file2}}


move arguments by one place dropping the first argument


move arguments by n places dropping the first n arguments


decompose one or more graphs into their connected components

ccomps {{path/to/input1.gv}} {{path/to/input2.gv ...}} > {{path/to/output.gv}}


print the number of nodes, edges, and connected components in one or more graphs

ccomps -v -s {{path/to/input1.gv}} {{path/to/input2.gv ...}}


write each connected component to numbered filenames based on `output.gv`

ccomps -x -o {{path/to/output.gv}} {{path/to/input1.gv}} {{path/to/input2.gv ...}}


do not prune loose objects (prunes by default)


display data about a git repository since a commitish


display data about a git repository, merging committers using different emails into 1 statistic for each author


display data about a git repository, showing the number of lines modified by each contributor


install packages from an url or local file archive (.tar.gz | .whl)


install the local package in the current directory in develop (editable) mode


display a list of logged in users according to a specific file


run all tests defined in the cmake project, executing 4 jobs at a time in parallel


run a single test based on its name, or filter on a regular expression

ctest --output-on-failure -R '^{{test_name}}$'


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


cat {{input.gml}} | gml2gv > {{output.gv}}


display the token to join a manager or a worker

docker swarm join-token {{worker|manager}}


docker swarm join --token {{token}} {{manager_node_url:2377}}


remove a worker from the swarm (run inside the worker node)


display the current ca certificate in pem format


rotate the current ca certificate and display the new certificate


change the valid period for node certificates

docker swarm update --cert-expiry {{hours}}h{{minutes}}m{{seconds}}s


wrap each line to default width (80 characters)


wrap each line to width "5" and break the line at spaces (puts each space separated word in a new line, words with length > 5 are wrapped)


convert to utf8 encoding and overwrite the file


set new line code to lf and overwrite (unix type)


set new line code to crlf and overwrite (windows type)


update platformio to the latest development (unstable) version


get the actual file to which the symlink points


report only statistics that have a level of concern greater than 0


compute a checksum with bsdcompatible algorithm and 1024byte blocks


compute a checksum with system vcompatible algorithm and 512byte blocks


set a size of 10 gb to an existing file, or create a new file with the specified size


extend the file size by 50 mib, fill with holes (which reads as zero bytes)


shrink the file by 2 gib, by removing data from the end of file


empty the file's content, but do not create the file if it does not exist

truncate --no-create --size 0 {{filename}}


print a text message. note quotes are optional


print a message with environment variables


print a message without the trailing newline


enable interpretation of backslash escapes (special characters)


start keepass 2, opening the most recently opened password database


start keepass 2, opening a specific password database


use a specific key file to open a password database


compile to javascript and save to a file with the same name


compile to javascript and save to a given output file

coffee --compile {{path/to/file.coffee}} --output {{path/to/file.js}}


watch script for changes and rerun script


set i/o scheduling class of a running process

ionice -c {{scheduling_class}} -p {{pid}}


run a command with custom i/o scheduling class and priority

ionice -c {{scheduling_class}} -n {{priority}} {{command}}


print the i/o scheduling class and priority of a running process


perform a basic analysis check on the current project


perform a basic analysis check on a specific project


perform an analysis check for a specific environment


perform an analysis check and only report a specified defect severity type

pio check --severity {{low|medium|high}}


perform an analysis check and show detailed information when processing environments


randomize the order of lines in a file and output the result


only output the first 5 entries of the result


generate 3 random numbers in the range 110 (inclusive)

shuf --head-count={{3}} --input-range={{1-10}} --repeat


id3tag --artist={{artist}} --title={{title}} {{path/to/file.mp3}}


set album title of all mp3 files in the current directory


git annex add {{path/to/file_or_directory}}


show the current status of a file or directory

git annex status {{path/to/file_or_directory}}


synchronize a local repository with a remote


git annex get {{path/to/file_or_directory}}


open irssi and connect to a server with a nickname

irssi -n {{nickname}} -c {{irc.example.com}}


open irssi and connect with a specific server on a given port

irssi -c {{irc.example.com}} -p {{port}}


exit the application cleanly and quitting any server(s)


print system architecture and processor information


print kernel name, kernel release and kernel version

uname --kernel-name --kernel-release --kernel-version


set a secret for the current repository (user will be prompted for the value)


set a secret from a file for the current repository

gh secret set {{name}} < {{path/to/file}}


gh secret set {{name}} --body {{value}} --repo {{owner}}/{{repository}}


set an organization secret for specific repositories

gh secret set {{name}} --org {{organization}} --repos "{{repository1,repository2,...}}"


set an organization secret with a specific visibility

gh secret set {{name}} --org {{organization}} --visibility {{all|private|selected}}


show all references in the default remote repository


show only heads references in the default remote repository


show only tags references in the default remote repository


show all references from a remote repository based on name or url


show references from a remote repository filtered by a pattern

git ls-remote {{repository_name}} "{{pattern}}"


delete the underlying storage system for the storage pool specified by name or uuid (determine using `virsh poollist`)


execute a script, printing each command before executing it


start an interactive shell session in verbose mode, printing each command before executing it


create and switch to a new branch based on a specific reference (branch, remote/branch, tag are examples of valid references)

git checkout -b {{branch_name}} {{reference}}


switch to the previously checked out branch


git checkout --track {{remote_name}}/{{branch_name}}


discard all unstaged changes in the current directory (see `git reset` for more undolike commands)


discard unstaged changes to a given file


replace a file in the current directory with the version of it committed in a given branch

git checkout {{branch_name}} -- {{filename}}


update to the last commit matching a specified date


view documentation for the original command


display the partition table stored in an image file


display the partition table with an additional column for the partition size


display the partition table in a split ewf image


mmls -t {{nested_table_type}} -o {{offset}} {{path/to/image_file}}


list releases in a github repository, limited to 30 items


display information about a specific release


gh release upload {{tag}} {{path/to/file1}} {{path/to/file2}}


specific information about the message queue which has the id 32768


start `gpgtui` with color and ascii armored output


set the detail level for the selected key


bmaptool create -o {{blockmap.bmap}} {{source.img}}


bmaptool copy --bmap {{blockmap.bmap}} {{source.img}} {{/dev/sdb}}


bmaptool copy --bmap {{blockmap.bmap}} {{source.img.gz}} {{/dev/sdb}}


copy an image file into sdb without using a blockmap

bmaptool copy --nobmap {{source.img}} {{/dev/sdb}}


read ocaml commands from the user and execute them


read ocaml commands from a file and execute them


sudo route add -net {{ip_address}} netmask {{netmask_address}} gw {{gw_address}}


sudo route del -net {{ip_address}} netmask {{netmask_address}} dev {{gw_address}}


convert a scss or sass file to css and print out the result


convert a scss or sass file to css and save the result to a file


watch a scss or sass file for changes and output or update the css file with same filename


watch a scss or sass file for changes and output or update the css file with the given filename


display information about currently logged in users


display information about a specific user


display the user's login name, real name, terminal name, and other information


produce multiline output format displaying same information as `s` as well as user's home directory, home phone number, login shell, mail status, etc.


prevent matching against user's names and only use login names


use unix (or dos) pipes to pipe the stdout of any command through gnomon


show number of seconds since the start of the process

{{npm test}} | gnomon --type=elapsed-total


set a high threshold of 0.5 seconds for the elapsed time; exceeding which the timestamp will be colored bright red


set a medium threshold of 0.2 seconds (timestamp will be colored bright yellow)


show the sequence of commits starting from the current one in reverse chronological order


show the history of specific files or directories


show the difference between two references (such as branches or tags)


display commits from all branches and stashes


start in stash view, displaying all saved stashes


change the owner user of a file/directory


change the owner user and group of a file/directory


recursively change the owner of a directory and its contents


change the owner of a file/directory to match a reference file


start mitmproxy bound to custom address and port


docker logs {{container_name}} --tail {{5}}


print logs and append them with timestamps


print logs from a certain point in time of container execution (i.e. 23m, 10s, 20130102t132337)

docker logs {{container_name}} --until {{time}}


display the root location of the current repository


display the root location of the specified repository


convert command output to json via magic syntax


preview multiple svgs (use arrow keys to navigate)

inkview {{path/to/file_a.svg}} {{path/to/file_b.svg}} {{path/to/file_c.svg}}


acme.sh --issue --domain {{example.com}} --webroot {{/path/to/webroot}}


issue a certificate for multiple domains using standalone mode using port 80

acme.sh --issue --standalone --domain {{example.com}} --domain {{www.example.com}}


issue a certificate using standalone tls mode using port 443

acme.sh --issue --alpn --domain {{example.com}}


issue a certificate using a working nginx configuration

acme.sh --issue --nginx --domain {{example.com}}


issue a certificate using a working apache configuration

acme.sh --issue --apache --domain {{example.com}}


issue a wildcard (\*) certificate using an automatic dns api mode

acme.sh --issue --dns {{dns_cf}} --domain {{*.example.com}}


install certificate files into the specified locations (useful for automatic certificate renewal)

acme.sh --install-cert -d {{example.com}} --key-file {{/path/to/example.com.key}} --fullchain-file {{/path/to/example.com.cer}} --reloadcmd {{"systemctl force-reload nginx"}}


pack unpacked objects in the current directory


also remove redundant objects after packing


create a black window with display id "2"

Xephyr -br -ac -noreset -screen {{800x600}} {{:2}}


start an x application on the new screen


launch josm and reset all preferences to their default values


launch josm and download a specific bounding box


launch josm and download a specific bounding box as raw gps


view last logins, their duration and other information as read from `/var/log/wtmp`


specify how many of the last logins to show


print the full date and time for entries and then display the hostname column last to prevent truncation


view all logins by a specific user and show the ip address instead of the hostname


view all recorded reboots (i.e., the last logins of the pseudo user "reboot")


view all recorded shutdowns (i.e., the last logins of the pseudo user "shutdown")


commit all files matching a specified pattern


commit all files, excluding those that match a specified pattern


format the output of a command for a 30 characters wide display

printf "header1 header2\nbar foo\n" | column --output-width {{30}}


split columns automatically and autoalign them in a tabular format

printf "header1 header2\nbar foo\n" | column --table


specify the column delimiter character for the `table` option (e.g. "," for csv) (defaults to whitespace)

printf "header1,header2\nbar,foo\n" | column --table --separator {{,}}


printf "header1\nbar\nfoobar\n" | column --output-width {{30}} --fillrows


execute a highstate on all connected minions


upgrade packages using the os package manager (apt, yum, brew) on a subset of minions


execute an arbitrary command on a particular minion


terminate a process using the default sigterm (terminate) signal


list available signal names (to be used without the 'sig' prefix)


interactively ask for confirmation before termination


terminate a process using the sigint (interrupt) signal, which is the same signal sent by pressing `ctrl + c`


create a symbolic link to a file or directory

ln -s {{/path/to/file_or_directory}} {{path/to/symlink}}


overwrite an existing symbolic link to point to a different file

ln -sf {{/path/to/new_file}} {{path/to/symlink}}


connect to an influxdb running on localhost with no credentials


connect with a specific username (will prompt for a password)

influx -username {{username}} -password ""


influx -execute "{{influxql_command}}" -format {{json|csv|column}}


build the package or packages defined by the `cargo.toml` manifest file in the local path


build artifacts in release mode, with optimizations


run a project if the current directory contains a `project.godot` file, otherwise open the project manager


edit a project (the current directory must contain a `project.godot` file)


open the project manager even if the current directory contains a `project.godot` file


export a project for a given export preset (the preset must be defined in the project)

godot --export {{preset}} {{output_path}}


execute a standalone gdscript file (the script must inherit from `scenetree` or `mainloop`)


import a json file into a specific collection

mongoimport --file={{path/to/file.json}} --uri={{mongodb_uri}} --collection={{collection_name}}


import a csv file, using the first line of the file to determine field names

mongoimport --type={{csv}} --file={{path/to/file.csv}} --db={{database_name}} --collection={{collection_name}}


import a json array, using each element as a separate document


import a json file using a specific mode and a query to match existing documents

mongoimport --file={{path/to/file.json}} --mode={{delete|merge|upsert}} --upsertFields="{{field1,field2,...}}"


import a csv file, reading field names from a separate csv file and ignoring fields with empty values

mongoimport --type={{csv}} --file={{path/to/file.csv}} --fieldFile={{path/to/field_file.csv}} --ignoreBlanks


adjust one or more directed graphs to improve the layout aspect ratio

unflatten {{path/to/input1.gv}} {{path/to/input2.gv ...}} > {{path/to/output.gv}}


use `unflatten` as a preprocessor for `dot` layout to improve aspect ratio

unflatten {{path/to/input.gv}} | dot -T {{png}} {{path/to/output.png}}


list all available generators to destroy


destroy a scaffold for a model named post


initialize a new platformio project in a specific directory

pio project init --project-dir {{path/to/project_directory}}


initialize a new platformio project, specifying a board id

pio project init --board {{ATmega328P|uno|...}}


initialize a new platformio based project, specifying one or more project options

pio project init --project-option="{{option}}={{value}}" --project-option="{{option}}={{value}}"


lint using spaces as indentation instead of tabs


specify user password for pdf file to bypass security restrictions

pdfinfo -upw {{password}} {{path/to/file.pdf}}


specify owner password for pdf file to bypass security restrictions

pdfinfo -opw {{password}} {{path/to/file.pdf}}


unmount a filesystem, by passing the path to the source it is mounted from


unmount a filesystem, by passing the path to the target where it is mounted


unmount all mounted filesystems (except the `proc` filesystem)


list information about a resource with more details

kubectl get {{pod|service|deployment|ingress|...}} -o wide


update specified pod with the label 'unhealthy' and the value 'true'

kubectl label pods {{name}} unhealthy=true


display resource (cpu/memory/storage) usage of nodes or pods


print the address of the master and cluster services


display an explanation of a specific field


print the logs for a container in a pod or specified resource


get the absolute path to the root directory


colorize one or more ranked digraph (that were already processed by `dot`)

gvcolor {{path/to/layout1.gv}} {{path/to/layout2.gv ...}} > {{path/to/output.gv}}


lay out a graph and colorize it, then convert to a png image

dot {{path/to/input.gv}} | gvcolor | dot -T {{png}} > {{path/to/output.png}}


display number of occurrences of each line along with that line


display number of occurrences of each line, sorted by the most frequent


run command in a new container from a tagged image


run command in a new container in background and display its id


run command in a oneoff container in interactive mode and pseudotty

docker run --rm -it {{image}} {{command}}


run command in a new container with passed environment variables

docker run -e '{{variable}}={{value}}' -e {{variable}} {{image}} {{command}}


run command in a new container with bind mounted volumes

docker run -v {{path/to/host_path}}:{{path/to/container_path}} {{image}} {{command}}


run command in a new container with published ports

docker run -p {{host_port}}:{{container_port}} {{image}} {{command}}


show the content of all global and local `.gitignore` files


ignore file(s) privately, updating `.git/info/exclude` file


ignore file(s) locally, updating local `.gitignore` file


ignore file(s) globally, updating global `.gitignore` file


roll 1 8sided die, add 3 and sum the results


roll 4 6sided dice, keep the 3 highest results and sum the results


roll 2 12sided dice 2 times and show every roll


roll 2 20sided dice until the result is bigger than 10


roll 2 5sided dice 3 times and show the total sum


create a database at `/usr/local/var/postgres`


run the previous command as root (`!!` is replaced by the previous command)


run a command with the last argument of the previous command


run a command with the first argument of the previous command


run the command `n` lines back in the history


run the most recent command containing `string`


run the previous command, replacing `string1` with `string2`


perform a history expansion, but print the command that would be run instead of actually running it


xmllint --xpath "//{{foo}}" {{source_file.xml}}


return the contents of the first node named "foo" as a string

xmllint --xpath "string(//{{foo}})" {{source_file.xml}}


return the href attribute of the second anchor element in an html file

xmllint --html --xpath "string(//a[2]/@href)" webpage.xhtml


return humanreadable (indented) xml from file


check that an xml file meets the requirements of its doctype declaration


validate xml against dtd schema hosted online

xmllint --dtdvalid {{URL}} {{source_file.xml}}


find and compile all modules in the current directory


stop compilation after generating object files (.o)


analyse a directory and print the result


include only specific files from a commaseparated list (globs are allowed)

phploc {{path/to/directory}} --names {{files}}


exclude specific files from a commaseparated list (globs are allowed)

phploc {{path/to/directory}} --names-exclude {{files}}


exclude a specific directory from analysis

phploc {{path/to/directory}} --exclude {{path/to/exclude_directory}}


phploc {{path/to/directory}} --log-csv {{path/to/file}}


phploc {{path/to/directory}} --log-xml {{path/to/file}}


count phpunit test case classes and test methods


interactively create a `package.json` file


download all the packages listed as dependencies in package.json


download a specific version of a package and add it to the list of dependencies in `package.json`


download a package and add it to the list of dev dependencies in `package.json`


download a package and install it globally


uninstall a package and remove it from the list of dependencies in `package.json`


print a tree of locally installed dependencies


list toplevel globally installed modules


copy ("yank") or cut ("delete") the current line (paste it with `p`)


search for a pattern in the file (press `n`/`n` to go to next/previous match)


perform a regular expression substitution in the whole file


compress a file using the best compression method


compress a file using no compression and 4 processors


tar cf - {{path/to/directory}} | pigz > {{filename}}.tar.gz


list secret keys for the current repository


list secret keys for a specific organization


list secret keys for a specific repository

gh secret list --repo {{owner}}/{{repository}}


set a secret for the current repository (user will be prompted for the value)


set a secret from a file for the current repository

gh secret set {{name}} < {{path/to/file}}


set an organization secret for specific repositories

gh secret set {{name}} --org {{organization}} --repos {{repository1,repository2}}


remove a secret for the current repository


remove a secret for a specific organization

gh secret remove {{name}} --org {{organization}}


[c]reate an archive and write it to a [f]ile

tar cf {{target.tar}} {{file1}} {{file2}} {{file3}}


[c]reate a g[z]ipped archive and write it to a [f]ile

tar czf {{target.tar.gz}} {{file1}} {{file2}} {{file3}}


[c]reate a g[z]ipped archive from a directory using relative paths

tar czf {{target.tar.gz}} --directory={{path/to/directory}} .


e[x]tract a (compressed) archive [f]ile into the current directory [v]erbosely


e[x]tract a (compressed) archive [f]ile into the target directory

tar xf {{source.tar[.gz|.bz2|.xz]}} --directory={{directory}}


[c]reate a compressed archive and write it to a [f]ile, using [a]rchive suffix to determine the compression program

tar caf {{target.tar.xz}} {{file1}} {{file2}} {{file3}}


lis[t] the contents of a tar [f]ile [v]erbosely


e[x]tract files matching a pattern from an archive [f]ile

tar xf {{source.tar}} --wildcards "{{*.html}}"


perform a full update of all packages, development platforms and global libraries


update core packages only (skips platforms and libraries)


check for new versions of packages, platforms and libraries but do not actually update them


start r in vanilla mode (i.e. a blank session that doesn't save the workspace at the end)


list ssh keys for the currently authenticated user


add an ssh key to the currently authenticated user's account


add an ssh key to the currently authenticated user's account with a specific title

gh ssh-key add --title {{title}} {{path/to/key.pub}}


specify the "name" paragraph in the man page


specify the section for the man page (defaults to 1)

help2man {{executable}} --section {{section}}


help2man {{executable}} --output {{path/to/file}}


display a definition from a specific dictionary

sdcv --use-dict {{dictionary_name}} {{search_term}}


look up a definition with a fuzzy search


look up a definition with an exact search


look up a definition and format the output as json


search for dictionaries in a specific directory

sdvc --data-dir {{path/to/directory}} {{search_term}}


show the number of unique values in the "name" column

csvstat -c {{name}} --unique {{data.csv}}


generate a certificate signing request to be sent to a certificate authority

openssl req -new -sha256 -key {{filename.key}} -out {{filename.csr}}


generate a selfsigned certificate and a corresponding keypair, storing both in a file

openssl req -new -x509 -newkey {{rsa}}:{{4096}} -keyout {{filename.key}} -out {{filename.cert}} -subj "{{/C=XX/CN=foobar}}" -days {{365}}


fill a fake flash drive with a single partition that matches its real capacity


sudo f3fix --fs-type={{filesystem_type}} {{/dev/device_name}}


execute two different commands based on a condition

if {{command}}; then {{echo "true"}}; else {{echo "false"}}; fi


if [[ -n "{{$VARIABLE}}" ]]; then {{echo "defined"}}; else {{echo "not defined"}}; fi


if [[ -f "{{path/to/file}}" ]]; then {{echo "true"}}; else {{echo "false"}}; fi


if [[ -d "{{path/to/directory}}" ]]; then {{echo "true"}}; else {{echo "false"}}; fi


if [[ -e "{{path/to/file_or_directory}}" ]]; then {{echo "true"}}; else {{echo "false"}}; fi


list all possible conditions (`test` is an alias to `[`; both are commonly used with `if`)


compile one or more c# files to a cil executable


compile into a `.dll` library instead of an executable


automatically generate xml documentation


stronglyname the resulting assembly with a keyfile


kill the background process (note it will respawn if needed)


update the currently connected solo's firmware to the latest version


solo key wink --serial {{serial_number}}


generate random bytes using the currently connected solo's secure random number generator


connect to a remote server using a password supplied on a file descriptor (in this case, stdin)

sshpass -d {{0}} ssh {{user}}@{{hostname}}


connect to a remote server with the password supplied as an option, and automatically accept unknown ssh keys

sshpass -p {{password}} ssh -o StrictHostKeyChecking=no {{user}}@{{hostname}}


connect to a remote server using the first line of a file as the password, automatically accept unknown ssh keys, and launch a command

sshpass -f {{file}} ssh -o StrictHostKeyChecking=no {{user}}@{{hostname}} "{{command}}"


xdelta -d -s {{path/to/input_file}} {{path/to/delta_file.xdelta}} {{path/to/output_file}}


xdelta -e -s {{path/to/old_file}} {{path/to/new_file}} {{path/to/output_file.xdelta}}


list of all settable options and whether they are set


print a list of all options and their status formatted as runnable `shopt` commands


show events for today and tomorrow (or the weekend on friday) from the default calendar


look [a]head, showing events for the next 30 days


look [b]ack, showing events for the previous 7 days


show events from a custom calendar [f]ile


create and start all containers in the background using a `dockercompose.yml` file from the current directory


start all containers, rebuild if necessary


start all containers using an alternate compose file

docker-compose --file {{path/to/file}} up


stop and remove all containers, networks, images, and volumes


docker-compose logs --follow {{container_name}}


test if a given variable is equal to a given string


test {{condition}} && {{echo "true"}} || {{echo "false"}}


delete multiple local and remote git branches

git delete-branch {{branch_name1 branch_name2 ...}}


dump output of webpage to console, colorizing the text with ansi control codes

elinks -dump -dump-color-mode {{1}} {{url}}


start the current application in development mode


start the current application and listen on a specific port


build the current application optimized for production


start the compiled application in production mode


start the compiled application and listen on a specific port


export the current application to static html pages


task {{task_id}} modify {{new_thing_to_do}}


print a license to stdout, using the defaults (autodetected author name, and current year)


generate a license and save it to a file

license -o {{filename}} {{license_name}}


generate a license with custom author name and year

license --name {{author}} --year {{release_year}} {{license_name}}


extract all images from a pdf file and save them as pngs

pdfimages -png {{path/to/file.pdf}} {{filename_prefix}}


pdfimages -f {{3}} -l {{5}} {{path/to/file.pdf}} {{filename_prefix}}


extract images from a pdf file and include the page number in the output filenames

pdfimages -p {{path/to/file.pdf}} {{filename_prefix}}


list information about all the images in a pdf file


display amount of program memory available


display summarized information of the device


install one or more spaceseparated versions of ruby


upgrade a version of ruby to a new version

rvm upgrade {{current_version}} {{new_version}}


uninstall a version of ruby and keep its sources


remove a version of ruby and its sources


kill all processes which match their full command instead of just the process name


send sigusr1 signal to processes which match


kill the main `firefox` process to close the browser


list all installed development platforms


search for existing development platforms


show details about a development platform


extract an archive to the current directory


extract an archive to the specified directory

unar -o {{path/to/directory}} {{archive}}


force overwrite if files to be unpacked already exist


force rename if files to be unpacked already exist


force skip if files to be unpacked already exist


output a json file, in prettyprint format


output all elements from arrays (or all the values from objects) in a json file


read json objects from a file into an array, and output it (inverse of `jq .[]`)


output the value of a given key of each element in a json text from stdin

cat {{file.json}} | jq 'map(.{{key_name}})'


output the value of multiple keys as a new json object (assuming the input json has the keys `key_name` and `other_key_name`)

cat {{file.json}} | jq '{{{my_new_key}}: .{{key_name}}, {{my_other_key}}: .{{other_key_name}}}'


cat {{file.json}} | jq 'unique | sort | reverse'


output the value of a given key to a string (and disable json output)

cat {{file.json}} | jq --raw-output '"some text: \(.{{key_name}})"'


display a forecast using metric units for the next five days for rzeszow, poland

ansiweather -u {{metric}} -f {{5}} -l {{Rzeszow,PL}}


display a forecast showing symbols and daylight data for your current location


display a forecast showing wind and humidity data for your current location


calculate the sha256 checksum for a file


calculate the sha512 checksum for multiple files

shasum --algorithm 512 {{path/to/file1}} {{path/to/file2}}


calculate and save the list of sha256 checksums to a file

shasum --algorithm 256 {{path/to/file1}} {{path/to/file2}} > {{path/to/file.sha256}}


check a file with a list of sums against the directory's files


check a list of sums and only show a message for files for which verification fails


use a different version of python with virtualenv


display all filesystems and their disk usage


display all filesystems and their disk usage in humanreadable form


display the filesystem and its disk usage containing the given file or directory


display statistics on the number of free inodes


display filesystems but exclude the specified types


check out a working copy from a repository


bring changes from the repository into the working copy


put files and directories under version control, scheduling them for addition to repository. they will be added in next commit


send changes from your working copy to the repository

svn ci -m {{commit_log_message}} [{{PATH}}]


display changes from the last 10 revisions, showing modified files for each revision


view the services available from your organization


cf create-service {{service}} {{plan}} {{service_name}}


cf bind-service {{app_name}} {{service_name}}


run a script whose code is included in the app, but runs independently

cf run-task {{app_name}} "{{script_command}}" --name {{task_name}}


start an interactive ssh session with a vm hosting an app


get an ip address for the `eth0` interface


release an ip address for the `eth0` interface


interactively stage parts of a given file


display each file in the repository, showing commits and active days


display files modified by a specific number of commits or more, showing commits and active days


display files modified by a specific author, showing commits and active days


display files modified since a specific time/date, showing commits and active days


display only the specified files or directories, showing commits and active days

git effort {{path/to/file_or_directory1 path/to/file_or_directory2 ...}}


display all files in a specific directory, showing commits and active days


dwebp {{path/to/input.webp}} -o {{path/to/output.png}}


convert a `webp` file into a specific filetype

dwebp {{path/to/input.webp}} -bmp|-tiff|-pam|-ppm|-pgm|-yuv -o {{path/to/output}}


convert a `webp` file, using multithreading if possible

dwebp {{path/to/input.webp}} -o {{path/to/output.png}} -mt


convert a `webp` file, but also crop and scale at the same time

dwebp {{input.webp}} -o {{output.png}} -crop {{x_pos}} {{y_pos}} {{width}} {{height}} -scale {{width}} {{height}}


convert a `webp` file and flip the output

dwebp {{path/to/input.webp}} -o {{path/to/output.png}} -flip


convert a `webp` file and don't use inloop filtering to speed up the decoding process

dwebp {{path/to/input.webp}} -o {{path/to/output.png}} -nofilter


download a remote image from sylabs cloud

singularity pull --name {{image.sif}} {{library://godlovedc/funny/lolcow:latest}}


rebuild a remote image using the latest singularity image format

singularity build {{image.sif}} {{docker://godlovedc/lolcow}}


start a container from an image and get a shell inside it


start a container from an image and run a command

singularity exec {{image.sif}} {{command}}


start a container from an image and execute the internal runscript


build a singularity image from a recipe file

sudo singularity build {{image.sif}} {{recipe}}


save output to a wav audio file, rather than speaking it directly

espeak -w {{filename.wav}} "It's GNU plus Linux"


flush all pending write operations on all disks


flush all pending write operations on a single file to disk


virsh dumpxml {{guest_id}} > {{path/to/guest.xml}}


create a guest from a configuration file


edit a guest's configuration file (editor can be changed with $editor)


save the current state of a guest to a file


virsh destroy {{guest_id}} && virsh undefine {{guest_id}}


launch the default merge tool to resolve conflicts


launch the merge tool identified by a name


don't prompt before each invocation of the merge tool


explicitly use the gui merge tool (see the `merge.guitool` config variable)


explicitly use the regular merge tool (see the `merge.tool` config variable)


remove files or directories from the staging area


remove all staged files matching a specified pattern


remove all staged files, excluding those that match a specified pattern


remove files from the repository that have been physically removed


extract a file from an archive, replacing the original file if it exists


gunzip --stdout {{archive.tar.gz}} > {{archive.tar}}


extract a file and keep the archive file


remove file from repository index and filesystem


remove file from repository index but keep it untouched locally


extract files with original directory structure


extract files to a specified path with the original directory structure

unrar x {{compressed.rar}} {{path/to/extract}}


extract files into current directory, losing directory structure in the archive


test integrity of each file inside the archive file


list files inside the archive file without decompressing it


yank using the default delimiters (\f, \n, \r, \s, \t)


only yank fields matching a specific pattern


display the changes that would be performed without performing them (dryrun)


convert specific python 2 language features to python 3

2to3 --write {{path/to/file.py}} --fix={{raw_input}} --fix={{print}}


convert all python 2 language features except the specified ones to python 3

2to3 --write {{path/to/file.py}} --nofix={{has_key}} --nofix={{isinstance}}


display a list of all available language features that can be converted from python 2 to python 3


convert all python 2 files in a directory to python 3

2to3 --output-dir={{path/to/python3_directory}} --write-unchanged-files --nobackups {{path/to/python2_directory}}


2to3 --processes={{4}} --output-dir={{path/to/python3_directory}} --write --nobackups --no-diff {{path/to/python2_directory}}


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

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


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

twopi -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

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


render a `gif` image using stdin and stdout

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


ledger balance --file {{path/to/ledger.journal}}


list all postings in expenses ordered by amount

ledger register {{expenses}} --sorted {{amount}}


print total expenses other than drinks and food

ledger balance {{Expenses}} and not ({{Drinks}} or {{Food}})


print summary information about all the postings


calculate the sha224 checksum for a file


calculate sha224 checksums for multiple files


calculate and save the list of sha224 checksums to a file

sha224sum {{path/to/file1}} {{path/to/file2}} > {{path/to/file.sha224}}


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


only show a message for files for which verification fails

sha224sum --check --quiet {{path/to/file.sha224}}


print the go version used to build the named executable file


browse for ssh servers in a specified domain


print the remove commands instead of actually removing anything


initialize or mount an encrypted filesystem


initialize an encrypted filesystem with standard settings

encfs --standard {{/path/to/cipher_dir}} {{/path/to/mount_point}}


run encfs in the foreground instead of spawning a daemon

encfs -f {{/path/to/cipher_dir}} {{/path/to/mount_point}}


mount an encrypted snapshot of a plain directory

encfs --reverse {{path/to/plain_dir}} {{path/to/cipher_dir}}


list all formats that a video or playlist is available in


download a video or playlist at a specific quality

youtube-dl --format "{{best[height<=480]}}" '{{https://www.youtube.com/watch?v=oHg5SJYRHA0}}'


download the audio from a video and convert it to an mp3

youtube-dl -x --audio-format {{mp3}} '{{url}}'


download the best quality audio and video and merge them

youtube-dl -f bestvideo+bestaudio '{{url}}'


download video(s) as mp4 files with custom filenames

youtube-dl --format {{mp4}} -o "{{%(playlist_index)s-%(title)s by %(uploader)s on %(upload_date)s in %(playlist)s.%(ext)s}}" '{{url}}'


download a particular language's subtitles along with the video

youtube-dl --sub-lang {{en}} --write-sub '{{https://www.youtube.com/watch?v=Mwa0_nE9H7A}}'


download a playlist and extract mp3s from it

youtube-dl -f "bestaudio" --continue --no-overwrites --ignore-errors --extract-audio --audio-format mp3 -o "%(title)s.%(ext)s" {{url_to_playlist}}


display the number of available processing units


display the number of installed processing units, including any inactive ones


if possible, subtract a given number of units from the returned value


generate a sha512 timestamp request of a specific file and output to `file.tsq`

openssl ts -query -data {{path/to/file}} -sha512 -out {{path/to/file.tsq}}


check the date and metadata of a specific timestamp response file

openssl ts -reply -in {{path/to/file.tsr}} -text


verify a timestamp request file and a timestamp response file from the server with an ssl certificate file

openssl ts -verify -in {{path/to/file.tsr}} -queryfile {{path/to/file.tsq}} -partial_chain -CAfile {{path/to/cert.pem}}


create a timestamp response for request using key and signing certificate and output it to `file.tsr`

openssl ts -reply -queryfile {{path/to/file.tsq}} -inkey {{path/to/tsakey.pem}} -signer tsacert.pem -out {{path/to/file.tsr}}


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


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

dot -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

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


render a `gif` image using stdin and stdout

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


start in debug mode, keeping the process in the foreground


guacd -C {{my-cert.crt}} -K {{my-key.pem}}


display all locations containing the specified executable


display the name of the disk file that would be executed


delete all store paths unused by current generations of each profile


simulate the deletion of old store paths

sudo nix-collect-garbage --delete-old --dry-run


delete all store paths older than 30 days

sudo nix-collect-garbage --delete-older-than {{30d}}


install dependencies from a `shard.yml` file


create a new team with the specified description

pio team create --description {{description}} {{organization_name}}:{{team_name}}


pio team destroy {{organization_name}}:{{team_name}}


pio team add {{organization_name}}:{{team_name}} {{username}}


pio team remove {{organization_name}}:{{team_name}} {{username}}


list all teams that the user is part of and their members


pio team update --name {{new_team_name}} {{organization_name}}:{{team_name}}


pio team update --description {{new_description}} {{organization_name}}:{{team_name}}


launch gimp without showing the splash screen


start a new gimp instance, even if there is already a running one


print errors and warnings to the console instead of showing them in a dialog box


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

graphml2gv -o {{output.gv}} {{input.gml}}


cat {{input.gml}} | graphml2gv > {{output.gv}}


meld {{path/to/file_1}} {{path/to/file_2}} {{path/to/file_3}}


open a comparison as a new tab in a preexisting meld instance

meld --newtab {{path/to/file_1}} {{path/to/file_2}}


meld --diff {{path/to/file_1}} {{path/to/file_2}} --diff {{path/to/file_3}} {{path/to/file_4}}


clone a repository to a specified directory

hg clone {{remote_repository_source}} {{destination_path}}


clone a repository to the head of a specific branch, ignoring later commits

hg clone --branch {{branch}} {{remote_repository_source}}


clone a repository with only the `.hg` directory, without checking out files

hg clone --noupdate {{remote_repository_source}}


clone a repository to a specific revision, tag or branch, keeping the entire history

hg clone --updaterev {{revision}} {{remote_repository_source}}


clone a repository up to a specific revision without any newer history

hg clone --rev {{revision}} {{remote_repository_source}}


backup a directory via ftps to a remote machine, encrypting it with a password

FTP_PASSWORD={{ftp_login_password}} PASSPHRASE={{encryption_password}} duplicity {{path/to/source/directory}} {{ftps://user@hostname/target/directory/path/}}


backup a directory to amazon s3, doing a full backup every month

duplicity --full-if-older-than {{1M}} --use-new-style s3://{{bucket_name[/prefix]}}


delete versions older than 1 year from a backup stored on a webdav share

FTP_PASSWORD={{webdav_login_password}} duplicity remove-older-than {{1Y}} --force {{webdav[s]://user@hostname[:port]/some_dir}}


list the files in a backup stored on a remote machine, via ssh

duplicity list-current-files --time {{YYYY-MM-DD}} scp://{{user@hostname}}/path/to/backup/dir


restore a subdirectory from a gnupgencrypted local backup to a given location

PASSPHRASE={{gpg_key_password}} duplicity restore --encrypt-key {{gpg_key_id}} --file-to-restore {{relative/path/restoredirectory}} file://{{absolute/path/to/backup/directory}} {{path/to/directory/to/restore/to}}


output a list of words of length 1 to 3 with only lowercase characters


output a list of hexadecimal words of length 8


output a list of all permutations of abc (lengths are not processed)


output a list of all permutations of the given strings (lengths are not processed)


output a list of words generated according to the given pattern and a maximum number of duplicate letters


write a list of words in chunk files of a given size, starting with the given string


write a list of words stopping with the given string and inverting the wordlist


write a list of words in compressed chunk files with a specified number of words


convert blanks in each file to tabs, writing to standard output


convert blanks to tabs, reading from standard output


convert all blanks, instead of just initial blanks


convert only leading sequences of blanks (overrides a)


have tabs a certain number of characters apart, not 8 (enables a)


push changes to the "default" remote path


push changes to a specified remote repository


push a new branch if it does not exist (disabled by default)


specify a specific revision changeset to push


test if a given variable is equal to a given string


[ {{condition}} ] && {{echo "true"}} || {{echo "false"}}


run in offline mode to prevent gradle from accessing the network during builds


build an android package (apk) in release mode


add a todo to a specific project with a given context

topydo add "{{todo_message}} +{{project_name}} @{{context_name}}"


add a todo with a due date of tomorrow with a priority of `a`

topydo add "(A) {{todo _message}} due:{{1d}}"


topydo add "{{todo_message}} due:{{fri}}"


add a nonstrict repeating todo (next due = now + rec)

topydo add "water flowers due:{{mon}} rec:{{1w}}"


add a strict repeating todo (next due = current due + rec)


revert the last `topydo` command executed


change the commiter and author of a commit

git blame-someone-else "{{author <someone@example.com>}}" {{commit}}


open the first search result in the default pdf viewer


download and install a package, specified by its import path


compile and run a source file (it has to contain a `main` package)


compile a source file into a named executable


compile the package present in the current directory


execute all test cases of the current package (files have to end with `_test.go`)


initialize a new module in the current directory


get the properties of all the user limits


get hard limit for the number of simultaneously opened files


get soft limit for the number of simultaneously opened files


automatically start recording a video on launch


automatically start the replay buffer on launch


make the log more verbose (for debugging)


wpa_supplicant -i {{interface}} -c {{path/to/wpa_supplicant_conf.conf}}


join a protected wireless network and run it in a daemon

wpa_supplicant -B -i {{interface}} -c {{path/to/wpa_supplicant_conf.conf}}


reformat a file producing output lines of (at most) `n` characters


reformat a file without joining lines shorter than the given width together


reformat a file with uniform spacing (1 space between words and 2 spaces between paragraphs)


htpasswd -c {{path/to/file}} {{username}}


add user to htpasswd file or update existing user


add user to htpasswd file in batch mode without an interactive password prompt (for script usage)

htpasswd -b {{path/to/file}} {{username}} {{password}}


htpasswd -D {{path/to/file}} {{username}}


htpasswd -v {{path/to/file}} {{username}}


display a string with username (plain text) and password (md5)


view the command associated to a given alias


scan a file or directory for vulnerabilities


scan the current directory and output only infected files


move infected files to a specific directory


use multiple threads to scan a directory


pass the file descriptor instead of streaming the file to the daemon


flex --outfile {{analyser.c}} {{analyser.l}}


cc {{path/to/lex.yy.c}} --output {{executable}}


pio account register --username {{username}} --email {{email}} --password {{password}} --firstname {{firstname}} --lastname {{lastname}}


permanently delete your platformio account and related data


pio account login --username {{username}} --password {{password}}


pio account update --username {{username}} --email {{email}} --firstname {{firstname}} --lastname {{lastname}} --current-password {{password}}


show detailed information about your platformio account


reset your password using your username or email

pio account forgot --username {{username_or_email}}


print multiple files with a default header and footer


print with numbered lines and a custom date format


print all files together, one in each column, without a header or footer


print, beginning at page 2 up to page 5, with a given page length (including header and footer)


print with an offset for each line and a truncating custom page width

pr -o {{offset}} -W {{width}} {{file1}} {{file2}} {{file3}}


print the current directory, and resolve all symlinks (i.e. show the "physical" path)


do not actually run the actions (i.e. a dry run)


print the contents of the file and display a progress bar


measure the speed and amount of data flow between pipes (`s` is optional)

command1 | pv -s {{expected_amount_of_data_for_eta}} | command2


filter a file, see both progress and amount of output data

pv -cN in {{big_text_file}} | grep {{pattern}} | pv -cN out > {{filtered_file}}


attach to an already running process and see its file reading progress


read an erroneous file, skip errors as `dd conv=sync,noerror` would

pv -EE {{path/to/faulty_media}} > image.img


stop reading after reading specified amount of data, rate limit to 1k/s

pv -L 1K -S {{maximum_file_size_to_be_read}}


list the sizes of a directory and any subdirectories, in the given unit (b/kb/mb)