pigz

Multithreaded zlib compression utility. More information: https://github.com/madler/pigz.

Compress a file with default options:
pigz {{path/to/file}}
Compress a file using the best compression method:
pigz -9 {{path/to/file}}
Compress a file using no compression and 4 processors:
pigz -0 -p{{4}} {{path/to/file}}
Compress a directory using tar:
tar cf - {{path/to/directory}} | pigz > {{path/to/file}}.tar.gz
Decompress a file:
pigz -d {{archive.gz}}
List the contents of an archive:
pigz -l {{archive.tar.gz}}

git graft

Merge commits from a specific branch into another branch and delete the source branch. Part of git-extras. More information: https://github.com/tj/git-extras/blob/master/Commands.md#git-graft.

Merge all commits not present on the target branch from the source branch to target branch, and delete the source branch:
git graft {{source_branch}} {{target_branch}}

npm query

Print an array of dependency objects using CSS-like selectors. More information: https://docs.npmjs.com/cli/v8/commands/npm-query.

Print direct dependencies:
npm query ':root > *'
Print all direct production/development dependencies:
npm query ':root > .{{prod|dev}}'
Print dependencies with a specific name:
npm query '#{{package}}'
Print dependencies with a specific name and within a semantic versioning range:
npm query #{{package}}@{{semantic_version}}
Print dependencies which have no dependencies:
npm query ':empty'
Find all dependencies with postinstall scripts and uninstall them:
npm query ":attr(scripts, [postinstall])" | jq 'map(.name) | join("\n")' -r | xargs -I {} npm uninstall {}
Find all Git dependencies and print which application requires them:
npm query ":type(git)" | jq 'map(.name)' | xargs -I {} npm why {}

rustup component

Modify a toolchain's installed components. Without the --toolchain option rustup will use the default toolchain. See rustup help toolchain for more information about toolchains. More information: https://rust-lang.github.io/rustup.

Add a component to a toolchain:
rustup component add --toolchain {{toolchain}} {{component}}
Remove a component from a toolchain:
rustup component remove --toolchain {{toolchain}} {{component}}
List installed and available components for a toolchain:
rustup component list --toolchain {{toolchain}}
List installed components for a toolchain:
rustup component list --toolchain {{toolchain}} --installed

pdftotext

Convert PDF files to plain text format. More information: https://www.xpdfreader.com/pdftotext-man.html.

Convert filename.pdf to plain text and print it to stdout:
pdftotext {{filename.pdf}} -
Convert filename.pdf to plain text and save it as filename.txt:
pdftotext {{filename.pdf}}
Convert filename.pdf to plain text and preserve the layout:
pdftotext -layout {{filename.pdf}}
Convert input.pdf to plain text and save it as output.txt:
pdftotext {{input.pdf}} {{output.txt}}
Convert pages 2, 3 and 4 of input.pdf to plain text and save them as output.txt:
pdftotext -f {{2}} -l {{4}} {{input.pdf}} {{output.txt}}

xzcmp

Invokes cmp on files compressed with xz, lzma, gzip, bzip2, lzop, or zstd. All options specified are passed directly to cmp. More information: https://manned.org/xzcmp.

Compare two specific files:
xzcmp {{path/to/file1}} {{path/to/file2}}

nimble

Package manager for the Nim programming language. Manage Nim projects and their dependencies. More information: https://github.com/nim-lang/nimble.

Search for packages:
nimble search {{search_string}}
Install a package:
nimble install {{package}}
List installed packages:
nimble list -i
Create a new Nimble package in the current directory:
nimble init
Build a Nimble package:
nimble build
Install a Nimble package:
nimble install

serve

Static file serving and directory listing. More information: https://github.com/vercel/serve.

Start an HTTP server listening on the default port to serve the current directory:
serve
Start an HTTP server on a specific [p]ort to serve a specific directory:
serve -p {{port}} {{path/to/directory}}
Start an HTTP server with CORS enabled by including the Access-Control-Allow-Origin: * header in all responses:
serve --cors
Start an HTTP server on the default port rewriting all not-found requests to the index.html file:
serve --single
Start an HTTPS server on the default port using the specified certificate:
serve --ssl-cert {{path/to/cert.pem}} --ssl-key {{path/to/key.pem}}
Start an HTTP server on the default port using a specific configuration file:
serve --config {{path/to/serve.json}}
Display help:
serve --help

takeout

A Docker-based development-only dependency manager. More information: https://github.com/tighten/takeout.

Display a list of available services:
takeout enable
Enable a specific service:
takeout enable {{name}}
Enable a specific service with the default parameters:
takeout enable --default {{name}}
Display a list of enabled services:
takeout disable
Disable a specific service:
takeout disable {{name}}
Disable all services:
takeout disable --all
Start a specific container:
takeout start {{container_id}}
Stop a specific container:
takeout stop {{container_id}}

redshift

Adjust the color temperature of your screen according to your surroundings. More information: http://jonls.dk/redshift.

Turn on Redshift with 5700K temperature during day and 3600K at night:
redshift -t {{5700}}:{{3600}}
Turn on Redshift with a manually specified custom location:
redshift -l {{latitude}}:{{longitude}}
Turn on Redshift with 70% screen brightness during day and 40% brightness at night:
redshift -b {{0.7}}:{{0.4}}
Turn on Redshift with custom gamma levels (between 0 and 1):
redshift -g {{red}}:{{green}}:{{blue}}
Turn on Redshift with a constant unchanging color temperature:
redshift -O {{temperature}}

lzmore

This command is an alias of xzmore.

View documentation for the original command:
tldr xzmore

yarn

JavaScript and Node.js package manager alternative. More information: https://yarnpkg.com.

Install a module globally:
yarn global add {{module_name}}
Install all dependencies referenced in the package.json file (the install is optional):
yarn install
Install a module and save it as a dependency to the package.json file (add --dev to save as a dev dependency):
yarn add {{module_name}}@{{version}}
Uninstall a module and remove it from the package.json file:
yarn remove {{module_name}}
Interactively create a package.json file:
yarn init
Identify whether a module is a dependency and list other modules that depend upon it:
yarn why {{module_name}}

clash

A rule-based tunnel in Go. More information: https://github.com/Dreamacro/clash/wiki.

Specify a configuration [d]irectory:
clash -d {{path/to/directory}}
Specify a configuration [f]ile:
clash -f {{path/to/configuration_file}}

dirsearch

Web path scanner. More information: https://github.com/maurosoria/dirsearch.

Scan a web server for common paths with common extensions:
dirsearch --url {{url}} --extensions-list
Scan a list of web servers for common paths with the .php extension:
dirsearch --url-list {{path/to/url-list.txt}} --extensions {{php}}
Scan a web server for user-defined paths with common extensions:
dirsearch --url {{url}} --extensions-list --wordlist {{path/to/url-paths.txt}}
Scan a web server using a cookie:
dirsearch --url {{url}} --extensions {{php}} --cookie {{cookie}}
Scan a web server using the HEAD HTTP method:
dirsearch --url {{url}} --extensions {{php}} --http-method {{HEAD}}
Scan a web server, saving the results to a .json file:
dirsearch --url {{url}} --extensions {{php}} --json-report {{path/to/report.json}}

git bugreport

Captures debug information from the system and user, generating a text file to aid in the reporting of a bug in Git. More information: https://git-scm.com/docs/git-bugreport.

Create a new bug report file in the current directory:
git bugreport
Create a new bug report file in the specified directory, creating it if it does not exist:
git bugreport --output-directory {{path/to/directory}}
Create a new bug report file with the specified filename suffix in strftime format:
git bugreport --suffix {{%m%d%y}}

aws lambda

CLI for AWS lambda. More information: https://docs.aws.amazon.com/cli/latest/reference/lambda/.

Run a function:
aws lambda invoke --function-name {{name}} {{path/to/response}}.json
Run a function with an input payload in JSON format:
aws lambda invoke --function-name {{name}} --payload {{json}} {{path/to/response}}.json
List functions:
aws lambda list-functions
Display the configuration of a function:
aws lambda get-function-configuration --function-name {{name}}
List function aliases:
aws lambda list-aliases --function-name {{name}}
Display the reserved concurrency configuration for a function:
aws lambda get-function-concurrency --function-name {{name}}
List which AWS services can invoke the function:
aws lambda get-policy --function-name {{name}}

python3

This command is an alias of python.

View documentation for the original command:
tldr python

virsh pool-destroy

Stop an active virtual machine storage pool. See also: virsh, virsh-pool-delete. More information: https://manned.org/virsh.

Stop a storage pool specified by name or UUID (determine using virsh pool-list):
virsh pool-destroy --pool {{name|uuid}}

tred

Compute the transitive reduction of directed graphs. Graphviz filters: acyclic, bcomps, comps, edgepaint, gvcolor, gvpack, mingle, nop, sccmap, tred, & unflatten. More information: https://www.graphviz.org/pdf/tred.1.pdf.

Construct the transitive reduction graph of one or more directed graphs:
tred {{path/to/input1.gv}} {{path/to/input2.gv ...}} > {{path/to/output.gv}}
Display help:
tred -?

daps

DAPS is an open source program for transforming DocBook XML into output formats such as HTML or PDF. More information: https://opensuse.github.io/daps/doc/index.html.

Check if a DocBook XML file is valid:
daps -d {{path/to/file.xml}} validate
Convert a DocBook XML file into PDF:
daps -d {{path/to/file.xml}} pdf
Convert a DocBook XML file into a single HTML file:
daps -d {{path/to/file.xml}} html --single
Display help:
daps --help
Display version:
daps --version

hping3

Advanced ping utility which supports protocols such TCP, UDP, and raw IP. Best run with elevated privileges. More information: https://github.com/antirez/hping.

Ping a destination with 4 ICMP ping requests:
hping3 --icmp --count {{4}} {{ip_or_hostname}}
Ping an IP address over UDP on port 80:
hping3 --udp --destport {{80}} --syn {{ip_or_hostname}}
Scan TCP port 80, scanning from the specific local source port 5090:
hping3 --verbose --syn --destport {{80}} --baseport {{5090}} {{ip_or_hostname}}
Traceroute using a TCP scan to a specific destination port:
hping3 --traceroute --verbose --syn --destport {{80}} {{ip_or_hostname}}
Scan a set of TCP ports on a specific IP address:
hping3 --scan {{80,3000,9000}} --syn {{ip_or_hostname}}
Perform a TCP ACK scan to check if a given host is alive:
hping3 --count {{2}} --verbose --destport {{80}} --ack {{ip_or_hostname}}
Perform a charge test on port 80:
hping3 --flood --destport {{80}} --syn {{ip_or_hostname}}

unison

Bidirectional file synchronisation tool. More information: https://www.cis.upenn.edu/~bcpierce/unison/download/releases/stable/unison-manual.html.

Sync two directories (creates log first time these two directories are synchronized):
unison {{path/to/directory_1}} {{path/to/directory_2}}
Automatically accept the (non-conflicting) defaults:
unison {{path/to/directory_1}} {{path/to/directory_2}} -auto
Ignore some files using a pattern:
unison {{path/to/directory_1}} {{path/to/directory_2}} -ignore {{pattern}}
Show documentation:
unison -doc {{topics}}

aws configure

Manage configuration for the AWS CLI. More information: https://docs.aws.amazon.com/cli/latest/reference/configure/.

Configure AWS CLI interactively (creates a new configuration or updates the default):
aws configure
Configure a named profile for AWS CLI interactively (creates a new profile or updates an existing one):
aws configure --profile {{profile_name}}
Display the value from a specific configuration variable:
aws configure get {{name}}
Display the value for a configuration variable in a specific profile:
aws configure get {{name}} --profile {{profile_name}}
Set the value of a specific configuration variable:
aws configure set {{name}} {{value}}
Set the value of a configuration variable in a specific profile:
aws configure set {{name}} {{value}} --profile {{profile_name}}
List the configuration entries:
aws configure list
List the configuration entries for a specific profile:
aws configure list --profile {{profile_name}}

buku

Command-line browser-independent bookmark manager. More information: https://github.com/jarun/Buku.

Display all bookmarks matching "keyword" and with "privacy" tag:
buku {{keyword}} --stag {{privacy}}
Add bookmark with tags "search engine" and "privacy":
buku --add {{https://example.com}} {{search engine}}, {{privacy}}
Delete a bookmark:
buku --delete {{bookmark_id}}
Open editor to edit a bookmark:
buku --write {{bookmark_id}}
Remove "search engine" tag from a bookmark:
buku --update {{bookmark_id}} --tag {{-}} {{search engine}}

kubectl get

Get Kubernetes objects and resources. More information: https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#get.

Get all namespaces in the current cluster:
kubectl get namespaces
Get nodes in a specified namespace:
kubectl get nodes -n {{namespace}}
Get pods in a specified namespace:
kubectl get pods -n {{namespace}}
Get deployments in a specified namespace:
kubectl get deployments -n {{namespace}}
Get services in a specified namespace:
kubectl get services -n {{namespace}}
Get all resources in a specified namespace:
kubectl get all -n {{namespace}}
Get Kubernetes objects defined in a YAML manifest:
kubectl get -f {{path/to/manifest.yaml}}

eqn

Equation preprocessor for the groff (GNU Troff) document formatting system. See also troff and groff. More information: https://manned.org/eqn.

Process input with equations, saving the output for future typesetting with groff to PostScript:
eqn {{path/to/input.eqn}} > {{path/to/output.roff}}
Typeset an input file with equations to PDF using the [me] macro package:
eqn -T {{pdf}} {{path/to/input.eqn}} | groff -{{me}} -T {{pdf}} > {{path/to/output.pdf}}

spectacle

KDE's screenshot utility. More information: https://manned.org/spectacle.

Capture a screenshot of the entire desktop:
spectacle
Capture a screenshot of the active window:
spectacle --activewindow
Capture a screenshot of a specific region:
spectacle --region

jest

A zero-configuration JavaScript testing platform. More information: https://jestjs.io.

Run all available tests:
jest
Run the test suites from the given files:
jest {{path/to/file1}} {{path/to/file2}}
Run the test suites from files within the current and subdirectories, whose paths match the given regular expression:
jest {{regular_expression1}} {{regular_expression2}}
Run the tests whose names match the given regular expression:
jest --testNamePattern {{regular_expression}}
Run test suites related to a given source file:
jest --findRelatedTests {{path/to/source_file.js}}
Run test suites related to all uncommitted files:
jest --onlyChanged
Watch files for changes and automatically re-run related tests:
jest --watch
Show help:
jest --help

resume

Easily setup a new resume. More information: https://github.com/jsonresume/resume-cli.

Create a new resume.json file in the current working directory:
resume init
Validate a resume.json against schema tests to ensure it complies with the standard:
resume validate
Export a resume locally in a stylized HTML or PDF format:
resume export {{path/to/html_or_pdf}}
Start a web server that serves a local resume.json:
resume serve

csvstat

Print descriptive statistics for all columns in a CSV file. Included in csvkit. More information: https://csvkit.readthedocs.io/en/latest/scripts/csvstat.html.

Show all stats for all columns:
csvstat {{data.csv}}
Show all stats for columns 2 and 4:
csvstat -c {{2,4}} {{data.csv}}
Show sums for all columns:
csvstat --sum {{data.csv}}
Show the max value length for column 3:
csvstat -c {{3}} --len {{data.csv}}
Show the number of unique values in the "name" column:
csvstat -c {{name}} --unique {{data.csv}}

mosquitto_sub

A simple MQTT version 3.1.1 client that will subscribe to topics and print the messages that it receives. More information: https://mosquitto.org/man/mosquitto_sub-1.html.

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):
mosquitto_sub -t {{sensors/machines/+/temperature/+}}

rustup run

Run a command with an environment configured for a given Rust toolchain. Note: all commands managed by rustup have a shorthand for this: for example, cargo +nightly build is equivalent to rustup run nightly cargo build. More information: https://rust-lang.github.io/rustup.

Run a command using a given Rust toolchain (see rustup help toolchain for more information):
rustup run {{toolchain}} {{command}}

hostapd

Start an access point using a wireless interface. More information: https://w1.fi/hostapd/.

Start an access point:
sudo hostapd {{path/to/hostapd.conf}}
Start an access point, forking into the background:
sudo hostapd -B {{path/to/hostapd.conf}}

git-imerge

Perform a merge or rebase between two Git branches incrementally. Conflicts between branches are tracked down to pairs of individual commits, to simplify conflict resolution. More information: https://github.com/mhagger/git-imerge.

Start imerge-based rebase (checkout the branch to be rebased, first):
git imerge rebase {{branch_to_rebase_onto}}
Start imerge-based merge (checkout the branch to merge into, first):
git imerge merge {{branch_to_be_merged}}
Show ASCII diagram of in-progress merge or rebase:
git imerge diagram
Continue imerge operation after resolving conflicts (git add the conflicted files, first):
git imerge continue --no-edit
Wrap up imerge operation, after all conflicts are resolved:
git imerge finish
Abort imerge operation, and return to the previous branch:
git-imerge remove && git checkout {{previous_branch}}

pio home

Launch the PlatformIO Home web server. More information: https://docs.platformio.org/en/latest/core/userguide/cmd_home.html.

Open PlatformIO Home in the default web browser:
pio home
Use a specific HTTP port (defaults to 8008):
pio home --port {{port}}
Bind to a specific IP address (defaults to 127.0.0.1):
pio home --host {{ip_address}}
Do not automatically open PlatformIO Home in the default web browser:
pio home --no-open
Automatically shutdown the server on timeout (in seconds) when no clients are connected:
pio home --shutdown-timeout {{time}}
Specify a unique session identifier to keep PlatformIO Home isolated from other instances and protected from 3rd party access:
pio home --session-id {{id}}

git format-patch

Prepare .patch files. Useful when emailing commits elsewhere. See also git am, which can apply generated .patch files. More information: https://git-scm.com/docs/git-format-patch.

Create an auto-named .patch file for all the unpushed commits:
git format-patch {{origin}}
Write a .patch file for all the commits between 2 revisions to stdout:
git format-patch {{revision_1}}..{{revision_2}}
Write a .patch file for the 3 latest commits:
git format-patch -{{3}}

git switch

Switch between Git branches. Requires Git version 2.23+. See also git checkout. More information: https://git-scm.com/docs/git-switch.

Switch to an existing branch:
git switch {{branch_name}}
Create a new branch and switch to it:
git switch --create {{branch_name}}
Create a new branch based on an existing commit and switch to it:
git switch --create {{branch_name}} {{commit}}
Switch to the previous branch:
git switch -
Switch to a branch and update all submodules to match:
git switch --recurse-submodules {{branch_name}}
Switch to a branch and automatically merge the current branch and any uncommitted changes into it:
git switch --merge {{branch_name}}

ffplay

A simple and portable media player using the FFmpeg libraries and the SDL library. More information: https://ffmpeg.org/ffplay-all.html.

Play a media file:
ffplay {{path/to/file}}
Play audio from a media file without a GUI:
ffplay -nodisp {{path/to/file}}
Play media passed by ffmpeg through stdin:
ffmpeg -i {{path/to/file}} -c {{copy}} -f {{media_format}} - | ffplay -
Play a video and show motion vectors in real time:
ffplay -flags2 +export_mvs -vf codecview=mv=pf+bf+bb {{path/to/file}}
Show only video keyframes:
ffplay -vf select="{{eq(pict_type\,PICT_TYPE_I)}}" {{path/to/file}}

rtl_sdr

Raw data recorder for RTL-SDR receivers. Data is encoded using I/Q sampling (aka quadrature sampling). More information: https://osmocom.org/projects/rtl-sdr/wiki/Rtl-sdr.

Save RAW data from a frequency (specified in Hz) to a file:
rtl_sdr -f {{100000000}} {{path/to/file}}
Pipe data to another program:
rtl_sdr -f {{100000000}} - | {{aplay}}
Read a specified number of samples:
rtl_sdr -f {{100000000}} -n {{20}} -
Specify the sample rate in Hz (ranges 225001-300000 and 900001-3200000):
rtl_sdr -f {{100000000}} -s {{2400000}} -
Specify the device by its index:
rtl_sdr -f {{100000000}} -d {{0}} -
Specify the gain:
rtl_sdr -f {{100000000}} -g {{20}} -
Specify the output block size:
rtl_sdr -f {{100000000}} -b {{9999999}} -
Use synchronous output:
rtl_sdr -f {{100000000}} -S -

zsh

Z SHell, a Bash-compatible command-line interpreter. See also: bash, histexpand. More information: https://www.zsh.org.

Start an interactive shell session:
zsh
Execute specific [c]ommands:
zsh -c "{{echo Hello world}}"
Execute a specific script:
zsh {{path/to/script.zsh}}
Check a specific script for syntax errors without executing it:
zsh --no-exec {{path/to/script.zsh}}
Execute specific commands from stdin:
{{echo Hello world}} | zsh
Execute a specific script, printing each command in the script before executing it:
zsh --xtrace {{path/to/script.zsh}}
Start an interactive shell session in verbose mode, printing each command before executing it:
zsh --verbose
Execute a specific command inside zsh with disabled glob patterns:
noglob {{command}}

cs launch

Launch an application from the name directly from one or more Maven dependencies without the need of installing it. More information: https://get-coursier.io/docs/cli-launch.

Launch a specific application with arguments:
cs launch {{application_name}} -- {{argument1 argument2 ...}}
Launch a specific application version with arguments:
cs launch {{application_name}}:{{application_version}} -- {{argument1 argument2 ...}}
Launch a specific version of an application specifying which is the main file:
cs launch {{group_id}}:{{artifact_id}}:{{artifact_version}} --main-class {{path/to/main_class_file}}
Launch an application with specific java options and a jvm memory ones:
cs launch --java-opt {{-Doption_name1:option_value1 -Doption_name2:option_value2 ...}} --java-opt {{-Xjvm_option1 -Xjvm_option2 ...}} {{application_name}}

git commit

Commit files to the repository. More information: https://git-scm.com/docs/git-commit.

Commit staged files to the repository with a message:
git commit --message "{{message}}"
Commit staged files with a message read from a file:
git commit --file {{path/to/commit_message_file}}
Auto stage all modified and deleted files and commit with a message:
git commit --all --message "{{message}}"
Commit staged files and sign them with the specified GPG key (or the one defined in the config file if no argument is specified):
git commit --gpg-sign {{key_id}} --message "{{message}}"
Update the last commit by adding the currently staged changes, changing the commit's hash:
git commit --amend
Commit only specific (already staged) files:
git commit {{path/to/file1}} {{path/to/file2}}
Create a commit, even if there are no staged files:
git commit --message "{{message}}" --allow-empty

czkawka-cli

Command-line version of czkawka a multi-functional app to find duplicates, empty folders, similar images and much more. More information: https://github.com/qarmin/czkawka.

List duplicate or similar files in specific directories:
czkawka-cli {{dup|image}} --directories {{path/to/directory1 path/to/directory2 ...}}
Find duplicate files in specific directories and delete them (default: NONE):
czkawka-cli dup --directories {{path/to/directory1 path/to/directory2 ...}} --delete-method {{AEN|AEO|ON|OO|HARD|NONE}}

n

Tool to manage multiple node versions. More information: https://github.com/tj/n.

Install a given version of node. If the version is already installed, it will be activated:
n {{version}}
Display installed versions and interactively activate one of them:
n
Remove a version:
n rm {{version}}
Execute a file with a given version:
n use {{version}} {{file.js}}
Output binary path for a version:
n bin {{version}}

git archive

Create an archive of files from a named tree. More information: https://git-scm.com/docs/git-archive.

Create a tar archive from the contents of the current HEAD and print it to stdout:
git archive --verbose HEAD
Create a zip archive from the current HEAD and print it to stdout:
git archive --verbose --format=zip HEAD
Same as above, but write the zip archive to file:
git archive --verbose --output={{path/to/file.zip}} HEAD
Create a tar archive from the contents of the latest commit on a specific branch:
git archive --output={{path/to/file.tar}} {{branch_name}}
Create a tar archive from the contents of a specific directory:
git archive --output={{path/to/file.tar}} HEAD:{{path/to/directory}}
Prepend a path to each file to archive it inside a specific directory:
git archive --output={{path/to/file.tar}} --prefix={{path/to/prepend}}/ HEAD

troff

Typesetting processor for the groff (GNU Troff) document formatting system. See also groff. More information: https://manned.org/troff.

Format output for a PostScript printer, saving the output to a file:
troff {{path/to/input.roff}} | grops > {{path/to/output.ps}}
Format output for a PostScript printer using the [me] macro package, saving the output to a file:
troff -{{me}} {{path/to/input.roff}} | grops > {{path/to/output.ps}}
Format output as [a]SCII text using the [man] macro package:
troff -T {{ascii}} -{{man}} {{path/to/input.roff}} | grotty
Format output as a [pdf] file, saving the output to a file:
troff -T {{pdf}} {{path/to/input.roff}} | gropdf > {{path/to/output.pdf}}

kcadm.sh

Perform administration tasks. More information: https://www.keycloak.org/docs/latest/server_admin/#admin-cli.

Start an authenticated session:
kcadm.sh config credentials --server {{host}} --realm {{realm_name}} --user {{username}} --password {{password}}
Create a user:
kcadm.sh create users -s username={{username}} -r {{realm_name}}
List all realms:
kcadm.sh get realms
Update a realm with JSON config:
kcadm.sh update realms/{{realm_name}} -f {{path/to/file.json}}

bash

Bourne-Again SHell, an sh-compatible command-line interpreter. See also: zsh, histexpand (history expansion). More information: https://gnu.org/software/bash/.

Start an interactive shell session:
bash
Start an interactive shell session without loading startup configs:
bash --norc
Execute specific [c]ommands:
bash -c "{{echo 'bash is executed'}}"
Execute a specific script:
bash {{path/to/script.sh}}
Execute a specific script while printing each command before executing it:
bash -x {{path/to/script.sh}}
Execute a specific script and stop at the first [e]rror:
bash -e {{path/to/script.sh}}
Execute specific commands from stdin:
{{echo "echo 'bash is executed'"}} | bash
Start a [r]estricted shell session:
bash -r

omz

Oh My Zsh command-line tool. More information: https://github.com/ohmyzsh/ohmyzsh.

Update Oh My Zsh:
omz update
Print the changes from the latest update of Oh My Zsh:
omz changelog
Restart the current Zsh session and Oh My Zsh:
omz reload
List all available plugins:
omz plugin list
Enable/Disable an Oh My Zsh plugin:
omz plugin {{enable|disable}} {{plugin}}
List all available themes:
omz theme list
Set an Oh My Zsh theme in ~/.zshrc:
omz theme set {{theme}}

gallery-dl

Download image galleries and collections from several image hosting sites. More information: https://github.com/mikf/gallery-dl.

Download images from the specified URL:
gallery-dl "{{url}}"
Retrieve pre-existing cookies from your web browser (useful for sites that require login):
gallery-dl --cookies-from-browser {{browser}} "{{url}}"
Get the direct URL of an image from a site supporting authentication with username and password:
gallery-dl --get-urls --username {{username}} --password {{password}} "{{url}}"
Filter manga chapters by chapter number and language:
gallery-dl --chapter-filter "{{10 <= chapter < 20}}" --option "lang={{language_code}}" "{{url}}"

csvclean

Finds and cleans common syntax errors in CSV files. Included in csvkit. More information: https://csvkit.readthedocs.io/en/latest/scripts/csvclean.html.

Clean a CSV file:
csvclean {{bad.csv}}
List locations of syntax errors in a CSV file:
csvclean -n {{bad.csv}}

wait

Wait for a process to complete before proceeding. More information: https://manned.org/wait.

Wait for a process to finish given its process ID (PID) and return its exit status:
wait {{pid}}
Wait for all processes known to the invoking shell to finish:
wait

swipl

SWI-Prolog - A comprehensive free Prolog environment. More information: https://www.swi-prolog.org/.

Start an interactive session:
swipl
Execute a command without showing any output:
swipl --quiet -t "{{command}}"
Execute a script:
swipl {{path/to/file.pl}}
Print all shell configuration variables:
swipl --dump-runtime-variables
Print the version:
swipl --version

conda create

Create new conda environments. More information: https://docs.conda.io/projects/conda/en/latest/commands/create.html.

Create a new environment named py39, and install Python 3.9 and NumPy v1.11 or above in it:
conda create --yes --name {{py39}} python={{3.9}} "{{numpy>=1.11}}"
Make exact copy of an environment:
conda create --clone {{py39}} --name {{py39-copy}}
Create a new environment with a specified name and install a given package:
conda create --name {{env_name}} {{package}}

finger

User information lookup program. More information: https://manned.org/finger.

Display information about currently logged in users:
finger
Display information about a specific user:
finger {{username}}
Display the user's login name, real name, terminal name, and other information:
finger -s
Produce multiline output format displaying same information as -s as well as user's home directory, home phone number, login shell, mail status, etc.:
finger -l
Prevent matching against user's names and only use login names:
finger -m

mkfifo

Makes FIFOs (named pipes). More information: https://www.gnu.org/software/coreutils/mkfifo.

Create a named pipe at a given path:
mkfifo {{path/to/pipe}}

comm

Select or reject lines common to two files. Both files must be sorted. More information: https://www.gnu.org/software/coreutils/comm.

Produce three tab-separated columns: lines only in first file, lines only in second file and common lines:
comm {{file1}} {{file2}}
Print only lines common to both files:
comm -12 {{file1}} {{file2}}
Print only lines common to both files, reading one file from stdin:
cat {{file1}} | comm -12 - {{file2}}
Get lines only found in first file, saving the result to a third file:
comm -23 {{file1}} {{file2}} > {{file1_only}}
Print lines only found in second file, when the files aren't sorted:
comm -13 <(sort {{file1}}) <(sort {{file2}})

pandoc

Convert documents between various formats. More information: https://pandoc.org.

Convert file to PDF (the output format is determined by file extension):
pandoc {{input.md}} -o {{output.pdf}}
Force conversion to use a specific format:
pandoc {{input.docx}} --to {{gfm}} -o {{output.md}}
Convert to a standalone file with the appropriate headers/footers (for LaTeX, HTML, etc.):
pandoc {{input.md}} -s -o {{output.tex}}
List all supported input formats:
pandoc --list-input-formats
List all supported output formats:
pandoc --list-output-formats

lzcat

This command is an alias of xz --format=lzma --decompress --stdout. More information: https://manned.org/lzcat.

View documentation for the original command:
tldr xz

lpstat

Show status information about printers. More information: https://manned.org/lpstat.

List printers present on the machine and whether they are enabled for printing:
lpstat -p
Show the default printer:
lpstat -d
Display all available status information:
lpstat -t
Show a list of print jobs queued by the specified user:
lpstat -u {{user}}

gst-inspect-1.0

Print information on GStreamer plugins. More information: https://gstreamer.freedesktop.org/documentation/tools/gst-inspect.html?gi-language=c.

Print information on a plugin:
gst-inspect-1.0 {{plugin}}
List hardware transcoding capabilities of your device:
gst-inspect-1.0 {{vaapi|nvcodec}}

git feature

Create or merge feature branches. Feature branches obey the format feature/. More information: https://github.com/tj/git-extras/blob/master/Commands.md#git-feature.

Create and switch to a new feature branch:
git feature {{feature_branch}}
Merge a feature branch into the current branch creating a merge commit:
git feature finish {{feature_branch}}
Merge a feature branch into the current branch squashing the changes into one commit:
git feature finish --squash {{feature_branch}}
Send changes from a specific feature branch to its remote counterpart:
git feature {{feature_branch}} --remote {{remote_name}}

nix-collect-garbage

Delete unused and unreachable nix store paths. Generations can be listed using nix-env --list-generations. More information: https://nixos.org/releases/nix/latest/manual/#sec-nix-collect-garbage.

Delete all store paths unused by current generations of each profile:
sudo nix-collect-garbage --delete-old
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

logname

Shows the user's login name. More information: https://www.gnu.org/software/coreutils/logname.

Display the currently logged in user's name:
logname

sshd

Secure Shell Daemon - allows remote machines to securely log in to the current machine. Remote machines can execute commands as it is executed at this machine. More information: https://man.openbsd.org/sshd.

Start daemon in the background:
sshd
Run sshd in the foreground:
sshd -D
Run with verbose output (for debugging):
sshd -D -d
Run on a specific port:
sshd -p {{port}}

trap

Automatically execute commands after receiving signals by processes or the operating system. Can be used to perform cleanups for interruptions by the user or other actions. More information: https://manned.org/trap.

List available signals to set traps for:
trap -l
List active traps for the current shell:
trap -p
Set a trap to execute commands when one or more signals are detected:
trap 'echo "Caught signal {{SIGHUP}}"' {{SIGHUP}}
Remove active traps:
trap - {{SIGHUP}} {{SIGINT}}

dirs

Displays or manipulates the directory stack. The directory stack is a list of recently visited directories that can be manipulated with the pushd and popd commands. More information: https://www.gnu.org/software/bash/manual/bash.html#Directory-Stack-Builtins.

Display the directory stack with a space between each entry:
dirs
Display the directory stack with one entry per line:
dirs -p
Display only the nth entry in the directory stack, starting at 0:
dirs +{{N}}
Clear the directory stack:
dirs -c

fastmod

A fast partial replacement for the codemod tool, replace and replace all in the whole codebase. Regexes are matched by Rust regex crate. More information: https://github.com/facebookincubator/fastmod.

Replace a regex pattern in all files of the current directory, ignoring files on .ignore and .gitignore:
fastmod {{regex_pattern}} {{replacement}}
Replace a regex pattern in case-insensitive mode in specific files or directories:
fastmod --ignore-case {{regex_pattern}} {{replacement}} -- {{path/to/file path/to/directory ...}}
Replace a regex pattern in a specific directory in files filtered with a case-insensitive glob pattern:
fastmod {{regex}} {{replacement}} --dir {{path/to/directory}} --iglob {{'**/*.{js,json}'}}
Replace for an exact string in .js or .json files:
fastmod --fixed-strings {{exact_string}} {{replacement}} --extensions {{json,js}}
Replace for an exact string without prompt for a confirmation (disables regular expressions):
fastmod --accept-all --fixed-strings {{exact_string}} {{replacement}}
Replace for an exact string without prompt for a confirmation, printing changed files:
fastmod --accept-all --print-changed-files --fixed-strings {{exact_string}} {{replacement}}

calligrawords

Calligra's word processor application. See also: calligraflow, calligrastage, calligrasheets. More information: https://manned.org/calligrawords.

Launch the word processor application:
calligrawords
Open a specific document:
calligrawords {{path/to/document}}
Display help or version:
calligrawords --{{help|version}}

dotnet build

Builds a .NET application and its dependencies. More information: https://learn.microsoft.com/dotnet/core/tools/dotnet-build.

Compile the project or solution in the current directory:
dotnet build
Compile a .NET project or solution in debug mode:
dotnet build {{path/to/project_or_solution}}
Compile in release mode:
dotnet build --configuration {{Release}}
Compile without restoring dependencies:
dotnet build --no-restore
Compile with a specific verbosity level:
dotnet build --verbosity {{quiet|minimal|normal|detailed|diagnostic}}
Compile for a specific runtime:
dotnet build --runtime {{runtime_identifier}}
Specify the output directory:
dotnet build --output {{path/to/directory}}

export

Command to mark shell variables in the current environment to be exported with any newly forked child processes. More information: https://www.gnu.org/software/bash/manual/bash.html#index-export.

Set a new environment variable:
export {{VARIABLE}}={{value}}
Remove an environment variable:
export -n {{VARIABLE}}
Mark a shell function for export:
export -f {{FUNCTION_NAME}}
Append something to the PATH variable:
export PATH=$PATH:{{path/to/append}}

doctl kubernetes cluster

Manage Kubernetes clusters and view configuration options relating to clusters. More information: https://docs.digitalocean.com/reference/doctl/reference/kubernetes/cluster/.

Create a Kubernetes cluster:
doctl kubernetes cluster create --count {{3}} --region {{nyc1}} --size {{s-1vcpu-2gb}} --version {{latest}} {{cluster_name}}
List all Kubernetes clusters:
doctl kubernetes cluster list
Fetch and save the kubeconfig:
doctl kubernetes cluster kubeconfig save {{cluster_name}}
Check for available upgrades:
doctl kubernetes cluster get-upgrades {{cluster_name}}
Upgrade a cluster to a new Kubernetes version:
doctl kubernetes cluster upgrade {{cluster_name}}
Delete a cluster:
doctl kubernetes cluster delete {{cluster_name}}

pathchk

Check the validity and portability of one or more pathnames. More information: https://www.gnu.org/software/coreutils/pathchk.

Check pathnames for validity in the current system:
pathchk {{path1 path2 …}}
Check pathnames for validity on a wider range of POSIX compliant systems:
pathchk -p {{path1 path2 …}}
Check pathnames for validity on all POSIX compliant systems:
pathchk --portability {{path1 path2 …}}
Only check for empty pathnames or leading dashes (-):
pathchk -P {{path1 path2 …}}

khal

A text-based calendar and scheduling application for the command-line. More information: https://lostpackets.de/khal.

Start Khal on interactive mode:
ikhal
Print all events scheduled in personal calendar for the next seven days:
khal list -a {{personal}} {{today}} {{7d}}
Print all events scheduled not in personal calendar for tomorrow at 10:00:
khal at -d {{personal}} {{tomorrow}} {{10:00}}
Print a calendar with a list of events for the next three months:
khal calendar
Add new event to personal calendar:
khal new -a {{personal}} {{2020-09-08}} {{18:00}} {{18:30}} "{{Dentist appointment}}"

x11docker

Securely run GUI applications and desktop UIs in Docker containers. See also xephyr. More information: https://github.com/mviereck/x11docker.

Launch VLC in a container:
x11docker --pulseaudio --share={{$HOME/Videos}} {{jess/vlc}}
Launch Xfce in a window:
x11docker --desktop {{x11docker/xfce}}
Launch GNOME in a window:
x11docker --desktop --gpu --init={{systemd}} {{x11docker/gnome}}
Launch KDE Plasma in a window:
x11docker --desktop --gpu --init={{systemd}} {{x11docker/kde-plasma}}
Display help:
x11docker --help

openssl dgst

OpenSSL command to generate digest values and perform signature operations. More information: https://www.openssl.org/docs/manmaster/man1/openssl-dgst.html.

Calculate the SHA256 digest for a file, saving the result to a specific file:
openssl dgst -sha256 -binary -out {{output_file}} {{input_file}}
Sign a file using an RSA key, saving the result to a specific file:
openssl dgst -sign {{private_key_file}} -sha256 -sigopt rsa_padding_mode:pss -out {{output_file}} {{input_file}}
Verify an RSA signature:
openssl dgst -verify {{public_key_file}} -signature {{signature_file}} -sigopt rsa_padding_mode:pss {{signature_message_file}}
Sign a file using and ECDSA key:
openssl dgst -sign {{private_key_file}} -sha256 -out {{output_file}} {{input_file}}
Verify an ECDSA signature:
openssl dgst -verify {{public_key_file}} -signature {{signature_file}} {{signature_message_file}}

timidity

TiMidity++ is a MIDI file player and converter. More information: http://timidity.sourceforge.net.

Play a MIDI file:
timidity {{path/to/file.mid}}
Play a MIDI file in a loop:
timidity --loop {{path/to/file.mid}}
Play a MIDI file in a specific key (0 = C major/A minor, -1 = F major/D minor, +1 = G major/E minor, etc.):
timidity --force-keysig={{-flats|+sharps}} {{path/to/file.mid}}
Convert a MIDI file to PCM (WAV) audio:
timidity --output-mode={{w}} --output-file={{path/to/file.wav}} {{path/to/file.mid}}
Convert a MIDI file to FLAC audio:
timidity --output-mode={{F}} --output-file={{path/to/file.flac}} {{path/to/file.mid}}

dart

The tool for managing Dart projects. More information: https://dart.dev/tools/dart-tool.

Initialize a new Dart project in a directory of the same name:
dart create {{project_name}}
Run a Dart file:
dart run {{path/to/file.dart}}
Download dependencies for the current project:
dart pub get
Run unit tests for the current project:
dart test
Update an outdated project's dependencies to support null-safety:
dart pub upgrade --null-safety
Compile a Dart file to a native binary:
dart compile exe {{path/to/file.dart}}

age-keygen

Generate age key pairs. See age for how to encrypt/decrypt files. More information: https://manned.org/age-keygen.

Generate a key pair, save it to an unencrypted file and print the public key to stdout:
age-keygen --output {{path/to/file}}
Convert an identity to a recipient and print the public key to stdout:
age-keygen -y {{path/to/file}}

mktemp

Create a temporary file or directory. More information: https://ss64.com/osx/mktemp.html.

Create an empty temporary file and print the absolute path to it:
mktemp
Create an empty temporary file with a given suffix and print the absolute path to file:
mktemp --suffix "{{.ext}}"
Create a temporary directory and print the absolute path to it:
mktemp -d

neofetch

Display information about your operating system, software and hardware. More information: https://github.com/dylanaraps/neofetch.

Return the default config, and create it if it's the first time the program runs:
neofetch
Trigger an info line from appearing in the output, where 'infoname' is the function name in the config file, e.g. memory:
neofetch --{{enable|disable}} {{infoname}}
Hide/Show OS architecture:
neofetch --os_arch {{on|off}}
Enable/Disable CPU brand in output:
neofetch --cpu_brand {{on|off}}

codespell

Spellchecker for source code. More information: https://github.com/codespell-project/codespell.

Check for typos in all text files in the current directory, recursively:
codespell
Correct all typos found in-place:
codespell --write-changes
Skip files with names that match the specified pattern (accepts a comma-separated list of patterns using wildcards):
codespell --skip "{{pattern}}"
Use a custom dictionary file when checking (--dictionary can be used multiple times):
codespell --dictionary {{path/to/file.txt}}
Do not check words that are listed in the specified file:
codespell --ignore-words {{path/to/file.txt}}
Do not check the specified words:
codespell --ignore-words-list {{words,to,ignore}}
Print 3 lines of context around, before or after each match:
codespell --{{context|before-context|after-context}} {{3}}
Check file names for typos, in addition to file contents:
codespell --check-filenames

cargo test

Execute the unit and integration tests of a Rust package. More information: https://doc.rust-lang.org/cargo/commands/cargo-test.html.

Only run tests containing a specific string in their names:
cargo test {{testname}}
Set the number of simultaneous running test cases:
cargo test -- --test-threads={{count}}
Require that Cargo.lock is up to date:
cargo test --locked
Test artifacts in release mode, with optimizations:
cargo test --release
Test all packages in the workspace:
cargo test --workspace
Run tests for a package:
cargo test --package {{package}}
Run tests without hiding output from test executions:
cargo test -- --nocapture

xml escape

Escape special XML characters, e.g. <a1> → <a1>. More information: http://xmlstar.sourceforge.net/doc/xmlstarlet.pdf.

Escape special XML characters in a string:
xml escape "{{<a1>}}"
Escape special XML characters from stdin:
echo "{{<a1>}}" | xml escape
Display help for the escape subcommand:
xml escape --help

xml select

Select from XML documents using XPATHs. Tip: use xml elements to display the XPATHs of an XML document. More information: http://xmlstar.sourceforge.net/docs.php.

Select all elements matching "XPATH1" and print the value of their sub-element "XPATH2":
xml select --template --match "{{XPATH1}}" --value-of "{{XPATH2}}" {{path/to/input.xml|URI}}
Match "XPATH1" and print the value of "XPATH2" as text with new-lines:
xml select --text --template --match "{{XPATH1}}" --value-of "{{XPATH2}}" --nl {{path/to/input.xml|URI}}
Count the elements of "XPATH1":
xml select --template --value-of "count({{XPATH1}})" {{path/to/input.xml|URI}}
Count all nodes in one or more XML documents:
xml select --text --template --inp-name --output " " --value-of "count(node())" --nl {{path/to/input1.xml|URI}} {{path/to/input2.xml|URI}}
Display help for the select subcommand:
xml select --help

git mv

Move or rename files and update the Git index. More information: https://git-scm.com/docs/git-mv.

Move a file inside the repo and add the movement to the next commit:
git mv {{path/to/file}} {{new/path/to/file}}
Rename a file or directory and add the renaming to the next commit:
git mv {{path/to/file_or_directory}} {{path/to/destination}}
Overwrite the file or directory in the target path if it exists:
git mv --force {{path/to/file_or_directory}} {{path/to/destination}}

oathtool

OATH one-time password tool. More information: https://www.nongnu.org/oath-toolkit/oathtool.1.html.

Generate TOTP token (behaves like Google Authenticator):
oathtool --totp --base32 "{{secret}}"
Generate a TOTP token for a specific time:
oathtool --totp --now "{{2004-02-29 16:21:42}}" --base32 "{{secret}}"
Validate a TOTP token:
oathtool --totp --base32 "{{secret}}" "{{token}}"

cbt

Utility for reading data from Google Cloud's Bigtable. More information: https://cloud.google.com/bigtable/docs/cbt-reference.

List tables in the current project:
cbt ls
Print count of rows in a specific table in the current project:
cbt count "{{table_name}}"
Display a single row from a specific table with only 1 (most recent) cell revision per column in the current project:
cbt lookup "{{table_name}}" "{{row_key}}" cells-per-column={{1}}
Display a single row with only specific column(s) (omit qualifier to return entire family) in the current project:
cbt lookup "{{table_name}}" "{{row_key}}" columns="{{family1:qualifier1,family2:qualifier2,...}}"
Search up to 5 rows in the current project by a specific regex pattern and print them:
cbt read "{{table_name}}" regex="{{row_key_pattern}}" count={{5}}
Read a specific range of rows and print only returned row keys in the current project:
cbt read {{table_name}} start={{start_row_key}} end={{end_row_key}} keys-only=true

pdfseparate

Portable Document Format (PDF) file page extractor. More information: https://manpages.debian.org/latest/poppler-utils/pdfseparate.1.en.html.

Extract pages from PDF file and make a separate PDF file for each page:
pdfseparate {{path/to/source_filename.pdf}} {{path/to/destination_filename-%d.pdf}}
Specify the first/start page for extraction:
pdfseparate -f {{3}} {{path/to/source_filename.pdf}} {{path/to/destination_filename-%d.pdf}}
Specify the last page for extraction:
pdfseparate -l {{10}} {{path/to/source_filename.pdf}} {{path/to/destination_filename-%d.pdf}}

convmv

Convert filenames (NOT file content) from one encoding to another. More information: https://www.j3e.de/linux/convmv/man/.

Test filename encoding conversion (don't actually change the filename):
convmv -f {{from_encoding}} -t {{to_encoding}} {{input_file}}
Convert filename encoding and rename the file to the new encoding:
convmv -f {{from_encoding}} -t {{to_encoding}} --notest {{input_file}}

subfinder

A subdomain discovery tool that discovers valid subdomains for websites. Designed as a passive framework to be useful for bug bounties and safe for penetration testing. More information: https://github.com/subfinder/subfinder.

Find subdomains for a specific domain:
subfinder -d {{example.com}}
Show only the subdomains found:
subfinder --silent -d {{example.com}}
Use a brute-force attack to find subdomains:
subfinder -d {{example.com}} -b
Remove wildcard subdomains:
subfinder -nW -d {{example.com}}
Use a given comma-separated list of resolvers:
subfinder -r {{8.8.8.8}},{{1.1.1.1}} -d {{example.com}}

sha224sum

Calculate SHA224 cryptographic checksums. More information: https://www.gnu.org/software/coreutils/manual/html_node/sha2-utilities.html.

Calculate the SHA224 checksum for one or more files:
sha224sum {{path/to/file1 path/to/file2 ...}}
Calculate and save the list of SHA224 checksums to a file:
sha224sum {{path/to/file1 path/to/file2 ...}} > {{path/to/file.sha224}}
Calculate a SHA224 checksum from stdin:
{{command}} | sha224sum
Read a file of SHA224 sums and filenames and verify all files have matching checksums:
sha224sum --check {{path/to/file.sha224}}
Only show a message for missing files or when verification fails:
sha224sum --check --quiet {{path/to/file.sha224}}
Only show a message when verification fails, ignoring missing files:
sha224sum --ignore-missing --check --quiet {{path/to/file.sha224}}

rustup

Install, manage, and update Rust toolchains. Some subcommands, such as toolchain, target, update, etc. have their own usage documentation. More information: https://rust-lang.github.io/rustup.

Install the nightly toolchain for your system:
rustup install nightly
Switch the default toolchain to nightly so that the cargo and rustc commands will use it:
rustup default nightly
Use the nightly toolchain when inside the current project but leave global settings unchanged:
rustup override set nightly
Update all toolchains:
rustup update
List installed toolchains:
rustup show
Run cargo build with a certain toolchain:
rustup run {{toolchain}} cargo build
Open the local Rust documentation in the default web browser:
rustup doc

docsify

Initialize and serve markdown documentation. More information: https://cli.docsifyjs.org.

Initialize a new documentation in the current directory:
docsify init
Initialize a new documentation in the specified directory:
docsify init {{path/to/directory}}
Serve local documentation on localhost:3000 with live reload:
docsify serve {{path/to/directory}}
Serve local documentation on localhost at the specified port:
docsify serve --port {{80}} {{path/to/directory}}
Generate a sidebar markdown file in the specified directory:
docsify generate {{path/to/directory}}

install

Copy files and set attributes. Copy files (often executable) to a system location like /usr/local/bin, give them the appropriate permissions/ownership. More information: https://www.gnu.org/software/coreutils/install.

Copy files to the destination:
install {{path/to/source_file1 path/to/source_file2 ...}} {{path/to/destination}}
Copy files to the destination, setting their ownership:
install --owner {{user}} {{path/to/source_file1 path/to/source_file2 ...}} {{path/to/destination}}
Copy files to the destination, setting their group ownership:
install --group {{user}} {{path/to/source_file1 path/to/source_file2 ...}} {{path/to/destination}}
Copy files to the destination, setting their mode:
install --mode {{+x}} {{path/to/source_file1 path/to/source_file2 ...}} {{path/to/destination}}
Copy files and apply access/modification times of source to the destination:
install --preserve-timestamps {{path/to/source_file1 path/to/source_file2 ...}} {{path/to/destination}}
Copy files and create the directories at the destination if they don't exist:
install -D {{path/to/source_file1 path/to/source_file2 ...}} {{path/to/destination}}

pageres

Capture screenshots of websites in various resolutions. More information: https://github.com/sindresorhus/pageres-cli.

Take multiple screenshots of multiple URLs at different resolutions:
pageres {{https://example.com/}} {{https://example2.com/}} {{1366x768}} {{1600x900}}
Provide specific options for a URL, overriding global options:
pageres [{{https://example.com/}} {{1366x768}} --no-crop] [{{https://example2.com/}} {{1024x768}}] --crop
Provide a custom filename template:
pageres {{https://example.com/}} {{1024x768}} --filename={{'<%= date %> - <%= url %>'}}
Capture a specific element on a page:
pageres {{https://example.com/}} {{1366x768}} --selector='{{.page-header}}'
Hide a specific element:
pageres {{https://example.com/}} {{1366x768}} --hide='{{.page-header}}'
Capture a screenshot of a local file:
pageres {{local_file_path.html}} {{1366x768}}

qemu-img

Tool for Quick Emulator Virtual HDD image creation and manipulation. More information: https://qemu.readthedocs.io/en/latest/tools/qemu-img.html.

Create disk image with a specific size (in gigabytes):
qemu-img create {{image_name.img}} {{gigabytes}}G
Show information about a disk image:
qemu-img info {{image_name.img}}
Increase or decrease image size:
qemu-img resize {{image_name.img}} {{gigabytes}}G
Dump the allocation state of every sector of the specified disk image:
qemu-img map {{image_name.img}}
Convert a VMware .vmdk disk image to a KVM .qcow2 disk image:
qemu-img convert -f {{vmdk}} -O {{qcow2}} {{path/to/file/foo.vmdk}} {{path/to/file/foo.qcow2}}

cmp

Compare two files byte by byte. More information: https://www.gnu.org/software/diffutils/manual/html_node/Invoking-cmp.html.

Output char and line number of the first difference between two files:
cmp {{path/to/file1}} {{path/to/file2}}
Output info of the first difference: char, line number, bytes, and values:
cmp --print-bytes {{path/to/file1}} {{path/to/file2}}
Output the byte numbers and values of every difference:
cmp --verbose {{path/to/file1}} {{path/to/file2}}
Compare files but output nothing, yield only the exit status:
cmp --quiet {{path/to/file1}} {{path/to/file2}}

lldb

The LLVM Low-Level Debugger. More information: https://lldb.llvm.org.

Debug an executable:
lldb {{executable}}
Attach lldb to a running process with a given PID:
lldb -p {{pid}}
Wait for a new process to launch with a given name, and attach to it:
lldb -w -n {{process_name}}

join

Join lines of two sorted files on a common field. More information: https://www.gnu.org/software/coreutils/join.

Join two files on the first (default) field:
join {{file1}} {{file2}}
Join two files using a comma (instead of a space) as the field separator:
join -t {{','}} {{file1}} {{file2}}
Join field3 of file1 with field1 of file2:
join -1 {{3}} -2 {{1}} {{file1}} {{file2}}
Produce a line for each unpairable line for file1:
join -a {{1}} {{file1}} {{file2}}
Join a file from stdin:
cat {{path/to/file1}} | join - {{path/to/file2}}

railway

Connect code to a Railway project. More information: https://railway.app/.

Login to a Railway account:
railway login
Link to an existing Project under a Railway account or team:
railway link {{projectId}}
Create a new project:
railway init
Run a local command using variables from the active environment:
railway run {{cmd}}
Deploy the linked project directory (if running from a subdirectory, the project root is still deployed):
railway up
Open an interactive shell to a database:
railway connect

hx

This command is an alias of helix.

View documentation for the original command:
tldr helix

virsh

Manage virsh guest domains. (NOTE: 'guest_id' can be the id, name or UUID of the guest). Some subcommands such as virsh list have their own usage documentation. More information: https://libvirt.org/virshcmdref.html.

Connect to a hypervisor session:
virsh connect {{qemu:///system}}
List all domains:
virsh list --all
Dump guest configuration file:
virsh dumpxml {{guest_id}} > {{path/to/guest.xml}}
Create a guest from a configuration file:
virsh create {{path/to/config_file.xml}}
Edit a guest's configuration file (editor can be changed with $EDITOR):
virsh edit {{guest_id}}
Start/reboot/shutdown/suspend/resume a guest:
virsh {{command}} {{guest_id}}
Save the current state of a guest to a file:
virsh save {{guest_id}} {{filename}}
Delete a running guest:
virsh destroy {{guest_id}} && virsh undefine {{guest_id}}

git check-ref-format

Checks if a given refname is acceptable, and exits with a non-zero status if it is not. More information: https://git-scm.com/docs/git-check-ref-format.

Check the format of the specified refname:
git check-ref-format {{refs/head/refname}}
Print the name of the last branch checked out:
git check-ref-format --branch @{-1}
Normalize a refname:
git check-ref-format --normalize {{refs/head/refname}}

podman images

Manage Podman images. More information: https://docs.podman.io/en/latest/markdown/podman-images.1.html.

List all Podman images:
podman images
List all Podman images including intermediates:
podman images --all
List the output in quiet mode (only numeric IDs):
podman images --quiet
List all Podman images not used by any container:
podman images --filter dangling=true
List images that contain a substring in their name:
podman images "{{*image|image*}}"

balena

Interact with the balenaCloud, openBalena and the balena API. More information: https://www.balena.io/docs/reference/cli/.

Log in to the balenaCloud account:
balena login
Create a balenaCloud or openBalena application:
balena app create {{app_name}}
List all balenaCloud or openBalena applications within the account:
balena apps
List all devices associated with the balenaCloud or openBalena account:
balena devices
Flash a balenaOS image to a local drive:
balena local flash {{path/to/balenaos.img}} --drive {{drive_location}}

home-manager

Manage a user environment using Nix. More information: https://github.com/rycee/home-manager.

Activate the configuration defined in ~/.config/nixpkgs/home.nix:
home-manager build
Activate the configuration and switch to it:
home-manager switch

git show

Show various types of Git objects (commits, tags, etc.). More information: https://git-scm.com/docs/git-show.

Show information about the latest commit (hash, message, changes, and other metadata):
git show
Show information about a given commit:
git show {{commit}}
Show information about the commit associated with a given tag:
git show {{tag}}
Show information about the 3rd commit from the HEAD of a branch:
git show {{branch}}~{{3}}
Show a commit's message in a single line, suppressing the diff output:
git show --oneline -s {{commit}}
Show only statistics (added/removed characters) about the changed files:
git show --stat {{commit}}
Show only the list of added, renamed or deleted files:
git show --summary {{commit}}
Show the contents of a file as it was at a given revision (e.g. branch, tag or commit):
git show {{revision}}:{{path/to/file}}

git annotate

Show commit hash and last author on each line of a file. See git blame, which is preferred over git annotate. git annotate is provided for those familiar with other version control systems. More information: https://git-scm.com/docs/git-annotate.

Print a file with the author name and commit hash prepended to each line:
git annotate {{path/to/file}}
Print a file with the author email and commit hash prepended to each line:
git annotate -e {{path/to/file}}
Print only rows that match a regular expression:
git annotate -L :{{regexp}} {{path/to/file}}

gulp

JavaScript task runner and streaming build system. Tasks are defined within gulpfile.js at the project root. More information: https://github.com/gulpjs/gulp-cli.

Run the default task:
gulp
Run individual tasks:
gulp {{task}} {{othertask}}

chafa

Image printing in the terminal. See also: catimg, pixterm. More information: https://hpjansson.org/chafa.

Render an image directly in the terminal:
chafa {{path/to/file}}
Render an image with 24-bit [c]olor:
chafa -c full {{path/to/file}}
Improve image rendering with small color palettes using dithering:
chafa -c 16 --dither ordered {{path/to/file}}
Render an image, making it appear pixelated:
chafa --symbols vhalf {{path/to/file}}
Render a monochrome image with only braille characters:
chafa -c none --symbols braille {{path/to/file}}

react-native start

Command-line tools to start the React Native server. More information: https://github.com/react-native-community/cli/blob/master/docs/commands.md#start.

Start the server that communicates with connected devices:
react-native start
Start the metro bundler with a clean cache:
react-native start --reset-cache
Start the server in a custom port (defaults to 8081):
react-native start --port {{3000}}
Start the server in verbose mode:
react-native start --verbose
Specify the maximum number of workers for transforming files (default is the number of CPU cores):
react-native start --max-workers {{count}}
Disable interactive mode:
react-native start --no-interactive

odps table

Create and modify tables in ODPS (Open Data Processing Service). See also odps. More information: https://www.alibabacloud.com/help/doc-detail/27971.htm.

Create a table with partition and lifecycle:
create table {{table_name}} ({{col}} {{type}}) partitioned by ({{col}} {{type}}) lifecycle {{days}};
Create a table based on the definition of another table:
create table {{table_name}} like {{another_table}};
Add partition to a table:
alter table {{table_name}} add partition ({{partition_spec}});
Delete partition from a table:
alter table {{table_name}} drop partition ({{partition_spec}});
Delete table:
drop table {{table_name}};

f3fix

Edit the partition table of a fake flash drive. See also f3probe, f3write, f3read. More information: http://oss.digirati.com.br/f3/.

Fill a fake flash drive with a single partition that matches its real capacity:
sudo f3fix {{/dev/device_name}}
Mark the partition as bootable:
sudo f3fix --boot {{/dev/device_name}}
Specify the filesystem:
sudo f3fix --fs-type={{filesystem_type}} {{/dev/device_name}}

clip-view

Command Line Interface Pages render. Render for a TlDr-like project with much a more extensive syntax and several render modes. More information: https://github.com/command-line-interface-pages/v2-tooling/tree/main/clip-view.

Render specific local pages:
clip-view {{path/to/page1.clip path/to/page2.clip ...}}
Render specific remote pages:
clip-view {{page_name1 page_name2 ...}}
Render pages by a specific render:
clip-view --render {{tldr|tldr-colorful|docopt|docopt-colorful}} {{page_name1 page_name2 ...}}
Render pages with a specific color theme:
clip-view --theme {{path/to/local_theme.yaml|remote_theme_name}} {{page_name1 page_name2 ...}}
Clear a page or theme cache:
clip-view --clear-{{page|theme}}-cache
Display help:
clip-view --help
Display version:
clip-view --version

vue serve

A subcommand provided by @vue/cli and @vue/cli-service-global that enables quick prototyping. More information: https://cli.vuejs.org/guide/prototyping.html.

Serve a .js or .vue file in development mode with zero config:
vue serve {{filename}}

git brv

Print a list of branches, sorted by last commit date. Part of git-extras. More information: https://github.com/tj/git-extras/blob/master/Commands.md#git-brv.

List each branch showing date, latest commit hash and message:
git brv

git info

Display Git repository information. Part of git-extras. More information: https://github.com/tj/git-extras/blob/master/Commands.md#git-info.

Display remote locations, remote and local branches, most recent commit data and .git/config settings:
git info
Display remote locations, remote and local branches and most recent commit data:
git info --no-config

imapsync

Email IMAP tool for syncing, copying and migrating email mailboxes between two IMAP servers, one way, and without duplicates. More information: https://imapsync.lamiral.info.

Synchronize IMAP account between host1 and host2:
imapsync --host1 {{host1}} --user1 {{user1}} --password1 {{secret1}} --host2 {{host2}} --user2 {{user2}} --password2 {{secret2}}

stack

Tool for managing Haskell projects. More information: https://github.com/commercialhaskell/stack.

Create a new package:
stack new {{package}} {{template}}
Compile a package:
stack build
Run tests inside a package:
stack test
Compile a project and re-compile every time a file changes:
stack build --file-watch
Compile a project and execute a command after compilation:
stack build --exec "{{command}}"
Run a program and pass an argument to it:
stack exec {{program}} -- {{argument}}

cmake

Cross-platform build automation system, that generates recipes for native build systems. More information: https://cmake.org/cmake/help/latest/manual/cmake.1.html.

Generate a build recipe in the current directory with CMakeLists.txt from a project directory:
cmake {{path/to/project_directory}}
Generate a build recipe, with build type set to Release with CMake variable:
cmake {{path/to/project_directory}} -D {{CMAKE_BUILD_TYPE=Release}}
Generate a build recipe using generator_name as the underlying build system:
cmake -G {{generator_name}} {{path/to/project_directory}}
Use a generated recipe in a given directory to build artifacts:
cmake --build {{path/to/build_directory}}
Install the build artifacts into /usr/local/ and strip debugging symbols:
cmake --install {{path/to/build_directory}} --strip
Install the build artifacts using the custom prefix for paths:
cmake --install {{path/to/build_directory}} --strip --prefix {{path/to/directory}}
Run a custom build target:
cmake --build {{path/to/build_directory}} --target {{target_name}}
Display help, obtain a list of generators:
cmake --help

xetex

Compile a PDF document from XeTeX source files. More information: https://www.tug.org/xetex/.

Compile a PDF document:
xetex {{source.tex}}
Compile a PDF document, specifying an output directory:
xetex -output-directory={{path/to/directory}} {{source.tex}}
Compile a PDF document, exiting if errors occur:
xetex -halt-on-error {{source.tex}}

pve-firewall

Manage Proxmox VE Firewall. More information: https://pve.proxmox.com/wiki/Firewall.

Compile and print all firewall rules:
pve-firewall compile
Show information about the local network:
pve-firewall localnet
Restart the Proxmox VE Firewall service:
pve-firewall restart
Start the Proxmox VE Firewall service:
pve-firewall start
Stop the Proxmox VE Firewall service:
pve-firewall stop
Simulate all firewall rules:
pve-firewall simulate
Show the status of Proxmox VE Firewall:
pve-firewall status

aws s3 presign

Generate pre-signed URLs for Amazon S3 objects. More information: https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3/presign.html.

Generate a pre-signed URL for a specific S3 object that is valid for one hour:
aws s3 presign s3://{{bucket_name}}/{{path/to/file}}
Generate a pre-signed URL valid for a specific lifetime:
aws s3 presign s3://{{bucket_name}}/{{path/to/file}} --expires-in {{duration_in_seconds}}
Display help:
aws s3 presign help

tldr-lint

Lint and format tldr pages. More information: https://github.com/tldr-pages/tldr-lint.

Lint all pages:
tldr-lint {{pages_directory}}
Format a specific page to stdout:
tldr-lint --format {{page.md}}
Format all pages in place:
tldr-lint --format --in-place {{pages_directory}}

Pint

An opinionated PHP code style fixer based on PHP-CS-Fixer. More information: https://laravel.com/docs/pint.

Execute code style fixing:
pint
Display all files that are changed:
pint -v
Execute code style linting without applying changes:
pint --test
Execute code style fixes using a specific config file:
pint --config {{path/to/pint.json}}
Execute code style fixes using a specific preset:
pint --preset {{psr12}}

fdroidcl

F-Droid CLI client. More information: https://github.com/mvdan/fdroidcl.

Fetch the F-Droid index:
fdroidcl update
Display info about an app:
fdroidcl show {{app_id}}
Download an APK file:
fdroidcl download {{app_id}}
Search for an app in the index:
fdroidcl search {{search_pattern}}
Install an app on a connected device:
fdroidcl install {{app_id}}

aws ec2

CLI for AWS EC2. Provides secure and resizable computing capacity in the AWS cloud to enable faster development and deployment of applications. More information: https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/index.html.

Display information about a specific instance:
aws ec2 describe-instances --instance-ids {{instance_id}}
Display information about all instances:
aws ec2 describe-instances
Display information about all EC2 volumes:
aws ec2 describe-volumes
Delete an EC2 volume:
aws ec2 delete-volume --volume-id {{volume_id}}
Create a snapshot from an EC2 volume:
aws ec2 create-snapshot --volume-id {{volume_id}}
List available AMIs (Amazon Machine Images):
aws ec2 describe-images
Show list of all available EC2 commands:
aws ec2 help
Show help for specific EC2 subcommand:
aws ec2 {{subcommand}} help

minetestserver

Multiplayer infinite-world block sandbox server. See also minetest, the graphical client. More information: https://wiki.minetest.net/Setting_up_a_server.

Start the server:
minetestserver
List available worlds:
minetestserver --world list
Specify the world name to load:
minetestserver --world {{world_name}}
List the available game IDs:
minetestserver --gameid list
Specify a game to use:
minetestserver --gameid {{game_id}}
Listen on a specific port:
minetestserver --port {{34567}}
Migrate to a different data backend:
minetestserver --migrate {{sqlite3|leveldb|redis}}
Start an interactive terminal after starting the server:
minetestserver --terminal

singularity

Manage Singularity containers and images. More information: https://singularity-docs.readthedocs.io/en/latest/#commands.

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:
singularity shell {{image.sif}}
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:
singularity run {{image.sif}}
Build a singularity image from a recipe file:
sudo singularity build {{image.sif}} {{recipe}}

compare

View the difference between 2 images. More information: https://imagemagick.org/script/compare.php.

Compare 2 images:
compare {{image1.png}} {{image2.png}} {{diff.png}}
Compare 2 images using a custom metric:
compare -verbose -metric {{PSNR}} {{image1.png}} {{image2.png}} {{diff.png}}

linode-cli

Manage Linode cloud services. Some subcommands such as events have their own usage documentation. More information: https://www.linode.com/docs/products/tools/cli/get-started/.

List all Linodes:
linode-cli linodes list
View docmentation for managing Linode accounts:
tldr linode-cli account
View documentation for managing Linodes:
tldr linode-cli linodes
View documentation for managing Linode Kubernetes Engine (LKE) clusters:
tldr linode-cli lke
View documentation for managing NodeBalancers:
tldr linode-cli nodebalancers
View documentation for managing Object Storage:
tldr linode-cli object-storage
View documentation for managing DNS domains:
tldr linode-cli domains
View documentation for managing Linode Volumes:
tldr linode-cli volumes

git credential

Retrieve and store user credentials. More information: https://git-scm.com/docs/git-credential.

Display credential information, retrieving the username and password from configuration files:
echo "{{url=http://example.com}}" | git credential fill
Send credential information to all configured credential helpers to store for later use:
echo "{{url=http://example.com}}" | git credential approve
Erase the specified credential information from all the configured credential helpers:
echo "{{url=http://example.com}}" | git credential reject

rbash

Restricted Bash shell, equivalent to bash --restricted. Does not permit changing the working directory, redirecting command output, or modifying environment variables, among other things. See also histexpand for history expansion. More information: https://www.gnu.org/software/bash/manual/html_node/The-Restricted-Shell.

Start an interactive shell session:
rbash
Execute a command and then exit:
rbash -c "{{command}}"
Execute a script:
rbash {{path/to/script.sh}}
Execute a script, printing each command before executing it:
rbash -x {{path/to/script.sh}}
Execute commands from a script, stopping at the first error:
rbash -e {{path/to/script.sh}}
Read and execute commands from stdin:
rbash -s

git stage

Add file contents to the staging area. Synonym of git add. More information: https://git-scm.com/docs/git-stage.

Add a file to the index:
git stage {{path/to/file}}
Add all files (tracked and untracked):
git stage -A
Only add already tracked files:
git stage -u
Also add ignored files:
git stage -f
Interactively stage parts of files:
git stage -p
Interactively stage parts of a given file:
git stage -p {{path/to/file}}
Interactively stage a file:
git stage -i

middleman

Static site generator written in Ruby. More information: https://middlemanapp.com/.

Create a new Middleman project:
middleman init "{{project_name}}"
Start local server for current project on port 4567:
middleman server
Start local server for current project on a specified port:
middleman server -p "{{port}}"
Build the project in the current directory to prepare for deployment:
bundle exec middleman build
Deploy the Middleman project in the current directory:
middleman deploy

apktool

Reverse engineer APK files. More information: https://ibotpeaches.github.io/Apktool/.

Decode an APK file:
apktool d {{path/to/file.apk}}
Build an APK file from a directory:
apktool b {{path/to/directory}}
Install and store a framework:
apktool if {{path/to/framework.apk}}

amass enum

Find subdomains of a domain. More information: https://github.com/OWASP/Amass/blob/master/doc/user_guide.md#the-enum-subcommand.

Passively find subdomains of a domain:
amass enum -passive -d {{domain_name}}
Find subdomains of a domain and actively verify them attempting to resolve the found subdomains:
amass enum -active -d {{domain_name}} -p {{80,443,8080}}
Do a brute force search for subdomains:
amass enum -brute -d {{domain_name}}
Save the results to a text file:
amass enum -o {{output_file}} -d {{domain_name}}
Save the results to a database:
amass enum -o {{output_file}} -dir {{path/to/database_directory}}

flite

Speech synthesis engine. More information: http://www.festvox.org/flite/doc/.

List all available voices:
flite -lv
Convert a text string to speech:
flite -t "{{string}}"
Convert the contents of a file to speech:
flite -f {{path/to/file.txt}}
Specify which voice to use:
flite -voice {{file://path/to/filename.flitevox|url}}
Store output into a wav file:
flite -voice {{file://path/to/filename.flitevox|url}} -f {{path/to/file.txt}} -o {{output.wav}}
Display version:
flite --version

az bicep

Bicep CLI command group. Part of azure-cli. More information: https://learn.microsoft.com/cli/azure/bicep.

Install Bicep CLI:
az bicep install
Build a Bicep file:
az bicep build --file {{path/to/file.bicep}}
Attempt to decompile an ARM template file to a Bicep file:
az bicep decompile --file {{path/to/template_file.json}}
Upgrade Bicep CLI to the latest version:
az bicep upgrade
Display the installed version of Bicep CLI:
az bicep version
List all available versions of Bicep CLI:
az bicep list-versions
Uninstall Bicep CLI:
az bicep uninstall

atuin

Store your shell history in a searchable database. Optionally sync your encrypted history between machines. More information: https://atuin.sh/docs/overview/introduction/.

Install atuin into your shell:
eval "$(atuin init {{bash|zsh|fish}})"
Import history from the shell default history file:
atuin import auto
Search shell history for a specific command:
atuin search {{command}}
Register an account on the default sync server:
atuin register -u {{username}} -e {{email}} -p {{password}}
Login to the default sync server:
atuin login -u {{username}} -p {{password}}
Sync history with the sync server:
atuin sync

stow

Symlink manager. Often used to manage dotfiles. More information: https://www.gnu.org/software/stow.

Symlink all files recursively to a given directory:
stow --target={{path/to/target_directory}} {{file1 directory1 file2 directory2}}
Delete symlinks recursively from a given directory:
stow --delete --target={{path/to/target_directory}} {{file1 directory1 file2 directory2}}
Simulate to see what the result would be like:
stow --simulate --target={{path/to/target_directory}} {{file1 directory1 file2 directory2}}
Delete and resymlink:
stow --restow --target={{path/to/target_directory}} {{file1 directory1 file2 directory2}}
Exclude files matching a regular expression:
stow --ignore={{regular_expression}} --target={{path/to/target_directory}} {{file1 directory1 file2 directory2}}

googler

Search Google from command-line. More information: https://github.com/jarun/googler.

Search Google for a keyword:
googler {{keyword}}
Search Google and open the first result in web browser:
googler -j {{keyword}}
Show N search results (default 10):
googler -n {{N}} {{keyword}}
Disable automatic spelling correction:
googler -x {{keyword}}
Search one site for a keyword:
googler -w {{site}} {{keyword}}
Show Google search result in JSON format:
googler --json {{keyword}}
Perform in-place self-upgrade:
googler -u
For more help in interactive mode:
?

acme.sh --dns

Use a DNS-01 challenge to issue a TLS certificate. More information: https://github.com/acmesh-official/acme.sh/wiki.

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

atoum

A simple, modern and intuitive unit testing framework for PHP. More information: http://atoum.org.

Initialize a configuration file:
atoum --init
Run all tests:
atoum
Run tests using the specified configuration file:
atoum -c {{path/to/file}}
Run a specific test file:
atoum -f {{path/to/file}}
Run a specific directory of tests:
atoum -d {{path/to/directory}}
Run all tests under a specific namespace:
atoum -ns {{namespace}}
Run all tests with a specific tag:
atoum -t {{tag}}
Load a custom bootstrap file before running tests:
atoum --bootstrap-file {{path/to/file}}

ansible-pull

Pull ansible playbooks from a VCS repo and executes them for the local host. More information: https://docs.ansible.com/ansible/latest/cli/ansible-pull.html.

Pull a playbook from a VCS and execute a default local.yml playbook:
ansible-pull -U {{repository_url}}
Pull a playbook from a VCS and execute a specific playbook:
ansible-pull -U {{repository_url}} {{playbook}}
Pull a playbook from a VCS at a specific branch and execute a specific playbook:
ansible-pull -U {{repository_url}} -C {{branch}} {{playbook}}
Pull a playbook from a VCS, specify hosts file and execute a specific playbook:
ansible-pull -U {{repository_url}} -i {{hosts_file}} {{playbook}}

gh issue

Manage GitHub issues. More information: https://cli.github.com/manual/gh_issue.

Display a specific issue:
gh issue view {{issue_number}}
Display a specific issue in the default web browser:
gh issue view {{issue_number}} --web
Create a new issue in the default web browser:
gh issue create --web
List the last 10 issues with the bug label:
gh issue list --limit {{10}} --label "{{bug}}"
List closed issues made by a specific user:
gh issue list --state closed --author {{username}}
Display the status of issues relevant to the user, in a specific repository:
gh issue status --repo {{owner}}/{{repository}}
Reopen a specific issue:
gh issue reopen {{issue_number}}

valac

Vala code compiler. Tutorial: https://wiki.gnome.org/Projects/Vala/Tutorial. More information: https://valadoc.org/.

Compile a vala file, with gtk+:
valac {{path/to/file.vala}} --pkg {{gtk+-3.0}}
Display version info:
valac --version
Display helper message:
valac --help

fossil add

Put files or directories under Fossil version control. More information: https://fossil-scm.org/home/help/add.

Put a file or directory under version control, so it will be in the current checkout:
fossil add {{path/to/file_or_directory}}
Remove all added files from the current checkout:
fossil add --reset

docker container

Manage Docker containers. More information: https://docs.docker.com/engine/reference/commandline/container/.

List currently running Docker containers:
docker container ls
Start one or more stopped containers:
docker container start {{container1_name}} {{container2_name}}
Kill one or more running containers:
docker container kill {{container_name}}
Stop one or more running containers:
docker container stop {{container_name}}
Pause all processes within one or more containers:
docker container pause {{container_name}}
Display detailed information on one or more containers:
docker container inspect {{container_name}}
Export a container's filesystem as a tar archive:
docker container export {{container_name}}
Create a new image from a container's changes:
docker container commit {{container_name}}

csvgrep

Filter CSV rows with string and pattern matching. Included in csvkit. More information: https://csvkit.readthedocs.io/en/latest/scripts/csvgrep.html.

Find rows that have a certain string in column 1:
csvgrep -c {{1}} -m {{string_to_match}} {{data.csv}}
Find rows in which columns 3 or 4 match a certain regular expression:
csvgrep -c {{3,4}} -r {{regular_expression}} {{data.csv}}
Find rows in which the "name" column does NOT include the string "John Doe":
csvgrep -i -c {{name}} -m "{{John Doe}}" {{data.csv}}

swagger-codegen

Generate code and documentation for your REST api from a OpenAPI/swagger definition. More information: https://github.com/swagger-api/swagger-codegen.

Generate documentation and code from an OpenAPI/swagger file:
swagger-codegen generate -i {{swagger_file}} -l {{language}}
Generate Java code using the library retrofit2 and the option useRxJava2:
swagger-codegen generate -i {{http://petstore.swagger.io/v2/swagger.json}} -l {{java}} --library {{retrofit2}} -D{{useRxJava2}}={{true}}
List available languages:
swagger-codegen langs
Display help options for the generate command:
swagger-codegen help {{generate}}

mkfile

Create one or more empty files of any size. More information: https://manned.org/mkfile.

Create an empty file of 15 kilobytes:
mkfile -n {{15k}} {{path/to/file}}
Create a file of a given size and unit (bytes, KB, MB, GB):
mkfile -n {{size}}{{b|k|m|g}} {{path/to/file}}
Create two files of 4 megabytes each:
mkfile -n {{4m}} {{first_filename}} {{second_filename}}

zm

A tool for managing articles of newspapers and blogs. More information: https://github.com/ZERMZeitung/zm2.

Make a new draft:
zm new
Edit a draft:
zm edit
Publish a draft and commit it with git:
zm publish

nf-core

The nf-core framework tools, to create, check and develop best-practice guidelines for Nextflow. More information: https://nf-co.re/tools.

List existing pipelines on nf-core:
nf-core list
Create a new pipeline skeleton:
nf-core create
Lint the pipeline code:
nf-core lint {{path/to/directory}}
Bump software versions in pipeline recipe:
nf-core bump-version {{path/to/directory}} {{new_version}}
Launch an nf-core pipeline:
nf-core launch {{pipeline_name}}
Download an nf-core pipeline for offline use:
nf-core download {{pipeline_name}}

sleep

Delay for a specified amount of time. More information: https://pubs.opengroup.org/onlinepubs/9699919799/utilities/sleep.html.

Delay in seconds:
sleep {{seconds}}
Execute a specific command after 20 seconds delay:
sleep 20 && {{command}}

vue build

A subcommand provided by @vue/cli and @vue/cli-service-global that enables quick prototyping. More information: https://cli.vuejs.org/guide/prototyping.html.

Build a .js or .vue file in production mode with zero config:
vue build {{filename}}

popd

Remove a directory placed on the directory stack via the pushd shell built-in. See also pushd to place a directory on the stack and dirs to display directory stack contents. More information: https://www.gnu.org/software/bash/manual/html_node/Directory-Stack-Builtins.html.

Remove the top directory from the stack and cd to it:
popd
Remove the Nth directory (starting from zero to the left from the list printed with dirs):
popd +N
Remove the Nth directory (starting from zero to the right from the list printed with dirs):
popd -N
Remove the 1st directory (starting from zero to the left from the list printed with dirs):
popd -n

ipaggcreate

Produce aggregate statistics of TCP/IP dumps. More information: https://manned.org/ipaggcreate.

Count the number of packets sent from each source address appearing in a pcap file:
ipaggcreate --src {{path/to/file.pcap}}
Group and count packets read from a network interface by IP packet length:
ipaggcreate --interface {{eth0}} --length
Count the number of bytes sent between each address pair appearing in a pcap file:
ipaggcreate --address-pairs --bytes {{path/to/file.pcap}}

supervisord

Supervisor is a client/server system for controlling some processes on UNIX-like operating systems. Supervisord is the server part of supervisor; it is primarily managed via a configuration file. More information: http://supervisord.org.

Start supervisord with specified configuration file:
supervisord -c {{path/to/file}}
Run supervisord in the foreground:
supervisord -n

charm

Set of tools that makes adding a backend to your terminal-based applications, without worrying about user accounts, data storage and encryption. More information: https://github.com/charmbracelet/charm.

Backup your Charm account keys:
charm backup-keys
Backup Charm account keys to a specific location:
charm backup-keys -o {{path/to/output_file.tar}}
Import previously backed up Charm account keys:
charm import-keys "{{charm-keys-backup.tar}}"
Find where your cloud.charm.sh folder resides on your machine:
charm where
Start your Charm server:
charm serve
Print linked SSH keys:
charm keys
Print your Charm ID:
charm id

dolt branch

Manage Dolt branches. More information: https://github.com/dolthub/dolt.

List local branches (current branch is highlighted by *):
dolt branch
List all local and remote branches:
dolt branch --all
Create a new branch based on the current branch:
dolt branch {{branch_name}}
Create a new branch with the specified commit as the latest:
dolt branch {{branch_name}} {{commit}}
Rename a branch:
dolt branch --move {{branch_name1}} {{branch_name2}}
Duplicate a branch:
dolt branch --copy {{branch_name1}} {{branch_name2}}
Delete a branch:
dolt branch --delete {{branch_name}}
Display the name of the current branch:
dolt branch --show-current

exenv

A tool to easily install Elixir versions and manage application environments. More information: https://github.com/exenv/exenv.

Display a list of installed versions:
exenv versions
Use a specific version of Elixir across the whole system:
exenv global {{version}}
Use a specific version of Elixir for the current application/project directory:
exenv local {{version}}
Show the currently selected Elixir version:
exenv {{version}}
Install a version of Elixir (requires elixir-build plugin https://github.com/mururu/elixir-build):
exenv install {{version}}

html5validator

Validate HTML5. More information: https://github.com/svenkreiss/html5validator.

Validate a specific file:
html5validator {{path/to/file}}
Validate all HTML files in a specific directory:
html5validator --root {{path/to/directory}}
Show warnings as well as errors:
html5validator --show-warnings {{path/to/file}}
Match multiple files using a glob pattern:
html5validator --root {{path/to/directory}} --match "{{*.html *.php}}"
Ignore specific directory names:
html5validator --root {{path/to/directory}} --blacklist "{{node_modules vendor}}"
Output the results in a specific format:
html5validator --format {{gnu|xml|json|text}} {{path/to/file}}
Output the log at a specific verbosity level:
html5validator --root {{path/to/directory}} --log {{debug|info|warning}}

odps inst

Manage instances in ODPS (Open Data Processing Service). See also odps. More information: https://www.alibabacloud.com/help/doc-detail/27971.htm.

Show instances created by current user:
show instances;
Describe the details of an instance:
desc instance {{instance_id}};
Check the status of an instance:
status {{instance_id}};
Wait on the termination of an instance, printing log and progress information until then:
wait {{instance_id}};
Kill an instance:
kill {{instance_id}};

kaggle

Official CLI for Kaggle implemented in Python 3. More information: https://github.com/Kaggle/kaggle-api.

View current configuration values:
kaggle config view
Download a specific file from a competition dataset:
kaggle competitions download {{competition}} -f {{filename}}

git bug

A distributed bug tracker that uses git's internal storage, so no files are added in your project. You may submit your problems to the same git remote you use to interact with others, much like commits and branches. More information: https://github.com/MichaelMure/git-bug/blob/master/doc/md/git-bug.md.

Create a new identity:
git bug user create
Create a new bug:
git bug add
You can push your new entry to a remote:
git bug push
You can pull for updates:
git bug pull
List existing bugs:
git bug ls
Filter and sort bugs using a query:
git bug ls "{{status}}:{{open}} {{sort}}:{{edit}}"
Search for bugs by text content:
git bug ls "{{search_query}}" baz

serialver

Returns the serialVersionUID of classes. It does not set a security manager by default. More information: https://docs.oracle.com/en/java/javase/20/docs/specs/man/serialver.html.

Display the serialVersionUID of a class:
serialver {{classnames}}
Display the serialVersionUID for a colon-separated list of classes and resources:
serialver -classpath {{path/to/directory}} {{classname1:classname2:...}}
Use a specific option from reference page of Java application launcher to the Java Virtual Machine:
serialver -Joption {{classnames}}

rvm

A tool for easily installing, managing, and working with multiple ruby environments. More information: https://rvm.io.

Install one or more space-separated versions of Ruby:
rvm install {{version(s)}}
Display a list of installed versions:
rvm list
Use a specific version of Ruby:
rvm use {{version}}
Set the default Ruby version:
rvm --default use {{version}}
Upgrade a version of Ruby to a new version:
rvm upgrade {{current_version}} {{new_version}}
Uninstall a version of Ruby and keep its sources:
rvm uninstall {{version}}
Remove a version of Ruby and its sources:
rvm remove {{version}}
Show specific dependencies for your OS:
rvm requirements

gource

Renders an animated tree diagram of Git, SVN, Mercurial and Bazaar repositories. It shows files and directories being created, modified or removed over time. More information: https://gource.io.

Run gource in a directory (if it isn't the repository's root directory, the root is sought up from there):
gource {{path/to/repository}}
Run gource in the current directory, with a custom output resolution:
gource -{{width}}x{{height}}
Set a custom timescale for the animation:
gource -c {{time_scale_multiplier}}
Set how long each day should be in the animation (this combines with -c, if provided):
gource -s {{seconds}}
Set fullscreen mode and a custom background color:
gource -f -b {{hex_color_code}}
Set a title for the animation:
gource --title {{title}}

pinta

Pinta is a free, open source program for drawing and image editing. More information: https://www.pinta-project.com/.

Start Pinta:
pinta
Open specific files:
pinta {{path/to/image1 path/to/image2 ...}}

git standup

See commits from a specified user. Part of git-extras. More information: https://github.com/tj/git-extras/blob/master/Commands.md#git-standup.

Show a given author's commits from the last 10 days:
git standup -a {{name|email}} -d {{10}}
Show a given author's commits from the last 10 days and whether they are GPG signed:
git standup -a {[name|email}} -d {{10}} -g
Show all the commits from all contributors for the last 10 days:
git standup -a all -d {{10}}
Display help:
git standup -h

git rebase

Reapply commits from one branch on top of another branch. Commonly used to "move" an entire branch to another base, creating copies of the commits in the new location. More information: https://git-scm.com/docs/git-rebase.

Rebase the current branch on top of another specified branch:
git rebase {{new_base_branch}}
Start an interactive rebase, which allows the commits to be reordered, omitted, combined or modified:
git rebase -i {{target_base_branch_or_commit_hash}}
Continue a rebase that was interrupted by a merge failure, after editing conflicting files:
git rebase --continue
Continue a rebase that was paused due to merge conflicts, by skipping the conflicted commit:
git rebase --skip
Abort a rebase in progress (e.g. if it is interrupted by a merge conflict):
git rebase --abort
Move part of the current branch onto a new base, providing the old base to start from:
git rebase --onto {{new_base}} {{old_base}}
Reapply the last 5 commits in-place, stopping to allow them to be reordered, omitted, combined or modified:
git rebase -i {{HEAD~5}}
Auto-resolve any conflicts by favoring the working branch version (theirs keyword has reversed meaning in this case):
git rebase -X theirs {{branch_name}}

eval

Execute arguments as a single command in the current shell and return its result. More information: https://manned.org/eval.

Call echo with the "foo" argument:
eval "{{echo foo}}"
Set a variable in the current shell:
eval "{{foo=bar}}"

grip

Preview GitHub-flavoured Markdown files locally. More information: https://github.com/joeyespo/grip.

Start the server and serve the rendered README file of a current directory:
grip
Start the server and serve a specific Markdown file:
grip {{path/to/file.md}}
Start the server and open the README file of the current directory in the browser:
grip --browser
Start the server in the specified port and serve the rendered README file of the current directory:
grip {{port}}

clang-tidy

An LLVM-based C/C++ linter to find style violations, bugs and security flaws through static analysis. More information: https://clang.llvm.org/extra/clang-tidy/.

Run default checks on a source file:
clang-tidy {{path/to/file.cpp}}
Don't run any checks other than the cppcoreguidelines checks on a file:
clang-tidy {{path/to/file.cpp}} -checks={{-*,cppcoreguidelines-*}}
List all available checks:
clang-tidy -checks={{*}} -list-checks
Specify defines and includes as compilation options (after --):
clang-tidy {{path/to/file.cpp}} -- -I{{my_project/include}} -D{{definitions}}

arp

Show and manipulate your system's ARP cache. More information: https://manned.org/arp.

Show the current ARP table:
arp -a
Delete a specific entry:
arp -d {{address}}
Create an entry in the ARP table:
arp -s {{address}} {{mac_address}}

lzip

Lzip is a lossless data compressor with a user interface similar to gzip or bzip2. Lzip uses a simplified form of the "Lempel-Ziv-Markovchain-Algorithm"z (LZMA) stream format and provides a 3 factor integrity checking to maximize interoperability and optimize safety. More information: https://www.nongnu.org/lzip.

Archive a file, replacing it with with a compressed version:
lzip {{path/to/file}}
Archive a file, keeping the input file:
lzip -k {{path/to/file}}
Archive a file with the best compression (level=9):
lzip -k {{path/to/file}} --best
Archive a file at the fastest speed (level=0):
lzip -k {{path/to/file}} --fast
Test the integrity of compressed file:
lzip --test {{path/to/archive.lz}}
Decompress a file, replacing it with the original uncompressed version:
lzip -d {{path/to/archive.lz}}
Decompress a file, keeping the archive:
lzip -d -k {{path/to/archive.lz}}
List files which are in an archive and show compression stats:
lzip --list {{path/to/archive.lz}}

ts

Add timestamps to every line from stdin. More information: https://joeyh.name/code/moreutils/.

Add a timestamp to the beginning of each line:
{{command}} | ts
Add timestamps with microsecond precision:
{{command}} | ts "{{%b %d %H:%M:%.S}}"
Add [i]ncremental timestamps with microsecond precision, starting from zero:
{{command}} | ts -i "{{%H:%M:%.S}}"
Convert existing timestamps in a text file (eg. a log file) into [r]elative format:
cat {{path/to/file}} | ts -r

mk

Task runner for targets described in Mkfile. Mostly used to control the compilation of an executable from source code. More information: http://doc.cat-v.org/plan_9/4th_edition/papers/mk.

Call the first target specified in the Mkfile (usually named "all"):
mk
Call a specific target:
mk {{target}}
Call a specific target, executing 4 jobs at a time in parallel:
NPROC=4 mk {{target}}
Force mking of a target, even if source files are unchanged:
mk -w{{target}} {{target}}
Assume all targets to be out of date. Thus, update target and all of its dependencies:
mk -a {{target}}
Keep going as far as possible on error:
mk -k

dd

Convert and copy a file. More information: https://www.gnu.org/software/coreutils/dd.

Make a bootable USB drive from an isohybrid file (such like archlinux-xxx.iso):
dd if={{path/to/file.iso}} of=/dev/{{usb_drive}}
Clone a drive to another drive with 4 MiB block and ignore error:
dd if=/dev/{{source_drive}} of=/dev/{{dest_drive}} bs={{4194304}} conv={{noerror}}
Generate a file of 100 random bytes by using kernel random driver:
dd if=/dev/urandom of={{path/to/random_file}} bs={{100}} count={{1}}
Benchmark the write performance of a disk:
dd if=/dev/zero of={{path/to/file_1GB}} bs={{1024}} count={{1000000}}
Generate a system backup into an IMG file:
dd if={{/dev/drive_device}} of={{path/to/file.img}}
Restore a drive from an IMG file:
dd if={{path/to/file.img}} of={{/dev/drive_device}}

mcfly

A smart command history search and management tool. Replaces your default shell history search (ctrl-r) with an intelligent search engine providing context and relevance to the commands. More information: https://github.com/cantino/mcfly.

Print the mcfly integration code for the specified shell:
mcfly init {{bash|fish|zsh}}
Search the history for a command, with 20 results:
mcfly search --results {{20}} "{{search_terms}}"
Add a new command to the history:
mcfly add "{{command}}"
Record that a directory has moved and transfer the historical records from the old path to the new one:
mcfly move "{{path/to/old_directory}}" "{{path/to/new_directory}}"
Train the suggestion engine (developer tool):
mcfly train
Display help for a specific subcommand:
mcfly help {{subcommand}}

odps auth

User authorities in ODPS (Open Data Processing Service). See also odps. More information: https://www.alibabacloud.com/help/doc-detail/27971.htm.

Add a user to the current project:
add user {{username}};
Grant a set of authorities to a user:
grant {{action_list}} on {{object_type}} {{object_name}} to user {{username}};
Show authorities of a user:
show grants for {{username}};
Create a user role:
create role {{role_name}};
Grant a set of authorities to a role:
grant {{action_list}} on {{object_type}} {{object_name}} to role {{role_name}};
Describe authorities of a role:
desc role {{role_name}};
Grant a role to a user:
grant {{role_name}} to {{username}};

airdecap-ng

Decrypt a WEP, WPA or WPA2 encrypted capture file. Part of Aircrack-ng network software suite. More information: https://www.aircrack-ng.org/doku.php?id=airdecap-ng.

Remove wireless headers from an open network capture file and use the access point's MAC address to filter:
airdecap-ng -b {{ap_mac}} {{path/to/capture.cap}}
Decrypt a WEP encrypted capture file using the key in hex format:
airdecap-ng -w {{hex_key}} {{path/to/capture.cap}}
Decrypt a WPA/WPA2 encrypted capture file using the access point's [e]ssid and [p]assword:
airdecap-ng -e {{essid}} -p {{password}} {{path/to/capture.cap}}
Decrypt a WPA/WPA2 encrypted capture file preserving the headers using the access point's [e]ssid and [p]assword:
airdecap-ng -l -e {{essid}} -p {{password}} {{path/to/capture.cap}}
Decrypt a WPA/WPA2 encrypted capture file using the access point's [e]ssid and [p]assword and use its MAC address to filter:
airdecap-ng -b {{ap_mac}} -e {{essid}} -p {{password}} {{path/to/capture.cap}}

puppet

Help to manage and automate the configuration of servers. Some subcommands such as puppet agent have their own usage documentation. More information: https://puppet.com/.

Execute a Puppet subcommand:
puppet {{subcommand}}
Check the Puppet version:
puppet --version
Display help:
puppet --help
Display help for a subcommand:
puppet help {{subcommand}}

llvm-config

Get various configuration information needed to compile programs which use LLVM. Typically called from build systems, like in Makefiles or configure scripts. More information: https://llvm.org/docs/CommandGuide/llvm-config.html.

Compile and link an LLVM based program:
clang++ $(llvm-config --cxxflags --ldflags --libs) --output {{path/to/output_executable}} {{path/to/source.cc}}
Print the PREFIX of your LLVM installation:
llvm-config --prefix
Print all targets supported by your LLVM build:
llvm-config --targets-built

twurl

Curl-like command but tailored specifically for the Twitter API. More information: https://github.com/twitter/twurl.

Authorize twurl to access a Twitter account:
twurl authorize --consumer-key {{twitter_api_key}} --consumer-secret {{twitter_api_secret}}
Make a GET request to an API endpoint:
twurl -X GET {{twitter_api_endpoint}}
Make a POST request to an API endpoint:
twurl -X POST -d '{{endpoint_params}}' {{twitter_api_endpoint}}
Upload media to Twitter:
twurl -H "{{twitter_upload_url}}" -X POST "{{twitter_upload_endpoint}}" --file "{{path/to/media.jpg}}" --file-field "media"
Access a different Twitter API host:
twurl -H {{twitter_api_url}} -X GET {{twitter_api_endpoint}}
Create an alias for a requested resource:
twurl alias {{alias_name}} {{resource}}

bssh

A GUI tool for browsing for SSH/VNC servers on the local network. See also: bvnc and bshell. More information: https://linux.extremeoverclocking.com/man/1/bssh.

Browse for SSH servers:
bssh
Browse for VNC servers:
bssh --vnc
Browse for both SSH and VNC servers:
bssh --shell
Browse for SSH servers in a specified domain:
bssh --domain={{domain}}

hn

Command-line interface for Hacker News. More information: https://github.com/rafaelrinaldi/hn-cli.

View stories on Hacker News:
hn
View number of stories on Hacker News:
hn --limit {{number}}
View stories on Hacker News, and keep the list open after selecting a link:
hn --keep-open
View stories on Hacker News sorted by submission date:
hn --latest

netstat

Displays network-related information such as open connections, open socket ports, etc. More information: https://man7.org/linux/man-pages/man8/netstat.8.html.

List all ports:
netstat --all
List all listening ports:
netstat --listening
List listening TCP ports:
netstat --tcp
Display PID and program names:
netstat --program
List information continuously:
netstat --continuous
List routes and do not resolve IP addresses to hostnames:
netstat --route --numeric
List listening TCP and UDP ports (+ user and process if you're root):
netstat --listening --program --numeric --tcp --udp --extend

pngcrush

PNG compression utility. More information: https://pmt.sourceforge.io/pngcrush.

Compress a PNG file:
pngcrush {{in.png}} {{out.png}}
Compress all PNGs and output them to the specified directory:
pngcrush -d {{path/to/output}} *.png
Compress PNG file with all 114 available algorithms and pick the best result:
pngcrush -rem allb -brute -reduce {{in.png}} {{out.png}}

moro

Track work time. More information: https://moro.js.org.

Invoke moro without parameters, to set the current time as the start of the working day:
moro
Specify a custom time for the start of the working day:
moro hi {{09:30}}
Invoke moro without parameters a second time, to set the current time at the end of the working day:
moro
Specify a custom time for the end of the working day:
moro bye {{17:30}}
Add a note on the current working day:
moro note {{3 hours on project Foo}}
Show a report of time logs and notes for the current working day:
moro report
Show a report of time logs and notes for all working days on record:
moro report --all

git commits-since

Display commits since a specific time or date. Part of git-extras. More information: https://github.com/tj/git-extras/blob/master/Commands.md#git-commits-since.

Display commits since yesterday:
git commits-since {{yesterday}}
Display commits since last week:
git commits-since {{last week}}
Display commits since last month:
git commits-since {{last month}}
Display commits since yesterday 2pm:
git commits-since {{yesterday 2pm}}

consul

Distributed key-value store with health checking and service discovery. Some subcommands such as consul kv have their own usage documentation. More information: https://www.consul.io/commands.

Check the Consul version:
consul --version
Show general help:
consul --help
Show help for a sub-command:
consul {{sub-command}} --help

fls

List files and directories in an image file or device. More information: https://wiki.sleuthkit.org/index.php?title=Fls.

Build a recursive fls list over a device, output paths will start with C:
fls -r -m {{C:}} {{/dev/loop1p1}}
Analyze a single partition, providing the sector offset at which the filesystem starts in the image:
fls -r -m {{C:}} -o {{sector}} {{path/to/image_file}}
Analyze a single partition, providing the timezone of the original system:
fls -r -m {{C:}} -z {{timezone}} {{/dev/loop1p1}}

gist

Upload code to https://gist.github.com. More information: https://github.com/defunkt/gist.

Log in in gist on this computer:
gist --login
Create a gist from any number of text files:
gist {{file.txt}} {{file2.txt}}
Create a private gist with a description:
gist --private --description "{{A meaningful description}}" {{file.txt}}
Read contents from stdin and create a gist from it:
{{echo "hello world"}} | gist
List your public and private gists:
gist --list
List all public gists for any user:
gist --list {{username}}
Update a gist using the ID from URL:
gist --update {{GIST_ID}} {{file.txt}}

dolt commit

Commit staged changes to tables. More information: https://docs.dolthub.com/interfaces/cli#dolt-commit.

Commit all staged changes, opening the editor specified by $EDITOR to enter the commit message:
dolt commit
Commit all staged changes with the specified message:
dolt commit --message "{{commit_message}}"
Stage all unstaged changes to tables before committing:
dolt commit --all
Use the specified ISO 8601 commit date (defaults to current date and time):
dolt commit --date "{{2021-12-31T00:00:00}}"
Use the specified author for the commit:
dolt commit --author "{{author_name}} <{{author_email}}>"
Allow creating an empty commit, with no changes:
dolt commit --allow-empty
Ignore foreign key warnings:
dolt commit --force

linode-cli lke

Manage Linode Kubernetes Engine (LKE) clusters. See also: linode-cli. More information: https://www.linode.com/docs/products/tools/cli/guides/linode-kubernetes-engine/.

List all LKE clusters:
linode-cli lke clusters list
Create a new LKE cluster:
linode-cli lke clusters create --region {{region}} --type {{type}} --node-type {{node_type}} --nodes-count {{count}}
View details of a specific LKE cluster:
linode-cli lke clusters view {{cluster_id}}
Update an existing LKE cluster:
linode-cli lke clusters update {{cluster_id}} --node-type {{new_node_type}}
Delete an LKE cluster:
linode-cli lke clusters delete {{cluster_id}}

git diff-files

Compare files using their sha1 hashes and modes. More information: https://git-scm.com/docs/git-diff-files.

Compare all changed files:
git diff-files
Compare only specified files:
git diff-files {{path/to/file}}
Show only the names of changed files:
git diff-files --name-only
Output a summary of extended header information:
git diff-files --summary

conda install

Install packages into an existing conda environment. More information: https://docs.conda.io/projects/conda/en/latest/commands/install.html.

Install a single package into the currently active conda environment:
conda install {{package}}
Install a single package into the currently active conda environment using channel conda-forge:
conda install -c conda-forge {{package}}
Install a single package into the currently active conda environment using channel conda-forge and ignoring other channels:
conda install -c conda-forge --override-channels {{package}}
Install multiple packages:
conda install {{package1 package2 ...}}
Install a specific version of a package:
conda install {{package}}={{version}}
Install a package into a specific environment:
conda install --name {{environment}} {{package}}
Update a package in the current environment:
conda install --upgrade {{package}}
Install a package and agree to the transactions without prompting:
conda install --yes {{package}}

git update-index

Git command for manipulating the index. More information: https://git-scm.com/docs/git-update-index.

Pretend that a modified file is unchanged (git status will not show this as changed):
git update-index --skip-worktree {{path/to/modified_file}}

xml format

Format an XML document. More information: http://xmlstar.sourceforge.net/docs.php.

Format an XML document, indenting with tabs:
xml format --indent-tab {{path/to/input.xml|URI}} > {{path/to/output.xml}}
Format an HTML document, indenting with 4 spaces:
xml format --html --indent-spaces {{4}} {{path/to/input.html|URI}} > {{path/to/output.html}}
Recover parsable parts of a malformed XML document, without indenting:
xml format --recover --noindent {{path/to/malformed.xml|URI}} > {{path/to/recovered.xml}}
Format an XML document from stdin, removing the DOCTYPE declaration:
cat {{path\to\input.xml}} | xml format --dropdtd > {{path/to/output.xml}}
Format an XML document, omitting the XML declaration:
xml format --omit-decl {{path\to\input.xml|URI}} > {{path/to/output.xml}}
Display help for the format subcommand:
xml format --help

watson

A wonderful CLI to track your time. More information: https://github.com/TailorDev/Watson.

Start monitoring time in project:
watson start {{project}}
Start monitoring time in project with tags:
watson start {{project}} +{{tag}}
Stop monitoring time for the current project:
watson stop
Display the latest working sessions:
watson log
Edit most recent frame:
watson edit
Remove most recent frame:
watson remove

xidel

Download and extract data from HTML/XML pages as well as JSON APIs. More information: https://www.videlibri.de/xidel.html.

Print all URLs found by a Google search:
xidel {{https://www.google.com/search?q=test}} --extract "//a/extract(@href, 'url[?]q=([^&]+)&', 1)[. != '']"
Print the title of all pages found by a Google search and download them:
xidel {{https://www.google.com/search?q=test}} --follow "{{//a/extract(@href, 'url[?]q=([^&]+)&', 1)[. != '']}}" --extract {{//title}} --download {{'{$host}/'}}
Follow all links on a page and print the titles, with XPath:
xidel {{https://example.org}} --follow {{//a}} --extract {{//title}}
Follow all links on a page and print the titles, with CSS selectors:
xidel {{https://example.org}} --follow "{{css('a')}}" --css {{title}}
Follow all links on a page and print the titles, with pattern matching:
xidel {{https://example.org}} --follow "{{<a>{.}</a>*}}" --extract "{{<title>{.}</title>}}"
Read the pattern from example.xml (which will also check if the element containing "ood" is there, and fail otherwise):
xidel {{path/to/example.xml}} --extract "{{<x><foo>ood</foo><bar>{.}</bar></x>}}"
Print all newest Stack Overflow questions with title and URL using pattern matching on their RSS feed:
xidel {{http://stackoverflow.com/feeds}} --extract "{{<entry><title>{title:=.}</title><link>{uri:=@href}</link></entry>+}}"
Check for unread Reddit mail, Webscraping, combining CSS, XPath, JSONiq, and automatically form evaluation:
xidel {{https://reddit.com}} --follow "{{form(css('form.login-form')[1], {'user': '$your_username', 'passwd': '$your_password'})}}" --extract "{{css('#mail')/@title}}"

route

Use route cmd to set the route table. More information: https://manned.org/route.

Display the information of route table:
route -n
Add route rule:
sudo route add -net {{ip_address}} netmask {{netmask_address}} gw {{gw_address}}
Delete route rule:
sudo route del -net {{ip_address}} netmask {{netmask_address}} dev {{gw_address}}

yapf

Python style guide checker. More information: https://github.com/google/yapf.

Display a diff of the changes that would be made, without making them (dry-run):
yapf --diff {{path/to/file}}
Format the file in-place and display a diff of the changes:
yapf --diff --in-place {{path/to/file}}
Recursively format all Python files in a directory, concurrently:
yapf --recursive --in-place --style {{pep8}} --parallel {{path/to/directory}}

mdp

A command-line based tool to make presentations from Markdown files. More information: https://github.com/visit1985/mdp.

Launch a presentation in the terminal from a Markdown file:
mdp {{presentation.md}}
Disable fading transitions:
mdp --nofade {{presentation.md}}
Invert font colors to use in terminals with light background:
mdp --invert {{presentation.md}}
Disable transparency in transparent terminals:
mdp --notrans {{presentation.md}}

aws backup

Unified backup service designed to protect Amazon Web Services services and their associated data. More information: https://docs.aws.amazon.com/cli/latest/reference/backup/index.html.

Return BackupPlan details for a specific BackupPlanId:
aws backup get-backup-plan --backup-plan-id {{id}}
Create a backup plan using a specific backup plan name and backup rules:
aws backup create-backup-plan --backup-plan {{plan}}
Delete a specific backup plan:
aws backup delete-backup-plan --backup-plan-id {{id}}
Return a list of all active backup plans for the current account:
aws backup list-backup-plans
Display details about your report jobs:
aws backup list-report-jobs

g++

Compiles C++ source files. Part of GCC (GNU Compiler Collection). More information: https://gcc.gnu.org.

Compile a source code file into an executable binary:
g++ {{path/to/source.cpp}} -o {{path/to/output_executable}}
Display common warnings:
g++ {{path/to/source.cpp}} -Wall -o {{path/to/output_executable}}
Choose a language standard to compile for (C++98/C++11/C++14/C++17):
g++ {{path/to/source.cpp}} -std={{c++98|c++11|c++14|c++17}} -o {{path/to/output_executable}}
Include libraries located at a different path than the source file:
g++ {{path/to/source.cpp}} -o {{path/to/output_executable}} -I{{path/to/header}} -L{{path/to/library}} -l{{library_name}}
Compile and link multiple source code files into an executable binary:
g++ -c {{path/to/source_1.cpp path/to/source_2.cpp ...}} && g++ -o {{path/to/output_executable}} {{path/to/source_1.o path/to/source_2.o ...}}
Display version:
g++ --version

black

A Python auto code formatter. More information: https://black.readthedocs.io/en/stable/usage_and_configuration/the_basics.html.

Auto-format a file or entire directory:
black {{path/to/file_or_directory}}
Format the code passed in as a string:
black -c "{{code}}"
Output whether a file or a directory would have changes made to them if they were to be formatted:
black --check {{path/to/file_or_directory}}
Output changes that would be made to a file or a directory without performing them (dry-run):
black --diff {{path/to/file_or_directory}}
Auto-format a file or directory, emitting exclusively error messages to stderr:
black --quiet {{path/to/file_or_directory}}
Auto-format a file or directory without replacing single quotes with double quotes (adoption helper, avoid using this for new projects):
black --skip-string-normalization {{path/to/file_or_directory}}

pyats version

View and upgrade the pyATS installation. More information: https://developer.cisco.com/pyats/.

Display version of all packages:
pyats version check
Display outdated packages:
pyats version check --outdated
Update packages to the most recent version:
pyats version update
Update or downgrade packages to a specific version:
pyats version update {{version}}

clang++

Compiles C++ source files. Part of LLVM. More information: https://clang.llvm.org.

Compile a source code file into an executable binary:
clang++ {{path/to/source.cpp}} -o {{path/to/output_executable}}
Display (almost) all errors and warnings:
clang++ {{path/to/source.cpp}} -Wall -o {{path/to/output_executable}}
Choose a language standard to compile with:
clang++ {{path/to/source.cpp}} -std={{c++20}} -o {{path/to/output_executable}}
Include libraries located at a different path than the source file:
clang++ {{path/to/source.cpp}} -o {{path/to/output_executable}} -I{{path/to/header_path}} -L{{path/to/library_path}} -l{{path/to/library_name}}
Compile source code into LLVM Intermediate Representation (IR):
clang++ -S -emit-llvm {{path/to/source.cpp}} -o {{path/to/output.ll}}

ioping

Monitor I/O latency in real time. More information: https://github.com/koct9i/ioping.

Show disk I/O latency using the default values and the current directory:
ioping .
Measure latency on /tmp using 10 requests of 1 megabyte each:
ioping -c 10 -s 1M /tmp
Measure disk seek rate on /dev/sdX:
ioping -R {{/dev/sdX}}
Measure disk sequential speed on /dev/sdX:
ioping -RL {{/dev/sdX}}

dolt clone

Clone a repository into a new directory. More information: https://docs.dolthub.com/interfaces/cli#dolt-clone.

Clone an existing repository into a specific directory (defaults to the repository name):
dolt clone {{repository_url}} {{path/to/directory}}
Clone an existing repository and add a specific remote (defaults to origin):
dolt clone --remote {{remote_name}} {{repository_url}}
Clone an existing repository only fetching a specific branch (defaults to all branches):
dolt clone --branch {{branch_name}} {{repository_url}}
Clone a repository, using an AWS region (uses the profile's default region if none is provided):
dolt clone --aws-region {{region_name}} {{repository_url}}
Clone a repository, using an AWS credentials file:
dolt clone --aws-creds-file {{credentials_file}} {{repository_url}}
Clone a repository, using an AWS credentials profile (uses the default profile if none is provided):
dolt clone --aws-creds-profile {{profile_name}} {{repository_url}}
Clone a repository, using an AWS credentials type:
dolt clone --aws-creds-type {{credentials_type}} {{repository_url}}

wpaclean

Clean capture files to get only the 4-way handshake and a beacon. Part of Aircrack-ng network software suite. More information: https://manned.org/wpaclean.1.

Clean capture and save only the 4-way handshake and a beacon in the result:
wpaclean {{path/to/result.cap}} {{path/to/capture.cap}}
Clean multiple captures and save 4-way handshakes and beacons in the result:
wpaclean {{path/to/result.cap}} {{path/to/capture1.cap path/to/capture2.cap ...}}

strip-nondeterminism

A tool to remove non-deterministic information (e.g. timestamps) from files. More information: https://salsa.debian.org/reproducible-builds/strip-nondeterminism.

Strip nondeterministic information from a file:
strip-nondeterminism {{path/to/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}}

zip

Package and compress (archive) files into zip file. See also: unzip. More information: https://manned.org/zip.

Add files/directories to a specific archive ([r]ecursively):
zip -r {{path/to/compressed.zip}} {{path/to/file_or_directory1 path/to/file_or_directory2 ...}}
Remove files/directories from a specific archive ([d]elete):
zip -d {{path/to/compressed.zip}} {{path/to/file_or_directory1 path/to/file_or_directory2 ...}}
Archive files/directories e[x]cluding specified ones:
zip -r {{path/to/compressed.zip}} {{path/to/file_or_directory1 path/to/file_or_directory2 ...}} -x {{path/to/excluded_files_or_directories}}
Archive files/directories with a specific compression level (0 - the lowest, 9 - the highest):
zip -r -{{0-9}} {{path/to/compressed.zip}} {{path/to/file_or_directory1 path/to/file_or_directory2 ...}}
Create an [e]ncrypted archive with a specific password:
zip -r -e {{path/to/compressed.zip}} {{path/to/file_or_directory1 path/to/file_or_directory2 ...}}
Archive files/directories to a multi-part [s]plit zip file (e.g. 3 GB parts):
zip -r -s {{3g}} {{path/to/compressed.zip}} {{path/to/file_or_directory1 path/to/file_or_directory2 ...}}
Print a specific archive contents:
zip -sf {{path/to/compressed.zip}}

az storage container

Manage blob storage containers in Azure. Part of azure-cli. More information: https://learn.microsoft.com/cli/azure/storage/container.

Create a container in a storage account:
az storage container create --account-name {{storage_account_name}} --name {{container_name}} --public-access {{access_level}} --fail-on-exist
Generate a shared access signature for the container:
az storage container generate-sas --account-name {{storage_account_name}} --name {{container_name}} --permissions {{sas_permissions}} --expiry {{expiry_date}} --https-only
List containers in a storage account:
az storage container list --account-name {{storage_account_name}} --prefix {{filter_prefix}}
Mark the specified container for deletion:
az storage container delete --account-name {{storage_account_name}} --name {{container_name}} --fail-not-exist

aws cloud9

Manage Cloud9 - a collection of tools to code, build, run, test, debug, and release software in the cloud. More information: https://awscli.amazonaws.com/v2/documentation/api/latest/reference/cloud9/index.html.

Get a list of